/*
 * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
 * This devtool is neither made for production nor for readable output files.
 * It uses "eval()" calls to create a separate source file in the browser devtools.
 * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
 * or disable the default devtool with "devtool: false".
 * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
 */
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([["vendors-node_modules_lumino_coreutils_dist_index_js"],{

/***/ "../node_modules/@lumino/coreutils/dist/index.js":
/*!*******************************************************!*\
  !*** ../node_modules/@lumino/coreutils/dist/index.js ***!
  \*******************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

eval("(function (global, factory) {\n     true ? factory(exports, __webpack_require__(/*! @lumino/algorithm */ \"webpack/sharing/consume/default/@lumino/algorithm/@lumino/algorithm\")) :\n    0;\n})(this, (function (exports, algorithm) { 'use strict';\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * The namespace for JSON-specific functions.\n     */\n    exports.JSONExt = void 0;\n    (function (JSONExt) {\n        /**\n         * A shared frozen empty JSONObject\n         */\n        JSONExt.emptyObject = Object.freeze({});\n        /**\n         * A shared frozen empty JSONArray\n         */\n        JSONExt.emptyArray = Object.freeze([]);\n        /**\n         * Test whether a JSON value is a primitive.\n         *\n         * @param value - The JSON value of interest.\n         *\n         * @returns `true` if the value is a primitive,`false` otherwise.\n         */\n        function isPrimitive(value) {\n            return (value === null ||\n                typeof value === 'boolean' ||\n                typeof value === 'number' ||\n                typeof value === 'string');\n        }\n        JSONExt.isPrimitive = isPrimitive;\n        function isArray(value) {\n            return Array.isArray(value);\n        }\n        JSONExt.isArray = isArray;\n        function isObject(value) {\n            return !isPrimitive(value) && !isArray(value);\n        }\n        JSONExt.isObject = isObject;\n        /**\n         * Compare two JSON values for deep equality.\n         *\n         * @param first - The first JSON value of interest.\n         *\n         * @param second - The second JSON value of interest.\n         *\n         * @returns `true` if the values are equivalent, `false` otherwise.\n         */\n        function deepEqual(first, second) {\n            // Check referential and primitive equality first.\n            if (first === second) {\n                return true;\n            }\n            // If one is a primitive, the `===` check ruled out the other.\n            if (isPrimitive(first) || isPrimitive(second)) {\n                return false;\n            }\n            // Test whether they are arrays.\n            let a1 = isArray(first);\n            let a2 = isArray(second);\n            // Bail if the types are different.\n            if (a1 !== a2) {\n                return false;\n            }\n            // If they are both arrays, compare them.\n            if (a1 && a2) {\n                return deepArrayEqual(first, second);\n            }\n            // At this point, they must both be objects.\n            return deepObjectEqual(first, second);\n        }\n        JSONExt.deepEqual = deepEqual;\n        /**\n         * Create a deep copy of a JSON value.\n         *\n         * @param value - The JSON value to copy.\n         *\n         * @returns A deep copy of the given JSON value.\n         */\n        function deepCopy(value) {\n            // Do nothing for primitive values.\n            if (isPrimitive(value)) {\n                return value;\n            }\n            // Deep copy an array.\n            if (isArray(value)) {\n                return deepArrayCopy(value);\n            }\n            // Deep copy an object.\n            return deepObjectCopy(value);\n        }\n        JSONExt.deepCopy = deepCopy;\n        /**\n         * Compare two JSON arrays for deep equality.\n         */\n        function deepArrayEqual(first, second) {\n            // Check referential equality first.\n            if (first === second) {\n                return true;\n            }\n            // Test the arrays for equal length.\n            if (first.length !== second.length) {\n                return false;\n            }\n            // Compare the values for equality.\n            for (let i = 0, n = first.length; i < n; ++i) {\n                if (!deepEqual(first[i], second[i])) {\n                    return false;\n                }\n            }\n            // At this point, the arrays are equal.\n            return true;\n        }\n        /**\n         * Compare two JSON objects for deep equality.\n         */\n        function deepObjectEqual(first, second) {\n            // Check referential equality first.\n            if (first === second) {\n                return true;\n            }\n            // Check for the first object's keys in the second object.\n            for (let key in first) {\n                if (first[key] !== undefined && !(key in second)) {\n                    return false;\n                }\n            }\n            // Check for the second object's keys in the first object.\n            for (let key in second) {\n                if (second[key] !== undefined && !(key in first)) {\n                    return false;\n                }\n            }\n            // Compare the values for equality.\n            for (let key in first) {\n                // Get the values.\n                let firstValue = first[key];\n                let secondValue = second[key];\n                // If both are undefined, ignore the key.\n                if (firstValue === undefined && secondValue === undefined) {\n                    continue;\n                }\n                // If only one value is undefined, the objects are not equal.\n                if (firstValue === undefined || secondValue === undefined) {\n                    return false;\n                }\n                // Compare the values.\n                if (!deepEqual(firstValue, secondValue)) {\n                    return false;\n                }\n            }\n            // At this point, the objects are equal.\n            return true;\n        }\n        /**\n         * Create a deep copy of a JSON array.\n         */\n        function deepArrayCopy(value) {\n            let result = new Array(value.length);\n            for (let i = 0, n = value.length; i < n; ++i) {\n                result[i] = deepCopy(value[i]);\n            }\n            return result;\n        }\n        /**\n         * Create a deep copy of a JSON object.\n         */\n        function deepObjectCopy(value) {\n            let result = {};\n            for (let key in value) {\n                // Ignore undefined values.\n                let subvalue = value[key];\n                if (subvalue === undefined) {\n                    continue;\n                }\n                result[key] = deepCopy(subvalue);\n            }\n            return result;\n        }\n    })(exports.JSONExt || (exports.JSONExt = {}));\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * An object which stores MIME data for general application use.\n     *\n     * #### Notes\n     * This class does not attempt to enforce \"correctness\" of MIME types\n     * and their associated data. Since this class is designed to transfer\n     * arbitrary data and objects within the same application, it assumes\n     * that the user provides correct and accurate data.\n     */\n    class MimeData {\n        constructor() {\n            this._types = [];\n            this._values = [];\n        }\n        /**\n         * Get an array of the MIME types contained within the dataset.\n         *\n         * @returns A new array of the MIME types, in order of insertion.\n         */\n        types() {\n            return this._types.slice();\n        }\n        /**\n         * Test whether the dataset has an entry for the given type.\n         *\n         * @param mime - The MIME type of interest.\n         *\n         * @returns `true` if the dataset contains a value for the given\n         *   MIME type, `false` otherwise.\n         */\n        hasData(mime) {\n            return this._types.indexOf(mime) !== -1;\n        }\n        /**\n         * Get the data value for the given MIME type.\n         *\n         * @param mime - The MIME type of interest.\n         *\n         * @returns The value for the given MIME type, or `undefined` if\n         *   the dataset does not contain a value for the type.\n         */\n        getData(mime) {\n            let i = this._types.indexOf(mime);\n            return i !== -1 ? this._values[i] : undefined;\n        }\n        /**\n         * Set the data value for the given MIME type.\n         *\n         * @param mime - The MIME type of interest.\n         *\n         * @param data - The data value for the given MIME type.\n         *\n         * #### Notes\n         * This will overwrite any previous entry for the MIME type.\n         */\n        setData(mime, data) {\n            this.clearData(mime);\n            this._types.push(mime);\n            this._values.push(data);\n        }\n        /**\n         * Remove the data entry for the given MIME type.\n         *\n         * @param mime - The MIME type of interest.\n         *\n         * #### Notes\n         * This is a no-op if there is no entry for the given MIME type.\n         */\n        clearData(mime) {\n            let i = this._types.indexOf(mime);\n            if (i !== -1) {\n                this._types.splice(i, 1);\n                this._values.splice(i, 1);\n            }\n        }\n        /**\n         * Remove all data entries from the dataset.\n         */\n        clear() {\n            this._types.length = 0;\n            this._values.length = 0;\n        }\n    }\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /**\n     * Plugin registry.\n     */\n    class PluginRegistry {\n        constructor(options = {}) {\n            this._application = null;\n            this._validatePlugin = () => true;\n            this._plugins = new Map();\n            this._services = new Map();\n            if (options.validatePlugin) {\n                console.info('Plugins may be rejected by the custom validation plugin method.');\n                this._validatePlugin = options.validatePlugin;\n            }\n        }\n        /**\n         * The application object.\n         *\n         * It will be provided as first argument to the\n         * plugins activation and deactivation functions.\n         *\n         * It can only be set once.\n         *\n         * By default, it is `null`.\n         */\n        get application() {\n            return this._application;\n        }\n        set application(v) {\n            if (this._application !== null) {\n                throw Error('PluginRegistry.application is already set. It cannot be overridden.');\n            }\n            this._application = v;\n        }\n        /**\n         * The list of all the deferred plugins.\n         */\n        get deferredPlugins() {\n            return Array.from(this._plugins)\n                .filter(([id, plugin]) => plugin.autoStart === 'defer')\n                .map(([id, plugin]) => id);\n        }\n        /**\n         * Get a plugin description.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @returns The plugin description.\n         */\n        getPluginDescription(id) {\n            var _a, _b;\n            return (_b = (_a = this._plugins.get(id)) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : '';\n        }\n        /**\n         * Test whether a plugin is registered with the application.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @returns `true` if the plugin is registered, `false` otherwise.\n         */\n        hasPlugin(id) {\n            return this._plugins.has(id);\n        }\n        /**\n         * Test whether a plugin is activated with the application.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @returns `true` if the plugin is activated, `false` otherwise.\n         */\n        isPluginActivated(id) {\n            var _a, _b;\n            return (_b = (_a = this._plugins.get(id)) === null || _a === void 0 ? void 0 : _a.activated) !== null && _b !== void 0 ? _b : false;\n        }\n        /**\n         * List the IDs of the plugins registered with the application.\n         *\n         * @returns A new array of the registered plugin IDs.\n         */\n        listPlugins() {\n            return Array.from(this._plugins.keys());\n        }\n        /**\n         * Register a plugin with the application.\n         *\n         * @param plugin - The plugin to register.\n         *\n         * #### Notes\n         * An error will be thrown if a plugin with the same ID is already\n         * registered, or if the plugin has a circular dependency.\n         *\n         * If the plugin provides a service which has already been provided\n         * by another plugin, the new service will override the old service.\n         */\n        registerPlugin(plugin) {\n            // Throw an error if the plugin ID is already registered.\n            if (this._plugins.has(plugin.id)) {\n                throw new TypeError(`Plugin '${plugin.id}' is already registered.`);\n            }\n            if (!this._validatePlugin(plugin)) {\n                throw new Error(`Plugin '${plugin.id}' is not valid.`);\n            }\n            // Create the normalized plugin data.\n            const data = Private.createPluginData(plugin);\n            // Ensure the plugin does not cause a cyclic dependency.\n            Private.ensureNoCycle(data, this._plugins, this._services);\n            // Add the service token to the service map.\n            if (data.provides) {\n                this._services.set(data.provides, data.id);\n            }\n            // Add the plugin to the plugin map.\n            this._plugins.set(data.id, data);\n        }\n        /**\n         * Register multiple plugins with the application.\n         *\n         * @param plugins - The plugins to register.\n         *\n         * #### Notes\n         * This calls `registerPlugin()` for each of the given plugins.\n         */\n        registerPlugins(plugins) {\n            for (const plugin of plugins) {\n                this.registerPlugin(plugin);\n            }\n        }\n        /**\n         * Deregister a plugin with the application.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @param force - Whether to deregister the plugin even if it is active.\n         */\n        deregisterPlugin(id, force) {\n            const plugin = this._plugins.get(id);\n            if (!plugin) {\n                return;\n            }\n            if (plugin.activated && !force) {\n                throw new Error(`Plugin '${id}' is still active.`);\n            }\n            this._plugins.delete(id);\n        }\n        /**\n         * Activate the plugin with the given ID.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @returns A promise which resolves when the plugin is activated\n         *   or rejects with an error if it cannot be activated.\n         */\n        async activatePlugin(id) {\n            // Reject the promise if the plugin is not registered.\n            const plugin = this._plugins.get(id);\n            if (!plugin) {\n                throw new ReferenceError(`Plugin '${id}' is not registered.`);\n            }\n            // Resolve immediately if the plugin is already activated.\n            if (plugin.activated) {\n                return;\n            }\n            // Return the pending resolver promise if it exists.\n            if (plugin.promise) {\n                return plugin.promise;\n            }\n            // Resolve the required services for the plugin.\n            const required = plugin.requires.map(t => this.resolveRequiredService(t));\n            // Resolve the optional services for the plugin.\n            const optional = plugin.optional.map(t => this.resolveOptionalService(t));\n            // Setup the resolver promise for the plugin.\n            plugin.promise = Promise.all([...required, ...optional])\n                .then(services => plugin.activate.apply(undefined, [this.application, ...services]))\n                .then(service => {\n                plugin.service = service;\n                plugin.activated = true;\n                plugin.promise = null;\n            })\n                .catch(error => {\n                plugin.promise = null;\n                throw error;\n            });\n            // Return the pending resolver promise.\n            return plugin.promise;\n        }\n        /**\n         * Activate all the deferred plugins.\n         *\n         * @returns A promise which will resolve when each plugin is activated\n         * or rejects with an error if one cannot be activated.\n         */\n        async activatePlugins(kind, options = {}) {\n            switch (kind) {\n                case 'defer': {\n                    const promises = this.deferredPlugins\n                        .filter(pluginId => this._plugins.get(pluginId).autoStart)\n                        .map(pluginId => {\n                        return this.activatePlugin(pluginId);\n                    });\n                    await Promise.all(promises);\n                    break;\n                }\n                case 'startUp': {\n                    // Collect the ids of the startup plugins.\n                    const startups = Private.collectStartupPlugins(this._plugins, options);\n                    // Generate the activation promises.\n                    const promises = startups.map(async (id) => {\n                        try {\n                            return await this.activatePlugin(id);\n                        }\n                        catch (error) {\n                            console.error(`Plugin '${id}' failed to activate.`, error);\n                        }\n                    });\n                    await Promise.all(promises);\n                    break;\n                }\n            }\n        }\n        /**\n         * Deactivate the plugin and its downstream dependents if and only if the\n         * plugin and its dependents all support `deactivate`.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @returns A list of IDs of downstream plugins deactivated with this one.\n         */\n        async deactivatePlugin(id) {\n            // Reject the promise if the plugin is not registered.\n            const plugin = this._plugins.get(id);\n            if (!plugin) {\n                throw new ReferenceError(`Plugin '${id}' is not registered.`);\n            }\n            // Bail early if the plugin is not activated.\n            if (!plugin.activated) {\n                return [];\n            }\n            // Check that this plugin can deactivate.\n            if (!plugin.deactivate) {\n                throw new TypeError(`Plugin '${id}'#deactivate() method missing`);\n            }\n            // Find the optimal deactivation order for plugins downstream of this one.\n            const manifest = Private.findDependents(id, this._plugins, this._services);\n            const downstream = manifest.map(id => this._plugins.get(id));\n            // Check that all downstream plugins can deactivate.\n            for (const plugin of downstream) {\n                if (!plugin.deactivate) {\n                    throw new TypeError(`Plugin ${plugin.id}#deactivate() method missing (depends on ${id})`);\n                }\n            }\n            // Deactivate all downstream plugins.\n            for (const plugin of downstream) {\n                const services = [...plugin.requires, ...plugin.optional].map(service => {\n                    const id = this._services.get(service);\n                    return id ? this._plugins.get(id).service : null;\n                });\n                // Await deactivation so the next plugins only receive active services.\n                await plugin.deactivate(this.application, ...services);\n                plugin.service = null;\n                plugin.activated = false;\n            }\n            // Remove plugin ID and return manifest of deactivated plugins.\n            manifest.pop();\n            return manifest;\n        }\n        /**\n         * Resolve a required service of a given type.\n         *\n         * @param token - The token for the service type of interest.\n         *\n         * @returns A promise which resolves to an instance of the requested\n         *   service, or rejects with an error if it cannot be resolved.\n         *\n         * #### Notes\n         * Services are singletons. The same instance will be returned each\n         * time a given service token is resolved.\n         *\n         * If the plugin which provides the service has not been activated,\n         * resolving the service will automatically activate the plugin.\n         *\n         * User code will not typically call this method directly. Instead,\n         * the required services for the user's plugins will be resolved\n         * automatically when the plugin is activated.\n         */\n        async resolveRequiredService(token) {\n            // Reject the promise if there is no provider for the type.\n            const id = this._services.get(token);\n            if (!id) {\n                throw new TypeError(`No provider for: ${token.name}.`);\n            }\n            // Activate the plugin if necessary.\n            const plugin = this._plugins.get(id);\n            if (!plugin.activated) {\n                await this.activatePlugin(id);\n            }\n            return plugin.service;\n        }\n        /**\n         * Resolve an optional service of a given type.\n         *\n         * @param token - The token for the service type of interest.\n         *\n         * @returns A promise which resolves to an instance of the requested\n         *   service, or `null` if it cannot be resolved.\n         *\n         * #### Notes\n         * Services are singletons. The same instance will be returned each\n         * time a given service token is resolved.\n         *\n         * If the plugin which provides the service has not been activated,\n         * resolving the service will automatically activate the plugin.\n         *\n         * User code will not typically call this method directly. Instead,\n         * the optional services for the user's plugins will be resolved\n         * automatically when the plugin is activated.\n         */\n        async resolveOptionalService(token) {\n            // Resolve with `null` if there is no provider for the type.\n            const id = this._services.get(token);\n            if (!id) {\n                return null;\n            }\n            // Activate the plugin if necessary.\n            const plugin = this._plugins.get(id);\n            if (!plugin.activated) {\n                try {\n                    await this.activatePlugin(id);\n                }\n                catch (reason) {\n                    console.error(reason);\n                    return null;\n                }\n            }\n            return plugin.service;\n        }\n    }\n    /**\n     * The namespace for the module implementation details.\n     */\n    var Private;\n    (function (Private) {\n        class PluginData {\n            constructor(plugin) {\n                var _a, _b, _c, _d;\n                this._activated = false;\n                this._promise = null;\n                this._service = null;\n                this.id = plugin.id;\n                this.description = (_a = plugin.description) !== null && _a !== void 0 ? _a : '';\n                this.activate = plugin.activate;\n                this.deactivate = (_b = plugin.deactivate) !== null && _b !== void 0 ? _b : null;\n                this.provides = (_c = plugin.provides) !== null && _c !== void 0 ? _c : null;\n                this.autoStart = (_d = plugin.autoStart) !== null && _d !== void 0 ? _d : false;\n                this.requires = plugin.requires ? plugin.requires.slice() : [];\n                this.optional = plugin.optional ? plugin.optional.slice() : [];\n            }\n            /**\n             * Whether the plugin has been activated.\n             */\n            get activated() {\n                return this._activated;\n            }\n            set activated(a) {\n                this._activated = a;\n            }\n            /**\n             * The resolved service for the plugin, or `null`.\n             */\n            get service() {\n                return this._service;\n            }\n            set service(s) {\n                this._service = s;\n            }\n            /**\n             * The pending resolver promise, or `null`.\n             */\n            get promise() {\n                return this._promise;\n            }\n            set promise(p) {\n                this._promise = p;\n            }\n        }\n        /**\n         * Create a normalized plugin data object for the given plugin.\n         */\n        function createPluginData(plugin) {\n            return new PluginData(plugin);\n        }\n        Private.createPluginData = createPluginData;\n        /**\n         * Ensure no cycle is present in the plugin resolution graph.\n         *\n         * If a cycle is detected, an error will be thrown.\n         */\n        function ensureNoCycle(plugin, plugins, services) {\n            const dependencies = [...plugin.requires, ...plugin.optional];\n            const visit = (token) => {\n                if (token === plugin.provides) {\n                    return true;\n                }\n                const id = services.get(token);\n                if (!id) {\n                    return false;\n                }\n                const visited = plugins.get(id);\n                const dependencies = [...visited.requires, ...visited.optional];\n                if (dependencies.length === 0) {\n                    return false;\n                }\n                trace.push(id);\n                if (dependencies.some(visit)) {\n                    return true;\n                }\n                trace.pop();\n                return false;\n            };\n            // Bail early if there cannot be a cycle.\n            if (!plugin.provides || dependencies.length === 0) {\n                return;\n            }\n            // Setup a stack to trace service resolution.\n            const trace = [plugin.id];\n            // Throw an exception if a cycle is present.\n            if (dependencies.some(visit)) {\n                throw new ReferenceError(`Cycle detected: ${trace.join(' -> ')}.`);\n            }\n        }\n        Private.ensureNoCycle = ensureNoCycle;\n        /**\n         * Find dependents in deactivation order.\n         *\n         * @param id - The ID of the plugin of interest.\n         *\n         * @param plugins - The map containing all plugins.\n         *\n         * @param services - The map containing all services.\n         *\n         * @returns A list of dependent plugin IDs in order of deactivation\n         *\n         * #### Notes\n         * The final item of the returned list is always the plugin of interest.\n         */\n        function findDependents(id, plugins, services) {\n            const edges = new Array();\n            const add = (id) => {\n                const plugin = plugins.get(id);\n                // FIXME In the case of missing optional dependencies, we may consider\n                // deactivating and reactivating the plugin without the missing service.\n                const dependencies = [...plugin.requires, ...plugin.optional];\n                edges.push(...dependencies.reduce((acc, dep) => {\n                    const service = services.get(dep);\n                    if (service) {\n                        // An edge is oriented from dependent to provider.\n                        acc.push([id, service]);\n                    }\n                    return acc;\n                }, []));\n            };\n            for (const id of plugins.keys()) {\n                add(id);\n            }\n            // Filter edges\n            // - Get all packages that dependent on the package to be deactivated\n            const newEdges = edges.filter(edge => edge[1] === id);\n            let oldSize = 0;\n            while (newEdges.length > oldSize) {\n                const previousSize = newEdges.length;\n                // Get all packages that dependent on packages that will be deactivated\n                const packagesOfInterest = new Set(newEdges.map(edge => edge[0]));\n                for (const poi of packagesOfInterest) {\n                    edges\n                        .filter(edge => edge[1] === poi)\n                        .forEach(edge => {\n                        // We check it is not already included to deal with circular dependencies\n                        if (!newEdges.includes(edge)) {\n                            newEdges.push(edge);\n                        }\n                    });\n                }\n                oldSize = previousSize;\n            }\n            const sorted = algorithm.topologicSort(newEdges);\n            const index = sorted.findIndex(candidate => candidate === id);\n            if (index === -1) {\n                return [id];\n            }\n            return sorted.slice(0, index + 1);\n        }\n        Private.findDependents = findDependents;\n        /**\n         * Collect the IDs of the plugins to activate on startup.\n         */\n        function collectStartupPlugins(plugins, options) {\n            // Create a set to hold the plugin IDs.\n            const collection = new Set();\n            // Collect the auto-start (non deferred) plugins.\n            for (const id of plugins.keys()) {\n                if (plugins.get(id).autoStart === true) {\n                    collection.add(id);\n                }\n            }\n            // Add the startup plugins.\n            if (options.startPlugins) {\n                for (const id of options.startPlugins) {\n                    collection.add(id);\n                }\n            }\n            // Remove the ignored plugins.\n            if (options.ignorePlugins) {\n                for (const id of options.ignorePlugins) {\n                    collection.delete(id);\n                }\n            }\n            // Return the collected startup plugins.\n            return Array.from(collection);\n        }\n        Private.collectStartupPlugins = collectStartupPlugins;\n    })(Private || (Private = {}));\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * A class which wraps a promise into a delegate object.\n     *\n     * #### Notes\n     * This class is useful when the logic to resolve or reject a promise\n     * cannot be defined at the point where the promise is created.\n     */\n    class PromiseDelegate {\n        /**\n         * Construct a new promise delegate.\n         */\n        constructor() {\n            this.promise = new Promise((resolve, reject) => {\n                this._resolve = resolve;\n                this._reject = reject;\n            });\n        }\n        /**\n         * Resolve the wrapped promise with the given value.\n         *\n         * @param value - The value to use for resolving the promise.\n         */\n        resolve(value) {\n            let resolve = this._resolve;\n            resolve(value);\n        }\n        /**\n         * Reject the wrapped promise with the given value.\n         *\n         * @reason - The reason for rejecting the promise.\n         */\n        reject(reason) {\n            let reject = this._reject;\n            reject(reason);\n        }\n    }\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * A runtime object which captures compile-time type information.\n     *\n     * #### Notes\n     * A token captures the compile-time type of an interface or class in\n     * an object which can be used at runtime in a type-safe fashion.\n     */\n    class Token {\n        /**\n         * Construct a new token.\n         *\n         * @param name - A human readable name for the token.\n         * @param description - Token purpose description for documentation.\n         */\n        constructor(name, description) {\n            this.name = name;\n            this.description = description !== null && description !== void 0 ? description : '';\n            this._tokenStructuralPropertyT = null;\n        }\n    }\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    // Fallback\n    function fallbackRandomValues(buffer) {\n        let value = 0;\n        for (let i = 0, n = buffer.length; i < n; ++i) {\n            if (i % 4 === 0) {\n                value = (Math.random() * 0xffffffff) >>> 0;\n            }\n            buffer[i] = value & 0xff;\n            value >>>= 8;\n        }\n    }\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * The namespace for random number related functionality.\n     */\n    exports.Random = void 0;\n    (function (Random) {\n        /**\n         * A function which generates random bytes.\n         *\n         * @param buffer - The `Uint8Array` to fill with random bytes.\n         *\n         * #### Notes\n         * A cryptographically strong random number generator will be used if\n         * available. Otherwise, `Math.random` will be used as a fallback for\n         * randomness.\n         *\n         * The following RNGs are supported, listed in order of precedence:\n         *   - `window.crypto.getRandomValues`\n         *   - `window.msCrypto.getRandomValues`\n         *   - `require('crypto').randomFillSync\n         *   - `require('crypto').randomBytes\n         *   - `Math.random`\n         */\n        Random.getRandomValues = (() => {\n            // Look up the crypto module if available.\n            const crypto = (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) ||\n                null;\n            // Modern browsers and IE 11\n            if (crypto && typeof crypto.getRandomValues === 'function') {\n                return function getRandomValues(buffer) {\n                    return crypto.getRandomValues(buffer);\n                };\n            }\n            // Fallback\n            return fallbackRandomValues;\n        })();\n    })(exports.Random || (exports.Random = {}));\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * A function which creates a function that generates UUID v4 identifiers.\n     *\n     * @returns A new function that creates a UUID v4 string.\n     *\n     * #### Notes\n     * This implementation complies with RFC 4122.\n     *\n     * This uses `Random.getRandomValues()` for random bytes, which in\n     * turn will use the underlying `crypto` module of the platform if\n     * it is available. The fallback for randomness is `Math.random`.\n     */\n    function uuid4Factory(getRandomValues) {\n        // Create a 16 byte array to hold the random values.\n        const bytes = new Uint8Array(16);\n        // Create a look up table from bytes to hex strings.\n        const lut = new Array(256);\n        // Pad the single character hex digits with a leading zero.\n        for (let i = 0; i < 16; ++i) {\n            lut[i] = '0' + i.toString(16);\n        }\n        // Populate the rest of the hex digits.\n        for (let i = 16; i < 256; ++i) {\n            lut[i] = i.toString(16);\n        }\n        // Return a function which generates the UUID.\n        return function uuid4() {\n            // Get a new batch of random values.\n            getRandomValues(bytes);\n            // Set the UUID version number to 4.\n            bytes[6] = 0x40 | (bytes[6] & 0x0f);\n            // Set the clock sequence bit to the RFC spec.\n            bytes[8] = 0x80 | (bytes[8] & 0x3f);\n            // Assemble the UUID string.\n            return (lut[bytes[0]] +\n                lut[bytes[1]] +\n                lut[bytes[2]] +\n                lut[bytes[3]] +\n                '-' +\n                lut[bytes[4]] +\n                lut[bytes[5]] +\n                '-' +\n                lut[bytes[6]] +\n                lut[bytes[7]] +\n                '-' +\n                lut[bytes[8]] +\n                lut[bytes[9]] +\n                '-' +\n                lut[bytes[10]] +\n                lut[bytes[11]] +\n                lut[bytes[12]] +\n                lut[bytes[13]] +\n                lut[bytes[14]] +\n                lut[bytes[15]]);\n        };\n    }\n\n    // Copyright (c) Jupyter Development Team.\n    // Distributed under the terms of the Modified BSD License.\n    /*-----------------------------------------------------------------------------\n    | Copyright (c) 2014-2017, PhosphorJS Contributors\n    |\n    | Distributed under the terms of the BSD 3-Clause License.\n    |\n    | The full license is in the file LICENSE, distributed with this software.\n    |----------------------------------------------------------------------------*/\n    /**\n     * The namespace for UUID related functionality.\n     */\n    exports.UUID = void 0;\n    (function (UUID) {\n        /**\n         * A function which generates UUID v4 identifiers.\n         *\n         * @returns A new UUID v4 string.\n         *\n         * #### Notes\n         * This implementation complies with RFC 4122.\n         *\n         * This uses `Random.getRandomValues()` for random bytes, which in\n         * turn will use the underlying `crypto` module of the platform if\n         * it is available. The fallback for randomness is `Math.random`.\n         */\n        UUID.uuid4 = uuid4Factory(exports.Random.getRandomValues);\n    })(exports.UUID || (exports.UUID = {}));\n\n    exports.MimeData = MimeData;\n    exports.PluginRegistry = PluginRegistry;\n    exports.PromiseDelegate = PromiseDelegate;\n    exports.Token = Token;\n\n}));\n//# sourceMappingURL=index.js.map\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@lumino/coreutils/dist/index.js?");

/***/ })

}]);