/*
 * 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) {

eval("(function (global, factory) {\n     true ? factory(exports) :\n    0;\n})(this, (function (exports) { '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    | 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    /**\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    /**\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.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?");

/***/ })

}]);