/*
 * 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_jupyterlab_coreutils_lib_index_js"],{

/***/ "../node_modules/@jupyterlab/coreutils/lib/activitymonitor.js":
/*!********************************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/activitymonitor.js ***!
  \********************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.ActivityMonitor = void 0;\nconst signaling_1 = __webpack_require__(/*! @lumino/signaling */ \"webpack/sharing/consume/default/@lumino/signaling/@lumino/signaling\");\n/**\n * A class that monitors activity on a signal.\n */\nclass ActivityMonitor {\n    /**\n     * Construct a new activity monitor.\n     */\n    constructor(options) {\n        this._timer = -1;\n        this._timeout = -1;\n        this._isDisposed = false;\n        this._activityStopped = new signaling_1.Signal(this);\n        options.signal.connect(this._onSignalFired, this);\n        this._timeout = options.timeout || 1000;\n    }\n    /**\n     * A signal emitted when activity has ceased.\n     */\n    get activityStopped() {\n        return this._activityStopped;\n    }\n    /**\n     * The timeout associated with the monitor, in milliseconds.\n     */\n    get timeout() {\n        return this._timeout;\n    }\n    set timeout(value) {\n        this._timeout = value;\n    }\n    /**\n     * Test whether the monitor has been disposed.\n     *\n     * #### Notes\n     * This is a read-only property.\n     */\n    get isDisposed() {\n        return this._isDisposed;\n    }\n    /**\n     * Dispose of the resources used by the activity monitor.\n     */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        this._isDisposed = true;\n        signaling_1.Signal.clearData(this);\n    }\n    /**\n     * A signal handler for the monitored signal.\n     */\n    _onSignalFired(sender, args) {\n        clearTimeout(this._timer);\n        this._sender = sender;\n        this._args = args;\n        this._timer = setTimeout(() => {\n            this._activityStopped.emit({\n                sender: this._sender,\n                args: this._args\n            });\n        }, this._timeout);\n    }\n}\nexports.ActivityMonitor = ActivityMonitor;\n//# sourceMappingURL=activitymonitor.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/activitymonitor.js?");

/***/ }),

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

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/**\n * @packageDocumentation\n * @module coreutils\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n__exportStar(__webpack_require__(/*! ./activitymonitor */ \"../node_modules/@jupyterlab/coreutils/lib/activitymonitor.js\"), exports);\n__exportStar(__webpack_require__(/*! ./interfaces */ \"../node_modules/@jupyterlab/coreutils/lib/interfaces.js\"), exports);\n__exportStar(__webpack_require__(/*! ./lru */ \"../node_modules/@jupyterlab/coreutils/lib/lru.js\"), exports);\n__exportStar(__webpack_require__(/*! ./markdowncodeblocks */ \"../node_modules/@jupyterlab/coreutils/lib/markdowncodeblocks.js\"), exports);\n__exportStar(__webpack_require__(/*! ./pageconfig */ \"../node_modules/@jupyterlab/coreutils/lib/pageconfig.js\"), exports);\n__exportStar(__webpack_require__(/*! ./path */ \"../node_modules/@jupyterlab/coreutils/lib/path.js\"), exports);\n__exportStar(__webpack_require__(/*! ./signal */ \"../node_modules/@jupyterlab/coreutils/lib/signal.js\"), exports);\n__exportStar(__webpack_require__(/*! ./text */ \"../node_modules/@jupyterlab/coreutils/lib/text.js\"), exports);\n__exportStar(__webpack_require__(/*! ./time */ \"../node_modules/@jupyterlab/coreutils/lib/time.js\"), exports);\n__exportStar(__webpack_require__(/*! ./url */ \"../node_modules/@jupyterlab/coreutils/lib/url.js\"), exports);\n//# sourceMappingURL=index.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/index.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/interfaces.js":
/*!***************************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/interfaces.js ***!
  \***************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\n//# sourceMappingURL=interfaces.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/interfaces.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/lru.js":
/*!********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/lru.js ***!
  \********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.LruCache = void 0;\nconst DEFAULT_MAX_SIZE = 128;\n/** A least-recently-used cache. */\nclass LruCache {\n    constructor(options = {}) {\n        this._map = new Map();\n        this._maxSize = (options === null || options === void 0 ? void 0 : options.maxSize) || DEFAULT_MAX_SIZE;\n    }\n    /**\n     * Return the current size of the cache.\n     */\n    get size() {\n        return this._map.size;\n    }\n    /**\n     * Clear the values in the cache.\n     */\n    clear() {\n        this._map.clear();\n    }\n    /**\n     * Get a value (or null) from the cache, pushing the item to the front of the cache.\n     */\n    get(key) {\n        const item = this._map.get(key) || null;\n        if (item != null) {\n            this._map.delete(key);\n            this._map.set(key, item);\n        }\n        return item;\n    }\n    /**\n     * Set a value in the cache, potentially evicting an old item.\n     */\n    set(key, value) {\n        if (this._map.size >= this._maxSize) {\n            this._map.delete(this._map.keys().next().value);\n        }\n        this._map.set(key, value);\n    }\n}\nexports.LruCache = LruCache;\n//# sourceMappingURL=lru.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/lru.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/markdowncodeblocks.js":
/*!***********************************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/markdowncodeblocks.js ***!
  \***********************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.MarkdownCodeBlocks = void 0;\n/**\n * The namespace for code block functions which help\n * in extract code from markdown text\n */\nvar MarkdownCodeBlocks;\n(function (MarkdownCodeBlocks) {\n    MarkdownCodeBlocks.CODE_BLOCK_MARKER = '```';\n    const markdownExtensions = [\n        '.markdown',\n        '.mdown',\n        '.mkdn',\n        '.md',\n        '.mkd',\n        '.mdwn',\n        '.mdtxt',\n        '.mdtext',\n        '.text',\n        '.txt',\n        '.Rmd'\n    ];\n    class MarkdownCodeBlock {\n        constructor(startLine) {\n            this.startLine = startLine;\n            this.code = '';\n            this.endLine = -1;\n        }\n    }\n    MarkdownCodeBlocks.MarkdownCodeBlock = MarkdownCodeBlock;\n    /**\n     * Check whether the given file extension is a markdown extension\n     * @param extension - A file extension\n     *\n     * @returns true/false depending on whether this is a supported markdown extension\n     */\n    function isMarkdown(extension) {\n        return markdownExtensions.indexOf(extension) > -1;\n    }\n    MarkdownCodeBlocks.isMarkdown = isMarkdown;\n    /**\n     * Construct all code snippets from current text\n     * (this could be potentially optimized if we can cache and detect differences)\n     * @param text - A string to parse codeblocks from\n     *\n     * @returns An array of MarkdownCodeBlocks.\n     */\n    function findMarkdownCodeBlocks(text) {\n        if (!text || text === '') {\n            return [];\n        }\n        const lines = text.split('\\n');\n        const codeBlocks = [];\n        let currentBlock = null;\n        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {\n            const line = lines[lineIndex];\n            const lineContainsMarker = line.indexOf(MarkdownCodeBlocks.CODE_BLOCK_MARKER) === 0;\n            const constructingBlock = currentBlock != null;\n            // Skip this line if it is not part of any code block and doesn't contain a marker.\n            if (!lineContainsMarker && !constructingBlock) {\n                continue;\n            }\n            // Check if we are already constructing a code block.\n            if (!constructingBlock) {\n                // Start constructing a new code block.\n                currentBlock = new MarkdownCodeBlock(lineIndex);\n                // Check whether this is a single line code block of the form ```a = 10```.\n                const firstIndex = line.indexOf(MarkdownCodeBlocks.CODE_BLOCK_MARKER);\n                const lastIndex = line.lastIndexOf(MarkdownCodeBlocks.CODE_BLOCK_MARKER);\n                const isSingleLine = firstIndex !== lastIndex;\n                if (isSingleLine) {\n                    currentBlock.code = line.substring(firstIndex + MarkdownCodeBlocks.CODE_BLOCK_MARKER.length, lastIndex);\n                    currentBlock.endLine = lineIndex;\n                    codeBlocks.push(currentBlock);\n                    currentBlock = null;\n                }\n            }\n            else if (currentBlock) {\n                if (lineContainsMarker) {\n                    // End of block, finish it up.\n                    currentBlock.endLine = lineIndex - 1;\n                    codeBlocks.push(currentBlock);\n                    currentBlock = null;\n                }\n                else {\n                    // Append the current line.\n                    currentBlock.code += line + '\\n';\n                }\n            }\n        }\n        return codeBlocks;\n    }\n    MarkdownCodeBlocks.findMarkdownCodeBlocks = findMarkdownCodeBlocks;\n})(MarkdownCodeBlocks || (exports.MarkdownCodeBlocks = MarkdownCodeBlocks = {}));\n//# sourceMappingURL=markdowncodeblocks.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/markdowncodeblocks.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/pageconfig.js":
/*!***************************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/pageconfig.js ***!
  \***************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";
eval("/* provided dependency */ var process = __webpack_require__(/*! process/browser */ \"../node_modules/process/browser.js\");\n\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.PageConfig = void 0;\nconst coreutils_1 = __webpack_require__(/*! @lumino/coreutils */ \"webpack/sharing/consume/default/@lumino/coreutils/@lumino/coreutils\");\nconst minimist_1 = __importDefault(__webpack_require__(/*! minimist */ \"../node_modules/minimist/index.js\"));\nconst url_1 = __webpack_require__(/*! ./url */ \"../node_modules/@jupyterlab/coreutils/lib/url.js\");\n/**\n * The namespace for `PageConfig` functions.\n */\nvar PageConfig;\n(function (PageConfig) {\n    /**\n     * Get global configuration data for the Jupyter application.\n     *\n     * @param name - The name of the configuration option.\n     *\n     * @returns The config value or an empty string if not found.\n     *\n     * #### Notes\n     * All values are treated as strings.\n     * For browser based applications, it is assumed that the page HTML\n     * includes a script tag with the id `jupyter-config-data` containing the\n     * configuration as valid JSON.  In order to support the classic Notebook,\n     * we fall back on checking for `body` data of the given `name`.\n     *\n     * For node applications, it is assumed that the process was launched\n     * with a `--jupyter-config-data` option pointing to a JSON settings\n     * file.\n     */\n    function getOption(name) {\n        if (configData) {\n            return configData[name] || getBodyData(name);\n        }\n        configData = Object.create(null);\n        let found = false;\n        // Use script tag if available.\n        if (typeof document !== 'undefined' && document) {\n            const el = document.getElementById('jupyter-config-data');\n            if (el) {\n                configData = JSON.parse(el.textContent || '');\n                found = true;\n            }\n        }\n        // Otherwise use CLI if given.\n        if (!found && typeof process !== 'undefined' && process.argv) {\n            try {\n                const cli = (0, minimist_1.default)(process.argv.slice(2));\n                const path = __webpack_require__(/*! path */ \"../node_modules/path-browserify/index.js\");\n                let fullPath = '';\n                if ('jupyter-config-data' in cli) {\n                    fullPath = path.resolve(cli['jupyter-config-data']);\n                }\n                else if ('JUPYTER_CONFIG_DATA' in process.env) {\n                    fullPath = path.resolve(process.env['JUPYTER_CONFIG_DATA']);\n                }\n                if (fullPath) {\n                    // Force Webpack to ignore this require.\n                    // eslint-disable-next-line\n                    configData = eval('require')(fullPath);\n                }\n            }\n            catch (e) {\n                console.error(e);\n            }\n        }\n        if (!coreutils_1.JSONExt.isObject(configData)) {\n            configData = Object.create(null);\n        }\n        else {\n            for (const key in configData) {\n                // PageConfig expects strings\n                if (typeof configData[key] !== 'string') {\n                    configData[key] = JSON.stringify(configData[key]);\n                }\n            }\n        }\n        return configData[name] || getBodyData(name);\n    }\n    PageConfig.getOption = getOption;\n    /**\n     * Set global configuration data for the Jupyter application.\n     *\n     * @param name - The name of the configuration option.\n     * @param value - The value to set the option to.\n     *\n     * @returns The last config value or an empty string if it doesn't exist.\n     */\n    function setOption(name, value) {\n        const last = getOption(name);\n        configData[name] = value;\n        return last;\n    }\n    PageConfig.setOption = setOption;\n    /**\n     * Get the base url for a Jupyter application, or the base url of the page.\n     */\n    function getBaseUrl() {\n        return url_1.URLExt.normalize(getOption('baseUrl') || '/');\n    }\n    PageConfig.getBaseUrl = getBaseUrl;\n    /**\n     * Get the tree url for a JupyterLab application.\n     */\n    function getTreeUrl() {\n        return url_1.URLExt.join(getBaseUrl(), getOption('treeUrl'));\n    }\n    PageConfig.getTreeUrl = getTreeUrl;\n    /**\n     * Get the base url for sharing links (usually baseUrl)\n     */\n    function getShareUrl() {\n        return url_1.URLExt.normalize(getOption('shareUrl') || getBaseUrl());\n    }\n    PageConfig.getShareUrl = getShareUrl;\n    /**\n     * Get the tree url for shareable links.\n     * Usually the same as treeUrl,\n     * but overridable e.g. when sharing with JupyterHub.\n     */\n    function getTreeShareUrl() {\n        return url_1.URLExt.normalize(url_1.URLExt.join(getShareUrl(), getOption('treeUrl')));\n    }\n    PageConfig.getTreeShareUrl = getTreeShareUrl;\n    /**\n     * Create a new URL given an optional mode and tree path.\n     *\n     * This is used to create URLS when the mode or tree path change as the user\n     * changes mode or the current document in the main area. If fields in\n     * options are omitted, the value in PageConfig will be used.\n     *\n     * @param options - IGetUrlOptions for the new path.\n     */\n    function getUrl(options) {\n        var _a, _b, _c, _d;\n        let path = options.toShare ? getShareUrl() : getBaseUrl();\n        const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : getOption('mode');\n        const workspace = (_b = options.workspace) !== null && _b !== void 0 ? _b : getOption('workspace');\n        const labOrDoc = mode === 'single-document' ? 'doc' : 'lab';\n        path = url_1.URLExt.join(path, labOrDoc);\n        if (workspace !== PageConfig.defaultWorkspace) {\n            path = url_1.URLExt.join(path, 'workspaces', encodeURIComponent((_c = getOption('workspace')) !== null && _c !== void 0 ? _c : PageConfig.defaultWorkspace));\n        }\n        const treePath = (_d = options.treePath) !== null && _d !== void 0 ? _d : getOption('treePath');\n        if (treePath) {\n            path = url_1.URLExt.join(path, 'tree', url_1.URLExt.encodeParts(treePath));\n        }\n        return path;\n    }\n    PageConfig.getUrl = getUrl;\n    PageConfig.defaultWorkspace = 'default';\n    /**\n     * Get the base websocket url for a Jupyter application, or an empty string.\n     */\n    function getWsUrl(baseUrl) {\n        let wsUrl = getOption('wsUrl');\n        if (!wsUrl) {\n            baseUrl = baseUrl ? url_1.URLExt.normalize(baseUrl) : getBaseUrl();\n            if (baseUrl.indexOf('http') !== 0) {\n                return '';\n            }\n            wsUrl = 'ws' + baseUrl.slice(4);\n        }\n        return url_1.URLExt.normalize(wsUrl);\n    }\n    PageConfig.getWsUrl = getWsUrl;\n    /**\n     * Returns the URL converting this notebook to a certain\n     * format with nbconvert.\n     */\n    function getNBConvertURL({ path, format, download }) {\n        const notebookPath = url_1.URLExt.encodeParts(path);\n        const url = url_1.URLExt.join(getBaseUrl(), 'nbconvert', format, notebookPath);\n        if (download) {\n            return url + '?download=true';\n        }\n        return url;\n    }\n    PageConfig.getNBConvertURL = getNBConvertURL;\n    /**\n     * Get the authorization token for a Jupyter application.\n     */\n    function getToken() {\n        return getOption('token') || getBodyData('jupyterApiToken');\n    }\n    PageConfig.getToken = getToken;\n    /**\n     * Get the Notebook version info [major, minor, patch].\n     */\n    function getNotebookVersion() {\n        const notebookVersion = getOption('notebookVersion');\n        if (notebookVersion === '') {\n            return [0, 0, 0];\n        }\n        return JSON.parse(notebookVersion);\n    }\n    PageConfig.getNotebookVersion = getNotebookVersion;\n    /**\n     * Private page config data for the Jupyter application.\n     */\n    let configData = null;\n    /**\n     * Get a url-encoded item from `body.data` and decode it\n     * We should never have any encoded URLs anywhere else in code\n     * until we are building an actual request.\n     */\n    function getBodyData(key) {\n        if (typeof document === 'undefined' || !document.body) {\n            return '';\n        }\n        const val = document.body.dataset[key];\n        if (typeof val === 'undefined') {\n            return '';\n        }\n        return decodeURIComponent(val);\n    }\n    /**\n     * The namespace for page config `Extension` functions.\n     */\n    let Extension;\n    (function (Extension) {\n        /**\n         * Populate an array from page config.\n         *\n         * @param key - The page config key (e.g., `deferredExtensions`).\n         *\n         * #### Notes\n         * This is intended for `deferredExtensions` and `disabledExtensions`.\n         */\n        function populate(key) {\n            try {\n                const raw = getOption(key);\n                if (raw) {\n                    return JSON.parse(raw);\n                }\n            }\n            catch (error) {\n                console.warn(`Unable to parse ${key}.`, error);\n            }\n            return [];\n        }\n        /**\n         * The collection of deferred extensions in page config.\n         */\n        Extension.deferred = populate('deferredExtensions');\n        /**\n         * The collection of disabled extensions in page config.\n         */\n        Extension.disabled = populate('disabledExtensions');\n        /**\n         * Returns whether a plugin is deferred.\n         *\n         * @param id - The plugin ID.\n         */\n        function isDeferred(id) {\n            // Check for either a full plugin id match or an extension\n            // name match.\n            const separatorIndex = id.indexOf(':');\n            let extName = '';\n            if (separatorIndex !== -1) {\n                extName = id.slice(0, separatorIndex);\n            }\n            return Extension.deferred.some(val => val === id || (extName && val === extName));\n        }\n        Extension.isDeferred = isDeferred;\n        /**\n         * Returns whether a plugin is disabled.\n         *\n         * @param id - The plugin ID.\n         */\n        function isDisabled(id) {\n            // Check for either a full plugin id match or an extension\n            // name match.\n            const separatorIndex = id.indexOf(':');\n            let extName = '';\n            if (separatorIndex !== -1) {\n                extName = id.slice(0, separatorIndex);\n            }\n            return Extension.disabled.some(val => val === id || (extName && val === extName));\n        }\n        Extension.isDisabled = isDisabled;\n    })(Extension = PageConfig.Extension || (PageConfig.Extension = {}));\n})(PageConfig || (exports.PageConfig = PageConfig = {}));\n//# sourceMappingURL=pageconfig.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/pageconfig.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/path.js":
/*!*********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/path.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.PathExt = void 0;\nconst path_1 = __webpack_require__(/*! path */ \"../node_modules/path-browserify/index.js\");\n/**\n * The namespace for path-related functions.\n *\n * Note that Jupyter server paths do not start with a leading slash.\n */\nvar PathExt;\n(function (PathExt) {\n    /**\n     * Join all arguments together and normalize the resulting path.\n     * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.\n     *\n     * @param paths - The string paths to join.\n     */\n    function join(...paths) {\n        const path = path_1.posix.join(...paths);\n        return path === '.' ? '' : removeSlash(path);\n    }\n    PathExt.join = join;\n    /**\n     * Join all arguments together and normalize the resulting path and preserve the leading slash.\n     *\n     * @param paths - The string paths to join.\n     */\n    function joinWithLeadingSlash(...paths) {\n        const path = path_1.posix.join(...paths);\n        return path === '.' ? '' : path;\n    }\n    PathExt.joinWithLeadingSlash = joinWithLeadingSlash;\n    /**\n     * Return the last portion of a path. Similar to the Unix basename command.\n     * Often used to extract the file name from a fully qualified path.\n     *\n     * @param path - The path to evaluate.\n     *\n     * @param ext - An extension to remove from the result.\n     */\n    function basename(path, ext) {\n        return path_1.posix.basename(path, ext);\n    }\n    PathExt.basename = basename;\n    /**\n     * Get the directory name of a path, similar to the Unix dirname command.\n     * When an empty path is given, returns the root path.\n     *\n     * @param path - The file path.\n     */\n    function dirname(path) {\n        const dir = removeSlash(path_1.posix.dirname(path));\n        return dir === '.' ? '' : dir;\n    }\n    PathExt.dirname = dirname;\n    /**\n     * Get the extension of the path.\n     *\n     * @param path - The file path.\n     *\n     * @returns the extension of the file.\n     *\n     * #### Notes\n     * The extension is the string from the last occurrence of the `.`\n     * character to end of string in the last portion of the path, inclusive.\n     * If there is no `.` in the last portion of the path, or if the first\n     * character of the basename of path [[basename]] is `.`, then an\n     * empty string is returned.\n     */\n    function extname(path) {\n        return path_1.posix.extname(path);\n    }\n    PathExt.extname = extname;\n    /**\n     * Normalize a string path, reducing '..' and '.' parts.\n     * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.\n     * When an empty path is given, returns the root path.\n     *\n     * @param path - The string path to normalize.\n     */\n    function normalize(path) {\n        if (path === '') {\n            return '';\n        }\n        return removeSlash(path_1.posix.normalize(path));\n    }\n    PathExt.normalize = normalize;\n    /**\n     * Resolve a sequence of paths or path segments into an absolute path.\n     * The root path in the application has no leading slash, so it is removed.\n     *\n     * @param parts - The paths to join.\n     *\n     * #### Notes\n     * The right-most parameter is considered \\{to\\}.  Other parameters are considered an array of \\{from\\}.\n     *\n     * Starting from leftmost \\{from\\} parameter, resolves \\{to\\} to an absolute path.\n     *\n     * If \\{to\\} isn't already absolute, \\{from\\} arguments are prepended in right to left order, until an absolute path is found. If after using all \\{from\\} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.\n     */\n    function resolve(...parts) {\n        return removeSlash(path_1.posix.resolve(...parts));\n    }\n    PathExt.resolve = resolve;\n    /**\n     * Solve the relative path from \\{from\\} to \\{to\\}.\n     *\n     * @param from - The source path.\n     *\n     * @param to - The target path.\n     *\n     * #### Notes\n     * If from and to each resolve to the same path (after calling\n     * path.resolve() on each), a zero-length string is returned.\n     * If a zero-length string is passed as from or to, `/`\n     * will be used instead of the zero-length strings.\n     */\n    function relative(from, to) {\n        return removeSlash(path_1.posix.relative(from, to));\n    }\n    PathExt.relative = relative;\n    /**\n     * Normalize a file extension to be of the type `'.foo'`.\n     *\n     * @param extension - the file extension.\n     *\n     * #### Notes\n     * Adds a leading dot if not present and converts to lower case.\n     */\n    function normalizeExtension(extension) {\n        if (extension.length > 0 && extension.indexOf('.') !== 0) {\n            extension = `.${extension}`;\n        }\n        return extension;\n    }\n    PathExt.normalizeExtension = normalizeExtension;\n    /**\n     * Remove the leading slash from a path.\n     *\n     * @param path the path from which to remove a leading slash.\n     */\n    function removeSlash(path) {\n        if (path.indexOf('/') === 0) {\n            path = path.slice(1);\n        }\n        return path;\n    }\n    PathExt.removeSlash = removeSlash;\n})(PathExt || (exports.PathExt = PathExt = {}));\n//# sourceMappingURL=path.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/path.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/signal.js":
/*!***********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/signal.js ***!
  \***********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
eval("\n/*\n * Copyright (c) Jupyter Development Team.\n * Distributed under the terms of the Modified BSD License.\n */\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.signalToPromise = signalToPromise;\nconst coreutils_1 = __webpack_require__(/*! @lumino/coreutils */ \"webpack/sharing/consume/default/@lumino/coreutils/@lumino/coreutils\");\n/**\n * Convert a signal into a promise for the first emitted value.\n *\n * @param signal - The signal we are listening to.\n * @param timeout - Timeout to wait for signal in ms (not timeout if not defined or 0)\n *\n * @returns a Promise that resolves with a `(sender, args)` pair.\n */\nfunction signalToPromise(signal, timeout) {\n    const waitForSignal = new coreutils_1.PromiseDelegate();\n    function cleanup() {\n        signal.disconnect(slot);\n    }\n    function slot(sender, args) {\n        cleanup();\n        waitForSignal.resolve([sender, args]);\n    }\n    signal.connect(slot);\n    if ((timeout !== null && timeout !== void 0 ? timeout : 0) > 0) {\n        setTimeout(() => {\n            cleanup();\n            waitForSignal.reject(`Signal not emitted within ${timeout} ms.`);\n        }, timeout);\n    }\n    return waitForSignal.promise;\n}\n//# sourceMappingURL=signal.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/signal.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/text.js":
/*!*********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/text.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Text = void 0;\n/**\n * The namespace for text-related functions.\n */\nvar Text;\n(function (Text) {\n    // javascript stores text as utf16 and string indices use \"code units\",\n    // which stores high-codepoint characters as \"surrogate pairs\",\n    // which occupy two indices in the javascript string.\n    // We need to translate cursor_pos in the Jupyter protocol (in characters)\n    // to js offset (with surrogate pairs taking two spots).\n    const HAS_SURROGATES = '𝐚'.length > 1;\n    /**\n     * Convert a javascript string index into a unicode character offset\n     *\n     * @param jsIdx - The javascript string index (counting surrogate pairs)\n     *\n     * @param text - The text in which the offset is calculated\n     *\n     * @returns The unicode character offset\n     */\n    function jsIndexToCharIndex(jsIdx, text) {\n        if (HAS_SURROGATES) {\n            // not using surrogates, nothing to do\n            return jsIdx;\n        }\n        let charIdx = jsIdx;\n        for (let i = 0; i + 1 < text.length && i < jsIdx; i++) {\n            const charCode = text.charCodeAt(i);\n            // check for surrogate pair\n            if (charCode >= 0xd800 && charCode <= 0xdbff) {\n                const nextCharCode = text.charCodeAt(i + 1);\n                if (nextCharCode >= 0xdc00 && nextCharCode <= 0xdfff) {\n                    charIdx--;\n                    i++;\n                }\n            }\n        }\n        return charIdx;\n    }\n    Text.jsIndexToCharIndex = jsIndexToCharIndex;\n    /**\n     * Convert a unicode character offset to a javascript string index.\n     *\n     * @param charIdx - The index in unicode characters\n     *\n     * @param text - The text in which the offset is calculated\n     *\n     * @returns The js-native index\n     */\n    function charIndexToJsIndex(charIdx, text) {\n        if (HAS_SURROGATES) {\n            // not using surrogates, nothing to do\n            return charIdx;\n        }\n        let jsIdx = charIdx;\n        for (let i = 0; i + 1 < text.length && i < jsIdx; i++) {\n            const charCode = text.charCodeAt(i);\n            // check for surrogate pair\n            if (charCode >= 0xd800 && charCode <= 0xdbff) {\n                const nextCharCode = text.charCodeAt(i + 1);\n                if (nextCharCode >= 0xdc00 && nextCharCode <= 0xdfff) {\n                    jsIdx++;\n                    i++;\n                }\n            }\n        }\n        return jsIdx;\n    }\n    Text.charIndexToJsIndex = charIndexToJsIndex;\n    /**\n     * Given a 'snake-case', 'snake_case', 'snake:case', or\n     * 'snake case' string, will return the camel case version: 'snakeCase'.\n     *\n     * @param str the snake-case input string.\n     *\n     * @param upper default = false. If true, the first letter of the\n     * returned string will be capitalized.\n     *\n     * @returns the camel case version of the input string.\n     */\n    function camelCase(str, upper = false) {\n        return str.replace(/^(\\w)|[\\s-_:]+(\\w)/g, function (match, p1, p2) {\n            if (p2) {\n                return p2.toUpperCase();\n            }\n            else {\n                return upper ? p1.toUpperCase() : p1.toLowerCase();\n            }\n        });\n    }\n    Text.camelCase = camelCase;\n    /**\n     * Given a string, title case the words in the string.\n     *\n     * @param str the string to title case.\n     *\n     * @returns the same string, but with each word capitalized.\n     */\n    function titleCase(str) {\n        return (str || '')\n            .toLowerCase()\n            .split(' ')\n            .map(word => word.charAt(0).toUpperCase() + word.slice(1))\n            .join(' ');\n    }\n    Text.titleCase = titleCase;\n})(Text || (exports.Text = Text = {}));\n//# sourceMappingURL=text.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/text.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/time.js":
/*!*********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/time.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.Time = void 0;\n/**\n * A list of time units with their associated value in milliseconds.\n */\nconst UNITS = [\n    { name: 'years', milliseconds: 365 * 24 * 60 * 60 * 1000 },\n    { name: 'months', milliseconds: 30 * 24 * 60 * 60 * 1000 },\n    { name: 'days', milliseconds: 24 * 60 * 60 * 1000 },\n    { name: 'hours', milliseconds: 60 * 60 * 1000 },\n    { name: 'minutes', milliseconds: 60 * 1000 },\n    { name: 'seconds', milliseconds: 1000 }\n];\n/**\n * The namespace for date functions.\n */\nvar Time;\n(function (Time) {\n    /**\n     * Convert a timestring to a human readable string (e.g. 'two minutes ago').\n     *\n     * @param value - The date timestring or date object.\n     *\n     * @returns A formatted date.\n     */\n    function formatHuman(value, format = 'long') {\n        const lang = document.documentElement.lang || 'en';\n        const formatter = new Intl.RelativeTimeFormat(lang, {\n            numeric: 'auto',\n            style: format\n        });\n        const delta = new Date(value).getTime() - Date.now();\n        for (let unit of UNITS) {\n            const amount = Math.ceil(delta / unit.milliseconds);\n            if (amount === 0) {\n                continue;\n            }\n            return formatter.format(amount, unit.name);\n        }\n        return formatter.format(0, 'seconds');\n    }\n    Time.formatHuman = formatHuman;\n    /**\n     * Convenient helper to convert a timestring to a date format.\n     *\n     * @param value - The date timestring or date object.\n     *\n     * @returns A formatted date.\n     */\n    function format(value) {\n        const lang = document.documentElement.lang || 'en';\n        const formatter = new Intl.DateTimeFormat(lang, {\n            dateStyle: 'short',\n            timeStyle: 'short'\n        });\n        return formatter.format(new Date(value));\n    }\n    Time.format = format;\n})(Time || (exports.Time = Time = {}));\n//# sourceMappingURL=time.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/time.js?");

/***/ }),

/***/ "../node_modules/@jupyterlab/coreutils/lib/url.js":
/*!********************************************************!*\
  !*** ../node_modules/@jupyterlab/coreutils/lib/url.js ***!
  \********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";
eval("\n// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", ({ value: true }));\nexports.URLExt = void 0;\nconst path_1 = __webpack_require__(/*! path */ \"../node_modules/path-browserify/index.js\");\nconst url_parse_1 = __importDefault(__webpack_require__(/*! url-parse */ \"../node_modules/url-parse/index.js\"));\n/**\n * The namespace for URL-related functions.\n */\nvar URLExt;\n(function (URLExt) {\n    /**\n     * Parse a url into a URL object.\n     *\n     * @param url - The URL string to parse.\n     *\n     * @returns A URL object.\n     */\n    function parse(url) {\n        if (typeof document !== 'undefined' && document) {\n            const a = document.createElement('a');\n            a.href = url;\n            return a;\n        }\n        return (0, url_parse_1.default)(url);\n    }\n    URLExt.parse = parse;\n    /**\n     * Parse URL and retrieve hostname\n     *\n     * @param url - The URL string to parse\n     *\n     * @returns a hostname string value\n     */\n    function getHostName(url) {\n        return (0, url_parse_1.default)(url).hostname;\n    }\n    URLExt.getHostName = getHostName;\n    function normalize(url) {\n        return url && parse(url).toString();\n    }\n    URLExt.normalize = normalize;\n    /**\n     * Join a sequence of url components and normalizes as in node `path.join`.\n     *\n     * @param parts - The url components.\n     *\n     * @returns the joined url.\n     */\n    function join(...parts) {\n        let u = (0, url_parse_1.default)(parts[0], {});\n        // Schema-less URL can be only parsed as relative to a base URL\n        // see https://github.com/unshiftio/url-parse/issues/219#issuecomment-1002219326\n        const isSchemaLess = u.protocol === '' && u.slashes;\n        if (isSchemaLess) {\n            u = (0, url_parse_1.default)(parts[0], 'https:' + parts[0]);\n        }\n        const prefix = `${isSchemaLess ? '' : u.protocol}${u.slashes ? '//' : ''}${u.auth}${u.auth ? '@' : ''}${u.host}`;\n        // If there was a prefix, then the first path must start at the root.\n        const path = path_1.posix.join(`${!!prefix && u.pathname[0] !== '/' ? '/' : ''}${u.pathname}`, ...parts.slice(1));\n        return `${prefix}${path === '.' ? '' : path}`;\n    }\n    URLExt.join = join;\n    /**\n     * Encode the components of a multi-segment url.\n     *\n     * @param url - The url to encode.\n     *\n     * @returns the encoded url.\n     *\n     * #### Notes\n     * Preserves the `'/'` separators.\n     * Should not include the base url, since all parts are escaped.\n     */\n    function encodeParts(url) {\n        return join(...url.split('/').map(encodeURIComponent));\n    }\n    URLExt.encodeParts = encodeParts;\n    /**\n     * Return a serialized object string suitable for a query.\n     *\n     * @param value The source object.\n     *\n     * @returns an encoded url query.\n     *\n     * #### Notes\n     * Modified version of [stackoverflow](http://stackoverflow.com/a/30707423).\n     */\n    function objectToQueryString(value) {\n        const keys = Object.keys(value).filter(key => key.length > 0);\n        if (!keys.length) {\n            return '';\n        }\n        return ('?' +\n            keys\n                .map(key => {\n                const content = encodeURIComponent(String(value[key]));\n                return key + (content ? '=' + content : '');\n            })\n                .join('&'));\n    }\n    URLExt.objectToQueryString = objectToQueryString;\n    /**\n     * Return a parsed object that represents the values in a query string.\n     */\n    function queryStringToObject(value) {\n        return value\n            .replace(/^\\?/, '')\n            .split('&')\n            .reduce((acc, val) => {\n            const [key, value] = val.split('=');\n            if (key.length > 0) {\n                acc[key] = decodeURIComponent(value || '');\n            }\n            return acc;\n        }, {});\n    }\n    URLExt.queryStringToObject = queryStringToObject;\n    /**\n     * Test whether the url is a local url.\n     *\n     * @param allowRoot - Whether the paths starting at Unix-style filesystem root (`/`) are permitted.\n     *\n     * #### Notes\n     * This function returns `false` for any fully qualified url, including\n     * `data:`, `file:`, and `//` protocol URLs.\n     */\n    function isLocal(url, allowRoot = false) {\n        const { protocol } = parse(url);\n        return ((!protocol || url.toLowerCase().indexOf(protocol) !== 0) &&\n            (allowRoot ? url.indexOf('//') !== 0 : url.indexOf('/') !== 0));\n    }\n    URLExt.isLocal = isLocal;\n})(URLExt || (exports.URLExt = URLExt = {}));\n//# sourceMappingURL=url.js.map\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@jupyterlab/coreutils/lib/url.js?");

/***/ }),

/***/ "../node_modules/minimist/index.js":
/*!*****************************************!*\
  !*** ../node_modules/minimist/index.js ***!
  \*****************************************/
/***/ ((module) => {

"use strict";
eval("\n\nfunction hasKey(obj, keys) {\n\tvar o = obj;\n\tkeys.slice(0, -1).forEach(function (key) {\n\t\to = o[key] || {};\n\t});\n\n\tvar key = keys[keys.length - 1];\n\treturn key in o;\n}\n\nfunction isNumber(x) {\n\tif (typeof x === 'number') { return true; }\n\tif ((/^0x[0-9a-f]+$/i).test(x)) { return true; }\n\treturn (/^[-+]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(e[-+]?\\d+)?$/).test(x);\n}\n\nfunction isConstructorOrProto(obj, key) {\n\treturn (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';\n}\n\nmodule.exports = function (args, opts) {\n\tif (!opts) { opts = {}; }\n\n\tvar flags = {\n\t\tbools: {},\n\t\tstrings: {},\n\t\tunknownFn: null,\n\t};\n\n\tif (typeof opts.unknown === 'function') {\n\t\tflags.unknownFn = opts.unknown;\n\t}\n\n\tif (typeof opts.boolean === 'boolean' && opts.boolean) {\n\t\tflags.allBools = true;\n\t} else {\n\t\t[].concat(opts.boolean).filter(Boolean).forEach(function (key) {\n\t\t\tflags.bools[key] = true;\n\t\t});\n\t}\n\n\tvar aliases = {};\n\n\tfunction aliasIsBoolean(key) {\n\t\treturn aliases[key].some(function (x) {\n\t\t\treturn flags.bools[x];\n\t\t});\n\t}\n\n\tObject.keys(opts.alias || {}).forEach(function (key) {\n\t\taliases[key] = [].concat(opts.alias[key]);\n\t\taliases[key].forEach(function (x) {\n\t\t\taliases[x] = [key].concat(aliases[key].filter(function (y) {\n\t\t\t\treturn x !== y;\n\t\t\t}));\n\t\t});\n\t});\n\n\t[].concat(opts.string).filter(Boolean).forEach(function (key) {\n\t\tflags.strings[key] = true;\n\t\tif (aliases[key]) {\n\t\t\t[].concat(aliases[key]).forEach(function (k) {\n\t\t\t\tflags.strings[k] = true;\n\t\t\t});\n\t\t}\n\t});\n\n\tvar defaults = opts.default || {};\n\n\tvar argv = { _: [] };\n\n\tfunction argDefined(key, arg) {\n\t\treturn (flags.allBools && (/^--[^=]+$/).test(arg))\n\t\t\t|| flags.strings[key]\n\t\t\t|| flags.bools[key]\n\t\t\t|| aliases[key];\n\t}\n\n\tfunction setKey(obj, keys, value) {\n\t\tvar o = obj;\n\t\tfor (var i = 0; i < keys.length - 1; i++) {\n\t\t\tvar key = keys[i];\n\t\t\tif (isConstructorOrProto(o, key)) { return; }\n\t\t\tif (o[key] === undefined) { o[key] = {}; }\n\t\t\tif (\n\t\t\t\to[key] === Object.prototype\n\t\t\t\t|| o[key] === Number.prototype\n\t\t\t\t|| o[key] === String.prototype\n\t\t\t) {\n\t\t\t\to[key] = {};\n\t\t\t}\n\t\t\tif (o[key] === Array.prototype) { o[key] = []; }\n\t\t\to = o[key];\n\t\t}\n\n\t\tvar lastKey = keys[keys.length - 1];\n\t\tif (isConstructorOrProto(o, lastKey)) { return; }\n\t\tif (\n\t\t\to === Object.prototype\n\t\t\t|| o === Number.prototype\n\t\t\t|| o === String.prototype\n\t\t) {\n\t\t\to = {};\n\t\t}\n\t\tif (o === Array.prototype) { o = []; }\n\t\tif (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') {\n\t\t\to[lastKey] = value;\n\t\t} else if (Array.isArray(o[lastKey])) {\n\t\t\to[lastKey].push(value);\n\t\t} else {\n\t\t\to[lastKey] = [o[lastKey], value];\n\t\t}\n\t}\n\n\tfunction setArg(key, val, arg) {\n\t\tif (arg && flags.unknownFn && !argDefined(key, arg)) {\n\t\t\tif (flags.unknownFn(arg) === false) { return; }\n\t\t}\n\n\t\tvar value = !flags.strings[key] && isNumber(val)\n\t\t\t? Number(val)\n\t\t\t: val;\n\t\tsetKey(argv, key.split('.'), value);\n\n\t\t(aliases[key] || []).forEach(function (x) {\n\t\t\tsetKey(argv, x.split('.'), value);\n\t\t});\n\t}\n\n\tObject.keys(flags.bools).forEach(function (key) {\n\t\tsetArg(key, defaults[key] === undefined ? false : defaults[key]);\n\t});\n\n\tvar notFlags = [];\n\n\tif (args.indexOf('--') !== -1) {\n\t\tnotFlags = args.slice(args.indexOf('--') + 1);\n\t\targs = args.slice(0, args.indexOf('--'));\n\t}\n\n\tfor (var i = 0; i < args.length; i++) {\n\t\tvar arg = args[i];\n\t\tvar key;\n\t\tvar next;\n\n\t\tif ((/^--.+=/).test(arg)) {\n\t\t\t// Using [\\s\\S] instead of . because js doesn't support the\n\t\t\t// 'dotall' regex modifier. See:\n\t\t\t// http://stackoverflow.com/a/1068308/13216\n\t\t\tvar m = arg.match(/^--([^=]+)=([\\s\\S]*)$/);\n\t\t\tkey = m[1];\n\t\t\tvar value = m[2];\n\t\t\tif (flags.bools[key]) {\n\t\t\t\tvalue = value !== 'false';\n\t\t\t}\n\t\t\tsetArg(key, value, arg);\n\t\t} else if ((/^--no-.+/).test(arg)) {\n\t\t\tkey = arg.match(/^--no-(.+)/)[1];\n\t\t\tsetArg(key, false, arg);\n\t\t} else if ((/^--.+/).test(arg)) {\n\t\t\tkey = arg.match(/^--(.+)/)[1];\n\t\t\tnext = args[i + 1];\n\t\t\tif (\n\t\t\t\tnext !== undefined\n\t\t\t\t&& !(/^(-|--)[^-]/).test(next)\n\t\t\t\t&& !flags.bools[key]\n\t\t\t\t&& !flags.allBools\n\t\t\t\t&& (aliases[key] ? !aliasIsBoolean(key) : true)\n\t\t\t) {\n\t\t\t\tsetArg(key, next, arg);\n\t\t\t\ti += 1;\n\t\t\t} else if ((/^(true|false)$/).test(next)) {\n\t\t\t\tsetArg(key, next === 'true', arg);\n\t\t\t\ti += 1;\n\t\t\t} else {\n\t\t\t\tsetArg(key, flags.strings[key] ? '' : true, arg);\n\t\t\t}\n\t\t} else if ((/^-[^-]+/).test(arg)) {\n\t\t\tvar letters = arg.slice(1, -1).split('');\n\n\t\t\tvar broken = false;\n\t\t\tfor (var j = 0; j < letters.length; j++) {\n\t\t\t\tnext = arg.slice(j + 2);\n\n\t\t\t\tif (next === '-') {\n\t\t\t\t\tsetArg(letters[j], next, arg);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tif ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') {\n\t\t\t\t\tsetArg(letters[j], next.slice(1), arg);\n\t\t\t\t\tbroken = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\t(/[A-Za-z]/).test(letters[j])\n\t\t\t\t\t&& (/-?\\d+(\\.\\d*)?(e-?\\d+)?$/).test(next)\n\t\t\t\t) {\n\t\t\t\t\tsetArg(letters[j], next, arg);\n\t\t\t\t\tbroken = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (letters[j + 1] && letters[j + 1].match(/\\W/)) {\n\t\t\t\t\tsetArg(letters[j], arg.slice(j + 2), arg);\n\t\t\t\t\tbroken = true;\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tsetArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tkey = arg.slice(-1)[0];\n\t\t\tif (!broken && key !== '-') {\n\t\t\t\tif (\n\t\t\t\t\targs[i + 1]\n\t\t\t\t\t&& !(/^(-|--)[^-]/).test(args[i + 1])\n\t\t\t\t\t&& !flags.bools[key]\n\t\t\t\t\t&& (aliases[key] ? !aliasIsBoolean(key) : true)\n\t\t\t\t) {\n\t\t\t\t\tsetArg(key, args[i + 1], arg);\n\t\t\t\t\ti += 1;\n\t\t\t\t} else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) {\n\t\t\t\t\tsetArg(key, args[i + 1] === 'true', arg);\n\t\t\t\t\ti += 1;\n\t\t\t\t} else {\n\t\t\t\t\tsetArg(key, flags.strings[key] ? '' : true, arg);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (!flags.unknownFn || flags.unknownFn(arg) !== false) {\n\t\t\t\targv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));\n\t\t\t}\n\t\t\tif (opts.stopEarly) {\n\t\t\t\targv._.push.apply(argv._, args.slice(i + 1));\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tObject.keys(defaults).forEach(function (k) {\n\t\tif (!hasKey(argv, k.split('.'))) {\n\t\t\tsetKey(argv, k.split('.'), defaults[k]);\n\n\t\t\t(aliases[k] || []).forEach(function (x) {\n\t\t\t\tsetKey(argv, x.split('.'), defaults[k]);\n\t\t\t});\n\t\t}\n\t});\n\n\tif (opts['--']) {\n\t\targv['--'] = notFlags.slice();\n\t} else {\n\t\tnotFlags.forEach(function (k) {\n\t\t\targv._.push(k);\n\t\t});\n\t}\n\n\treturn argv;\n};\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/minimist/index.js?");

/***/ }),

/***/ "../node_modules/path-browserify/index.js":
/*!************************************************!*\
  !*** ../node_modules/path-browserify/index.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
eval("/* provided dependency */ var process = __webpack_require__(/*! process/browser */ \"../node_modules/process/browser.js\");\n// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/path-browserify/index.js?");

/***/ }),

/***/ "../node_modules/process/browser.js":
/*!******************************************!*\
  !*** ../node_modules/process/browser.js ***!
  \******************************************/
/***/ ((module) => {

eval("// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/process/browser.js?");

/***/ }),

/***/ "../node_modules/querystringify/index.js":
/*!***********************************************!*\
  !*** ../node_modules/querystringify/index.js ***!
  \***********************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
eval("\n\nvar has = Object.prototype.hasOwnProperty\n  , undef;\n\n/**\n * Decode a URI encoded string.\n *\n * @param {String} input The URI encoded string.\n * @returns {String|Null} The decoded string.\n * @api private\n */\nfunction decode(input) {\n  try {\n    return decodeURIComponent(input.replace(/\\+/g, ' '));\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Attempts to encode a given input.\n *\n * @param {String} input The string that needs to be encoded.\n * @returns {String|Null} The encoded string.\n * @api private\n */\nfunction encode(input) {\n  try {\n    return encodeURIComponent(input);\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Simple query string parser.\n *\n * @param {String} query The query string that needs to be parsed.\n * @returns {Object}\n * @api public\n */\nfunction querystring(query) {\n  var parser = /([^=?#&]+)=?([^&]*)/g\n    , result = {}\n    , part;\n\n  while (part = parser.exec(query)) {\n    var key = decode(part[1])\n      , value = decode(part[2]);\n\n    //\n    // Prevent overriding of existing properties. This ensures that build-in\n    // methods like `toString` or __proto__ are not overriden by malicious\n    // querystrings.\n    //\n    // In the case if failed decoding, we want to omit the key/value pairs\n    // from the result.\n    //\n    if (key === null || value === null || key in result) continue;\n    result[key] = value;\n  }\n\n  return result;\n}\n\n/**\n * Transform a query string to an object.\n *\n * @param {Object} obj Object that should be transformed.\n * @param {String} prefix Optional prefix.\n * @returns {String}\n * @api public\n */\nfunction querystringify(obj, prefix) {\n  prefix = prefix || '';\n\n  var pairs = []\n    , value\n    , key;\n\n  //\n  // Optionally prefix with a '?' if needed\n  //\n  if ('string' !== typeof prefix) prefix = '?';\n\n  for (key in obj) {\n    if (has.call(obj, key)) {\n      value = obj[key];\n\n      //\n      // Edge cases where we actually want to encode the value to an empty\n      // string instead of the stringified value.\n      //\n      if (!value && (value === null || value === undef || isNaN(value))) {\n        value = '';\n      }\n\n      key = encode(key);\n      value = encode(value);\n\n      //\n      // If we failed to encode the strings, we should bail out as we don't\n      // want to add invalid strings to the query.\n      //\n      if (key === null || value === null) continue;\n      pairs.push(key +'='+ value);\n    }\n  }\n\n  return pairs.length ? prefix + pairs.join('&') : '';\n}\n\n//\n// Expose the module.\n//\nexports.stringify = querystringify;\nexports.parse = querystring;\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/querystringify/index.js?");

/***/ }),

/***/ "../node_modules/requires-port/index.js":
/*!**********************************************!*\
  !*** ../node_modules/requires-port/index.js ***!
  \**********************************************/
/***/ ((module) => {

"use strict";
eval("\n\n/**\n * Check if we're required to add a port number.\n *\n * @see https://url.spec.whatwg.org/#default-port\n * @param {Number|String} port Port number we need to check\n * @param {String} protocol Protocol we need to check against.\n * @returns {Boolean} Is it a default port for the given protocol\n * @api private\n */\nmodule.exports = function required(port, protocol) {\n  protocol = protocol.split(':')[0];\n  port = +port;\n\n  if (!port) return false;\n\n  switch (protocol) {\n    case 'http':\n    case 'ws':\n    return port !== 80;\n\n    case 'https':\n    case 'wss':\n    return port !== 443;\n\n    case 'ftp':\n    return port !== 21;\n\n    case 'gopher':\n    return port !== 70;\n\n    case 'file':\n    return false;\n  }\n\n  return port !== 0;\n};\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/requires-port/index.js?");

/***/ }),

/***/ "../node_modules/url-parse/index.js":
/*!******************************************!*\
  !*** ../node_modules/url-parse/index.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
eval("\n\nvar required = __webpack_require__(/*! requires-port */ \"../node_modules/requires-port/index.js\")\n  , qs = __webpack_require__(/*! querystringify */ \"../node_modules/querystringify/index.js\")\n  , controlOrWhitespace = /^[\\x00-\\x20\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]+/\n  , CRHTLF = /[\\n\\r\\t]/g\n  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//\n  , port = /:\\d+$/\n  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\\\/]+)?([\\S\\s]*)/i\n  , windowsDriveLetter = /^[a-zA-Z]:/;\n\n/**\n * Remove control characters and whitespace from the beginning of a string.\n *\n * @param {Object|String} str String to trim.\n * @returns {String} A new string representing `str` stripped of control\n *     characters and whitespace from its beginning.\n * @public\n */\nfunction trimLeft(str) {\n  return (str ? str : '').toString().replace(controlOrWhitespace, '');\n}\n\n/**\n * These are the parse rules for the URL parser, it informs the parser\n * about:\n *\n * 0. The char it Needs to parse, if it's a string it should be done using\n *    indexOf, RegExp using exec and NaN means set as current value.\n * 1. The property we should set when parsing this value.\n * 2. Indication if it's backwards or forward parsing, when set as number it's\n *    the value of extra chars that should be split off.\n * 3. Inherit from location if non existing in the parser.\n * 4. `toLowerCase` the resulting value.\n */\nvar rules = [\n  ['#', 'hash'],                        // Extract from the back.\n  ['?', 'query'],                       // Extract from the back.\n  function sanitize(address, url) {     // Sanitize what is left of the address\n    return isSpecial(url.protocol) ? address.replace(/\\\\/g, '/') : address;\n  },\n  ['/', 'pathname'],                    // Extract from the back.\n  ['@', 'auth', 1],                     // Extract from the front.\n  [NaN, 'host', undefined, 1, 1],       // Set left over value.\n  [/:(\\d*)$/, 'port', undefined, 1],    // RegExp the back.\n  [NaN, 'hostname', undefined, 1, 1]    // Set left over.\n];\n\n/**\n * These properties should not be copied or inherited from. This is only needed\n * for all non blob URL's as a blob URL does not include a hash, only the\n * origin.\n *\n * @type {Object}\n * @private\n */\nvar ignore = { hash: 1, query: 1 };\n\n/**\n * The location object differs when your code is loaded through a normal page,\n * Worker or through a worker using a blob. And with the blobble begins the\n * trouble as the location object will contain the URL of the blob, not the\n * location of the page where our code is loaded in. The actual origin is\n * encoded in the `pathname` so we can thankfully generate a good \"default\"\n * location from it so we can generate proper relative URL's again.\n *\n * @param {Object|String} loc Optional default location object.\n * @returns {Object} lolcation object.\n * @public\n */\nfunction lolcation(loc) {\n  var globalVar;\n\n  if (typeof window !== 'undefined') globalVar = window;\n  else if (typeof __webpack_require__.g !== 'undefined') globalVar = __webpack_require__.g;\n  else if (typeof self !== 'undefined') globalVar = self;\n  else globalVar = {};\n\n  var location = globalVar.location || {};\n  loc = loc || location;\n\n  var finaldestination = {}\n    , type = typeof loc\n    , key;\n\n  if ('blob:' === loc.protocol) {\n    finaldestination = new Url(unescape(loc.pathname), {});\n  } else if ('string' === type) {\n    finaldestination = new Url(loc, {});\n    for (key in ignore) delete finaldestination[key];\n  } else if ('object' === type) {\n    for (key in loc) {\n      if (key in ignore) continue;\n      finaldestination[key] = loc[key];\n    }\n\n    if (finaldestination.slashes === undefined) {\n      finaldestination.slashes = slashes.test(loc.href);\n    }\n  }\n\n  return finaldestination;\n}\n\n/**\n * Check whether a protocol scheme is special.\n *\n * @param {String} The protocol scheme of the URL\n * @return {Boolean} `true` if the protocol scheme is special, else `false`\n * @private\n */\nfunction isSpecial(scheme) {\n  return (\n    scheme === 'file:' ||\n    scheme === 'ftp:' ||\n    scheme === 'http:' ||\n    scheme === 'https:' ||\n    scheme === 'ws:' ||\n    scheme === 'wss:'\n  );\n}\n\n/**\n * @typedef ProtocolExtract\n * @type Object\n * @property {String} protocol Protocol matched in the URL, in lowercase.\n * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n * @property {String} rest Rest of the URL that is not part of the protocol.\n */\n\n/**\n * Extract protocol information from a URL with/without double slash (\"//\").\n *\n * @param {String} address URL we want to extract from.\n * @param {Object} location\n * @return {ProtocolExtract} Extracted information.\n * @private\n */\nfunction extractProtocol(address, location) {\n  address = trimLeft(address);\n  address = address.replace(CRHTLF, '');\n  location = location || {};\n\n  var match = protocolre.exec(address);\n  var protocol = match[1] ? match[1].toLowerCase() : '';\n  var forwardSlashes = !!match[2];\n  var otherSlashes = !!match[3];\n  var slashesCount = 0;\n  var rest;\n\n  if (forwardSlashes) {\n    if (otherSlashes) {\n      rest = match[2] + match[3] + match[4];\n      slashesCount = match[2].length + match[3].length;\n    } else {\n      rest = match[2] + match[4];\n      slashesCount = match[2].length;\n    }\n  } else {\n    if (otherSlashes) {\n      rest = match[3] + match[4];\n      slashesCount = match[3].length;\n    } else {\n      rest = match[4]\n    }\n  }\n\n  if (protocol === 'file:') {\n    if (slashesCount >= 2) {\n      rest = rest.slice(2);\n    }\n  } else if (isSpecial(protocol)) {\n    rest = match[4];\n  } else if (protocol) {\n    if (forwardSlashes) {\n      rest = rest.slice(2);\n    }\n  } else if (slashesCount >= 2 && isSpecial(location.protocol)) {\n    rest = match[4];\n  }\n\n  return {\n    protocol: protocol,\n    slashes: forwardSlashes || isSpecial(protocol),\n    slashesCount: slashesCount,\n    rest: rest\n  };\n}\n\n/**\n * Resolve a relative URL pathname against a base URL pathname.\n *\n * @param {String} relative Pathname of the relative URL.\n * @param {String} base Pathname of the base URL.\n * @return {String} Resolved pathname.\n * @private\n */\nfunction resolve(relative, base) {\n  if (relative === '') return base;\n\n  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))\n    , i = path.length\n    , last = path[i - 1]\n    , unshift = false\n    , up = 0;\n\n  while (i--) {\n    if (path[i] === '.') {\n      path.splice(i, 1);\n    } else if (path[i] === '..') {\n      path.splice(i, 1);\n      up++;\n    } else if (up) {\n      if (i === 0) unshift = true;\n      path.splice(i, 1);\n      up--;\n    }\n  }\n\n  if (unshift) path.unshift('');\n  if (last === '.' || last === '..') path.push('');\n\n  return path.join('/');\n}\n\n/**\n * The actual URL instance. Instead of returning an object we've opted-in to\n * create an actual constructor as it's much more memory efficient and\n * faster and it pleases my OCD.\n *\n * It is worth noting that we should not use `URL` as class name to prevent\n * clashes with the global URL instance that got introduced in browsers.\n *\n * @constructor\n * @param {String} address URL we want to parse.\n * @param {Object|String} [location] Location defaults for relative paths.\n * @param {Boolean|Function} [parser] Parser for the query string.\n * @private\n */\nfunction Url(address, location, parser) {\n  address = trimLeft(address);\n  address = address.replace(CRHTLF, '');\n\n  if (!(this instanceof Url)) {\n    return new Url(address, location, parser);\n  }\n\n  var relative, extracted, parse, instruction, index, key\n    , instructions = rules.slice()\n    , type = typeof location\n    , url = this\n    , i = 0;\n\n  //\n  // The following if statements allows this module two have compatibility with\n  // 2 different API:\n  //\n  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n  //    where the boolean indicates that the query string should also be parsed.\n  //\n  // 2. The `URL` interface of the browser which accepts a URL, object as\n  //    arguments. The supplied object will be used as default values / fall-back\n  //    for relative paths.\n  //\n  if ('object' !== type && 'string' !== type) {\n    parser = location;\n    location = null;\n  }\n\n  if (parser && 'function' !== typeof parser) parser = qs.parse;\n\n  location = lolcation(location);\n\n  //\n  // Extract protocol information before running the instructions.\n  //\n  extracted = extractProtocol(address || '', location);\n  relative = !extracted.protocol && !extracted.slashes;\n  url.slashes = extracted.slashes || relative && location.slashes;\n  url.protocol = extracted.protocol || location.protocol || '';\n  address = extracted.rest;\n\n  //\n  // When the authority component is absent the URL starts with a path\n  // component.\n  //\n  if (\n    extracted.protocol === 'file:' && (\n      extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) ||\n    (!extracted.slashes &&\n      (extracted.protocol ||\n        extracted.slashesCount < 2 ||\n        !isSpecial(url.protocol)))\n  ) {\n    instructions[3] = [/(.*)/, 'pathname'];\n  }\n\n  for (; i < instructions.length; i++) {\n    instruction = instructions[i];\n\n    if (typeof instruction === 'function') {\n      address = instruction(address, url);\n      continue;\n    }\n\n    parse = instruction[0];\n    key = instruction[1];\n\n    if (parse !== parse) {\n      url[key] = address;\n    } else if ('string' === typeof parse) {\n      index = parse === '@'\n        ? address.lastIndexOf(parse)\n        : address.indexOf(parse);\n\n      if (~index) {\n        if ('number' === typeof instruction[2]) {\n          url[key] = address.slice(0, index);\n          address = address.slice(index + instruction[2]);\n        } else {\n          url[key] = address.slice(index);\n          address = address.slice(0, index);\n        }\n      }\n    } else if ((index = parse.exec(address))) {\n      url[key] = index[1];\n      address = address.slice(0, index.index);\n    }\n\n    url[key] = url[key] || (\n      relative && instruction[3] ? location[key] || '' : ''\n    );\n\n    //\n    // Hostname, host and protocol should be lowercased so they can be used to\n    // create a proper `origin`.\n    //\n    if (instruction[4]) url[key] = url[key].toLowerCase();\n  }\n\n  //\n  // Also parse the supplied query string in to an object. If we're supplied\n  // with a custom parser as function use that instead of the default build-in\n  // parser.\n  //\n  if (parser) url.query = parser(url.query);\n\n  //\n  // If the URL is relative, resolve the pathname against the base URL.\n  //\n  if (\n      relative\n    && location.slashes\n    && url.pathname.charAt(0) !== '/'\n    && (url.pathname !== '' || location.pathname !== '')\n  ) {\n    url.pathname = resolve(url.pathname, location.pathname);\n  }\n\n  //\n  // Default to a / for pathname if none exists. This normalizes the URL\n  // to always have a /\n  //\n  if (url.pathname.charAt(0) !== '/' && isSpecial(url.protocol)) {\n    url.pathname = '/' + url.pathname;\n  }\n\n  //\n  // We should not add port numbers if they are already the default port number\n  // for a given protocol. As the host also contains the port number we're going\n  // override it with the hostname which contains no port number.\n  //\n  if (!required(url.port, url.protocol)) {\n    url.host = url.hostname;\n    url.port = '';\n  }\n\n  //\n  // Parse down the `auth` for the username and password.\n  //\n  url.username = url.password = '';\n\n  if (url.auth) {\n    index = url.auth.indexOf(':');\n\n    if (~index) {\n      url.username = url.auth.slice(0, index);\n      url.username = encodeURIComponent(decodeURIComponent(url.username));\n\n      url.password = url.auth.slice(index + 1);\n      url.password = encodeURIComponent(decodeURIComponent(url.password))\n    } else {\n      url.username = encodeURIComponent(decodeURIComponent(url.auth));\n    }\n\n    url.auth = url.password ? url.username +':'+ url.password : url.username;\n  }\n\n  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  //\n  // The href is just the compiled result.\n  //\n  url.href = url.toString();\n}\n\n/**\n * This is convenience method for changing properties in the URL instance to\n * insure that they all propagate correctly.\n *\n * @param {String} part          Property we need to adjust.\n * @param {Mixed} value          The newly assigned value.\n * @param {Boolean|Function} fn  When setting the query, it will be the function\n *                               used to parse the query.\n *                               When setting the protocol, double slash will be\n *                               removed from the final url if it is true.\n * @returns {URL} URL instance for chaining.\n * @public\n */\nfunction set(part, value, fn) {\n  var url = this;\n\n  switch (part) {\n    case 'query':\n      if ('string' === typeof value && value.length) {\n        value = (fn || qs.parse)(value);\n      }\n\n      url[part] = value;\n      break;\n\n    case 'port':\n      url[part] = value;\n\n      if (!required(value, url.protocol)) {\n        url.host = url.hostname;\n        url[part] = '';\n      } else if (value) {\n        url.host = url.hostname +':'+ value;\n      }\n\n      break;\n\n    case 'hostname':\n      url[part] = value;\n\n      if (url.port) value += ':'+ url.port;\n      url.host = value;\n      break;\n\n    case 'host':\n      url[part] = value;\n\n      if (port.test(value)) {\n        value = value.split(':');\n        url.port = value.pop();\n        url.hostname = value.join(':');\n      } else {\n        url.hostname = value;\n        url.port = '';\n      }\n\n      break;\n\n    case 'protocol':\n      url.protocol = value.toLowerCase();\n      url.slashes = !fn;\n      break;\n\n    case 'pathname':\n    case 'hash':\n      if (value) {\n        var char = part === 'pathname' ? '/' : '#';\n        url[part] = value.charAt(0) !== char ? char + value : value;\n      } else {\n        url[part] = value;\n      }\n      break;\n\n    case 'username':\n    case 'password':\n      url[part] = encodeURIComponent(value);\n      break;\n\n    case 'auth':\n      var index = value.indexOf(':');\n\n      if (~index) {\n        url.username = value.slice(0, index);\n        url.username = encodeURIComponent(decodeURIComponent(url.username));\n\n        url.password = value.slice(index + 1);\n        url.password = encodeURIComponent(decodeURIComponent(url.password));\n      } else {\n        url.username = encodeURIComponent(decodeURIComponent(value));\n      }\n  }\n\n  for (var i = 0; i < rules.length; i++) {\n    var ins = rules[i];\n\n    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();\n  }\n\n  url.auth = url.password ? url.username +':'+ url.password : url.username;\n\n  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  url.href = url.toString();\n\n  return url;\n}\n\n/**\n * Transform the properties back in to a valid and full URL string.\n *\n * @param {Function} stringify Optional query stringify function.\n * @returns {String} Compiled version of the URL.\n * @public\n */\nfunction toString(stringify) {\n  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;\n\n  var query\n    , url = this\n    , host = url.host\n    , protocol = url.protocol;\n\n  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';\n\n  var result =\n    protocol +\n    ((url.protocol && url.slashes) || isSpecial(url.protocol) ? '//' : '');\n\n  if (url.username) {\n    result += url.username;\n    if (url.password) result += ':'+ url.password;\n    result += '@';\n  } else if (url.password) {\n    result += ':'+ url.password;\n    result += '@';\n  } else if (\n    url.protocol !== 'file:' &&\n    isSpecial(url.protocol) &&\n    !host &&\n    url.pathname !== '/'\n  ) {\n    //\n    // Add back the empty userinfo, otherwise the original invalid URL\n    // might be transformed into a valid one with `url.pathname` as host.\n    //\n    result += '@';\n  }\n\n  //\n  // Trailing colon is removed from `url.host` when it is parsed. If it still\n  // ends with a colon, then add back the trailing colon that was removed. This\n  // prevents an invalid URL from being transformed into a valid one.\n  //\n  if (host[host.length - 1] === ':' || (port.test(url.hostname) && !url.port)) {\n    host += ':';\n  }\n\n  result += host + url.pathname;\n\n  query = 'object' === typeof url.query ? stringify(url.query) : url.query;\n  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;\n\n  if (url.hash) result += url.hash;\n\n  return result;\n}\n\nUrl.prototype = { set: set, toString: toString };\n\n//\n// Expose the URL parser and some additional properties that might be useful for\n// others or testing.\n//\nUrl.extractProtocol = extractProtocol;\nUrl.location = lolcation;\nUrl.trimLeft = trimLeft;\nUrl.qs = qs;\n\nmodule.exports = Url;\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/url-parse/index.js?");

/***/ })

}]);