@difizen/libro-lsp 0.1.2

package/es/virtual/document.js

@@ -0,0 +1,1263 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, catch: function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { Emitter } from '@difizen/mana-app';
+import { DocumentConnectionManager } from "../connection-manager.js";
+import { DefaultMap, untilReady } from "../utils.js";
+/**
+ * Check if given position is within range.
+ * Both start and end are inclusive.
+ * @param position
+ * @param range
+ */
+export function isWithinRange(position, range) {
+  if (range.start.line === range.end.line) {
+    return position.line === range.start.line && position.column >= range.start.column && position.column <= range.end.column;
+  }
+  return position.line === range.start.line && position.column >= range.start.column && position.line < range.end.line || position.line > range.start.line && position.column <= range.end.column && position.line === range.end.line || position.line > range.start.line && position.line < range.end.line;
+}
+
+/**
+ * A virtual implementation of IDocumentInfo
+ */
+export var VirtualDocumentInfo = /*#__PURE__*/function () {
+  /**
+   * Creates an instance of VirtualDocumentInfo.
+   * @param document - the virtual document need to
+   * be wrapped.
+   */
+  function VirtualDocumentInfo(document) {
+    _classCallCheck(this, VirtualDocumentInfo);
+    /**
+     * Current version of the virtual document.
+     */
+    this.version = 0;
+    this._document = document;
+  }
+  _createClass(VirtualDocumentInfo, [{
+    key: "text",
+    get:
+    /**
+     * Get the text content of the virtual document.
+     */
+    function get() {
+      return this._document.value;
+    }
+
+    /**
+     * Get the uri of the virtual document, if the document is not available,
+     * it returns an empty string, users need to check for the length of returned
+     * value before using it.
+     */
+  }, {
+    key: "uri",
+    get: function get() {
+      var uris = DocumentConnectionManager.solveUris(this._document, this.languageId);
+      if (!uris) {
+        return '';
+      }
+      return uris.document;
+    }
+
+    /**
+     * Get the language identifier of the document.
+     */
+  }, {
+    key: "languageId",
+    get: function get() {
+      return this._document.language;
+    }
+
+    /**
+     * The wrapped virtual document.
+     */
+  }]);
+  return VirtualDocumentInfo;
+}();
+/**
+ *
+ * A notebook can hold one or more virtual documents; there is always one,
+ * "root" document, corresponding to the language of the kernel. All other
+ * virtual documents are extracted out of the notebook, based on magics,
+ * or other syntax constructs, depending on the kernel language.
+ *
+ * Virtual documents represent the underlying code in a single language,
+ * which has been parsed excluding interactive kernel commands (magics)
+ * which could be misunderstood by the specific LSP server.
+ *
+ * VirtualDocument has no awareness of the notebook or editor it lives in,
+ * however it is able to transform its content back to the notebook space,
+ * as it keeps editor coordinates for each virtual line.
+ *
+ * The notebook/editor aware transformations are preferred to be placed in
+ * VirtualEditor descendants rather than here.
+ *
+ * No dependency on editor implementation (such as CodeMirrorEditor)
+ * is allowed for VirtualEditor.
+ */
+export var VirtualDocument = /*#__PURE__*/function () {
+  function VirtualDocument(options) {
+    _classCallCheck(this, VirtualDocument);
+    /**
+     * Number of blank lines appended to the virtual document between
+     * each cell.
+     */
+    this.blankLinesBetweenCells = 2;
+    this._isDisposed = false;
+    this._foreignDocumentClosed = new Emitter();
+    this._foreignDocumentOpened = new Emitter();
+    this._changed = new Emitter();
+    this.options = options;
+    this.path = this.options.path;
+    this.fileExtension = options.fileExtension;
+    this.hasLspSupportedFile = options.hasLspSupportedFile;
+    this.parent = options.parent;
+    this.language = options.language;
+    this.virtualLines = new Map();
+    this.sourceLines = new Map();
+    this.foreignDocuments = new Map();
+    this._editorToSourceLine = new Map();
+    this._foreignCodeExtractors = options.foreignCodeExtractors;
+    this.standalone = options.standalone || false;
+    this.instanceId = VirtualDocument.instancesCount;
+    VirtualDocument.instancesCount += 1;
+    this.unusedStandaloneDocuments = new DefaultMap(function () {
+      return new Array();
+    });
+    this._remainingLifetime = 6;
+    this.unusedDocuments = new Set();
+    this.documentInfo = new VirtualDocumentInfo(this);
+    this.updateManager = new UpdateManager(this);
+    this.updateManager.updateBegan(this._updateBeganSlot, this);
+    this.updateManager.blockAdded(this._blockAddedSlot, this);
+    this.updateManager.updateFinished(this._updateFinishedSlot, this);
+    this.clear();
+  }
+
+  /**
+   * Convert from code editor position into code mirror position.
+   */
+  _createClass(VirtualDocument, [{
+    key: "isDisposed",
+    get:
+    /**
+     * Line number of the last line in the real document.
+     */
+
+    /**
+     * Line number of the last line in the virtual document.
+     */
+
+    /**
+     * the remote document uri, version and other server-related info
+     */
+
+    /**
+     * Parent of the current virtual document.
+     */
+
+    /**
+     * The language identifier of the document.
+     */
+
+    /**
+     * Being standalone is relevant to foreign documents
+     * and defines whether following chunks of code in the same
+     * language should be appended to this document (false, not standalone)
+     * or should be considered separate documents (true, standalone)
+     */
+
+    /**
+     * Path to the document.
+     */
+
+    /**
+     * File extension of the document.
+     */
+
+    /**
+     * Notebooks or any other aggregates of documents are not supported
+     * by the LSP specification, and we need to make appropriate
+     * adjustments for them, pretending they are simple files
+     * so that the LSP servers do not refuse to cooperate.
+     */
+
+    /**
+     * Map holding the children `VirtualDocument` .
+     */
+
+    /**
+     * The update manager object.
+     */
+
+    /**
+     * Unique id of the virtual document.
+     */
+
+    /**
+     * Test whether the document is disposed.
+     */
+    function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * Signal emitted when the foreign document is closed
+     */
+  }, {
+    key: "foreignDocumentClosed",
+    get: function get() {
+      return this._foreignDocumentClosed.event;
+    }
+
+    /**
+     * Signal emitted when the foreign document is opened
+     */
+  }, {
+    key: "foreignDocumentOpened",
+    get: function get() {
+      return this._foreignDocumentOpened.event;
+    }
+
+    /**
+     * Signal emitted when the foreign document is changed
+     */
+  }, {
+    key: "changed",
+    get: function get() {
+      return this._changed.event;
+    }
+
+    /**
+     * Id of the virtual document.
+     */
+  }, {
+    key: "virtualId",
+    get: function get() {
+      // for easier debugging, the language information is included in the ID:
+      return this.standalone ? this.instanceId + '(' + this.language + ')' : this.language;
+    }
+
+    /**
+     * Return the ancestry to this document.
+     */
+  }, {
+    key: "ancestry",
+    get: function get() {
+      if (!this.parent) {
+        return [this];
+      }
+      return this.parent.ancestry.concat([this]);
+    }
+
+    /**
+     * Return the id path to the virtual document.
+     */
+  }, {
+    key: "idPath",
+    get: function get() {
+      if (!this.parent) {
+        return this.virtualId;
+      }
+      return this.parent.idPath + '-' + this.virtualId;
+    }
+
+    /**
+     * Get the uri of the virtual document.
+     */
+  }, {
+    key: "uri",
+    get: function get() {
+      var encodedPath = encodeURI(this.path);
+      if (!this.parent) {
+        return encodedPath;
+      }
+      return encodedPath + '.' + this.idPath + '.' + this.fileExtension;
+    }
+
+    /**
+     * Get the text value of the document
+     */
+  }, {
+    key: "value",
+    get: function get() {
+      var linesPadding = '\n'.repeat(this.blankLinesBetweenCells);
+      return this.lineBlocks.join(linesPadding);
+    }
+
+    /**
+     * Get the last line in the virtual document
+     */
+  }, {
+    key: "lastLine",
+    get: function get() {
+      var linesInLastBlock = this.lineBlocks[this.lineBlocks.length - 1].split('\n');
+      return linesInLastBlock[linesInLastBlock.length - 1];
+    }
+
+    /**
+     * Get the root document of current virtual document.
+     */
+  }, {
+    key: "root",
+    get: function get() {
+      return this.parent ? this.parent.root : this;
+    }
+
+    /**
+     * Dispose the virtual document.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._isDisposed = true;
+      this.parent = null;
+      this.closeAllForeignDocuments();
+      this.updateManager.dispose();
+      // clear all the maps
+
+      this.foreignDocuments.clear();
+      this.sourceLines.clear();
+      this.unusedDocuments.clear();
+      this.unusedStandaloneDocuments.clear();
+      this.virtualLines.clear();
+
+      // just to be sure - if anything is accessed after disposal (it should not) we
+      // will get altered by errors in the console AND this will limit memory leaks
+
+      this.documentInfo = null;
+      this.lineBlocks = null;
+    }
+
+    /**
+     * Clear the virtual document and all related stuffs
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      var _iterator = _createForOfIteratorHelper(this.foreignDocuments.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var document = _step.value;
+          document.clear();
+        }
+
+        // TODO - deep clear (assure that there is no memory leak)
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this.unusedStandaloneDocuments.clear();
+      this.unusedDocuments = new Set();
+      this.virtualLines.clear();
+      this.sourceLines.clear();
+      this.lastVirtualLine = 0;
+      this.lastSourceLine = 0;
+      this.lineBlocks = [];
+    }
+
+    /**
+     * Get the virtual document from the cursor position of the source
+     * document
+     * @param position - position in source document
+     */
+  }, {
+    key: "documentAtSourcePosition",
+    value: function documentAtSourcePosition(position) {
+      var sourceLine = this.sourceLines.get(position.line);
+      if (!sourceLine) {
+        return this;
+      }
+      var sourcePositionCe = {
+        line: sourceLine.editorLine,
+        column: position.ch
+      };
+      var _iterator2 = _createForOfIteratorHelper(sourceLine.foreignDocumentsMap),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            range = _step2$value[0],
+            document = _step2$value[1].virtualDocument;
+          if (isWithinRange(sourcePositionCe, range)) {
+            var sourcePositionCm = {
+              line: sourcePositionCe.line - range.start.line,
+              ch: sourcePositionCe.column - range.start.column
+            };
+            return document.documentAtSourcePosition(sourcePositionCm);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return this;
+    }
+
+    /**
+     * Detect if the input source position is belong to the current
+     * virtual document.
+     *
+     * @param sourcePosition - position in the source document
+     */
+  }, {
+    key: "isWithinForeign",
+    value: function isWithinForeign(sourcePosition) {
+      var sourceLine = this.sourceLines.get(sourcePosition.line);
+      var sourcePositionCe = {
+        line: sourceLine.editorLine,
+        column: sourcePosition.ch
+      };
+      var _iterator3 = _createForOfIteratorHelper(sourceLine.foreignDocumentsMap),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = _slicedToArray(_step3.value, 1),
+            range = _step3$value[0];
+          if (isWithinRange(sourcePositionCe, range)) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return false;
+    }
+
+    /**
+     * Compute the position in root document from the position of
+     * a child editor.
+     *
+     * @param editor - the active editor.
+     * @param position - position in the active editor.
+     */
+  }, {
+    key: "transformFromEditorToRoot",
+    value: function transformFromEditorToRoot(editor, position) {
+      if (!this._editorToSourceLine.has(editor)) {
+        console.warn('Editor not found in _editorToSourceLine map');
+        return null;
+      }
+      var shift = this._editorToSourceLine.get(editor);
+      return _objectSpread(_objectSpread({}, position), {}, {
+        line: position.line + shift
+      });
+    }
+
+    /**
+     * Compute the position in virtual document from the position of
+     * a child editor.
+     *
+     * @param editor - the active editor.
+     * @param position - position in the active editor.
+     */
+  }, {
+    key: "transformEditorToVirtual",
+    value: function transformEditorToVirtual(editor, position) {
+      var rootPosition = this.transformFromEditorToRoot(editor, position);
+      if (!rootPosition) {
+        return null;
+      }
+      return this.virtualPositionAtDocument(rootPosition);
+    }
+
+    /**
+     * Compute the position in the virtual document from the position
+     * in the source document.
+     *
+     * @param sourcePosition - position in source document
+     */
+  }, {
+    key: "virtualPositionAtDocument",
+    value: function virtualPositionAtDocument(sourcePosition) {
+      var sourceLine = this.sourceLines.get(sourcePosition.line);
+      if (!sourceLine) {
+        throw new Error('Source line not mapped to virtual position');
+      }
+      var virtualLine = sourceLine.virtualLine;
+
+      // position inside the cell (block)
+      var sourcePositionCe = {
+        line: sourceLine.editorLine,
+        column: sourcePosition.ch
+      };
+      var _iterator4 = _createForOfIteratorHelper(sourceLine.foreignDocumentsMap),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _step4$value = _slicedToArray(_step4.value, 2),
+            range = _step4$value[0],
+            content = _step4$value[1];
+          // eslint-disable-next-line @typescript-eslint/no-shadow
+          var _virtualLine = content.virtualLine,
+            document = content.virtualDocument;
+          if (isWithinRange(sourcePositionCe, range)) {
+            // position inside the foreign document block
+            var sourcePositionCm = {
+              line: sourcePositionCe.line - range.start.line,
+              ch: sourcePositionCe.column - range.start.column
+            };
+            if (document.isWithinForeign(sourcePositionCm)) {
+              return this.virtualPositionAtDocument(sourcePositionCm);
+            } else {
+              // where in this block in the entire foreign document?
+              sourcePositionCm.line += _virtualLine;
+              return sourcePositionCm;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return {
+        ch: sourcePosition.ch,
+        line: virtualLine
+      };
+    }
+
+    /**
+     * Append a code block to the end of the virtual document.
+     *
+     * @param  block - block to be appended
+     * @param  editorShift - position shift in source
+     * document
+     * @param  [virtualShift] - position shift in
+     * virtual document.
+     */
+  }, {
+    key: "appendCodeBlock",
+    value: function appendCodeBlock(block) {
+      var editorShift = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+        line: 0,
+        column: 0
+      };
+      var virtualShift = arguments.length > 2 ? arguments[2] : undefined;
+      var cellCode = block.value;
+      var ceEditor = block.ceEditor;
+      if (this.isDisposed) {
+        console.warn('Cannot append code block: document disposed');
+        return;
+      }
+      var sourceCellLines = cellCode.split('\n');
+      var _this$prepareCodeBloc = this.prepareCodeBlock(block, editorShift),
+        lines = _this$prepareCodeBloc.lines,
+        foreignDocumentsMap = _this$prepareCodeBloc.foreignDocumentsMap;
+      for (var i = 0; i < lines.length; i++) {
+        this.virtualLines.set(this.lastVirtualLine + i, {
+          skipInspect: [],
+          editor: ceEditor,
+          // TODO this is incorrect, wont work if something was extracted
+          sourceLine: this.lastSourceLine + i
+        });
+      }
+      for (var _i = 0; _i < sourceCellLines.length; _i++) {
+        this.sourceLines.set(this.lastSourceLine + _i, {
+          editorLine: _i,
+          editorShift: {
+            line: editorShift.line - ((virtualShift === null || virtualShift === void 0 ? void 0 : virtualShift.line) || 0),
+            column: _i === 0 ? editorShift.column - ((virtualShift === null || virtualShift === void 0 ? void 0 : virtualShift.column) || 0) : 0
+          },
+          // TODO: move those to a new abstraction layer (DocumentBlock class)
+          editor: ceEditor,
+          foreignDocumentsMap: foreignDocumentsMap,
+          // TODO this is incorrect, wont work if something was extracted
+          virtualLine: this.lastVirtualLine + _i
+        });
+      }
+      this.lastVirtualLine += lines.length;
+
+      // one empty line is necessary to separate code blocks, next 'n' lines are to silence linters;
+      // the final cell does not get the additional lines (thanks to the use of join, see below)
+
+      this.lineBlocks.push(lines.join('\n') + '\n');
+
+      // adding the virtual lines for the blank lines
+      for (var _i2 = 0; _i2 < this.blankLinesBetweenCells; _i2++) {
+        this.virtualLines.set(this.lastVirtualLine + _i2, {
+          skipInspect: [this.idPath],
+          editor: ceEditor,
+          sourceLine: null
+        });
+      }
+      this.lastVirtualLine += this.blankLinesBetweenCells;
+      this.lastSourceLine += sourceCellLines.length;
+    }
+
+    /**
+     * Extract a code block into list of string in supported language and
+     * a map of foreign document if any.
+     * @param  block - block to be appended
+     * @param  editorShift - position shift in source document
+     */
+  }, {
+    key: "prepareCodeBlock",
+    value: function prepareCodeBlock(block) {
+      var editorShift = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+        line: 0,
+        column: 0
+      };
+      var _this$extractForeignC = this.extractForeignCode(block, editorShift),
+        cellCodeKept = _this$extractForeignC.cellCodeKept,
+        foreignDocumentsMap = _this$extractForeignC.foreignDocumentsMap;
+      var lines = cellCodeKept.split('\n');
+      return {
+        lines: lines,
+        foreignDocumentsMap: foreignDocumentsMap
+      };
+    }
+
+    /**
+     * Extract the foreign code from input block by using the registered
+     * extractors.
+     * @param  block - block to be appended
+     * @param  editorShift - position shift in source document
+     */
+  }, {
+    key: "extractForeignCode",
+    value: function extractForeignCode(block, editorShift) {
+      var foreignDocumentsMap = new Map();
+      var cellCode = block.value;
+      var extractorsForAnyLang = this._foreignCodeExtractors.getExtractors(block.type, null);
+      var extractorsForCurrentLang = this._foreignCodeExtractors.getExtractors(block.type, this.language);
+      for (var _i3 = 0, _arr = [].concat(_toConsumableArray(extractorsForAnyLang), _toConsumableArray(extractorsForCurrentLang)); _i3 < _arr.length; _i3++) {
+        var extractor = _arr[_i3];
+        if (!extractor.hasForeignCode(cellCode, block.type)) {
+          continue;
+        }
+        var results = extractor.extractForeignCode(cellCode);
+        var keptCellCode = '';
+        var _iterator5 = _createForOfIteratorHelper(results),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var result = _step5.value;
+            if (result.foreignCode !== null) {
+              // result.range should only be null if result.foregin_code is null
+              if (result.range === null) {
+                console.warn('Failure in foreign code extraction: `range` is null but `foreign_code` is not!');
+                continue;
+              }
+              var foreignDocument = this.chooseForeignDocument(extractor);
+              foreignDocumentsMap.set(result.range, {
+                virtualLine: foreignDocument.lastVirtualLine,
+                virtualDocument: foreignDocument,
+                editor: block.ceEditor
+              });
+              var foreignShift = {
+                line: editorShift.line + result.range.start.line,
+                column: editorShift.column + result.range.start.column
+              };
+              foreignDocument.appendCodeBlock({
+                value: result.foreignCode,
+                ceEditor: block.ceEditor,
+                type: 'code'
+              }, foreignShift, result.virtualShift);
+            }
+            if (result.hostCode !== null) {
+              keptCellCode += result.hostCode;
+            }
+          }
+          // not breaking - many extractors are allowed to process the code, one after each other
+          // (think JS and CSS in HTML, or %R inside of %%timeit).
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        cellCode = keptCellCode;
+      }
+      return {
+        cellCodeKept: cellCode,
+        foreignDocumentsMap: foreignDocumentsMap
+      };
+    }
+
+    /**
+     * Close a foreign document and disconnect all associated signals
+     */
+  }, {
+    key: "closeForeign",
+    value: function closeForeign(document) {
+      this._foreignDocumentClosed.fire({
+        foreignDocument: document,
+        parentHost: this
+      });
+      // remove it from foreign documents list
+      this.foreignDocuments.delete(document.virtualId);
+      // and delete the documents within it
+      document.closeAllForeignDocuments();
+
+      // document.foreignDocumentClosed.disconnect(this.forwardClosedSignal, this);
+      // document.foreignDocumentOpened.disconnect(this.forwardOpenedSignal, this);
+      document.dispose();
+    }
+
+    /**
+     * Close all foreign documents.
+     */
+  }, {
+    key: "closeAllForeignDocuments",
+    value: function closeAllForeignDocuments() {
+      var _iterator6 = _createForOfIteratorHelper(this.foreignDocuments.values()),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var document = _step6.value;
+          this.closeForeign(document);
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    }
+
+    /**
+     * Close all expired documents.
+     */
+  }, {
+    key: "closeExpiredDocuments",
+    value: function closeExpiredDocuments() {
+      var _iterator7 = _createForOfIteratorHelper(this.unusedDocuments.values()),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var document = _step7.value;
+          document.remainingLifetime -= 1;
+          if (document.remainingLifetime <= 0) {
+            document.dispose();
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+
+    /**
+     * Transform the position of the source to the editor
+     * position.
+     *
+     * @param  pos - position in the source document
+     * @return position in the editor.
+     */
+  }, {
+    key: "transformSourceToEditor",
+    value: function transformSourceToEditor(pos) {
+      var sourceLine = this.sourceLines.get(pos.line);
+      var editorLine = sourceLine.editorLine;
+      var editorShift = sourceLine.editorShift;
+      return {
+        // only shift column in the line beginning the virtual document (first list of the editor in cell magics, but might be any line of editor in line magics!)
+        ch: pos.ch + (editorLine === 0 ? editorShift.column : 0),
+        line: editorLine + editorShift.line
+        // TODO or:
+        //  line: pos.line + editor_shift.line - this.first_line_of_the_block(editor)
+      };
+    }
+
+    /**
+     * Transform the position in the virtual document to the
+     * editor position.
+     * Can be null because some lines are added as padding/anchors
+     * to the virtual document and those do not exist in the source document
+     * and thus they are absent in the editor.
+     */
+  }, {
+    key: "transformVirtualToEditor",
+    value: function transformVirtualToEditor(virtualPosition) {
+      var sourcePosition = this.transformVirtualToSource(virtualPosition);
+      if (!sourcePosition) {
+        return null;
+      }
+      return this.transformSourceToEditor(sourcePosition);
+    }
+
+    /**
+     * Transform the position in the virtual document to the source.
+     * Can be null because some lines are added as padding/anchors
+     * to the virtual document and those do not exist in the source document.
+     */
+  }, {
+    key: "transformVirtualToSource",
+    value: function transformVirtualToSource(position) {
+      var line = this.virtualLines.get(position.line).sourceLine;
+      if (line === null) {
+        return null;
+      }
+      return {
+        ch: position.ch,
+        line: line
+      };
+    }
+
+    /**
+     * Get the corresponding editor of the virtual line.
+     */
+  }, {
+    key: "getEditorAtVirtualLine",
+    value: function getEditorAtVirtualLine(pos) {
+      var line = pos.line;
+      // tolerate overshot by one (the hanging blank line at the end)
+      if (!this.virtualLines.has(line)) {
+        line -= 1;
+      }
+      return this.virtualLines.get(line).editor;
+    }
+
+    /**
+     * Get the corresponding editor of the source line
+     */
+  }, {
+    key: "getEditorAtSourceLine",
+    value: function getEditorAtSourceLine(pos) {
+      return this.sourceLines.get(pos.line).editor;
+    }
+
+    /**
+     * Recursively emits changed signal from the document or any descendant foreign document.
+     */
+  }, {
+    key: "maybeEmitChanged",
+    value: function maybeEmitChanged() {
+      if (this.value !== this.previousValue) {
+        this._changed.fire(this);
+      }
+      this.previousValue = this.value;
+      var _iterator8 = _createForOfIteratorHelper(this.foreignDocuments.values()),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var document = _step8.value;
+          document.maybeEmitChanged();
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+    }
+
+    /**
+     * When this counter goes down to 0, the document will be destroyed and the associated connection will be closed;
+     * This is meant to reduce the number of open connections when a a foreign code snippet was removed from the document.
+     *
+     * Note: top level virtual documents are currently immortal (unless killed by other means); it might be worth
+     * implementing culling of unused documents, but if and only if JupyterLab will also implement culling of
+     * idle kernels - otherwise the user experience could be a bit inconsistent, and we would need to invent our own rules.
+     */
+  }, {
+    key: "remainingLifetime",
+    get: function get() {
+      if (!this.parent) {
+        return Infinity;
+      }
+      return this._remainingLifetime;
+    },
+    set: function set(value) {
+      if (this.parent) {
+        this._remainingLifetime = value;
+      }
+    }
+
+    /**
+     * Virtual lines keep all the lines present in the document AND extracted to the foreign document.
+     */
+  }, {
+    key: "chooseForeignDocument",
+    value:
+    /**
+     * Get the foreign document that can be opened with the input extractor.
+     */
+    function chooseForeignDocument(extractor) {
+      var foreignDocument;
+      // if not standalone, try to append to existing document
+      var foreignExists = this.foreignDocuments.has(extractor.language);
+      if (!extractor.standalone && foreignExists) {
+        foreignDocument = this.foreignDocuments.get(extractor.language);
+      } else {
+        // if (previous document does not exists) or (extractor produces standalone documents
+        // and no old standalone document could be reused): create a new document
+        foreignDocument = this.openForeign(extractor.language, extractor.standalone, extractor.fileExtension);
+      }
+      return foreignDocument;
+    }
+
+    /**
+     * Create a foreign document from input language and file extension.
+     *
+     * @param  language - the required language
+     * @param  standalone - the document type is supported natively by LSP?
+     * @param  fileExtension - File extension.
+     */
+  }, {
+    key: "openForeign",
+    value: function openForeign(language, standalone, fileExtension) {
+      var _this = this;
+      var document = new VirtualDocument(_objectSpread(_objectSpread({}, this.options), {}, {
+        parent: this,
+        standalone: standalone,
+        fileExtension: fileExtension,
+        language: language
+      }));
+      var context = {
+        foreignDocument: document,
+        parentHost: this
+      };
+      this._foreignDocumentOpened.fire(context);
+      // pass through any future signals
+      document.foreignDocumentClosed(function () {
+        return _this.forwardClosedSignal(context);
+      });
+      document.foreignDocumentOpened(function () {
+        return _this.forwardOpenedSignal(context);
+      });
+      this.foreignDocuments.set(document.virtualId, document);
+      return document;
+    }
+
+    /**
+     * Forward the closed signal from the foreign document to the host document's
+     * signal
+     */
+  }, {
+    key: "forwardClosedSignal",
+    value: function forwardClosedSignal(context) {
+      this._foreignDocumentClosed.fire(context);
+    }
+
+    /**
+     * Forward the opened signal from the foreign document to the host document's
+     * signal
+     */
+  }, {
+    key: "forwardOpenedSignal",
+    value: function forwardOpenedSignal(context) {
+      this._foreignDocumentOpened.fire(context);
+    }
+
+    /**
+     * Slot of the `updateBegan` signal.
+     */
+  }, {
+    key: "_updateBeganSlot",
+    value: function _updateBeganSlot() {
+      this._editorToSourceLineNew = new Map();
+    }
+
+    /**
+     * Slot of the `blockAdded` signal.
+     */
+  }, {
+    key: "_blockAddedSlot",
+    value: function _blockAddedSlot(blockData) {
+      this._editorToSourceLineNew.set(blockData.block.ceEditor, blockData.virtualDocument.lastSourceLine);
+    }
+
+    /**
+     * Slot of the `updateFinished` signal.
+     */
+  }, {
+    key: "_updateFinishedSlot",
+    value: function _updateFinishedSlot() {
+      this._editorToSourceLine = this._editorToSourceLineNew;
+    }
+  }], [{
+    key: "ceToCm",
+    value: function ceToCm(position) {
+      return {
+        line: position.line,
+        ch: position.column
+      };
+    }
+  }]);
+  return VirtualDocument;
+}();
+VirtualDocument.instancesCount = 0;
+/**
+ * Create foreign documents if available from input virtual documents.
+ * @param virtualDocument - the virtual document to be collected
+ * @return - Set of generated foreign documents
+ */
+export function collectDocuments(virtualDocument) {
+  var collected = new Set();
+  collected.add(virtualDocument);
+  var _iterator9 = _createForOfIteratorHelper(virtualDocument.foreignDocuments.values()),
+    _step9;
+  try {
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var foreign = _step9.value;
+      var foreignLanguages = collectDocuments(foreign);
+      foreignLanguages.forEach(collected.add, collected);
+    }
+  } catch (err) {
+    _iterator9.e(err);
+  } finally {
+    _iterator9.f();
+  }
+  return collected;
+}
+export var UpdateManager = /*#__PURE__*/function () {
+  // eslint-disable-next-line @typescript-eslint/parameter-properties, @typescript-eslint/no-parameter-properties
+  function UpdateManager(virtualDocument) {
+    _classCallCheck(this, UpdateManager);
+    this.virtualDocument = virtualDocument;
+    this._isDisposed = false;
+    /**
+     * Promise resolved when the updating process finishes.
+     */
+    this._updateDone = new Promise(function (resolve) {
+      resolve();
+    });
+    /**
+     * Virtual documents update guard.
+     */
+    this._isUpdateInProgress = false;
+    /**
+     * Update lock to prevent multiple updates are applied at the same time.
+     */
+    this._updateLock = false;
+    this._blockAdded = new Emitter();
+    this._documentUpdated = new Emitter();
+    this._updateBegan = new Emitter();
+    this._updateFinished = new Emitter();
+    this.documentUpdated(this._onUpdated);
+  }
+
+  /**
+   * Promise resolved when the updating process finishes.
+   */
+  _createClass(UpdateManager, [{
+    key: "updateDone",
+    get: function get() {
+      return this._updateDone;
+    }
+    /**
+     * Test whether the document is disposed.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this._isDisposed;
+    }
+
+    /**
+     * Signal emitted when a code block is added to the document.
+     */
+  }, {
+    key: "blockAdded",
+    get: function get() {
+      return this._blockAdded.event;
+    }
+
+    /**
+     * Signal emitted by the editor that triggered the update,
+     * providing the root document of the updated documents.
+     */
+  }, {
+    key: "documentUpdated",
+    get: function get() {
+      return this._documentUpdated.event;
+    }
+
+    /**
+     * Signal emitted when the update is started
+     */
+  }, {
+    key: "updateBegan",
+    get: function get() {
+      return this._updateBegan.event;
+    }
+
+    /**
+     * Signal emitted when the update is finished
+     */
+  }, {
+    key: "updateFinished",
+    get: function get() {
+      return this._updateFinished.event;
+    }
+
+    /**
+     * Dispose the class
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._isDisposed = true;
+    }
+
+    /**
+     * Execute provided callback within an update-locked context, which guarantees that:
+     *  - the previous updates must have finished before the callback call, and
+     *  - no update will happen when executing the callback
+     * @param fn - the callback to execute in update lock
+     */
+  }, {
+    key: "withUpdateLock",
+    value: function () {
+      var _withUpdateLock = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(fn) {
+        var _this2 = this;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return untilReady(function () {
+                return _this2._canUpdate();
+              }, 12, 10).then(function () {
+                try {
+                  _this2._updateLock = true;
+                  fn();
+                } catch (ex) {
+                  console.error(ex);
+                } finally {
+                  _this2._updateLock = false;
+                }
+                return;
+              });
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function withUpdateLock(_x) {
+        return _withUpdateLock.apply(this, arguments);
+      }
+      return withUpdateLock;
+    }()
+    /**
+     * Update all the virtual documents, emit documents updated with root document if succeeded,
+     * and resolve a void promise. The promise does not contain the text value of the root document,
+     * as to avoid an easy trap of ignoring the changes in the virtual documents.
+     */
+  }, {
+    key: "updateDocuments",
+    value: function () {
+      var _updateDocuments = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(blocks) {
+        var _this3 = this;
+        var update;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              update = new Promise(function (resolve, reject) {
+                // defer the update by up to 50 ms (10 retrials * 5 ms break),
+                // awaiting for the previous update to complete.
+                untilReady(function () {
+                  return _this3._canUpdate();
+                }, 10, 5).then(function () {
+                  if (_this3.isDisposed || !_this3.virtualDocument) {
+                    resolve();
+                  }
+                  try {
+                    _this3._isUpdateInProgress = true;
+                    _this3._updateBegan.fire(blocks);
+                    _this3.virtualDocument.clear();
+                    var _iterator10 = _createForOfIteratorHelper(blocks),
+                      _step10;
+                    try {
+                      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+                        var codeBlock = _step10.value;
+                        _this3._blockAdded.fire({
+                          block: codeBlock,
+                          virtualDocument: _this3.virtualDocument
+                        });
+                        _this3.virtualDocument.appendCodeBlock(codeBlock);
+                      }
+                    } catch (err) {
+                      _iterator10.e(err);
+                    } finally {
+                      _iterator10.f();
+                    }
+                    _this3._updateFinished.fire(blocks);
+                    if (_this3.virtualDocument) {
+                      _this3._documentUpdated.fire(_this3.virtualDocument);
+                      _this3.virtualDocument.maybeEmitChanged();
+                    }
+                    resolve();
+                  } catch (e) {
+                    console.warn('Documents update failed:', e);
+                    reject(e);
+                  } finally {
+                    _this3._isUpdateInProgress = false;
+                  }
+                  return;
+                }).catch(console.error);
+              });
+              this._updateDone = update;
+              return _context2.abrupt("return", update);
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function updateDocuments(_x2) {
+        return _updateDocuments.apply(this, arguments);
+      }
+      return updateDocuments;
+    }()
+  }, {
+    key: "_onUpdated",
+    value:
+    /**
+     * Once all the foreign documents were refreshed, the unused documents (and their connections)
+     * should be terminated if their lifetime has expired.
+     */
+    function _onUpdated(rootDocument) {
+      try {
+        rootDocument.closeExpiredDocuments();
+      } catch (e) {
+        console.warn('Failed to close expired documents');
+      }
+    }
+
+    /**
+     * Check if the document can be updated.
+     */
+  }, {
+    key: "_canUpdate",
+    value: function _canUpdate() {
+      return !this.isDisposed && !this._isUpdateInProgress && !this._updateLock;
+    }
+  }]);
+  return UpdateManager;
+}();