@difizen/libro-kernel 0.0.2-alpha.0

package/es/kernel/kernel-connection.js

@@ -0,0 +1,1957 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _dec, _dec2, _dec3, _dec4, _dec5, _class, _class2, _descriptor, _descriptor2, _descriptor3, _descriptor4;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+import { deepCopy, URL } from '@difizen/libro-common';
+import { prop } from '@difizen/mana-app';
+import { Deferred, Emitter } from '@difizen/mana-app';
+import { inject, transient } from '@difizen/mana-app';
+import { v4 } from 'uuid';
+import { KernelSpecRestAPI } from "../kernelspec/index.js";
+import { NetworkError, ServerConnection } from "../server/index.js";
+import { CommHandler } from "./comm.js";
+import { KernelControlFutureHandler, KernelShellFutureHandler } from "./future.js";
+import { KernelConnectionOptions, LibroKernelConnectionFactory } from "./libro-kernel-protocol.js";
+import { isDisplayDataMsg, isExecuteResultMsg, isInfoRequestMsg, isUpdateDisplayDataMsg } from "./libro-kernel-utils.js";
+import * as KernelMessage from "./messages.js";
+import * as restapi from "./restapi.js";
+import { KernelRestAPI } from "./restapi.js";
+import { deserialize, serialize } from "./serialize.js";
+import * as validate from "./validate.js";
+
+// 以下 三个 没必要follow jupyter lab
+
+// Stub for requirejs.
+/**
+ * A protected namespace for the Kernel.
+ */
+var Private;
+(function (_Private) {
+  function logKernelStatus(kernel) {
+    switch (kernel.status) {
+      case 'idle':
+      case 'busy':
+      case 'unknown':
+        return;
+      default:
+        // eslint-disable-next-line no-console
+        console.debug("Kernel: ".concat(kernel.status, " (").concat(kernel.id, ")"));
+        break;
+    }
+  }
+  _Private.logKernelStatus = logKernelStatus;
+  function handleShellMessage(_x10, _x11) {
+    return _handleShellMessage.apply(this, arguments);
+  }
+  function _handleShellMessage() {
+    _handleShellMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(kernel, msg) {
+      var future;
+      return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            future = kernel.sendShellMessage(msg, true);
+            return _context14.abrupt("return", future.done);
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    }));
+    return _handleShellMessage.apply(this, arguments);
+  }
+  _Private.handleShellMessage = handleShellMessage;
+  function loadObject(name, moduleName, registry) {
+    return new Promise(function (resolve, reject) {
+      // Try loading the module using require.js
+      if (moduleName) {
+        if (typeof requirejs === 'undefined') {
+          throw new Error('requirejs not found');
+        }
+        requirejs([moduleName], function (mod) {
+          if (mod[name] === void 0) {
+            var _msg = "Object '".concat(name, "' not found in module '").concat(moduleName, "'");
+            reject(new Error(_msg));
+          } else {
+            resolve(mod[name]);
+          }
+        }, reject);
+      } else {
+        if (registry !== null && registry !== void 0 && registry[name]) {
+          resolve(registry[name]);
+        } else {
+          reject(new Error("Object '".concat(name, "' not found in registry")));
+        }
+      }
+    });
+  }
+  _Private.loadObject = loadObject;
+  function getRandomIntInclusive(min, max) {
+    var _min = Math.ceil(min);
+    var _max = Math.floor(max);
+    return Math.floor(Math.random() * (_max - _min + 1)) + _min;
+  }
+  _Private.getRandomIntInclusive = getRandomIntInclusive;
+})(Private || (Private = {}));
+var KERNEL_INFO_TIMEOUT = 3000;
+var RESTARTING_KERNEL_SESSION = '_RESTARTING_';
+var STARTING_KERNEL_SESSION = '';
+
+/**
+ * Implementation of the Kernel object.
+ *
+ * #### Notes
+ * Messages from the server are handled in the order they were received and
+ * asynchronously. Any message handler can return a promise, and message
+ * handling will pause until the promise is fulfilled.
+ */
+export var KernelConnection = (_dec = transient(), _dec2 = inject(KernelSpecRestAPI), _dec3 = inject(KernelRestAPI), _dec4 = inject(LibroKernelConnectionFactory), _dec5 = prop(), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  /**
+   * Construct a kernel object.
+   */
+  function KernelConnection(options, serverConnection) {
+    var _this = this,
+      _options$clientId,
+      _options$username,
+      _options$handleComms;
+    _classCallCheck(this, KernelConnection);
+    _initializerDefineProperty(this, "kernelSpecRestAPI", _descriptor, this);
+    _initializerDefineProperty(this, "kernelRestAPI", _descriptor2, this);
+    _initializerDefineProperty(this, "libroKernelConnectionFactory", _descriptor3, this);
+    /**
+     * Forcefully clear the socket state.
+     *
+     * #### Notes
+     * This will clear all socket state without calling any handlers and will
+     * not update the connection status. If you call this method, you are
+     * responsible for updating the connection status as needed and recreating
+     * the socket if you plan to reconnect.
+     */
+    this._clearSocket = function () {
+      if (_this._ws !== null) {
+        // Clear the websocket event handlers and the socket itself.
+        _this._ws.onopen = _this._noOp;
+        _this._ws.onclose = _this._noOp;
+        _this._ws.onerror = _this._noOp;
+        _this._ws.onmessage = _this._noOp;
+        _this._ws.close();
+        _this._ws = null;
+      }
+    };
+    /**
+     * Create the kernel websocket connection and add socket status handlers.
+     */
+    this._createSocket = function () {
+      var useProtocols = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      _this._errorIfDisposed();
+
+      // Make sure the socket is clear
+      _this._clearSocket();
+
+      // Update the connection status to reflect opening a new connection.
+      _this._updateConnectionStatus('connecting');
+      var settings = _this.serverSettings;
+      var partialUrl = URL.join(settings.wsUrl, restapi.KERNEL_SERVICE_URL, encodeURIComponent(_this._id));
+
+      // Strip any authentication from the display string.
+      // eslint-disable-next-line no-useless-escape
+      var display = partialUrl.replace(/^((?:\w+:)?\/\/)(?:[^@\/]+@)/, '$1');
+      // eslint-disable-next-line no-console
+      console.debug("Starting WebSocket: ".concat(display));
+      var url = URL.join(partialUrl, 'channels?session_id=' + encodeURIComponent(_this._clientId));
+
+      // If token authentication is in use.
+      var token = settings.token;
+      if (settings.appendToken && token !== '') {
+        url = url + "&token=".concat(encodeURIComponent(token));
+      }
+
+      // Try opening the websocket with our list of subprotocols.
+      // If the server doesn't handle subprotocols,
+      // the accepted protocol will be ''.
+      // But we cannot send '' as a subprotocol, so if connection fails,
+      // reconnect without subprotocols.
+      var supportedProtocols = useProtocols ? _this._supportedProtocols : [];
+      _this._ws = new settings.WebSocket(url, supportedProtocols);
+
+      // Ensure incoming binary messages are not Blobs
+      _this._ws.binaryType = 'arraybuffer';
+      var alreadyCalledOnclose = false;
+      var getKernelModel = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(evt) {
+          var model, _err$response, _err$response2, timeout;
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!_this._isDisposed) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return");
+              case 2:
+                _this._reason = '';
+                _this._model = undefined;
+                _context.prev = 4;
+                _context.next = 7;
+                return _this.kernelRestAPI.getKernelModel(_this._id, settings);
+              case 7:
+                model = _context.sent;
+                _this._model = model;
+                if ((model === null || model === void 0 ? void 0 : model.execution_state) === 'dead') {
+                  _this._updateStatus('dead');
+                } else {
+                  _this._onWSClose(evt);
+                }
+                _context.next = 15;
+                break;
+              case 12:
+                _context.prev = 12;
+                _context.t0 = _context["catch"](4);
+                // Try again, if there is a network failure
+                // Handle network errors, as well as cases where we are on a
+                // JupyterHub and the server is not running. JupyterHub returns a
+                // 503 (<2.0) or 424 (>2.0) in that case.
+                if (_context.t0 instanceof NetworkError || ((_err$response = _context.t0.response) === null || _err$response === void 0 ? void 0 : _err$response.status) === 503 || ((_err$response2 = _context.t0.response) === null || _err$response2 === void 0 ? void 0 : _err$response2.status) === 424) {
+                  timeout = Private.getRandomIntInclusive(10, 30) * 1e3;
+                  setTimeout(getKernelModel, timeout, evt);
+                } else {
+                  _this._reason = 'Kernel died unexpectedly';
+                  _this._updateStatus('dead');
+                }
+              case 15:
+                return _context.abrupt("return");
+              case 16:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[4, 12]]);
+        }));
+        return function getKernelModel(_x) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      var earlyClose = /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(evt) {
+          return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!alreadyCalledOnclose) {
+                  _context2.next = 2;
+                  break;
+                }
+                return _context2.abrupt("return");
+              case 2:
+                alreadyCalledOnclose = true;
+                _context2.next = 5;
+                return getKernelModel(evt);
+              case 5:
+                return _context2.abrupt("return");
+              case 6:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        return function earlyClose(_x2) {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+      _this._ws.onmessage = _this._onWSMessage;
+      _this._ws.onopen = _this._onWSOpen;
+      _this._ws.onclose = earlyClose;
+      _this._ws.onerror = earlyClose;
+    };
+    // Make websocket callbacks arrow functions so they bind `this`.
+    /**
+     * Handle a websocket open event.
+     */
+    this._onWSOpen = function () {
+      if (_this._ws.protocol !== '' && !_this._supportedProtocols.includes(_this._ws.protocol)) {
+        console.warn('Server selected unknown kernel wire protocol:', _this._ws.protocol);
+        _this._updateStatus('dead');
+        throw new Error("Unknown kernel wire protocol:  ".concat(_this._ws.protocol));
+      }
+      // Remember the kernel wire protocol selected by the server.
+      _this._selectedProtocol = _this._ws.protocol;
+      _this._ws.onclose = _this._onWSClose;
+      _this._ws.onerror = _this._onWSClose;
+      _this._updateConnectionStatus('connected');
+    };
+    /**
+     * Handle a websocket message, validating and routing appropriately.
+     */
+    this._onWSMessage = function (evt) {
+      // Notify immediately if there is an error with the message.
+      var msg;
+      try {
+        msg = deserialize(evt.data, _this._ws.protocol);
+        validate.validateMessage(msg);
+      } catch (error) {
+        error.message = "Kernel message validation error: ".concat(error.message);
+        // We throw the error so that it bubbles up to the top, and displays the right stack.
+        throw error;
+      }
+
+      // Update the current kernel session id
+      _this._kernelSession = msg.header.session;
+
+      // Handle the message asynchronously, in the order received.
+      _this._msgChain = _this._msgChain.then(function () {
+        // Return so that any promises from handling a message are fulfilled
+        // before proceeding to the next message.
+        return _this._handleMessage(msg);
+      }).catch(function (error) {
+        // Log any errors in handling the message, thus resetting the _msgChain
+        // promise so we can process more messages.
+        // Ignore the "Canceled" errors that are thrown during kernel dispose.
+        if (error.message.startsWith('Canceled future for ')) {
+          console.error(error);
+        }
+      });
+
+      // Emit the message receive signal
+      _this.anyMessageEmitter.fire({
+        msg: msg,
+        direction: 'recv'
+      });
+    };
+    /**
+     * Handle a websocket close event.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    this._onWSClose = function (_evt) {
+      if (!_this.isDisposed) {
+        _this._reconnect();
+      }
+    };
+    this._id = '';
+    this._name = '';
+    _initializerDefineProperty(this, "_status", _descriptor4, this);
+    this._connectionStatus = 'connecting';
+    this._kernelSession = '';
+    this._isDisposed = false;
+    /**
+     * Websocket to communicate with kernel.
+     */
+    this._ws = null;
+    this._username = '';
+    this._reconnectLimit = 7;
+    this._reconnectAttempt = 0;
+    this._reconnectTimeout = null;
+    this._supportedProtocols = Object.values(KernelMessage.supportedKernelWebSocketProtocols);
+    this._selectedProtocol = '';
+    this._futures = new Map();
+    this._comms = new Map();
+    this._targetRegistry = Object.create(null);
+    this._info = new Deferred();
+    this._pendingMessages = [];
+    this.statusChangedEmitter = new Emitter();
+    this.connectionStatusChangedEmitter = new Emitter();
+    this.onDisposedEmitter = new Emitter();
+    this.iopubMessageEmitter = new Emitter();
+    this.anyMessageEmitter = new Emitter();
+    this.pendingInputEmitter = new Emitter();
+    this.unhandledMessageEmitter = new Emitter();
+    this._displayIdToParentIds = new Map();
+    this._msgIdToDisplayIds = new Map();
+    this._msgChain = Promise.resolve();
+    this._hasPendingInput = false;
+    this._reason = '';
+    this._noOp = function () {
+      /* no-op */
+    };
+    this.serverSettings = _objectSpread(_objectSpread({}, serverConnection.settings), options.serverSettings);
+    this._name = options.model.name;
+    this._id = options.model.id;
+    this._clientId = (_options$clientId = options.clientId) !== null && _options$clientId !== void 0 ? _options$clientId : v4();
+    this._username = (_options$username = options.username) !== null && _options$username !== void 0 ? _options$username : '';
+    this.handleComms = (_options$handleComms = options.handleComms) !== null && _options$handleComms !== void 0 ? _options$handleComms : true;
+    this._createSocket();
+  }
+  KernelConnection = inject(ServerConnection)(KernelConnection, undefined, 1) || KernelConnection;
+  KernelConnection = inject(KernelConnectionOptions)(KernelConnection, undefined, 0) || KernelConnection;
+  _createClass(KernelConnection, [{
+    key: "send",
+    value: function send(msg) {
+      var _this$_ws;
+      (_this$_ws = this._ws) === null || _this$_ws === void 0 ? void 0 : _this$_ws.send(msg);
+    }
+  }, {
+    key: "onDisposed",
+    get: function get() {
+      return this.onDisposedEmitter.event;
+    }
+
+    /**
+     * The server settings for the kernel.
+     */
+
+    /**
+     * Handle comm messages
+     *
+     * #### Notes
+     * The comm message protocol currently has implicit assumptions that only
+     * one kernel connection is handling comm messages. This option allows a
+     * kernel connection to opt out of handling comms.
+     *
+     * See https://github.com/jupyter/jupyter_client/issues/263
+     */
+  }, {
+    key: "statusChanged",
+    get:
+    /**
+     * A signal emitted when the kernel status changes.
+     */
+    function get() {
+      return this.statusChangedEmitter.event;
+    }
+
+    /**
+     * A signal emitted when the kernel status changes.
+     */
+  }, {
+    key: "connectionStatusChanged",
+    get: function get() {
+      return this.connectionStatusChangedEmitter.event;
+    }
+
+    /**
+     * A signal emitted for iopub kernel messages.
+     *
+     * #### Notes
+     * This signal is emitted after the iopub message is handled asynchronously.
+     */
+  }, {
+    key: "iopubMessage",
+    get: function get() {
+      return this.iopubMessageEmitter.event;
+    }
+
+    /**
+     * A signal emitted for unhandled kernel message.
+     *
+     * #### Notes
+     * This signal is emitted for a message that was not handled. It is emitted
+     * during the asynchronous message handling code.
+     */
+  }, {
+    key: "unhandledMessage",
+    get: function get() {
+      return this.unhandledMessageEmitter.event;
+    }
+
+    /**
+     * The kernel model
+     */
+  }, {
+    key: "model",
+    get: function get() {
+      return this._model || {
+        id: this.id,
+        name: this.name,
+        reason: this._reason
+      };
+    }
+
+    /**
+     * A signal emitted for any kernel message.
+     *
+     * #### Notes
+     * This signal is emitted when a message is received, before it is handled
+     * asynchronously.
+     *
+     * This message is emitted when a message is queued for sending (either in
+     * the websocket buffer, or our own pending message buffer). The message may
+     * actually be sent across the wire at a later time.
+     *
+     * The message emitted in this signal should not be modified in any way.
+     */
+  }, {
+    key: "anyMessage",
+    get: function get() {
+      return this.anyMessageEmitter.event;
+    }
+
+    /**
+     * A signal emitted when a kernel has pending inputs from the user.
+     */
+  }, {
+    key: "pendingInput",
+    get: function get() {
+      return this.pendingInputEmitter.event;
+    }
+
+    /**
+     * The id of the server-side kernel.
+     */
+  }, {
+    key: "id",
+    get: function get() {
+      return this._id;
+    }
+
+    /**
+     * The name of the server-side kernel.
+     */
+  }, {
+    key: "name",
+    get: function get() {
+      return this._name;
+    }
+
+    /**
+     * The client username.
+     */
+  }, {
+    key: "username",
+    get: function get() {
+      return this._username;
+    }
+
+    /**
+     * The client unique id.
+     */
+  }, {
+    key: "clientId",
+    get: function get() {
+      return this._clientId;
+    }
+
+    /**
+     * The current status of the kernel.
+     */
+  }, {
+    key: "status",
+    get: function get() {
+      return this._status;
+    }
+
+    /**
+     * The current connection status of the kernel connection.
+     */
+  }, {
+    key: "connectionStatus",
+    get: function get() {
+      return this._connectionStatus;
+    }
+
+    /**
+     * Test whether the kernel has been disposed.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * The cached kernel info.
+     *
+     * @returns A promise that resolves to the kernel info.
+     */
+  }, {
+    key: "info",
+    get: function get() {
+      return this._info.promise;
+    }
+
+    /**
+     * The kernel spec.
+     *
+     * @returns A promise that resolves to the kernel spec.
+     */
+  }, {
+    key: "spec",
+    get: function get() {
+      var _this2 = this;
+      if (this._specPromise) {
+        return this._specPromise;
+      }
+      this._specPromise = this.kernelSpecRestAPI.getSpecs(this.serverSettings).then(function (specs) {
+        return specs.kernelspecs[_this2._name];
+      });
+      return this._specPromise;
+    }
+
+    /**
+     * Clone the current kernel with a new clientId.
+     */
+  }, {
+    key: "clone",
+    value: function clone() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.libroKernelConnectionFactory(_objectSpread({
+        model: this.model,
+        username: this.username,
+        // handleComms defaults to false since that is safer
+        handleComms: false
+      }, options));
+    }
+
+    /**
+     * Dispose of the resources held by the kernel.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this.isDisposed) {
+        return;
+      }
+      this.onDisposedEmitter.fire();
+      this._updateConnectionStatus('disconnected');
+      this._clearKernelState();
+      this._pendingMessages = [];
+      this._clearSocket();
+      this.connectionStatusChangedEmitter.dispose();
+      this.statusChangedEmitter.dispose();
+      this.onDisposedEmitter.dispose();
+      this.iopubMessageEmitter.dispose();
+      this.anyMessageEmitter.dispose();
+      this.pendingInputEmitter.dispose();
+      this.unhandledMessageEmitter.dispose();
+      this._isDisposed = true;
+    }
+
+    /**
+     * Send a shell message to the kernel.
+     *
+     * #### Notes
+     * Send a message to the kernel's shell channel, yielding a future object
+     * for accepting replies.
+     *
+     * If `expectReply` is given and `true`, the future is disposed when both a
+     * shell reply and an idle status message are received. If `expectReply`
+     * is not given or is `false`, the future is resolved when an idle status
+     * message is received.
+     * If `disposeOnDone` is not given or is `true`, the Future is disposed at this point.
+     * If `disposeOnDone` is given and `false`, it is up to the caller to dispose of the Future.
+     *
+     * All replies are validated as valid kernel messages.
+     *
+     * If the kernel status is `dead`, this will throw an error.
+     */
+  }, {
+    key: "sendShellMessage",
+    value: function sendShellMessage(msg) {
+      var expectReply = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var disposeOnDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      return this._sendKernelShellControl(KernelShellFutureHandler, msg, expectReply, disposeOnDone);
+    }
+
+    /**
+     * Send a control message to the kernel.
+     *
+     * #### Notes
+     * Send a message to the kernel's control channel, yielding a future object
+     * for accepting replies.
+     *
+     * If `expectReply` is given and `true`, the future is disposed when both a
+     * control reply and an idle status message are received. If `expectReply`
+     * is not given or is `false`, the future is resolved when an idle status
+     * message is received.
+     * If `disposeOnDone` is not given or is `true`, the Future is disposed at this point.
+     * If `disposeOnDone` is given and `false`, it is up to the caller to dispose of the Future.
+     *
+     * All replies are validated as valid kernel messages.
+     *
+     * If the kernel status is `dead`, this will throw an error.
+     */
+  }, {
+    key: "sendControlMessage",
+    value: function sendControlMessage(msg) {
+      var expectReply = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var disposeOnDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      return this._sendKernelShellControl(KernelControlFutureHandler, msg, expectReply, disposeOnDone);
+    }
+  }, {
+    key: "_sendKernelShellControl",
+    value: function _sendKernelShellControl(ctor, msg) {
+      var _this3 = this;
+      var expectReply = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var disposeOnDone = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+      this._sendMessage(msg);
+      this.anyMessageEmitter.fire({
+        msg: msg,
+        direction: 'send'
+      });
+      var future = new ctor(function () {
+        var msgId = msg.header.msg_id;
+        _this3._futures.delete(msgId);
+        // Remove stored display id information.
+        var displayIds = _this3._msgIdToDisplayIds.get(msgId);
+        if (!displayIds) {
+          return;
+        }
+        displayIds.forEach(function (displayId) {
+          var msgIds = _this3._displayIdToParentIds.get(displayId);
+          if (msgIds) {
+            var idx = msgIds.indexOf(msgId);
+            if (idx === -1) {
+              return;
+            }
+            if (msgIds.length === 1) {
+              _this3._displayIdToParentIds.delete(displayId);
+            } else {
+              msgIds.splice(idx, 1);
+              _this3._displayIdToParentIds.set(displayId, msgIds);
+            }
+          }
+        });
+        _this3._msgIdToDisplayIds.delete(msgId);
+      }, msg, expectReply, disposeOnDone, this);
+      this._futures.set(msg.header.msg_id, future);
+      return future;
+    }
+
+    /**
+     * Send a message on the websocket.
+     *
+     * If queue is true, queue the message for later sending if we cannot send
+     * now. Otherwise throw an error.
+     *
+     * #### Notes
+     * As an exception to the queueing, if we are sending a kernel_info_request
+     * message while we think the kernel is restarting, we send the message
+     * immediately without queueing. This is so that we can trigger a message
+     * back, which will then clear the kernel restarting state.
+     */
+  }, {
+    key: "_sendMessage",
+    value: function _sendMessage(msg) {
+      var queue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      if (this.status === 'dead') {
+        throw new Error('Kernel is dead');
+      }
+
+      // If we have a kernel_info_request and we are starting or restarting, send the
+      // kernel_info_request immediately if we can, and if not throw an error so
+      // we can retry later. On restarting we do this because we must get at least one message
+      // from the kernel to reset the kernel session (thus clearing the restart
+      // status sentinel).
+      if ((this._kernelSession === STARTING_KERNEL_SESSION || this._kernelSession === RESTARTING_KERNEL_SESSION) && isInfoRequestMsg(msg)) {
+        if (this.connectionStatus === 'connected') {
+          this._ws.send(serialize(msg, this._ws.protocol));
+          return;
+        } else {
+          throw new Error('Could not send message: status is not connected');
+        }
+      }
+
+      // If there are pending messages, add to the queue so we keep messages in order
+      if (queue && this._pendingMessages.length > 0) {
+        this._pendingMessages.push(msg);
+        return;
+      }
+
+      // Send if the ws allows it, otherwise queue the message.
+      if (this.connectionStatus === 'connected' && this._kernelSession !== RESTARTING_KERNEL_SESSION) {
+        this._ws.send(serialize(msg, this._ws.protocol));
+      } else if (queue) {
+        this._pendingMessages.push(msg);
+      } else {
+        throw new Error('Could not send message');
+      }
+    }
+
+    /**
+     * Interrupt a kernel.
+     *
+     * #### Notes
+     * Uses the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/kernels).
+     *
+     * The promise is fulfilled on a valid response and rejected otherwise.
+     *
+     * It is assumed that the API call does not mutate the kernel id or name.
+     *
+     * The promise will be rejected if the kernel status is `Dead` or if the
+     * request fails or the response is invalid.
+     */
+  }, {
+    key: "interrupt",
+    value: function () {
+      var _interrupt = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              this.hasPendingInput = false;
+              if (!(this.status === 'dead')) {
+                _context3.next = 3;
+                break;
+              }
+              throw new Error('Kernel is dead');
+            case 3:
+              return _context3.abrupt("return", this.kernelRestAPI.interruptKernel(this.id, this.serverSettings));
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function interrupt() {
+        return _interrupt.apply(this, arguments);
+      }
+      return interrupt;
+    }()
+    /**
+     * Request a kernel restart.
+     *
+     * #### Notes
+     * Uses the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/kernels)
+     * and validates the response model.
+     *
+     * Any existing Future or Comm objects are cleared once the kernel has
+     * actually be restarted.
+     *
+     * The promise is fulfilled on a valid server response (after the kernel restarts)
+     * and rejected otherwise.
+     *
+     * It is assumed that the API call does not mutate the kernel id or name.
+     *
+     * The promise will be rejected if the request fails or the response is
+     * invalid.
+     */
+  }, {
+    key: "restart",
+    value: function () {
+      var _restart = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (!(this.status === 'dead')) {
+                _context4.next = 2;
+                break;
+              }
+              throw new Error('Kernel is dead');
+            case 2:
+              this._updateStatus('restarting');
+              this._clearKernelState();
+              this._kernelSession = RESTARTING_KERNEL_SESSION;
+              _context4.next = 7;
+              return this.kernelRestAPI.restartKernel(this.id, this.serverSettings);
+            case 7:
+              _context4.next = 9;
+              return this.reconnect();
+            case 9:
+              this.hasPendingInput = false;
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function restart() {
+        return _restart.apply(this, arguments);
+      }
+      return restart;
+    }()
+    /**
+     * Reconnect to a kernel.
+     *
+     * #### Notes
+     * This may try multiple times to reconnect to a kernel, and will sever any
+     * existing connection.
+     */
+  }, {
+    key: "reconnect",
+    value: function reconnect() {
+      this._errorIfDisposed();
+      var result = new Deferred();
+      var toDispose = undefined;
+
+      // Set up a listener for the connection status changing, which accepts or
+      // rejects after the retries are done.
+      var fulfill = function fulfill(status) {
+        if (status === 'connected') {
+          result.resolve();
+          if (toDispose) {
+            toDispose.dispose();
+            toDispose = undefined;
+          }
+        } else if (status === 'disconnected') {
+          result.reject(new Error('Kernel connection disconnected'));
+          if (toDispose) {
+            toDispose.dispose();
+            toDispose = undefined;
+          }
+        }
+      };
+      toDispose = this.connectionStatusChanged(fulfill);
+
+      // Reset the reconnect limit so we start the connection attempts fresh
+      this._reconnectAttempt = 0;
+
+      // Start the reconnection process, which will also clear any existing
+      // connection.
+      this._reconnect();
+
+      // Return the promise that should resolve on connection or reject if the
+      // retries don't work.
+      return result.promise;
+    }
+
+    /**
+     * Shutdown a kernel.
+     *
+     * #### Notes
+     * Uses the [Jupyter Notebook API](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/notebook/master/notebook/services/api/api.yaml#!/kernels).
+     *
+     * The promise is fulfilled on a valid response and rejected otherwise.
+     *
+     * On a valid response, disposes this kernel connection.
+     *
+     * If the kernel is already `dead`, disposes this kernel connection without
+     * a server request.
+     */
+  }, {
+    key: "shutdown",
+    value: function () {
+      var _shutdown = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              if (!(this.status !== 'dead')) {
+                _context5.next = 3;
+                break;
+              }
+              _context5.next = 3;
+              return this.kernelRestAPI.shutdownKernel(this.id, this.serverSettings);
+            case 3:
+              this.handleShutdown();
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function shutdown() {
+        return _shutdown.apply(this, arguments);
+      }
+      return shutdown;
+    }()
+    /**
+     * Handles a kernel shutdown.
+     *
+     * #### Notes
+     * This method should be called if we know from outside information that a
+     * kernel is dead (for example, we cannot find the kernel model on the
+     * server).
+     */
+  }, {
+    key: "handleShutdown",
+    value: function handleShutdown() {
+      this._updateStatus('dead');
+      this.dispose();
+    }
+
+    /**
+     * Send a `kernel_info_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info).
+     *
+     * Fulfills with the `kernel_info_response` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestKernelInfo",
+    value: function () {
+      var _requestKernelInfo = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+        var msg, reply;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              msg = KernelMessage.createMessage({
+                msgType: 'kernel_info_request',
+                channel: 'shell',
+                username: this._username,
+                session: this._clientId,
+                content: {}
+              });
+              _context6.prev = 1;
+              _context6.next = 4;
+              return Private.handleShellMessage(this, msg);
+            case 4:
+              reply = _context6.sent;
+              _context6.next = 14;
+              break;
+            case 7:
+              _context6.prev = 7;
+              _context6.t0 = _context6["catch"](1);
+              if (!this.isDisposed) {
+                _context6.next = 13;
+                break;
+              }
+              return _context6.abrupt("return");
+            case 13:
+              throw _context6.t0;
+            case 14:
+              this._errorIfDisposed();
+              if (reply) {
+                _context6.next = 17;
+                break;
+              }
+              return _context6.abrupt("return");
+            case 17:
+              // Kernels sometimes do not include a status field on kernel_info_reply
+              // messages, so set a default for now.
+              // See https://github.com/jupyterlab/jupyterlab/issues/6760
+              if (reply.content.status === undefined) {
+                reply.content.status = 'ok';
+              }
+              if (!(reply.content.status !== 'ok')) {
+                _context6.next = 21;
+                break;
+              }
+              this._info.reject('Kernel info reply errored');
+              return _context6.abrupt("return", reply);
+            case 21:
+              this._info.resolve(reply.content);
+              this._kernelSession = reply.header.session;
+              return _context6.abrupt("return", reply);
+            case 24:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[1, 7]]);
+      }));
+      function requestKernelInfo() {
+        return _requestKernelInfo.apply(this, arguments);
+      }
+      return requestKernelInfo;
+    }()
+    /**
+     * Send a `complete_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion).
+     *
+     * Fulfills with the `complete_reply` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestComplete",
+    value: function requestComplete(content) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'complete_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return Private.handleShellMessage(this, msg);
+    }
+
+    /**
+     * Send an `inspect_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection).
+     *
+     * Fulfills with the `inspect_reply` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestInspect",
+    value: function requestInspect(content) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'inspect_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return Private.handleShellMessage(this, msg);
+    }
+
+    /**
+     * Send a `history_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#history).
+     *
+     * Fulfills with the `history_reply` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestHistory",
+    value: function requestHistory(content) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'history_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return Private.handleShellMessage(this, msg);
+    }
+
+    /**
+     * Send an `execute_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute).
+     *
+     * Future `onReply` is called with the `execute_reply` content when the
+     * shell reply is received and validated. The future will resolve when
+     * this message is received and the `idle` iopub status is received.
+     * The future will also be disposed at this point unless `disposeOnDone`
+     * is specified and `false`, in which case it is up to the caller to dispose
+     * of the future.
+     *
+     * **See also:** [[IExecuteReply]]
+     */
+  }, {
+    key: "requestExecute",
+    value: function requestExecute(content) {
+      var disposeOnDone = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var metadata = arguments.length > 2 ? arguments[2] : undefined;
+      var defaults = {
+        silent: false,
+        store_history: true,
+        user_expressions: {},
+        allow_stdin: true,
+        stop_on_error: true
+      };
+      var msg = KernelMessage.createMessage({
+        msgType: 'execute_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: _objectSpread(_objectSpread({}, defaults), content),
+        metadata: metadata
+      });
+      return this.sendShellMessage(msg, true, disposeOnDone);
+    }
+
+    /**
+     * Send an experimental `debug_request` message.
+     *
+     * @hidden
+     *
+     * #### Notes
+     * Debug messages are experimental messages that are not in the official
+     * kernel message specification. As such, this function is *NOT* considered
+     * part of the public API, and may change without notice.
+     */
+  }, {
+    key: "requestDebug",
+    value: function requestDebug(content) {
+      var disposeOnDone = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var msg = KernelMessage.createMessage({
+        msgType: 'debug_request',
+        channel: 'control',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return this.sendControlMessage(msg, true, disposeOnDone);
+    }
+
+    /**
+     * Send an `is_complete_request` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness).
+     *
+     * Fulfills with the `is_complete_response` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestIsComplete",
+    value: function requestIsComplete(content) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'is_complete_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return Private.handleShellMessage(this, msg);
+    }
+
+    /**
+     * Send a `comm_info_request` message.
+     *
+     * #### Notes
+     * Fulfills with the `comm_info_reply` content when the shell reply is
+     * received and validated.
+     */
+  }, {
+    key: "requestCommInfo",
+    value: function requestCommInfo(content) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'comm_info_request',
+        channel: 'shell',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      return Private.handleShellMessage(this, msg);
+    }
+
+    /**
+     * Send an `input_reply` message.
+     *
+     * #### Notes
+     * See [Messaging in Jupyter](https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-sockets).
+     */
+  }, {
+    key: "sendInputReply",
+    value: function sendInputReply(content, parent_header) {
+      var msg = KernelMessage.createMessage({
+        msgType: 'input_reply',
+        channel: 'stdin',
+        username: this._username,
+        session: this._clientId,
+        content: content
+      });
+      msg.parent_header = parent_header;
+      this._sendMessage(msg);
+      this.anyMessageEmitter.fire({
+        msg: msg,
+        direction: 'send'
+      });
+      this.hasPendingInput = false;
+    }
+
+    /**
+     * Create a new comm.
+     *
+     * #### Notes
+     * If a client-side comm already exists with the given commId, an error is thrown.
+     * If the kernel does not handle comms, an error is thrown.
+     */
+  }, {
+    key: "createComm",
+    value: function createComm(targetName) {
+      var _this4 = this;
+      var commId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : v4();
+      if (!this.handleComms) {
+        throw new Error('Comms are disabled on this kernel connection');
+      }
+      if (this._comms.has(commId)) {
+        throw new Error('Comm is already created');
+      }
+      var comm = new CommHandler(targetName, commId, this, function () {
+        _this4._unregisterComm(commId);
+      });
+      this._comms.set(commId, comm);
+      return comm;
+    }
+
+    /**
+     * Check if a comm exists.
+     */
+  }, {
+    key: "hasComm",
+    value: function hasComm(commId) {
+      return this._comms.has(commId);
+    }
+
+    /**
+     * Register a comm target handler.
+     *
+     * @param targetName - The name of the comm target.
+     *
+     * @param callback - The callback invoked for a comm open message.
+     *
+     * @returns A disposable used to unregister the comm target.
+     *
+     * #### Notes
+     * Only one comm target can be registered to a target name at a time, an
+     * existing callback for the same target name will be overridden.  A registered
+     * comm target handler will take precedence over a comm which specifies a
+     * `target_module`.
+     *
+     * If the callback returns a promise, kernel message processing will pause
+     * until the returned promise is fulfilled.
+     */
+  }, {
+    key: "registerCommTarget",
+    value: function registerCommTarget(targetName, callback) {
+      if (!this.handleComms) {
+        return;
+      }
+      this._targetRegistry[targetName] = callback;
+    }
+
+    /**
+     * Remove a comm target handler.
+     *
+     * @param targetName - The name of the comm target to remove.
+     *
+     * @param callback - The callback to remove.
+     *
+     * #### Notes
+     * The comm target is only removed if the callback argument matches.
+     */
+  }, {
+    key: "removeCommTarget",
+    value: function removeCommTarget(targetName, callback) {
+      if (!this.handleComms) {
+        return;
+      }
+      if (!this.isDisposed && this._targetRegistry[targetName] === callback) {
+        delete this._targetRegistry[targetName];
+      }
+    }
+
+    /**
+     * Register an IOPub message hook.
+     *
+     * @param msg_id - The parent_header message id the hook will intercept.
+     *
+     * @param hook - The callback invoked for the message.
+     *
+     * #### Notes
+     * The IOPub hook system allows you to preempt the handlers for IOPub
+     * messages that are responses to a given message id.
+     *
+     * The most recently registered hook is run first. A hook can return a
+     * boolean or a promise to a boolean, in which case all kernel message
+     * processing pauses until the promise is fulfilled. If a hook return value
+     * resolves to false, any later hooks will not run and the function will
+     * return a promise resolving to false. If a hook throws an error, the error
+     * is logged to the console and the next hook is run. If a hook is
+     * registered during the hook processing, it will not run until the next
+     * message. If a hook is removed during the hook processing, it will be
+     * deactivated immediately.
+     *
+     * See also [[IFuture.registerMessageHook]].
+     */
+  }, {
+    key: "registerMessageHook",
+    value: function registerMessageHook(msgId, hook) {
+      var _this$_futures;
+      var future = (_this$_futures = this._futures) === null || _this$_futures === void 0 ? void 0 : _this$_futures.get(msgId);
+      if (future) {
+        future.registerMessageHook(hook);
+      }
+    }
+
+    /**
+     * Remove an IOPub message hook.
+     *
+     * @param msg_id - The parent_header message id the hook intercepted.
+     *
+     * @param hook - The callback invoked for the message.
+     *
+     */
+  }, {
+    key: "removeMessageHook",
+    value: function removeMessageHook(msgId, hook) {
+      var _this$_futures2;
+      var future = (_this$_futures2 = this._futures) === null || _this$_futures2 === void 0 ? void 0 : _this$_futures2.get(msgId);
+      if (future) {
+        future.removeMessageHook(hook);
+      }
+    }
+
+    /**
+     * Remove the input guard, if any.
+     */
+  }, {
+    key: "removeInputGuard",
+    value: function removeInputGuard() {
+      this.hasPendingInput = false;
+    }
+
+    /**
+     * Handle a message with a display id.
+     *
+     * @returns Whether the message was handled.
+     */
+  }, {
+    key: "_handleDisplayId",
+    value: function () {
+      var _handleDisplayId2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(displayId, msg) {
+        var _this5 = this,
+          _this$_displayIdToPar,
+          _this$_msgIdToDisplay;
+        var msgId, parentIds, updateMsg, displayIds;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              msgId = msg.parent_header.msg_id;
+              parentIds = this._displayIdToParentIds.get(displayId);
+              if (!parentIds) {
+                _context8.next = 7;
+                break;
+              }
+              // We've seen it before, update existing outputs with same display_id
+              // by handling display_data as update_display_data.
+              updateMsg = {
+                header: deepCopy(msg.header),
+                parent_header: deepCopy(msg.parent_header),
+                metadata: deepCopy(msg.metadata),
+                content: deepCopy(msg.content),
+                channel: msg.channel,
+                buffers: msg.buffers ? msg.buffers.slice() : []
+              };
+              updateMsg.header.msg_type = 'update_display_data';
+              _context8.next = 7;
+              return Promise.all(parentIds.map( /*#__PURE__*/function () {
+                var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(parentId) {
+                  var future;
+                  return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+                    while (1) switch (_context7.prev = _context7.next) {
+                      case 0:
+                        future = _this5._futures && _this5._futures.get(parentId);
+                        if (!future) {
+                          _context7.next = 4;
+                          break;
+                        }
+                        _context7.next = 4;
+                        return future.handleMsg(updateMsg);
+                      case 4:
+                      case "end":
+                        return _context7.stop();
+                    }
+                  }, _callee7);
+                }));
+                return function (_x5) {
+                  return _ref3.apply(this, arguments);
+                };
+              }()));
+            case 7:
+              if (!(msg.header.msg_type === 'update_display_data')) {
+                _context8.next = 9;
+                break;
+              }
+              return _context8.abrupt("return", true);
+            case 9:
+              // Regular display_data with id, record it for future updating
+              // in _displayIdToParentIds for future lookup.
+              parentIds = (_this$_displayIdToPar = this._displayIdToParentIds.get(displayId)) !== null && _this$_displayIdToPar !== void 0 ? _this$_displayIdToPar : [];
+              if (parentIds.indexOf(msgId) === -1) {
+                parentIds.push(msgId);
+              }
+              this._displayIdToParentIds.set(displayId, parentIds);
+
+              // Add to our map of display ids for this message.
+              displayIds = (_this$_msgIdToDisplay = this._msgIdToDisplayIds.get(msgId)) !== null && _this$_msgIdToDisplay !== void 0 ? _this$_msgIdToDisplay : [];
+              if (displayIds.indexOf(msgId) === -1) {
+                displayIds.push(msgId);
+              }
+              this._msgIdToDisplayIds.set(msgId, displayIds);
+
+              // Let the message propagate to the intended recipient.
+              return _context8.abrupt("return", false);
+            case 16:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function _handleDisplayId(_x3, _x4) {
+        return _handleDisplayId2.apply(this, arguments);
+      }
+      return _handleDisplayId;
+    }()
+  }, {
+    key: "_updateStatus",
+    value:
+    /**
+     * Handle status iopub messages from the kernel.
+     */
+    function _updateStatus(status) {
+      if (this._status === status || this._status === 'dead') {
+        return;
+      }
+      this._status = status;
+      Private.logKernelStatus(this);
+      this.statusChangedEmitter.fire(status);
+      if (status === 'dead') {
+        this.dispose();
+      }
+    }
+
+    /**
+     * Send pending messages to the kernel.
+     */
+  }, {
+    key: "_sendPending",
+    value: function _sendPending() {
+      // We check to make sure we are still connected each time. For
+      // example, if a websocket buffer overflows, it may close, so we should
+      // stop sending messages.
+      while (this.connectionStatus === 'connected' && this._kernelSession !== RESTARTING_KERNEL_SESSION && this._pendingMessages.length > 0) {
+        this._sendMessage(this._pendingMessages[0], false);
+
+        // We shift the message off the queue after the message is sent so that
+        // if there is an exception, the message is still pending.
+        this._pendingMessages.shift();
+      }
+    }
+
+    /**
+     * Clear the internal state.
+     */
+  }, {
+    key: "_clearKernelState",
+    value: function _clearKernelState() {
+      this._kernelSession = '';
+      this._pendingMessages = [];
+      this._futures.forEach(function (future) {
+        future.dispose();
+      });
+      this._comms.forEach(function (comm) {
+        comm.dispose();
+      });
+      this._msgChain = Promise.resolve();
+      this._futures = new Map();
+      this._comms = new Map();
+      this._displayIdToParentIds.clear();
+      this._msgIdToDisplayIds.clear();
+    }
+
+    /**
+     * Check to make sure it is okay to proceed to handle a message.
+     *
+     * #### Notes
+     * Because we handle messages asynchronously, before a message is handled the
+     * kernel might be disposed or restarted (and have a different session id).
+     * This function throws an error in each of these cases. This is meant to be
+     * called at the start of an asynchronous message handler to cancel message
+     * processing if the message no longer is valid.
+     */
+  }, {
+    key: "_assertCurrentMessage",
+    value: function _assertCurrentMessage(msg) {
+      this._errorIfDisposed();
+      if (msg.header.session !== this._kernelSession) {
+        throw new Error("Canceling handling of old message: ".concat(msg.header.msg_type));
+      }
+    }
+
+    /**
+     * Handle a `comm_open` kernel message.
+     */
+  }, {
+    key: "_handleCommOpen",
+    value: function () {
+      var _handleCommOpen2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(msg) {
+        var _this6 = this;
+        var content, comm, target;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              this._assertCurrentMessage(msg);
+              content = msg.content;
+              comm = new CommHandler(content.target_name, content.comm_id, this, function () {
+                _this6._unregisterComm(content.comm_id);
+              });
+              this._comms.set(content.comm_id, comm);
+              _context9.prev = 4;
+              _context9.next = 7;
+              return Private.loadObject(content.target_name, content.target_module, this._targetRegistry);
+            case 7:
+              target = _context9.sent;
+              _context9.next = 10;
+              return target(comm, msg);
+            case 10:
+              _context9.next = 17;
+              break;
+            case 12:
+              _context9.prev = 12;
+              _context9.t0 = _context9["catch"](4);
+              // Close the comm asynchronously. We cannot block message processing on
+              // kernel messages to wait for another kernel message.
+              comm.close();
+              console.error('Exception opening new comm');
+              throw _context9.t0;
+            case 17:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this, [[4, 12]]);
+      }));
+      function _handleCommOpen(_x6) {
+        return _handleCommOpen2.apply(this, arguments);
+      }
+      return _handleCommOpen;
+    }()
+    /**
+     * Handle 'comm_close' kernel message.
+     */
+  }, {
+    key: "_handleCommClose",
+    value: function () {
+      var _handleCommClose2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(msg) {
+        var content, comm, onClose;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              this._assertCurrentMessage(msg);
+              content = msg.content;
+              comm = this._comms.get(content.comm_id);
+              if (comm) {
+                _context10.next = 6;
+                break;
+              }
+              console.error('Comm not found for comm id ' + content.comm_id);
+              return _context10.abrupt("return");
+            case 6:
+              this._unregisterComm(comm.commId);
+              onClose = comm.onClose;
+              if (!onClose) {
+                _context10.next = 11;
+                break;
+              }
+              _context10.next = 11;
+              return onClose(msg);
+            case 11:
+              comm.dispose();
+            case 12:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function _handleCommClose(_x7) {
+        return _handleCommClose2.apply(this, arguments);
+      }
+      return _handleCommClose;
+    }()
+    /**
+     * Handle a 'comm_msg' kernel message.
+     */
+  }, {
+    key: "_handleCommMsg",
+    value: function () {
+      var _handleCommMsg2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(msg) {
+        var content, comm, onMsg;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              this._assertCurrentMessage(msg);
+              content = msg.content;
+              comm = this._comms.get(content.comm_id);
+              if (comm) {
+                _context11.next = 5;
+                break;
+              }
+              return _context11.abrupt("return");
+            case 5:
+              onMsg = comm.onMsg;
+              if (!onMsg) {
+                _context11.next = 9;
+                break;
+              }
+              _context11.next = 9;
+              return onMsg(msg);
+            case 9:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function _handleCommMsg(_x8) {
+        return _handleCommMsg2.apply(this, arguments);
+      }
+      return _handleCommMsg;
+    }()
+    /**
+     * Unregister a comm instance.
+     */
+  }, {
+    key: "_unregisterComm",
+    value: function _unregisterComm(commId) {
+      this._comms.delete(commId);
+    }
+  }, {
+    key: "_updateConnectionStatus",
+    value:
+    /**
+     * Handle connection status changes.
+     */
+    function _updateConnectionStatus(connectionStatus) {
+      var _this7 = this;
+      if (this._connectionStatus === connectionStatus) {
+        return;
+      }
+      this._connectionStatus = connectionStatus;
+
+      // If we are not 'connecting', reset any reconnection attempts.
+      if (connectionStatus !== 'connecting') {
+        this._reconnectAttempt = 0;
+        clearTimeout(this._reconnectTimeout);
+      }
+      if (this.status !== 'dead') {
+        if (connectionStatus === 'connected') {
+          var restarting = this._kernelSession === RESTARTING_KERNEL_SESSION;
+
+          // Send a kernel info request to make sure we send at least one
+          // message to get kernel status back. Always request kernel info
+          // first, to get kernel status back and ensure iopub is fully
+          // established. If we are restarting, this message will skip the queue
+          // and be sent immediately.
+          var p = this.requestKernelInfo();
+
+          // Send any pending messages after the kernelInfo resolves, or after a
+          // timeout as a failsafe.
+
+          var sendPendingCalled = false;
+          var timeoutHandle = null;
+          var sendPendingOnce = function sendPendingOnce() {
+            if (sendPendingCalled) {
+              return;
+            }
+            sendPendingCalled = true;
+            if (restarting && _this7._kernelSession === RESTARTING_KERNEL_SESSION) {
+              // We were restarting and a message didn't arrive to set the
+              // session, but we just assume the restart succeeded and send any
+              // pending messages.
+
+              // FIXME: it would be better to retry the kernel_info_request here
+              _this7._kernelSession = '';
+            }
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
+            if (_this7._pendingMessages.length > 0) {
+              _this7._sendPending();
+            }
+          };
+          void p.then(sendPendingOnce);
+          // FIXME: if sent while zmq subscriptions are not established,
+          // kernelInfo may not resolve, so use a timeout to ensure we don't hang forever.
+          // It may be preferable to retry kernelInfo rather than give up after one timeout.
+          timeoutHandle = setTimeout(sendPendingOnce, KERNEL_INFO_TIMEOUT);
+        } else {
+          // If the connection is down, then we do not know what is happening
+          // with the kernel, so set the status to unknown.
+          this._updateStatus('unknown');
+        }
+      }
+
+      // Notify others that the connection status changed.
+      this.connectionStatusChangedEmitter.fire(connectionStatus);
+    }
+  }, {
+    key: "_handleMessage",
+    value: function () {
+      var _handleMessage2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(msg) {
+        var _this8 = this;
+        var handled, _msg$content$transien, _transient, displayId, _this$_futures3, parentHeader, future, owned, executionState;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              handled = false; // Check to see if we have a display_id we need to reroute.
+              if (!(msg.parent_header && msg.channel === 'iopub' && (isDisplayDataMsg(msg) || isUpdateDisplayDataMsg(msg) || isExecuteResultMsg(msg)))) {
+                _context13.next = 9;
+                break;
+              }
+              // display_data messages may re-route based on their display_id.
+              _transient = (_msg$content$transien = msg.content.transient) !== null && _msg$content$transien !== void 0 ? _msg$content$transien : {};
+              displayId = _transient['display_id'];
+              if (!displayId) {
+                _context13.next = 9;
+                break;
+              }
+              _context13.next = 7;
+              return this._handleDisplayId(displayId, msg);
+            case 7:
+              handled = _context13.sent;
+              // The await above may make this message out of date, so check again.
+              this._assertCurrentMessage(msg);
+            case 9:
+              if (!(!handled && msg.parent_header)) {
+                _context13.next = 20;
+                break;
+              }
+              parentHeader = msg.parent_header;
+              future = (_this$_futures3 = this._futures) === null || _this$_futures3 === void 0 ? void 0 : _this$_futures3.get(parentHeader.msg_id);
+              if (!future) {
+                _context13.next = 18;
+                break;
+              }
+              _context13.next = 15;
+              return future.handleMsg(msg);
+            case 15:
+              this._assertCurrentMessage(msg);
+              _context13.next = 20;
+              break;
+            case 18:
+              // If the message was sent by us and was not iopub, it is orphaned.
+              owned = parentHeader.session === this.clientId;
+              if (msg.channel !== 'iopub' && owned) {
+                this.unhandledMessageEmitter.fire(msg);
+              }
+            case 20:
+              if (!(msg.channel === 'iopub')) {
+                _context13.next = 42;
+                break;
+              }
+              _context13.t0 = msg.header.msg_type;
+              _context13.next = _context13.t0 === 'status' ? 24 : _context13.t0 === 'comm_open' ? 28 : _context13.t0 === 'comm_msg' ? 32 : _context13.t0 === 'comm_close' ? 36 : 40;
+              break;
+            case 24:
+              // Updating the status is synchronous, and we call no async user code
+              executionState = msg.content.execution_state;
+              if (executionState === 'restarting') {
+                // The kernel has been auto-restarted by the server. After
+                // processing for this message is completely done, we want to
+                // handle this restart, so we don't await, but instead schedule
+                // the work as a microtask (i.e., in a promise resolution). We
+                // schedule this here so that it comes before any microtasks that
+                // might be scheduled in the status signal emission below.
+                void Promise.resolve().then( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                  return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                    while (1) switch (_context12.prev = _context12.next) {
+                      case 0:
+                        _this8._updateStatus('autorestarting');
+                        _this8._clearKernelState();
+
+                        // We must reconnect since the kernel connection information may have
+                        // changed, and the server only refreshes its zmq connection when a new
+                        // websocket is opened.
+                        _context12.next = 4;
+                        return _this8.reconnect();
+                      case 4:
+                        return _context12.abrupt("return");
+                      case 5:
+                      case "end":
+                        return _context12.stop();
+                    }
+                  }, _callee12);
+                })));
+              }
+              this._updateStatus(executionState);
+              return _context13.abrupt("break", 41);
+            case 28:
+              if (!this.handleComms) {
+                _context13.next = 31;
+                break;
+              }
+              _context13.next = 31;
+              return this._handleCommOpen(msg);
+            case 31:
+              return _context13.abrupt("break", 41);
+            case 32:
+              if (!this.handleComms) {
+                _context13.next = 35;
+                break;
+              }
+              _context13.next = 35;
+              return this._handleCommMsg(msg);
+            case 35:
+              return _context13.abrupt("break", 41);
+            case 36:
+              if (!this.handleComms) {
+                _context13.next = 39;
+                break;
+              }
+              _context13.next = 39;
+              return this._handleCommClose(msg);
+            case 39:
+              return _context13.abrupt("break", 41);
+            case 40:
+              return _context13.abrupt("break", 41);
+            case 41:
+              // If the message was a status dead message, we might have disposed ourselves.
+              if (!this.isDisposed) {
+                this._assertCurrentMessage(msg);
+                // the message wouldn't be emitted if we were disposed anyway.
+                this.iopubMessageEmitter.fire(msg);
+              }
+            case 42:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function _handleMessage(_x9) {
+        return _handleMessage2.apply(this, arguments);
+      }
+      return _handleMessage;
+    }()
+    /**
+     * Attempt a connection if we have not exhausted connection attempts.
+     */
+  }, {
+    key: "_reconnect",
+    value: function _reconnect() {
+      this._errorIfDisposed();
+
+      // Clear any existing reconnection attempt
+      clearTimeout(this._reconnectTimeout);
+
+      // Update the connection status and schedule a possible reconnection.
+      if (this._reconnectAttempt < this._reconnectLimit) {
+        this._updateConnectionStatus('connecting');
+
+        // The first reconnect attempt should happen immediately, and subsequent
+        // attempts should pick a random number in a growing range so that we
+        // don't overload the server with synchronized reconnection attempts
+        // across multiple kernels.
+        var timeout = Private.getRandomIntInclusive(0, 1e3 * (Math.pow(2, this._reconnectAttempt) - 1));
+        console.warn("Connection lost, reconnecting in ".concat(Math.floor(timeout / 1000), " seconds."));
+        // Try reconnection with subprotocols if the server had supported them.
+        // Otherwise, try reconnection without subprotocols.
+        var useProtocols = this._selectedProtocol !== '' ? true : false;
+        this._reconnectTimeout = setTimeout(this._createSocket, timeout, useProtocols);
+        this._reconnectAttempt += 1;
+      } else {
+        this._updateConnectionStatus('disconnected');
+      }
+
+      // Clear the websocket event handlers and the socket itself.
+      this._clearSocket();
+    }
+
+    /**
+     * Utility function to throw an error if this instance is disposed.
+     */
+  }, {
+    key: "_errorIfDisposed",
+    value: function _errorIfDisposed() {
+      if (this.isDisposed) {
+        throw new Error('Kernel connection is disposed');
+      }
+    }
+  }, {
+    key: "hasPendingInput",
+    get: function get() {
+      return this._hasPendingInput;
+    },
+    set: function set(value) {
+      this._hasPendingInput = value;
+      this.pendingInputEmitter.fire(value);
+    }
+  }]);
+  return KernelConnection;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "kernelSpecRestAPI", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "kernelRestAPI", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "libroKernelConnectionFactory", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor4 = _applyDecoratedDescriptor(_class2.prototype, "_status", [_dec5], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function initializer() {
+    return 'unknown';
+  }
+})), _class2)) || _class);