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

/***/ "../node_modules/@lumino/polling/dist/index.es6.js":
/*!*********************************************************!*\
  !*** ../node_modules/@lumino/polling/dist/index.es6.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   \"Debouncer\": () => (/* binding */ Debouncer),\n/* harmony export */   \"Poll\": () => (/* binding */ Poll),\n/* harmony export */   \"RateLimiter\": () => (/* binding */ RateLimiter),\n/* harmony export */   \"Throttler\": () => (/* binding */ Throttler)\n/* harmony export */ });\n/* harmony import */ var _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @lumino/coreutils */ \"webpack/sharing/consume/default/@lumino/coreutils/@lumino/coreutils\");\n/* harmony import */ var _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _lumino_signaling__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @lumino/signaling */ \"webpack/sharing/consume/default/@lumino/signaling/@lumino/signaling\");\n/* harmony import */ var _lumino_signaling__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_lumino_signaling__WEBPACK_IMPORTED_MODULE_1__);\n\n\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nfunction __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nfunction __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\n\n// Copyright (c) Jupyter Development Team.\n/**\n * A function to defer an action immediately.\n */\nvar defer = typeof requestAnimationFrame === 'function'\n    ? requestAnimationFrame\n    : setImmediate;\n/**\n * A function to cancel a deferred action.\n */\nvar cancel = typeof cancelAnimationFrame === 'function'\n    ? cancelAnimationFrame\n    : clearImmediate;\n/**\n * A class that wraps an asynchronous function to poll at a regular interval\n * with exponential increases to the interval length if the poll fails.\n *\n * @typeparam T - The resolved type of the factory's promises.\n * Defaults to `any`.\n *\n * @typeparam U - The rejected type of the factory's promises.\n * Defaults to `any`.\n *\n * @typeparam V - An optional type to extend the phases supported by a poll.\n * Defaults to `standby`, which already exists in the `Phase` type.\n */\nvar Poll = /** @class */ (function () {\n    /**\n     * Instantiate a new poll with exponential backoff in case of failure.\n     *\n     * @param options - The poll instantiation options.\n     */\n    function Poll(options) {\n        var _this = this;\n        this._disposed = new _lumino_signaling__WEBPACK_IMPORTED_MODULE_1__.Signal(this);\n        this._tick = new _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.PromiseDelegate();\n        this._ticked = new _lumino_signaling__WEBPACK_IMPORTED_MODULE_1__.Signal(this);\n        this._timeout = -1;\n        this._factory = options.factory;\n        this._standby = options.standby || Private.DEFAULT_STANDBY;\n        this._state = __assign(__assign({}, Private.DEFAULT_STATE), { timestamp: new Date().getTime() });\n        // Normalize poll frequency `max` to be the greater of\n        // default `max`, `options.frequency.max`, or `options.frequency.interval`.\n        var frequency = options.frequency || {};\n        var max = Math.max(frequency.interval || 0, frequency.max || 0, Private.DEFAULT_FREQUENCY.max);\n        this.frequency = __assign(__assign(__assign({}, Private.DEFAULT_FREQUENCY), frequency), { max: max });\n        this.name = options.name || Private.DEFAULT_NAME;\n        if ('auto' in options ? options.auto : true) {\n            defer(function () { return void _this.start(); });\n        }\n    }\n    Object.defineProperty(Poll.prototype, \"disposed\", {\n        /**\n         * A signal emitted when the poll is disposed.\n         */\n        get: function () {\n            return this._disposed;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"frequency\", {\n        /**\n         * The polling frequency parameters.\n         */\n        get: function () {\n            return this._frequency;\n        },\n        set: function (frequency) {\n            if (this.isDisposed || _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.JSONExt.deepEqual(frequency, this.frequency || {})) {\n                return;\n            }\n            var backoff = frequency.backoff, interval = frequency.interval, max = frequency.max;\n            interval = Math.round(interval);\n            max = Math.round(max);\n            if (typeof backoff === 'number' && backoff < 1) {\n                throw new Error('Poll backoff growth factor must be at least 1');\n            }\n            if ((interval < 0 || interval > max) && interval !== Poll.NEVER) {\n                throw new Error('Poll interval must be between 0 and max');\n            }\n            if (max > Poll.MAX_INTERVAL && max !== Poll.NEVER) {\n                throw new Error(\"Max interval must be less than \" + Poll.MAX_INTERVAL);\n            }\n            this._frequency = { backoff: backoff, interval: interval, max: max };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"isDisposed\", {\n        /**\n         * Whether the poll is disposed.\n         */\n        get: function () {\n            return this.state.phase === 'disposed';\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"standby\", {\n        /**\n         * Indicates when the poll switches to standby.\n         */\n        get: function () {\n            return this._standby;\n        },\n        set: function (standby) {\n            if (this.isDisposed || this.standby === standby) {\n                return;\n            }\n            this._standby = standby;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"state\", {\n        /**\n         * The poll state, which is the content of the current poll tick.\n         */\n        get: function () {\n            return this._state;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"tick\", {\n        /**\n         * A promise that resolves when the poll next ticks.\n         */\n        get: function () {\n            return this._tick.promise;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Poll.prototype, \"ticked\", {\n        /**\n         * A signal emitted when the poll ticks and fires off a new request.\n         */\n        get: function () {\n            return this._ticked;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Dispose the poll.\n     */\n    Poll.prototype.dispose = function () {\n        if (this.isDisposed) {\n            return;\n        }\n        this._state = __assign(__assign({}, Private.DISPOSED_STATE), { timestamp: new Date().getTime() });\n        this._tick.promise.catch(function (_) { return undefined; });\n        this._tick.reject(new Error(\"Poll (\" + this.name + \") is disposed.\"));\n        this._disposed.emit(undefined);\n        _lumino_signaling__WEBPACK_IMPORTED_MODULE_1__.Signal.clearData(this);\n    };\n    /**\n     * Refreshes the poll. Schedules `refreshed` tick if necessary.\n     *\n     * @returns A promise that resolves after tick is scheduled and never rejects.\n     *\n     * #### Notes\n     * The returned promise resolves after the tick is scheduled, but before\n     * the polling action is run. To wait until after the poll action executes,\n     * await the `poll.tick` promise: `await poll.refresh(); await poll.tick;`\n     */\n    Poll.prototype.refresh = function () {\n        return this.schedule({\n            cancel: function (_a) {\n                var phase = _a.phase;\n                return phase === 'refreshed';\n            },\n            interval: Poll.IMMEDIATE,\n            phase: 'refreshed'\n        });\n    };\n    /**\n     * Schedule the next poll tick.\n     *\n     * @param next - The next poll state data to schedule. Defaults to standby.\n     *\n     * @param next.cancel - Cancels state transition if function returns `true`.\n     *\n     * @returns A promise that resolves when the next poll state is active.\n     *\n     * #### Notes\n     * This method is not meant to be invoked by user code typically. It is public\n     * to allow poll instances to be composed into classes that schedule ticks.\n     */\n    Poll.prototype.schedule = function (next) {\n        if (next === void 0) { next = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            var last, pending, scheduled, state, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (this.isDisposed) {\n                            return [2 /*return*/];\n                        }\n                        // Check if the phase transition should be canceled.\n                        if (next.cancel && next.cancel(this.state)) {\n                            return [2 /*return*/];\n                        }\n                        last = this.state;\n                        pending = this._tick;\n                        scheduled = new _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.PromiseDelegate();\n                        state = __assign({ interval: this.frequency.interval, payload: null, phase: 'standby', timestamp: new Date().getTime() }, next);\n                        this._state = state;\n                        this._tick = scheduled;\n                        // Clear the schedule if possible.\n                        if (last.interval === Poll.IMMEDIATE) {\n                            cancel(this._timeout);\n                        }\n                        else {\n                            clearTimeout(this._timeout);\n                        }\n                        // Emit ticked signal, resolve pending promise, and await its settlement.\n                        this._ticked.emit(this.state);\n                        pending.resolve(this);\n                        return [4 /*yield*/, pending.promise];\n                    case 1:\n                        _a.sent();\n                        execute = function () {\n                            if (_this.isDisposed || _this.tick !== scheduled.promise) {\n                                return;\n                            }\n                            _this._execute();\n                        };\n                        this._timeout =\n                            state.interval === Poll.IMMEDIATE\n                                ? defer(execute)\n                                : state.interval === Poll.NEVER\n                                    ? -1\n                                    : setTimeout(execute, state.interval);\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    /**\n     * Starts the poll. Schedules `started` tick if necessary.\n     *\n     * @returns A promise that resolves after tick is scheduled and never rejects.\n     */\n    Poll.prototype.start = function () {\n        return this.schedule({\n            cancel: function (_a) {\n                var phase = _a.phase;\n                return phase !== 'constructed' && phase !== 'standby' && phase !== 'stopped';\n            },\n            interval: Poll.IMMEDIATE,\n            phase: 'started'\n        });\n    };\n    /**\n     * Stops the poll. Schedules `stopped` tick if necessary.\n     *\n     * @returns A promise that resolves after tick is scheduled and never rejects.\n     */\n    Poll.prototype.stop = function () {\n        return this.schedule({\n            cancel: function (_a) {\n                var phase = _a.phase;\n                return phase === 'stopped';\n            },\n            interval: Poll.NEVER,\n            phase: 'stopped'\n        });\n    };\n    /**\n     * Execute a new poll factory promise or stand by if necessary.\n     */\n    Poll.prototype._execute = function () {\n        var _this = this;\n        var standby = typeof this.standby === 'function' ? this.standby() : this.standby;\n        standby =\n            standby === 'never'\n                ? false\n                : standby === 'when-hidden'\n                    ? !!(typeof document !== 'undefined' && document && document.hidden)\n                    : standby;\n        // If in standby mode schedule next tick without calling the factory.\n        if (standby) {\n            void this.schedule();\n            return;\n        }\n        var pending = this.tick;\n        this._factory(this.state)\n            .then(function (resolved) {\n            if (_this.isDisposed || _this.tick !== pending) {\n                return;\n            }\n            void _this.schedule({\n                payload: resolved,\n                phase: _this.state.phase === 'rejected' ? 'reconnected' : 'resolved'\n            });\n        })\n            .catch(function (rejected) {\n            if (_this.isDisposed || _this.tick !== pending) {\n                return;\n            }\n            void _this.schedule({\n                interval: Private.sleep(_this.frequency, _this.state),\n                payload: rejected,\n                phase: 'rejected'\n            });\n        });\n    };\n    return Poll;\n}());\n/**\n * A namespace for `Poll` types, interfaces, and statics.\n */\n(function (Poll) {\n    /**\n     * An interval value that indicates the poll should tick immediately.\n     */\n    Poll.IMMEDIATE = 0;\n    /**\n     * Delays are 32-bit integers in many browsers so intervals need to be capped.\n     *\n     * #### Notes\n     * https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout#Maximum_delay_value\n     */\n    Poll.MAX_INTERVAL = 2147483647;\n    /**\n     * An interval value that indicates the poll should never tick.\n     */\n    Poll.NEVER = Infinity;\n})(Poll || (Poll = {}));\n/**\n * A namespace for private module data.\n */\nvar Private;\n(function (Private) {\n    /**\n     * The default backoff growth rate if `backoff` is `true`.\n     */\n    Private.DEFAULT_BACKOFF = 3;\n    /**\n     * The default polling frequency.\n     */\n    Private.DEFAULT_FREQUENCY = {\n        backoff: true,\n        interval: 1000,\n        max: 30 * 1000\n    };\n    /**\n     * The default poll name.\n     */\n    Private.DEFAULT_NAME = 'unknown';\n    /**\n     * The default poll standby behavior.\n     */\n    Private.DEFAULT_STANDBY = 'when-hidden';\n    /**\n     * The first poll tick state's default values superseded in constructor.\n     */\n    Private.DEFAULT_STATE = {\n        interval: Poll.NEVER,\n        payload: null,\n        phase: 'constructed',\n        timestamp: new Date(0).getTime()\n    };\n    /**\n     * The disposed tick state values.\n     */\n    Private.DISPOSED_STATE = {\n        interval: Poll.NEVER,\n        payload: null,\n        phase: 'disposed',\n        timestamp: new Date(0).getTime()\n    };\n    /**\n     * Get a random integer between min and max, inclusive of both.\n     *\n     * #### Notes\n     * From\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#Getting_a_random_integer_between_two_values_inclusive\n     *\n     * From the MDN page: It might be tempting to use Math.round() to accomplish\n     * that, but doing so would cause your random numbers to follow a non-uniform\n     * distribution, which may not be acceptable for your needs.\n     */\n    function getRandomIntInclusive(min, max) {\n        min = Math.ceil(min);\n        max = Math.floor(max);\n        return Math.floor(Math.random() * (max - min + 1)) + min;\n    }\n    /**\n     * Returns the number of milliseconds to sleep before the next tick.\n     *\n     * @param frequency - The poll's base frequency.\n     * @param last - The poll's last tick.\n     */\n    function sleep(frequency, last) {\n        var backoff = frequency.backoff, interval = frequency.interval, max = frequency.max;\n        if (interval === Poll.NEVER) {\n            return interval;\n        }\n        var growth = backoff === true ? Private.DEFAULT_BACKOFF : backoff === false ? 1 : backoff;\n        var random = getRandomIntInclusive(interval, last.interval * growth);\n        return Math.min(max, random);\n    }\n    Private.sleep = sleep;\n})(Private || (Private = {}));\n\n// Copyright (c) Jupyter Development Team.\n/**\n * A base class to implement rate limiters with different invocation strategies.\n *\n * @typeparam T - The resolved type of the underlying function.\n *\n * @typeparam U - The rejected type of the underlying function.\n */\nvar RateLimiter = /** @class */ (function () {\n    /**\n     * Instantiate a rate limiter.\n     *\n     * @param fn - The function to rate limit.\n     *\n     * @param limit - The rate limit; defaults to 500ms.\n     */\n    function RateLimiter(fn, limit) {\n        var _this = this;\n        if (limit === void 0) { limit = 500; }\n        /**\n         * A promise that resolves on each successful invocation.\n         */\n        this.payload = null;\n        this.limit = limit;\n        this.poll = new Poll({\n            auto: false,\n            factory: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, fn()];\n                    case 1: return [2 /*return*/, _a.sent()];\n                }\n            }); }); },\n            frequency: { backoff: false, interval: Poll.NEVER, max: Poll.NEVER },\n            standby: 'never'\n        });\n        this.payload = new _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.PromiseDelegate();\n        this.poll.ticked.connect(function (_, state) {\n            var payload = _this.payload;\n            if (state.phase === 'resolved') {\n                _this.payload = new _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.PromiseDelegate();\n                payload.resolve(state.payload);\n                return;\n            }\n            if (state.phase === 'rejected' || state.phase === 'stopped') {\n                _this.payload = new _lumino_coreutils__WEBPACK_IMPORTED_MODULE_0__.PromiseDelegate();\n                payload.promise.catch(function (_) { return undefined; });\n                payload.reject(state.payload);\n                return;\n            }\n        }, this);\n    }\n    Object.defineProperty(RateLimiter.prototype, \"isDisposed\", {\n        /**\n         * Whether the rate limiter is disposed.\n         */\n        get: function () {\n            return this.payload === null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Disposes the rate limiter.\n     */\n    RateLimiter.prototype.dispose = function () {\n        if (this.isDisposed) {\n            return;\n        }\n        this.payload = null;\n        this.poll.dispose();\n    };\n    /**\n     * Stop the function if it is mid-flight.\n     */\n    RateLimiter.prototype.stop = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                return [2 /*return*/, this.poll.stop()];\n            });\n        });\n    };\n    return RateLimiter;\n}());\n/**\n * Wraps and debounces a function that can be called multiple times and only\n * executes the underlying function one `interval` after the last invocation.\n *\n * @typeparam T - The resolved type of the underlying function. Defaults to any.\n *\n * @typeparam U - The rejected type of the underlying function. Defaults to any.\n */\nvar Debouncer = /** @class */ (function (_super) {\n    __extends(Debouncer, _super);\n    function Debouncer() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Invokes the function and only executes after rate limit has elapsed.\n     * Each invocation resets the timer.\n     */\n    Debouncer.prototype.invoke = function () {\n        void this.poll.schedule({ interval: this.limit, phase: 'invoked' });\n        return this.payload.promise;\n    };\n    return Debouncer;\n}(RateLimiter));\n/**\n * Wraps and throttles a function that can be called multiple times and only\n * executes the underlying function once per `interval`.\n *\n * @typeparam T - The resolved type of the underlying function. Defaults to any.\n *\n * @typeparam U - The rejected type of the underlying function. Defaults to any.\n */\nvar Throttler = /** @class */ (function (_super) {\n    __extends(Throttler, _super);\n    /**\n     * Instantiate a throttler.\n     *\n     * @param fn - The function being throttled.\n     *\n     * @param options - Throttling configuration or throttling limit in ms.\n     *\n     * #### Notes\n     * The `edge` defaults to `leading`; the `limit` defaults to `500`.\n     */\n    function Throttler(fn, options) {\n        var _this = _super.call(this, fn, typeof options === 'number' ? options : options && options.limit) || this;\n        var edge = 'leading';\n        if (typeof options !== 'number') {\n            options = options || {};\n            edge = 'edge' in options ? options.edge : edge;\n        }\n        _this._interval = edge === 'trailing' ? _this.limit : Poll.IMMEDIATE;\n        return _this;\n    }\n    /**\n     * Throttles function invocations if one is currently in flight.\n     */\n    Throttler.prototype.invoke = function () {\n        if (this.poll.state.phase !== 'invoked') {\n            void this.poll.schedule({ interval: this._interval, phase: 'invoked' });\n        }\n        return this.payload.promise;\n    };\n    return Throttler;\n}(RateLimiter));\n/**\n * A namespace for `Throttler` interfaces.\n */\n(function (Throttler) {\n})(Throttler || (Throttler = {}));\n\n\n//# sourceMappingURL=index.es6.js.map\n\n\n//# sourceURL=webpack://_JUPYTERLAB.CORE_OUTPUT/../node_modules/@lumino/polling/dist/index.es6.js?");

/***/ })

}]);