@difizen/libro-language-client 0.1.18

package/es/common/vscodeAdaptor/extHostTypes.js

@@ -0,0 +1,3825 @@
+var _Symbol$iterator;
+var _TaskGroup;
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+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 _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 _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 _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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
+var id = 0;
+function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
+/* eslint-disable no-useless-escape */
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable no-console */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// src/vs/workbench/api/common/extHostTypes.ts
+
+import { v4 as generateUuid } from 'uuid';
+import { URI } from 'vscode-uri';
+import { FileSystemProviderErrorCode, markAsFileSystemProviderError } from "./hostTypeUtil.js";
+import { CellEditType, isTextStreamMime } from "./hostTypeUtil.js";
+import { isNumber, isObject, isString, isStringArray } from "./hostTypeUtil.js";
+import { Mimes, normalizeMimeType } from "./hostTypeUtil.js";
+import { ResourceMap } from "./hostTypeUtil.js";
+import { MarkdownString as BaseMarkdownString } from "./hostTypeUtil.js";
+import { illegalArgument } from "./hostTypeUtil.js";
+import { asArray, coalesceInPlace, equals } from "./hostTypeUtil.js";
+export var TerminalOutputAnchor = /*#__PURE__*/function (TerminalOutputAnchor) {
+  TerminalOutputAnchor[TerminalOutputAnchor["Top"] = 0] = "Top";
+  TerminalOutputAnchor[TerminalOutputAnchor["Bottom"] = 1] = "Bottom";
+  return TerminalOutputAnchor;
+}({});
+export var TerminalQuickFixType = /*#__PURE__*/function (TerminalQuickFixType) {
+  TerminalQuickFixType[TerminalQuickFixType["TerminalCommand"] = 0] = "TerminalCommand";
+  TerminalQuickFixType[TerminalQuickFixType["Opener"] = 1] = "Opener";
+  TerminalQuickFixType[TerminalQuickFixType["Command"] = 3] = "Command";
+  return TerminalQuickFixType;
+}({});
+var _callOnDispose = /*#__PURE__*/_classPrivateFieldLooseKey("callOnDispose");
+export var Disposable = /*#__PURE__*/function () {
+  function Disposable(callOnDispose) {
+    _classCallCheck(this, Disposable);
+    Object.defineProperty(this, _callOnDispose, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _callOnDispose)[_callOnDispose] = callOnDispose;
+  }
+  _createClass(Disposable, [{
+    key: "dispose",
+    value: function dispose() {
+      if (typeof _classPrivateFieldLooseBase(this, _callOnDispose)[_callOnDispose] === 'function') {
+        _classPrivateFieldLooseBase(this, _callOnDispose)[_callOnDispose]();
+        _classPrivateFieldLooseBase(this, _callOnDispose)[_callOnDispose] = undefined;
+      }
+    }
+  }], [{
+    key: "from",
+    value: function from() {
+      for (var _len = arguments.length, inDisposables = new Array(_len), _key = 0; _key < _len; _key++) {
+        inDisposables[_key] = arguments[_key];
+      }
+      var disposables = inDisposables;
+      return new Disposable(function () {
+        if (disposables) {
+          for (var _i = 0, _disposables = disposables; _i < _disposables.length; _i++) {
+            var disposable = _disposables[_i];
+            if (disposable && typeof disposable.dispose === 'function') {
+              disposable.dispose();
+            }
+          }
+          disposables = undefined;
+        }
+      });
+    }
+  }]);
+  return Disposable;
+}();
+export var Position = /*#__PURE__*/function () {
+  function Position(line, character) {
+    _classCallCheck(this, Position);
+    if (line < 0) {
+      throw illegalArgument('line must be non-negative');
+    }
+    if (character < 0) {
+      throw illegalArgument('character must be non-negative');
+    }
+    this._line = line;
+    this._character = character;
+  }
+  _createClass(Position, [{
+    key: "line",
+    get: function get() {
+      return this._line;
+    }
+  }, {
+    key: "character",
+    get: function get() {
+      return this._character;
+    }
+  }, {
+    key: "isBefore",
+    value: function isBefore(other) {
+      if (this._line < other._line) {
+        return true;
+      }
+      if (other._line < this._line) {
+        return false;
+      }
+      return this._character < other._character;
+    }
+  }, {
+    key: "isBeforeOrEqual",
+    value: function isBeforeOrEqual(other) {
+      if (this._line < other._line) {
+        return true;
+      }
+      if (other._line < this._line) {
+        return false;
+      }
+      return this._character <= other._character;
+    }
+  }, {
+    key: "isAfter",
+    value: function isAfter(other) {
+      return !this.isBeforeOrEqual(other);
+    }
+  }, {
+    key: "isAfterOrEqual",
+    value: function isAfterOrEqual(other) {
+      return !this.isBefore(other);
+    }
+  }, {
+    key: "isEqual",
+    value: function isEqual(other) {
+      return this._line === other._line && this._character === other._character;
+    }
+  }, {
+    key: "compareTo",
+    value: function compareTo(other) {
+      if (this._line < other._line) {
+        return -1;
+      } else if (this._line > other.line) {
+        return 1;
+      } else {
+        // equal line
+        if (this._character < other._character) {
+          return -1;
+        } else if (this._character > other._character) {
+          return 1;
+        } else {
+          // equal line and character
+          return 0;
+        }
+      }
+    }
+  }, {
+    key: "translate",
+    value: function translate(lineDeltaOrChange) {
+      var characterDelta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (lineDeltaOrChange === null || characterDelta === null) {
+        throw illegalArgument();
+      }
+      var lineDelta;
+      if (typeof lineDeltaOrChange === 'undefined') {
+        lineDelta = 0;
+      } else if (typeof lineDeltaOrChange === 'number') {
+        lineDelta = lineDeltaOrChange;
+      } else {
+        lineDelta = typeof lineDeltaOrChange.lineDelta === 'number' ? lineDeltaOrChange.lineDelta : 0;
+        characterDelta = typeof lineDeltaOrChange.characterDelta === 'number' ? lineDeltaOrChange.characterDelta : 0;
+      }
+      if (lineDelta === 0 && characterDelta === 0) {
+        return this;
+      }
+      return new Position(this.line + lineDelta, this.character + characterDelta);
+    }
+  }, {
+    key: "with",
+    value: function _with(lineOrChange) {
+      var character = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.character;
+      if (lineOrChange === null || character === null) {
+        throw illegalArgument();
+      }
+      var line;
+      if (typeof lineOrChange === 'undefined') {
+        line = this.line;
+      } else if (typeof lineOrChange === 'number') {
+        line = lineOrChange;
+      } else {
+        line = typeof lineOrChange.line === 'number' ? lineOrChange.line : this.line;
+        character = typeof lineOrChange.character === 'number' ? lineOrChange.character : this.character;
+      }
+      if (line === this.line && character === this.character) {
+        return this;
+      }
+      return new Position(line, character);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        line: this.line,
+        character: this.character
+      };
+    }
+  }], [{
+    key: "Min",
+    value: function Min() {
+      if (arguments.length === 0) {
+        throw new TypeError();
+      }
+      var result = arguments.length <= 0 ? undefined : arguments[0];
+      for (var i = 1; i < arguments.length; i++) {
+        var p = i < 0 || arguments.length <= i ? undefined : arguments[i];
+        if (p.isBefore(result)) {
+          result = p;
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "Max",
+    value: function Max() {
+      if (arguments.length === 0) {
+        throw new TypeError();
+      }
+      var result = arguments.length <= 0 ? undefined : arguments[0];
+      for (var i = 1; i < arguments.length; i++) {
+        var p = i < 0 || arguments.length <= i ? undefined : arguments[i];
+        if (p.isAfter(result)) {
+          result = p;
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "isPosition",
+    value: function isPosition(other) {
+      if (!other) {
+        return false;
+      }
+      if (other instanceof Position) {
+        return true;
+      }
+      var _ref = other,
+        line = _ref.line,
+        character = _ref.character;
+      if (typeof line === 'number' && typeof character === 'number') {
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "of",
+    value: function of(obj) {
+      if (obj instanceof Position) {
+        return obj;
+      } else if (this.isPosition(obj)) {
+        return new Position(obj.line, obj.character);
+      }
+      throw new Error('Invalid argument, is NOT a position-like object');
+    }
+  }]);
+  return Position;
+}();
+export var Range = /*#__PURE__*/function () {
+  function Range(startLineOrStart, startColumnOrEnd, endLine, endColumn) {
+    _classCallCheck(this, Range);
+    var start;
+    var end;
+    if (typeof startLineOrStart === 'number' && typeof startColumnOrEnd === 'number' && typeof endLine === 'number' && typeof endColumn === 'number') {
+      start = new Position(startLineOrStart, startColumnOrEnd);
+      end = new Position(endLine, endColumn);
+    } else if (Position.isPosition(startLineOrStart) && Position.isPosition(startColumnOrEnd)) {
+      start = Position.of(startLineOrStart);
+      end = Position.of(startColumnOrEnd);
+    }
+    if (!start || !end) {
+      throw new Error('Invalid arguments');
+    }
+    if (start.isBefore(end)) {
+      this._start = start;
+      this._end = end;
+    } else {
+      this._start = end;
+      this._end = start;
+    }
+  }
+  _createClass(Range, [{
+    key: "start",
+    get: function get() {
+      return this._start;
+    }
+  }, {
+    key: "end",
+    get: function get() {
+      return this._end;
+    }
+  }, {
+    key: "contains",
+    value: function contains(positionOrRange) {
+      if (Range.isRange(positionOrRange)) {
+        return this.contains(positionOrRange.start) && this.contains(positionOrRange.end);
+      } else if (Position.isPosition(positionOrRange)) {
+        if (Position.of(positionOrRange).isBefore(this._start)) {
+          return false;
+        }
+        if (this._end.isBefore(positionOrRange)) {
+          return false;
+        }
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "isEqual",
+    value: function isEqual(other) {
+      return this._start.isEqual(other._start) && this._end.isEqual(other._end);
+    }
+  }, {
+    key: "intersection",
+    value: function intersection(other) {
+      var start = Position.Max(other.start, this._start);
+      var end = Position.Min(other.end, this._end);
+      if (start.isAfter(end)) {
+        // this happens when there is no overlap:
+        // |-----|
+        //          |----|
+        return undefined;
+      }
+      return new Range(start, end);
+    }
+  }, {
+    key: "union",
+    value: function union(other) {
+      if (this.contains(other)) {
+        return this;
+      } else if (other.contains(this)) {
+        return other;
+      }
+      var start = Position.Min(other.start, this._start);
+      var end = Position.Max(other.end, this.end);
+      return new Range(start, end);
+    }
+  }, {
+    key: "isEmpty",
+    get: function get() {
+      return this._start.isEqual(this._end);
+    }
+  }, {
+    key: "isSingleLine",
+    get: function get() {
+      return this._start.line === this._end.line;
+    }
+  }, {
+    key: "with",
+    value: function _with(startOrChange) {
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.end;
+      if (startOrChange === null || end === null) {
+        throw illegalArgument();
+      }
+      var start;
+      if (!startOrChange) {
+        start = this.start;
+      } else if (Position.isPosition(startOrChange)) {
+        start = startOrChange;
+      } else {
+        start = startOrChange.start || this.start;
+        end = startOrChange.end || this.end;
+      }
+      if (start.isEqual(this._start) && end.isEqual(this.end)) {
+        return this;
+      }
+      return new Range(start, end);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return [this.start, this.end];
+    }
+  }], [{
+    key: "isRange",
+    value: function isRange(thing) {
+      if (thing instanceof Range) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return Position.isPosition(thing.start) && Position.isPosition(thing.end);
+    }
+  }, {
+    key: "of",
+    value: function of(obj) {
+      if (obj instanceof Range) {
+        return obj;
+      }
+      if (this.isRange(obj)) {
+        return new Range(obj.start, obj.end);
+      }
+      throw new Error('Invalid argument, is NOT a range-like object');
+    }
+  }]);
+  return Range;
+}();
+export var Selection = /*#__PURE__*/function (_Range) {
+  _inherits(Selection, _Range);
+  var _super = _createSuper(Selection);
+  function Selection(anchorLineOrAnchor, anchorColumnOrActive, activeLine, activeColumn) {
+    var _this;
+    _classCallCheck(this, Selection);
+    var anchor;
+    var active;
+    if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
+      anchor = new Position(anchorLineOrAnchor, anchorColumnOrActive);
+      active = new Position(activeLine, activeColumn);
+    } else if (Position.isPosition(anchorLineOrAnchor) && Position.isPosition(anchorColumnOrActive)) {
+      anchor = Position.of(anchorLineOrAnchor);
+      active = Position.of(anchorColumnOrActive);
+    }
+    if (!anchor || !active) {
+      throw new Error('Invalid arguments');
+    }
+    _this = _super.call(this, anchor, active);
+    _this._anchor = anchor;
+    _this._active = active;
+    return _this;
+  }
+  _createClass(Selection, [{
+    key: "anchor",
+    get: function get() {
+      return this._anchor;
+    }
+  }, {
+    key: "active",
+    get: function get() {
+      return this._active;
+    }
+  }, {
+    key: "isReversed",
+    get: function get() {
+      return this._anchor === this._end;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        start: this.start,
+        end: this.end,
+        active: this.active,
+        anchor: this.anchor
+      };
+    }
+  }], [{
+    key: "isSelection",
+    value: function isSelection(thing) {
+      if (thing instanceof Selection) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return Range.isRange(thing) && Position.isPosition(thing.anchor) && Position.isPosition(thing.active) && typeof thing.isReversed === 'boolean';
+    }
+  }]);
+  return Selection;
+}(Range);
+var validateConnectionToken = function validateConnectionToken(connectionToken) {
+  if (typeof connectionToken !== 'string' || connectionToken.length === 0 || !/^[0-9A-Za-z_\-]+$/.test(connectionToken)) {
+    throw illegalArgument('connectionToken');
+  }
+};
+export var ResolvedAuthority = /*#__PURE__*/function () {
+  function ResolvedAuthority(host, port, connectionToken) {
+    _classCallCheck(this, ResolvedAuthority);
+    if (typeof host !== 'string' || host.length === 0) {
+      throw illegalArgument('host');
+    }
+    if (typeof port !== 'number' || port === 0 || Math.round(port) !== port) {
+      throw illegalArgument('port');
+    }
+    if (typeof connectionToken !== 'undefined') {
+      validateConnectionToken(connectionToken);
+    }
+    this.host = host;
+    this.port = Math.round(port);
+    this.connectionToken = connectionToken;
+  }
+  _createClass(ResolvedAuthority, null, [{
+    key: "isResolvedAuthority",
+    value: function isResolvedAuthority(resolvedAuthority) {
+      return resolvedAuthority && _typeof(resolvedAuthority) === 'object' && typeof resolvedAuthority.host === 'string' && typeof resolvedAuthority.port === 'number' && (resolvedAuthority.connectionToken === undefined || typeof resolvedAuthority.connectionToken === 'string');
+    }
+  }]);
+  return ResolvedAuthority;
+}();
+export var EndOfLine = /*#__PURE__*/function (EndOfLine) {
+  EndOfLine[EndOfLine["LF"] = 1] = "LF";
+  EndOfLine[EndOfLine["CRLF"] = 2] = "CRLF";
+  return EndOfLine;
+}({});
+export var EnvironmentVariableMutatorType = /*#__PURE__*/function (EnvironmentVariableMutatorType) {
+  EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Replace"] = 1] = "Replace";
+  EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Append"] = 2] = "Append";
+  EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
+  return EnvironmentVariableMutatorType;
+}({});
+export var TextEdit = /*#__PURE__*/function () {
+  function TextEdit(range, newText) {
+    _classCallCheck(this, TextEdit);
+    this._range = range;
+    this._newText = newText;
+  }
+  _createClass(TextEdit, [{
+    key: "range",
+    get: function get() {
+      return this._range;
+    },
+    set: function set(value) {
+      if (value && !Range.isRange(value)) {
+        throw illegalArgument('range');
+      }
+      this._range = value;
+    }
+  }, {
+    key: "newText",
+    get: function get() {
+      return this._newText || '';
+    },
+    set: function set(value) {
+      if (value && typeof value !== 'string') {
+        throw illegalArgument('newText');
+      }
+      this._newText = value;
+    }
+  }, {
+    key: "newEol",
+    get: function get() {
+      return this._newEol;
+    },
+    set: function set(value) {
+      if (value && typeof value !== 'number') {
+        throw illegalArgument('newEol');
+      }
+      this._newEol = value;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        range: this.range,
+        newText: this.newText,
+        newEol: this._newEol
+      };
+    }
+  }], [{
+    key: "isTextEdit",
+    value: function isTextEdit(thing) {
+      if (thing instanceof TextEdit) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return Range.isRange(thing) && typeof thing.newText === 'string';
+    }
+  }, {
+    key: "replace",
+    value: function replace(range, newText) {
+      return new TextEdit(range, newText);
+    }
+  }, {
+    key: "insert",
+    value: function insert(position, newText) {
+      return TextEdit.replace(new Range(position, position), newText);
+    }
+  }, {
+    key: "delete",
+    value: function _delete(range) {
+      return TextEdit.replace(range, '');
+    }
+  }, {
+    key: "setEndOfLine",
+    value: function setEndOfLine(eol) {
+      var ret = new TextEdit(new Range(new Position(0, 0), new Position(0, 0)), '');
+      ret.newEol = eol;
+      return ret;
+    }
+  }]);
+  return TextEdit;
+}();
+export var NotebookEdit = /*#__PURE__*/function () {
+  function NotebookEdit(range, newCells) {
+    _classCallCheck(this, NotebookEdit);
+    this.range = range;
+    this.newCells = newCells;
+  }
+  _createClass(NotebookEdit, null, [{
+    key: "isNotebookCellEdit",
+    value: function isNotebookCellEdit(thing) {
+      if (thing instanceof NotebookEdit) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return NotebookRange.isNotebookRange(thing) && Array.isArray(thing.newCells);
+    }
+  }, {
+    key: "replaceCells",
+    value: function replaceCells(range, newCells) {
+      return new NotebookEdit(range, newCells);
+    }
+  }, {
+    key: "insertCells",
+    value: function insertCells(index, newCells) {
+      return new NotebookEdit(new NotebookRange(index, index), newCells);
+    }
+  }, {
+    key: "deleteCells",
+    value: function deleteCells(range) {
+      return new NotebookEdit(range, []);
+    }
+  }, {
+    key: "updateCellMetadata",
+    value: function updateCellMetadata(index, newMetadata) {
+      var edit = new NotebookEdit(new NotebookRange(index, index), []);
+      edit.newCellMetadata = newMetadata;
+      return edit;
+    }
+  }, {
+    key: "updateNotebookMetadata",
+    value: function updateNotebookMetadata(newMetadata) {
+      var edit = new NotebookEdit(new NotebookRange(0, 0), []);
+      edit.newNotebookMetadata = newMetadata;
+      return edit;
+    }
+  }]);
+  return NotebookEdit;
+}();
+export var SnippetTextEdit = /*#__PURE__*/function () {
+  function SnippetTextEdit(range, snippet) {
+    _classCallCheck(this, SnippetTextEdit);
+    this.range = range;
+    this.snippet = snippet;
+  }
+  _createClass(SnippetTextEdit, null, [{
+    key: "isSnippetTextEdit",
+    value: function isSnippetTextEdit(thing) {
+      if (thing instanceof SnippetTextEdit) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return Range.isRange(thing.range) && SnippetString.isSnippetString(thing.snippet);
+    }
+  }, {
+    key: "replace",
+    value: function replace(range, snippet) {
+      return new SnippetTextEdit(range, snippet);
+    }
+  }, {
+    key: "insert",
+    value: function insert(position, snippet) {
+      return SnippetTextEdit.replace(new Range(position, position), snippet);
+    }
+  }]);
+  return SnippetTextEdit;
+}();
+export var FileEditType = /*#__PURE__*/function (FileEditType) {
+  FileEditType[FileEditType["File"] = 1] = "File";
+  FileEditType[FileEditType["Text"] = 2] = "Text";
+  FileEditType[FileEditType["Cell"] = 3] = "Cell";
+  FileEditType[FileEditType["CellReplace"] = 5] = "CellReplace";
+  FileEditType[FileEditType["Snippet"] = 6] = "Snippet";
+  return FileEditType;
+}({});
+export var WorkspaceEdit = /*#__PURE__*/function () {
+  function WorkspaceEdit() {
+    _classCallCheck(this, WorkspaceEdit);
+    this._edits = [];
+  }
+  _createClass(WorkspaceEdit, [{
+    key: "_allEntries",
+    value: function _allEntries() {
+      return this._edits;
+    }
+
+    // --- file
+  }, {
+    key: "renameFile",
+    value: function renameFile(from, to, options, metadata) {
+      this._edits.push({
+        _type: FileEditType.File,
+        from: from,
+        to: to,
+        options: options,
+        metadata: metadata
+      });
+    }
+  }, {
+    key: "createFile",
+    value: function createFile(uri, options, metadata) {
+      this._edits.push({
+        _type: FileEditType.File,
+        from: undefined,
+        to: uri,
+        options: options,
+        metadata: metadata
+      });
+    }
+  }, {
+    key: "deleteFile",
+    value: function deleteFile(uri, options, metadata) {
+      this._edits.push({
+        _type: FileEditType.File,
+        from: uri,
+        to: undefined,
+        options: options,
+        metadata: metadata
+      });
+    }
+
+    // --- notebook
+  }, {
+    key: "replaceNotebookMetadata",
+    value: function replaceNotebookMetadata(uri, value, metadata) {
+      this._edits.push({
+        _type: FileEditType.Cell,
+        metadata: metadata,
+        uri: uri,
+        edit: {
+          editType: CellEditType.DocumentMetadata,
+          metadata: value
+        },
+        notebookMetadata: value
+      });
+    }
+  }, {
+    key: "replaceNotebookCells",
+    value: function replaceNotebookCells(uri, startOrRange, cellData, metadata) {
+      var start = startOrRange.start;
+      var end = startOrRange.end;
+      if (start !== end || cellData.length > 0) {
+        this._edits.push({
+          _type: FileEditType.CellReplace,
+          uri: uri,
+          index: start,
+          count: end - start,
+          cells: cellData,
+          metadata: metadata
+        });
+      }
+    }
+  }, {
+    key: "replaceNotebookCellMetadata",
+    value: function replaceNotebookCellMetadata(uri, index, cellMetadata, metadata) {
+      this._edits.push({
+        _type: FileEditType.Cell,
+        metadata: metadata,
+        uri: uri,
+        edit: {
+          editType: CellEditType.Metadata,
+          index: index,
+          metadata: cellMetadata
+        }
+      });
+    }
+
+    // --- text
+  }, {
+    key: "replace",
+    value: function replace(uri, range, newText, metadata) {
+      this._edits.push({
+        _type: FileEditType.Text,
+        uri: uri,
+        edit: new TextEdit(range, newText),
+        metadata: metadata
+      });
+    }
+  }, {
+    key: "insert",
+    value: function insert(resource, position, newText, metadata) {
+      this.replace(resource, new Range(position, position), newText, metadata);
+    }
+  }, {
+    key: "delete",
+    value: function _delete(resource, range, metadata) {
+      this.replace(resource, range, '', metadata);
+    }
+
+    // --- text (Maplike)
+  }, {
+    key: "has",
+    value: function has(uri) {
+      return this._edits.some(function (edit) {
+        return edit._type === FileEditType.Text && edit.uri.toString() === uri.toString();
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(uri, edits) {
+      if (!edits) {
+        // remove all text, snippet, or notebook edits for `uri`
+        for (var i = 0; i < this._edits.length; i++) {
+          var element = this._edits[i];
+          switch (element._type) {
+            case FileEditType.Text:
+            case FileEditType.Snippet:
+            case FileEditType.Cell:
+            case FileEditType.CellReplace:
+              if (element.uri.toString() === uri.toString()) {
+                this._edits[i] = undefined; // will be coalesced down below
+              }
+              break;
+          }
+        }
+        coalesceInPlace(this._edits);
+      } else {
+        // append edit to the end
+        var _iterator = _createForOfIteratorHelper(edits),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var editOrTuple = _step.value;
+            if (!editOrTuple) {
+              continue;
+            }
+            var edit = void 0;
+            var metadata = void 0;
+            if (Array.isArray(editOrTuple)) {
+              edit = editOrTuple[0];
+              metadata = editOrTuple[1];
+            } else {
+              edit = editOrTuple;
+            }
+            if (NotebookEdit.isNotebookCellEdit(edit)) {
+              if (edit.newCellMetadata) {
+                this.replaceNotebookCellMetadata(uri, edit.range.start, edit.newCellMetadata, metadata);
+              } else if (edit.newNotebookMetadata) {
+                this.replaceNotebookMetadata(uri, edit.newNotebookMetadata, metadata);
+              } else {
+                this.replaceNotebookCells(uri, edit.range, edit.newCells, metadata);
+              }
+            } else if (SnippetTextEdit.isSnippetTextEdit(edit)) {
+              this._edits.push({
+                _type: FileEditType.Snippet,
+                uri: uri,
+                range: edit.range,
+                edit: edit.snippet,
+                metadata: metadata
+              });
+            } else {
+              this._edits.push({
+                _type: FileEditType.Text,
+                uri: uri,
+                edit: edit,
+                metadata: metadata
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+  }, {
+    key: "get",
+    value: function get(uri) {
+      var res = [];
+      var _iterator2 = _createForOfIteratorHelper(this._edits),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var candidate = _step2.value;
+          if (candidate._type === FileEditType.Text && candidate.uri.toString() === uri.toString()) {
+            res.push(candidate.edit);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return res;
+    }
+  }, {
+    key: "entries",
+    value: function entries() {
+      var textEdits = new ResourceMap();
+      var _iterator3 = _createForOfIteratorHelper(this._edits),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var candidate = _step3.value;
+          if (candidate._type === FileEditType.Text) {
+            var textEdit = textEdits.get(candidate.uri);
+            if (!textEdit) {
+              textEdit = [candidate.uri, []];
+              textEdits.set(candidate.uri, textEdit);
+            }
+            textEdit[1].push(candidate.edit);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return _toConsumableArray(textEdits.values());
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.entries().length;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this.entries();
+    }
+  }]);
+  return WorkspaceEdit;
+}();
+export var SnippetString = /*#__PURE__*/function () {
+  function SnippetString(value) {
+    _classCallCheck(this, SnippetString);
+    this._tabstop = 1;
+    this.value = value || '';
+  }
+  _createClass(SnippetString, [{
+    key: "appendText",
+    value: function appendText(string) {
+      this.value += SnippetString._escape(string);
+      return this;
+    }
+  }, {
+    key: "appendTabstop",
+    value: function appendTabstop() {
+      var number = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._tabstop++;
+      this.value += '$';
+      this.value += number;
+      return this;
+    }
+  }, {
+    key: "appendPlaceholder",
+    value: function appendPlaceholder(value) {
+      var number = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._tabstop++;
+      if (typeof value === 'function') {
+        var nested = new SnippetString();
+        nested._tabstop = this._tabstop;
+        value(nested);
+        this._tabstop = nested._tabstop;
+        value = nested.value;
+      } else {
+        value = SnippetString._escape(value);
+      }
+      this.value += '${';
+      this.value += number;
+      this.value += ':';
+      this.value += value;
+      this.value += '}';
+      return this;
+    }
+  }, {
+    key: "appendChoice",
+    value: function appendChoice(values) {
+      var number = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._tabstop++;
+      var value = values.map(function (s) {
+        return s.replaceAll(/[|\\,]/g, '\\$&');
+      }).join(',');
+      this.value += '${';
+      this.value += number;
+      this.value += '|';
+      this.value += value;
+      this.value += '|}';
+      return this;
+    }
+  }, {
+    key: "appendVariable",
+    value: function appendVariable(name, defaultValue) {
+      if (typeof defaultValue === 'function') {
+        var nested = new SnippetString();
+        nested._tabstop = this._tabstop;
+        defaultValue(nested);
+        this._tabstop = nested._tabstop;
+        defaultValue = nested.value;
+      } else if (typeof defaultValue === 'string') {
+        defaultValue = defaultValue.replace(/\$|}/g, '\\$&'); // CodeQL [SM02383] I do not want to escape backslashes here
+      }
+      this.value += '${';
+      this.value += name;
+      if (defaultValue) {
+        this.value += ':';
+        this.value += defaultValue;
+      }
+      this.value += '}';
+      return this;
+    }
+  }], [{
+    key: "isSnippetString",
+    value: function isSnippetString(thing) {
+      if (thing instanceof SnippetString) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return typeof thing.value === 'string';
+    }
+  }, {
+    key: "_escape",
+    value: function _escape(value) {
+      return value.replace(/\$|}|\\/g, '\\$&');
+    }
+  }]);
+  return SnippetString;
+}();
+export var DiagnosticTag = /*#__PURE__*/function (DiagnosticTag) {
+  DiagnosticTag[DiagnosticTag["Unnecessary"] = 1] = "Unnecessary";
+  DiagnosticTag[DiagnosticTag["Deprecated"] = 2] = "Deprecated";
+  return DiagnosticTag;
+}({});
+export var DiagnosticSeverity = /*#__PURE__*/function (DiagnosticSeverity) {
+  DiagnosticSeverity[DiagnosticSeverity["Hint"] = 3] = "Hint";
+  DiagnosticSeverity[DiagnosticSeverity["Information"] = 2] = "Information";
+  DiagnosticSeverity[DiagnosticSeverity["Warning"] = 1] = "Warning";
+  DiagnosticSeverity[DiagnosticSeverity["Error"] = 0] = "Error";
+  return DiagnosticSeverity;
+}({});
+export var Location = /*#__PURE__*/function () {
+  function Location(uri, rangeOrPosition) {
+    _classCallCheck(this, Location);
+    this.uri = uri;
+    if (!rangeOrPosition) {
+      //that's OK
+    } else if (Range.isRange(rangeOrPosition)) {
+      this.range = Range.of(rangeOrPosition);
+    } else if (Position.isPosition(rangeOrPosition)) {
+      this.range = new Range(rangeOrPosition, rangeOrPosition);
+    } else {
+      throw new Error('Illegal argument');
+    }
+  }
+  _createClass(Location, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        uri: this.uri,
+        range: this.range
+      };
+    }
+  }], [{
+    key: "isLocation",
+    value: function isLocation(thing) {
+      if (thing instanceof Location) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return Range.isRange(thing.range) && URI.isUri(thing.uri);
+    }
+  }]);
+  return Location;
+}();
+export var DiagnosticRelatedInformation = /*#__PURE__*/function () {
+  function DiagnosticRelatedInformation(location, message) {
+    _classCallCheck(this, DiagnosticRelatedInformation);
+    this.location = location;
+    this.message = message;
+  }
+  _createClass(DiagnosticRelatedInformation, null, [{
+    key: "is",
+    value: function is(thing) {
+      if (!thing) {
+        return false;
+      }
+      return typeof thing.message === 'string' && thing.location && Range.isRange(thing.location.range) && URI.isUri(thing.location.uri);
+    }
+  }, {
+    key: "isEqual",
+    value: function isEqual(a, b) {
+      if (a === b) {
+        return true;
+      }
+      if (!a || !b) {
+        return false;
+      }
+      return a.message === b.message && a.location.range.isEqual(b.location.range) && a.location.uri.toString() === b.location.uri.toString();
+    }
+  }]);
+  return DiagnosticRelatedInformation;
+}();
+export var Diagnostic = /*#__PURE__*/function () {
+  function Diagnostic(range, message) {
+    var severity = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DiagnosticSeverity.Error;
+    _classCallCheck(this, Diagnostic);
+    if (!Range.isRange(range)) {
+      throw new TypeError('range must be set');
+    }
+    if (!message) {
+      throw new TypeError('message must be set');
+    }
+    this.range = range;
+    this.message = message;
+    this.severity = severity;
+  }
+  _createClass(Diagnostic, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        severity: DiagnosticSeverity[this.severity],
+        message: this.message,
+        range: this.range,
+        source: this.source,
+        code: this.code
+      };
+    }
+  }], [{
+    key: "isEqual",
+    value: function isEqual(a, b) {
+      if (a === b) {
+        return true;
+      }
+      if (!a || !b) {
+        return false;
+      }
+      return a.message === b.message && a.severity === b.severity && a.code === b.code && a.severity === b.severity && a.source === b.source && a.range.isEqual(b.range) && equals(a.tags, b.tags) && equals(a.relatedInformation, b.relatedInformation, DiagnosticRelatedInformation.isEqual);
+    }
+  }]);
+  return Diagnostic;
+}();
+export var Hover = /*#__PURE__*/_createClass(function Hover(contents, range) {
+  _classCallCheck(this, Hover);
+  if (!contents) {
+    throw new Error('Illegal argument, contents must be defined');
+  }
+  if (Array.isArray(contents)) {
+    this.contents = contents;
+  } else {
+    this.contents = [contents];
+  }
+  this.range = range;
+});
+export var DocumentHighlightKind = /*#__PURE__*/function (DocumentHighlightKind) {
+  DocumentHighlightKind[DocumentHighlightKind["Text"] = 0] = "Text";
+  DocumentHighlightKind[DocumentHighlightKind["Read"] = 1] = "Read";
+  DocumentHighlightKind[DocumentHighlightKind["Write"] = 2] = "Write";
+  return DocumentHighlightKind;
+}({});
+export var DocumentHighlight = /*#__PURE__*/function () {
+  function DocumentHighlight(range) {
+    var kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DocumentHighlightKind.Text;
+    _classCallCheck(this, DocumentHighlight);
+    this.range = range;
+    this.kind = kind;
+  }
+  _createClass(DocumentHighlight, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        range: this.range,
+        kind: DocumentHighlightKind[this.kind]
+      };
+    }
+  }]);
+  return DocumentHighlight;
+}();
+export var MultiDocumentHighlight = /*#__PURE__*/function () {
+  function MultiDocumentHighlight(uri, highlights) {
+    _classCallCheck(this, MultiDocumentHighlight);
+    this.uri = uri;
+    this.highlights = highlights;
+  }
+  _createClass(MultiDocumentHighlight, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        uri: this.uri,
+        highlights: this.highlights.map(function (h) {
+          return h.toJSON();
+        })
+      };
+    }
+  }]);
+  return MultiDocumentHighlight;
+}();
+export var SymbolKind = /*#__PURE__*/function (SymbolKind) {
+  SymbolKind[SymbolKind["File"] = 0] = "File";
+  SymbolKind[SymbolKind["Module"] = 1] = "Module";
+  SymbolKind[SymbolKind["Namespace"] = 2] = "Namespace";
+  SymbolKind[SymbolKind["Package"] = 3] = "Package";
+  SymbolKind[SymbolKind["Class"] = 4] = "Class";
+  SymbolKind[SymbolKind["Method"] = 5] = "Method";
+  SymbolKind[SymbolKind["Property"] = 6] = "Property";
+  SymbolKind[SymbolKind["Field"] = 7] = "Field";
+  SymbolKind[SymbolKind["Constructor"] = 8] = "Constructor";
+  SymbolKind[SymbolKind["Enum"] = 9] = "Enum";
+  SymbolKind[SymbolKind["Interface"] = 10] = "Interface";
+  SymbolKind[SymbolKind["Function"] = 11] = "Function";
+  SymbolKind[SymbolKind["Variable"] = 12] = "Variable";
+  SymbolKind[SymbolKind["Constant"] = 13] = "Constant";
+  SymbolKind[SymbolKind["String"] = 14] = "String";
+  SymbolKind[SymbolKind["Number"] = 15] = "Number";
+  SymbolKind[SymbolKind["Boolean"] = 16] = "Boolean";
+  SymbolKind[SymbolKind["Array"] = 17] = "Array";
+  SymbolKind[SymbolKind["Object"] = 18] = "Object";
+  SymbolKind[SymbolKind["Key"] = 19] = "Key";
+  SymbolKind[SymbolKind["Null"] = 20] = "Null";
+  SymbolKind[SymbolKind["EnumMember"] = 21] = "EnumMember";
+  SymbolKind[SymbolKind["Struct"] = 22] = "Struct";
+  SymbolKind[SymbolKind["Event"] = 23] = "Event";
+  SymbolKind[SymbolKind["Operator"] = 24] = "Operator";
+  SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
+  return SymbolKind;
+}({});
+export var SymbolTag = /*#__PURE__*/function (SymbolTag) {
+  SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated";
+  return SymbolTag;
+}({});
+export var SymbolInformation = /*#__PURE__*/function () {
+  function SymbolInformation(name, kind, rangeOrContainer, locationOrUri, containerName) {
+    _classCallCheck(this, SymbolInformation);
+    this.name = name;
+    this.kind = kind;
+    this.containerName = containerName !== null && containerName !== void 0 ? containerName : '';
+    if (typeof rangeOrContainer === 'string') {
+      this.containerName = rangeOrContainer;
+    }
+    if (locationOrUri instanceof Location) {
+      this.location = locationOrUri;
+    } else if (rangeOrContainer instanceof Range) {
+      this.location = new Location(locationOrUri, rangeOrContainer);
+    }
+    SymbolInformation.validate(this);
+  }
+  _createClass(SymbolInformation, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        name: this.name,
+        kind: SymbolKind[this.kind],
+        location: this.location,
+        containerName: this.containerName
+      };
+    }
+  }], [{
+    key: "validate",
+    value: function validate(candidate) {
+      if (!candidate.name) {
+        throw new Error('name must not be falsy');
+      }
+    }
+  }]);
+  return SymbolInformation;
+}();
+export var DocumentSymbol = /*#__PURE__*/function () {
+  function DocumentSymbol(name, detail, kind, range, selectionRange) {
+    _classCallCheck(this, DocumentSymbol);
+    this.name = name;
+    this.detail = detail;
+    this.kind = kind;
+    this.range = range;
+    this.selectionRange = selectionRange;
+    this.children = [];
+    DocumentSymbol.validate(this);
+  }
+  _createClass(DocumentSymbol, null, [{
+    key: "validate",
+    value: function validate(candidate) {
+      var _candidate$children;
+      if (!candidate.name) {
+        throw new Error('name must not be falsy');
+      }
+      if (!candidate.range.contains(candidate.selectionRange)) {
+        throw new Error('selectionRange must be contained in fullRange');
+      }
+      (_candidate$children = candidate.children) === null || _candidate$children === void 0 || _candidate$children.forEach(DocumentSymbol.validate);
+    }
+  }]);
+  return DocumentSymbol;
+}();
+export var CodeActionTriggerKind = /*#__PURE__*/function (CodeActionTriggerKind) {
+  CodeActionTriggerKind[CodeActionTriggerKind["Invoke"] = 1] = "Invoke";
+  CodeActionTriggerKind[CodeActionTriggerKind["Automatic"] = 2] = "Automatic";
+  return CodeActionTriggerKind;
+}({});
+export var CodeAction = /*#__PURE__*/_createClass(function CodeAction(title, kind) {
+  _classCallCheck(this, CodeAction);
+  this.title = title;
+  this.kind = kind;
+});
+export var CodeActionKind = /*#__PURE__*/function () {
+  function CodeActionKind(value) {
+    _classCallCheck(this, CodeActionKind);
+    this.value = value;
+  }
+  _createClass(CodeActionKind, [{
+    key: "append",
+    value: function append(parts) {
+      return new CodeActionKind(this.value ? this.value + CodeActionKind.sep + parts : parts);
+    }
+  }, {
+    key: "intersects",
+    value: function intersects(other) {
+      return this.contains(other) || other.contains(this);
+    }
+  }, {
+    key: "contains",
+    value: function contains(other) {
+      return this.value === other.value || other.value.startsWith(this.value + CodeActionKind.sep);
+    }
+  }]);
+  return CodeActionKind;
+}();
+CodeActionKind.sep = '.';
+CodeActionKind.Empty = new CodeActionKind('');
+CodeActionKind.QuickFix = CodeActionKind.Empty.append('quickfix');
+CodeActionKind.Refactor = CodeActionKind.Empty.append('refactor');
+CodeActionKind.RefactorExtract = CodeActionKind.Refactor.append('extract');
+CodeActionKind.RefactorInline = CodeActionKind.Refactor.append('inline');
+CodeActionKind.RefactorMove = CodeActionKind.Refactor.append('move');
+CodeActionKind.RefactorRewrite = CodeActionKind.Refactor.append('rewrite');
+CodeActionKind.Source = CodeActionKind.Empty.append('source');
+CodeActionKind.SourceOrganizeImports = CodeActionKind.Source.append('organizeImports');
+CodeActionKind.SourceFixAll = CodeActionKind.Source.append('fixAll');
+CodeActionKind.Notebook = CodeActionKind.Empty.append('notebook');
+export var SelectionRange = /*#__PURE__*/_createClass(function SelectionRange(range, parent) {
+  _classCallCheck(this, SelectionRange);
+  this.range = range;
+  this.parent = parent;
+  if (parent && !parent.range.contains(this.range)) {
+    throw new Error('Invalid argument: parent must contain this range');
+  }
+});
+export var CallHierarchyItem = /*#__PURE__*/_createClass(function CallHierarchyItem(kind, name, detail, uri, range, selectionRange) {
+  _classCallCheck(this, CallHierarchyItem);
+  this.kind = kind;
+  this.name = name;
+  this.detail = detail;
+  this.uri = uri;
+  this.range = range;
+  this.selectionRange = selectionRange;
+});
+export var CallHierarchyIncomingCall = /*#__PURE__*/_createClass(function CallHierarchyIncomingCall(item, fromRanges) {
+  _classCallCheck(this, CallHierarchyIncomingCall);
+  this.fromRanges = fromRanges;
+  this.from = item;
+});
+export var CallHierarchyOutgoingCall = /*#__PURE__*/_createClass(function CallHierarchyOutgoingCall(item, fromRanges) {
+  _classCallCheck(this, CallHierarchyOutgoingCall);
+  this.fromRanges = fromRanges;
+  this.to = item;
+});
+export var LanguageStatusSeverity = /*#__PURE__*/function (LanguageStatusSeverity) {
+  LanguageStatusSeverity[LanguageStatusSeverity["Information"] = 0] = "Information";
+  LanguageStatusSeverity[LanguageStatusSeverity["Warning"] = 1] = "Warning";
+  LanguageStatusSeverity[LanguageStatusSeverity["Error"] = 2] = "Error";
+  return LanguageStatusSeverity;
+}({});
+export var CodeLens = /*#__PURE__*/function () {
+  function CodeLens(range, command) {
+    _classCallCheck(this, CodeLens);
+    this.range = range;
+    this.command = command;
+  }
+  _createClass(CodeLens, [{
+    key: "isResolved",
+    get: function get() {
+      return !!this.command;
+    }
+  }]);
+  return CodeLens;
+}();
+var _delegate = /*#__PURE__*/_classPrivateFieldLooseKey("delegate");
+export var MarkdownString = /*#__PURE__*/function () {
+  function MarkdownString(value) {
+    var supportThemeIcons = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, MarkdownString);
+    Object.defineProperty(this, _delegate, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _delegate)[_delegate] = new BaseMarkdownString(value, {
+      supportThemeIcons: supportThemeIcons
+    });
+  }
+  _createClass(MarkdownString, [{
+    key: "value",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _delegate)[_delegate].value;
+    },
+    set: function set(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].value = value;
+    }
+  }, {
+    key: "isTrusted",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _delegate)[_delegate].isTrusted;
+    },
+    set: function set(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].isTrusted = value;
+    }
+  }, {
+    key: "supportThemeIcons",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _delegate)[_delegate].supportThemeIcons;
+    },
+    set: function set(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].supportThemeIcons = value;
+    }
+  }, {
+    key: "supportHtml",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _delegate)[_delegate].supportHtml;
+    },
+    set: function set(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].supportHtml = value;
+    }
+  }, {
+    key: "baseUri",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _delegate)[_delegate].baseUri;
+    },
+    set: function set(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].baseUri = value;
+    }
+  }, {
+    key: "appendText",
+    value: function appendText(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].appendText(value);
+      return this;
+    }
+  }, {
+    key: "appendMarkdown",
+    value: function appendMarkdown(value) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].appendMarkdown(value);
+      return this;
+    }
+  }, {
+    key: "appendCodeblock",
+    value: function appendCodeblock(value, language) {
+      _classPrivateFieldLooseBase(this, _delegate)[_delegate].appendCodeblock(language !== null && language !== void 0 ? language : '', value);
+      return this;
+    }
+  }], [{
+    key: "isMarkdownString",
+    value: function isMarkdownString(thing) {
+      if (thing instanceof MarkdownString) {
+        return true;
+      }
+      return thing && thing.appendCodeblock && thing.appendMarkdown && thing.appendText && thing.value !== undefined;
+    }
+  }]);
+  return MarkdownString;
+}();
+export var ParameterInformation = /*#__PURE__*/_createClass(function ParameterInformation(label, documentation) {
+  _classCallCheck(this, ParameterInformation);
+  this.label = label;
+  this.documentation = documentation;
+});
+export var SignatureInformation = /*#__PURE__*/_createClass(function SignatureInformation(label, documentation) {
+  _classCallCheck(this, SignatureInformation);
+  this.label = label;
+  this.documentation = documentation;
+  this.parameters = [];
+});
+export var SignatureHelp = /*#__PURE__*/_createClass(function SignatureHelp() {
+  _classCallCheck(this, SignatureHelp);
+  this.activeSignature = 0;
+  this.activeParameter = 0;
+  this.signatures = [];
+});
+export var SignatureHelpTriggerKind = /*#__PURE__*/function (SignatureHelpTriggerKind) {
+  SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke";
+  SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter";
+  SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange";
+  return SignatureHelpTriggerKind;
+}({});
+export var InlayHintKind = /*#__PURE__*/function (InlayHintKind) {
+  InlayHintKind[InlayHintKind["Type"] = 1] = "Type";
+  InlayHintKind[InlayHintKind["Parameter"] = 2] = "Parameter";
+  return InlayHintKind;
+}({});
+export var InlayHintLabelPart = /*#__PURE__*/_createClass(function InlayHintLabelPart(value) {
+  _classCallCheck(this, InlayHintLabelPart);
+  this.value = value;
+});
+export var InlayHint = /*#__PURE__*/_createClass(function InlayHint(position, label, kind) {
+  _classCallCheck(this, InlayHint);
+  this.position = position;
+  this.label = label;
+  this.kind = kind;
+});
+export var CompletionTriggerKind = /*#__PURE__*/function (CompletionTriggerKind) {
+  CompletionTriggerKind[CompletionTriggerKind["Invoke"] = 0] = "Invoke";
+  CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 1] = "TriggerCharacter";
+  CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 2] = "TriggerForIncompleteCompletions";
+  return CompletionTriggerKind;
+}({});
+export var CompletionItemKind = /*#__PURE__*/function (CompletionItemKind) {
+  CompletionItemKind[CompletionItemKind["Text"] = 0] = "Text";
+  CompletionItemKind[CompletionItemKind["Method"] = 1] = "Method";
+  CompletionItemKind[CompletionItemKind["Function"] = 2] = "Function";
+  CompletionItemKind[CompletionItemKind["Constructor"] = 3] = "Constructor";
+  CompletionItemKind[CompletionItemKind["Field"] = 4] = "Field";
+  CompletionItemKind[CompletionItemKind["Variable"] = 5] = "Variable";
+  CompletionItemKind[CompletionItemKind["Class"] = 6] = "Class";
+  CompletionItemKind[CompletionItemKind["Interface"] = 7] = "Interface";
+  CompletionItemKind[CompletionItemKind["Module"] = 8] = "Module";
+  CompletionItemKind[CompletionItemKind["Property"] = 9] = "Property";
+  CompletionItemKind[CompletionItemKind["Unit"] = 10] = "Unit";
+  CompletionItemKind[CompletionItemKind["Value"] = 11] = "Value";
+  CompletionItemKind[CompletionItemKind["Enum"] = 12] = "Enum";
+  CompletionItemKind[CompletionItemKind["Keyword"] = 13] = "Keyword";
+  CompletionItemKind[CompletionItemKind["Snippet"] = 14] = "Snippet";
+  CompletionItemKind[CompletionItemKind["Color"] = 15] = "Color";
+  CompletionItemKind[CompletionItemKind["File"] = 16] = "File";
+  CompletionItemKind[CompletionItemKind["Reference"] = 17] = "Reference";
+  CompletionItemKind[CompletionItemKind["Folder"] = 18] = "Folder";
+  CompletionItemKind[CompletionItemKind["EnumMember"] = 19] = "EnumMember";
+  CompletionItemKind[CompletionItemKind["Constant"] = 20] = "Constant";
+  CompletionItemKind[CompletionItemKind["Struct"] = 21] = "Struct";
+  CompletionItemKind[CompletionItemKind["Event"] = 22] = "Event";
+  CompletionItemKind[CompletionItemKind["Operator"] = 23] = "Operator";
+  CompletionItemKind[CompletionItemKind["TypeParameter"] = 24] = "TypeParameter";
+  CompletionItemKind[CompletionItemKind["User"] = 25] = "User";
+  CompletionItemKind[CompletionItemKind["Issue"] = 26] = "Issue";
+  return CompletionItemKind;
+}({});
+export var CompletionItemTag = /*#__PURE__*/function (CompletionItemTag) {
+  CompletionItemTag[CompletionItemTag["Deprecated"] = 1] = "Deprecated";
+  return CompletionItemTag;
+}({});
+export var CompletionItem = /*#__PURE__*/function () {
+  function CompletionItem(label, kind) {
+    _classCallCheck(this, CompletionItem);
+    this.label = label;
+    this.kind = kind;
+  }
+  _createClass(CompletionItem, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        label: this.label,
+        kind: this.kind && CompletionItemKind[this.kind],
+        detail: this.detail,
+        documentation: this.documentation,
+        sortText: this.sortText,
+        filterText: this.filterText,
+        preselect: this.preselect,
+        insertText: this.insertText,
+        textEdit: this.textEdit
+      };
+    }
+  }]);
+  return CompletionItem;
+}();
+export var CompletionList = /*#__PURE__*/_createClass(function CompletionList() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var isIncomplete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  _classCallCheck(this, CompletionList);
+  this.items = items;
+  this.isIncomplete = isIncomplete;
+});
+export var InlineSuggestion = /*#__PURE__*/_createClass(function InlineSuggestion(insertText, range, command) {
+  _classCallCheck(this, InlineSuggestion);
+  this.insertText = insertText;
+  this.range = range;
+  this.command = command;
+});
+export var InlineSuggestionList = /*#__PURE__*/_createClass(function InlineSuggestionList(items) {
+  _classCallCheck(this, InlineSuggestionList);
+  this.commands = undefined;
+  this.suppressSuggestions = undefined;
+  this.items = items;
+});
+export var ViewColumn = /*#__PURE__*/function (ViewColumn) {
+  ViewColumn[ViewColumn["Active"] = -1] = "Active";
+  ViewColumn[ViewColumn["Beside"] = -2] = "Beside";
+  ViewColumn[ViewColumn["One"] = 1] = "One";
+  ViewColumn[ViewColumn["Two"] = 2] = "Two";
+  ViewColumn[ViewColumn["Three"] = 3] = "Three";
+  ViewColumn[ViewColumn["Four"] = 4] = "Four";
+  ViewColumn[ViewColumn["Five"] = 5] = "Five";
+  ViewColumn[ViewColumn["Six"] = 6] = "Six";
+  ViewColumn[ViewColumn["Seven"] = 7] = "Seven";
+  ViewColumn[ViewColumn["Eight"] = 8] = "Eight";
+  ViewColumn[ViewColumn["Nine"] = 9] = "Nine";
+  return ViewColumn;
+}({});
+export var StatusBarAlignment = /*#__PURE__*/function (StatusBarAlignment) {
+  StatusBarAlignment[StatusBarAlignment["Left"] = 1] = "Left";
+  StatusBarAlignment[StatusBarAlignment["Right"] = 2] = "Right";
+  return StatusBarAlignment;
+}({});
+export var TextEditorLineNumbersStyle = /*#__PURE__*/function (TextEditorLineNumbersStyle) {
+  TextEditorLineNumbersStyle[TextEditorLineNumbersStyle["Off"] = 0] = "Off";
+  TextEditorLineNumbersStyle[TextEditorLineNumbersStyle["On"] = 1] = "On";
+  TextEditorLineNumbersStyle[TextEditorLineNumbersStyle["Relative"] = 2] = "Relative";
+  return TextEditorLineNumbersStyle;
+}({});
+export var TextDocumentSaveReason = /*#__PURE__*/function (TextDocumentSaveReason) {
+  TextDocumentSaveReason[TextDocumentSaveReason["Manual"] = 1] = "Manual";
+  TextDocumentSaveReason[TextDocumentSaveReason["AfterDelay"] = 2] = "AfterDelay";
+  TextDocumentSaveReason[TextDocumentSaveReason["FocusOut"] = 3] = "FocusOut";
+  return TextDocumentSaveReason;
+}({});
+export var TextEditorRevealType = /*#__PURE__*/function (TextEditorRevealType) {
+  TextEditorRevealType[TextEditorRevealType["Default"] = 0] = "Default";
+  TextEditorRevealType[TextEditorRevealType["InCenter"] = 1] = "InCenter";
+  TextEditorRevealType[TextEditorRevealType["InCenterIfOutsideViewport"] = 2] = "InCenterIfOutsideViewport";
+  TextEditorRevealType[TextEditorRevealType["AtTop"] = 3] = "AtTop";
+  return TextEditorRevealType;
+}({});
+export var TextEditorSelectionChangeKind = /*#__PURE__*/function (TextEditorSelectionChangeKind) {
+  TextEditorSelectionChangeKind[TextEditorSelectionChangeKind["Keyboard"] = 1] = "Keyboard";
+  TextEditorSelectionChangeKind[TextEditorSelectionChangeKind["Mouse"] = 2] = "Mouse";
+  TextEditorSelectionChangeKind[TextEditorSelectionChangeKind["Command"] = 3] = "Command";
+  return TextEditorSelectionChangeKind;
+}({});
+export var TextDocumentChangeReason = /*#__PURE__*/function (TextDocumentChangeReason) {
+  TextDocumentChangeReason[TextDocumentChangeReason["Undo"] = 1] = "Undo";
+  TextDocumentChangeReason[TextDocumentChangeReason["Redo"] = 2] = "Redo";
+  return TextDocumentChangeReason;
+}({});
+
+/**
+ * These values match very carefully the values of `TrackedRangeStickiness`
+ */
+export var DecorationRangeBehavior = /*#__PURE__*/function (DecorationRangeBehavior) {
+  DecorationRangeBehavior[DecorationRangeBehavior["OpenOpen"] = 0] = "OpenOpen";
+  DecorationRangeBehavior[DecorationRangeBehavior["ClosedClosed"] = 1] = "ClosedClosed";
+  DecorationRangeBehavior[DecorationRangeBehavior["OpenClosed"] = 2] = "OpenClosed";
+  DecorationRangeBehavior[DecorationRangeBehavior["ClosedOpen"] = 3] = "ClosedOpen";
+  return DecorationRangeBehavior;
+}({});
+(function (_TextEditorSelectionChangeKind) {
+  function fromValue(s) {
+    switch (s) {
+      case 'keyboard':
+        return TextEditorSelectionChangeKind.Keyboard;
+      case 'mouse':
+        return TextEditorSelectionChangeKind.Mouse;
+      case 'api':
+        return TextEditorSelectionChangeKind.Command;
+    }
+    return undefined;
+  }
+  _TextEditorSelectionChangeKind.fromValue = fromValue;
+})(TextEditorSelectionChangeKind || (TextEditorSelectionChangeKind = {}));
+export var SyntaxTokenType = /*#__PURE__*/function (SyntaxTokenType) {
+  SyntaxTokenType[SyntaxTokenType["Other"] = 0] = "Other";
+  SyntaxTokenType[SyntaxTokenType["Comment"] = 1] = "Comment";
+  SyntaxTokenType[SyntaxTokenType["String"] = 2] = "String";
+  SyntaxTokenType[SyntaxTokenType["RegEx"] = 3] = "RegEx";
+  return SyntaxTokenType;
+}({});
+(function (_SyntaxTokenType) {
+  function toString(v) {
+    switch (v) {
+      case SyntaxTokenType.Other:
+        return 'other';
+      case SyntaxTokenType.Comment:
+        return 'comment';
+      case SyntaxTokenType.String:
+        return 'string';
+      case SyntaxTokenType.RegEx:
+        return 'regex';
+    }
+    return 'other';
+  }
+  _SyntaxTokenType.toString = toString;
+})(SyntaxTokenType || (SyntaxTokenType = {}));
+export var DocumentLink = /*#__PURE__*/_createClass(function DocumentLink(range, target) {
+  _classCallCheck(this, DocumentLink);
+  if (target && !URI.isUri(target)) {
+    throw illegalArgument('target');
+  }
+  if (!Range.isRange(range) || range.isEmpty) {
+    throw illegalArgument('range');
+  }
+  this.range = range;
+  this.target = target;
+});
+export var Color = /*#__PURE__*/_createClass(function Color(red, green, blue, alpha) {
+  _classCallCheck(this, Color);
+  this.red = red;
+  this.green = green;
+  this.blue = blue;
+  this.alpha = alpha;
+});
+export var ColorInformation = /*#__PURE__*/_createClass(function ColorInformation(range, color) {
+  _classCallCheck(this, ColorInformation);
+  if (color && !(color instanceof Color)) {
+    throw illegalArgument('color');
+  }
+  if (!Range.isRange(range) || range.isEmpty) {
+    throw illegalArgument('range');
+  }
+  this.range = range;
+  this.color = color;
+});
+export var ColorPresentation = /*#__PURE__*/_createClass(function ColorPresentation(label) {
+  _classCallCheck(this, ColorPresentation);
+  if (!label || typeof label !== 'string') {
+    throw illegalArgument('label');
+  }
+  this.label = label;
+});
+export var ColorFormat = /*#__PURE__*/function (ColorFormat) {
+  ColorFormat[ColorFormat["RGB"] = 0] = "RGB";
+  ColorFormat[ColorFormat["HEX"] = 1] = "HEX";
+  ColorFormat[ColorFormat["HSL"] = 2] = "HSL";
+  return ColorFormat;
+}({});
+export var SourceControlInputBoxValidationType = /*#__PURE__*/function (SourceControlInputBoxValidationType) {
+  SourceControlInputBoxValidationType[SourceControlInputBoxValidationType["Error"] = 0] = "Error";
+  SourceControlInputBoxValidationType[SourceControlInputBoxValidationType["Warning"] = 1] = "Warning";
+  SourceControlInputBoxValidationType[SourceControlInputBoxValidationType["Information"] = 2] = "Information";
+  return SourceControlInputBoxValidationType;
+}({});
+export var TerminalExitReason = /*#__PURE__*/function (TerminalExitReason) {
+  TerminalExitReason[TerminalExitReason["Unknown"] = 0] = "Unknown";
+  TerminalExitReason[TerminalExitReason["Shutdown"] = 1] = "Shutdown";
+  TerminalExitReason[TerminalExitReason["Process"] = 2] = "Process";
+  TerminalExitReason[TerminalExitReason["User"] = 3] = "User";
+  TerminalExitReason[TerminalExitReason["Extension"] = 4] = "Extension";
+  return TerminalExitReason;
+}({});
+export var TerminalLink = /*#__PURE__*/_createClass(function TerminalLink(startIndex, length, tooltip) {
+  _classCallCheck(this, TerminalLink);
+  this.startIndex = startIndex;
+  this.length = length;
+  this.tooltip = tooltip;
+  if (typeof startIndex !== 'number' || startIndex < 0) {
+    throw illegalArgument('startIndex');
+  }
+  if (typeof length !== 'number' || length < 1) {
+    throw illegalArgument('length');
+  }
+  if (tooltip !== undefined && typeof tooltip !== 'string') {
+    throw illegalArgument('tooltip');
+  }
+});
+export var TerminalQuickFixOpener = /*#__PURE__*/_createClass(function TerminalQuickFixOpener(uri) {
+  _classCallCheck(this, TerminalQuickFixOpener);
+  this.uri = uri;
+});
+export var TerminalQuickFixCommand = /*#__PURE__*/_createClass(function TerminalQuickFixCommand(terminalCommand) {
+  _classCallCheck(this, TerminalQuickFixCommand);
+  this.terminalCommand = terminalCommand;
+});
+export var TerminalLocation = /*#__PURE__*/function (TerminalLocation) {
+  TerminalLocation[TerminalLocation["Panel"] = 1] = "Panel";
+  TerminalLocation[TerminalLocation["Editor"] = 2] = "Editor";
+  return TerminalLocation;
+}({});
+export var TerminalProfile = /*#__PURE__*/_createClass(function TerminalProfile(options) {
+  _classCallCheck(this, TerminalProfile);
+  this.options = options;
+  if (_typeof(options) !== 'object') {
+    throw illegalArgument('options');
+  }
+});
+export var TaskRevealKind = /*#__PURE__*/function (TaskRevealKind) {
+  TaskRevealKind[TaskRevealKind["Always"] = 1] = "Always";
+  TaskRevealKind[TaskRevealKind["Silent"] = 2] = "Silent";
+  TaskRevealKind[TaskRevealKind["Never"] = 3] = "Never";
+  return TaskRevealKind;
+}({});
+export var TaskPanelKind = /*#__PURE__*/function (TaskPanelKind) {
+  TaskPanelKind[TaskPanelKind["Shared"] = 1] = "Shared";
+  TaskPanelKind[TaskPanelKind["Dedicated"] = 2] = "Dedicated";
+  TaskPanelKind[TaskPanelKind["New"] = 3] = "New";
+  return TaskPanelKind;
+}({});
+export var TaskGroup = /*#__PURE__*/function () {
+  function TaskGroup(id, label) {
+    _classCallCheck(this, TaskGroup);
+    this.label = label;
+    if (typeof id !== 'string') {
+      throw illegalArgument('name');
+    }
+    if (typeof label !== 'string') {
+      throw illegalArgument('name');
+    }
+    this._id = id;
+  }
+  _createClass(TaskGroup, [{
+    key: "id",
+    get: function get() {
+      return this._id;
+    }
+  }], [{
+    key: "from",
+    value: function from(value) {
+      switch (value) {
+        case 'clean':
+          return TaskGroup.Clean;
+        case 'build':
+          return TaskGroup.Build;
+        case 'rebuild':
+          return TaskGroup.Rebuild;
+        case 'test':
+          return TaskGroup.Test;
+        default:
+          return undefined;
+      }
+    }
+  }]);
+  return TaskGroup;
+}();
+_TaskGroup = TaskGroup;
+TaskGroup.Clean = new _TaskGroup('clean', 'Clean');
+TaskGroup.Build = new _TaskGroup('build', 'Build');
+TaskGroup.Rebuild = new _TaskGroup('rebuild', 'Rebuild');
+TaskGroup.Test = new _TaskGroup('test', 'Test');
+function computeTaskExecutionId(values) {
+  var id = '';
+  for (var i = 0; i < values.length; i++) {
+    id += values[i].replace(/,/g, ',,') + ',';
+  }
+  return id;
+}
+export var ProcessExecution = /*#__PURE__*/function () {
+  function ProcessExecution(process, varg1, varg2) {
+    _classCallCheck(this, ProcessExecution);
+    if (typeof process !== 'string') {
+      throw illegalArgument('process');
+    }
+    this._args = [];
+    this._process = process;
+    if (varg1 !== undefined) {
+      if (Array.isArray(varg1)) {
+        this._args = varg1;
+        this._options = varg2;
+      } else {
+        this._options = varg1;
+      }
+    }
+  }
+  _createClass(ProcessExecution, [{
+    key: "process",
+    get: function get() {
+      return this._process;
+    },
+    set: function set(value) {
+      if (typeof value !== 'string') {
+        throw illegalArgument('process');
+      }
+      this._process = value;
+    }
+  }, {
+    key: "args",
+    get: function get() {
+      return this._args;
+    },
+    set: function set(value) {
+      if (!Array.isArray(value)) {
+        value = [];
+      }
+      this._args = value;
+    }
+  }, {
+    key: "options",
+    get: function get() {
+      return this._options;
+    },
+    set: function set(value) {
+      this._options = value;
+    }
+  }, {
+    key: "computeId",
+    value: function computeId() {
+      var props = [];
+      props.push('process');
+      if (this._process !== undefined) {
+        props.push(this._process);
+      }
+      if (this._args && this._args.length > 0) {
+        var _iterator4 = _createForOfIteratorHelper(this._args),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var arg = _step4.value;
+            props.push(arg);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+      return computeTaskExecutionId(props);
+    }
+  }]);
+  return ProcessExecution;
+}();
+export var ShellExecution = /*#__PURE__*/function () {
+  function ShellExecution(arg0, arg1, arg2) {
+    _classCallCheck(this, ShellExecution);
+    this._args = [];
+    if (Array.isArray(arg1)) {
+      if (!arg0) {
+        throw illegalArgument("command can't be undefined or null");
+      }
+      if (typeof arg0 !== 'string' && typeof arg0.value !== 'string') {
+        throw illegalArgument('command');
+      }
+      this._command = arg0;
+      this._args = arg1;
+      this._options = arg2;
+    } else {
+      if (typeof arg0 !== 'string') {
+        throw illegalArgument('commandLine');
+      }
+      this._commandLine = arg0;
+      this._options = arg1;
+    }
+  }
+  _createClass(ShellExecution, [{
+    key: "commandLine",
+    get: function get() {
+      return this._commandLine;
+    },
+    set: function set(value) {
+      if (typeof value !== 'string') {
+        throw illegalArgument('commandLine');
+      }
+      this._commandLine = value;
+    }
+  }, {
+    key: "command",
+    get: function get() {
+      return this._command ? this._command : '';
+    },
+    set: function set(value) {
+      if (typeof value !== 'string' && typeof value.value !== 'string') {
+        throw illegalArgument('command');
+      }
+      this._command = value;
+    }
+  }, {
+    key: "args",
+    get: function get() {
+      return this._args;
+    },
+    set: function set(value) {
+      this._args = value || [];
+    }
+  }, {
+    key: "options",
+    get: function get() {
+      return this._options;
+    },
+    set: function set(value) {
+      this._options = value;
+    }
+  }, {
+    key: "computeId",
+    value: function computeId() {
+      var props = [];
+      props.push('shell');
+      if (this._commandLine !== undefined) {
+        props.push(this._commandLine);
+      }
+      if (this._command !== undefined) {
+        props.push(typeof this._command === 'string' ? this._command : this._command.value);
+      }
+      if (this._args && this._args.length > 0) {
+        var _iterator5 = _createForOfIteratorHelper(this._args),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var arg = _step5.value;
+            props.push(typeof arg === 'string' ? arg : arg.value);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+      return computeTaskExecutionId(props);
+    }
+  }]);
+  return ShellExecution;
+}();
+export var ShellQuoting = /*#__PURE__*/function (ShellQuoting) {
+  ShellQuoting[ShellQuoting["Escape"] = 1] = "Escape";
+  ShellQuoting[ShellQuoting["Strong"] = 2] = "Strong";
+  ShellQuoting[ShellQuoting["Weak"] = 3] = "Weak";
+  return ShellQuoting;
+}({});
+export var TaskScope = /*#__PURE__*/function (TaskScope) {
+  TaskScope[TaskScope["Global"] = 1] = "Global";
+  TaskScope[TaskScope["Workspace"] = 2] = "Workspace";
+  return TaskScope;
+}({});
+export var CustomExecution = /*#__PURE__*/function () {
+  function CustomExecution(callback) {
+    _classCallCheck(this, CustomExecution);
+    this._callback = callback;
+  }
+  _createClass(CustomExecution, [{
+    key: "computeId",
+    value: function computeId() {
+      return 'customExecution' + generateUuid();
+    }
+  }, {
+    key: "callback",
+    get: function get() {
+      return this._callback;
+    },
+    set: function set(value) {
+      this._callback = value;
+    }
+  }]);
+  return CustomExecution;
+}();
+export var Task = /*#__PURE__*/function () {
+  function Task(definition, arg2, arg3, arg4, arg5, arg6) {
+    _classCallCheck(this, Task);
+    this.__deprecated = false;
+    this._definition = this.definition = definition;
+    var problemMatchers;
+    if (typeof arg2 === 'string') {
+      this._name = this.name = arg2;
+      this._source = this.source = arg3;
+      this.execution = arg4;
+      problemMatchers = arg5;
+      this.__deprecated = true;
+    } else if (arg2 === TaskScope.Global || arg2 === TaskScope.Workspace) {
+      this.target = arg2;
+      this._name = this.name = arg3;
+      this._source = this.source = arg4;
+      this.execution = arg5;
+      problemMatchers = arg6;
+    } else {
+      this.target = arg2;
+      this._name = this.name = arg3;
+      this._source = this.source = arg4;
+      this.execution = arg5;
+      problemMatchers = arg6;
+    }
+    if (typeof problemMatchers === 'string') {
+      this._problemMatchers = [problemMatchers];
+      this._hasDefinedMatchers = true;
+    } else if (Array.isArray(problemMatchers)) {
+      this._problemMatchers = problemMatchers;
+      this._hasDefinedMatchers = true;
+    } else {
+      this._problemMatchers = [];
+      this._hasDefinedMatchers = false;
+    }
+    this._isBackground = false;
+    this._presentationOptions = Object.create(null);
+    this._runOptions = Object.create(null);
+  }
+  _createClass(Task, [{
+    key: "_id",
+    get: function get() {
+      return this.__id;
+    },
+    set: function set(value) {
+      this.__id = value;
+    }
+  }, {
+    key: "_deprecated",
+    get: function get() {
+      return this.__deprecated;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      if (this.__id === undefined) {
+        return;
+      }
+      this.__id = undefined;
+      this._scope = undefined;
+      this.computeDefinitionBasedOnExecution();
+    }
+  }, {
+    key: "computeDefinitionBasedOnExecution",
+    value: function computeDefinitionBasedOnExecution() {
+      if (this._execution instanceof ProcessExecution) {
+        this._definition = {
+          type: Task.ProcessType,
+          id: this._execution.computeId()
+        };
+      } else if (this._execution instanceof ShellExecution) {
+        this._definition = {
+          type: Task.ShellType,
+          id: this._execution.computeId()
+        };
+      } else if (this._execution instanceof CustomExecution) {
+        this._definition = {
+          type: Task.ExtensionCallbackType,
+          id: this._execution.computeId()
+        };
+      } else {
+        this._definition = {
+          type: Task.EmptyType,
+          id: generateUuid()
+        };
+      }
+    }
+  }, {
+    key: "definition",
+    get: function get() {
+      return this._definition;
+    },
+    set: function set(value) {
+      if (value === undefined || value === null) {
+        throw illegalArgument("Kind can't be undefined or null");
+      }
+      this.clear();
+      this._definition = value;
+    }
+  }, {
+    key: "scope",
+    get: function get() {
+      return this._scope;
+    }
+  }, {
+    key: "target",
+    set: function set(value) {
+      this.clear();
+      this._scope = value;
+    }
+  }, {
+    key: "name",
+    get: function get() {
+      return this._name;
+    },
+    set: function set(value) {
+      if (typeof value !== 'string') {
+        throw illegalArgument('name');
+      }
+      this.clear();
+      this._name = value;
+    }
+  }, {
+    key: "execution",
+    get: function get() {
+      return this._execution;
+    },
+    set: function set(value) {
+      if (value === null) {
+        value = undefined;
+      }
+      this.clear();
+      this._execution = value;
+      var type = this._definition.type;
+      if (Task.EmptyType === type || Task.ProcessType === type || Task.ShellType === type || Task.ExtensionCallbackType === type) {
+        this.computeDefinitionBasedOnExecution();
+      }
+    }
+  }, {
+    key: "problemMatchers",
+    get: function get() {
+      return this._problemMatchers;
+    },
+    set: function set(value) {
+      if (!Array.isArray(value)) {
+        this.clear();
+        this._problemMatchers = [];
+        this._hasDefinedMatchers = false;
+        return;
+      } else {
+        this.clear();
+        this._problemMatchers = value;
+        this._hasDefinedMatchers = true;
+      }
+    }
+  }, {
+    key: "hasDefinedMatchers",
+    get: function get() {
+      return this._hasDefinedMatchers;
+    }
+  }, {
+    key: "isBackground",
+    get: function get() {
+      return this._isBackground;
+    },
+    set: function set(value) {
+      if (value !== true && value !== false) {
+        value = false;
+      }
+      this.clear();
+      this._isBackground = value;
+    }
+  }, {
+    key: "source",
+    get: function get() {
+      return this._source;
+    },
+    set: function set(value) {
+      if (typeof value !== 'string' || value.length === 0) {
+        throw illegalArgument('source must be a string of length > 0');
+      }
+      this.clear();
+      this._source = value;
+    }
+  }, {
+    key: "group",
+    get: function get() {
+      return this._group;
+    },
+    set: function set(value) {
+      if (value === null) {
+        value = undefined;
+      }
+      this.clear();
+      this._group = value;
+    }
+  }, {
+    key: "detail",
+    get: function get() {
+      return this._detail;
+    },
+    set: function set(value) {
+      if (value === null) {
+        value = undefined;
+      }
+      this._detail = value;
+    }
+  }, {
+    key: "presentationOptions",
+    get: function get() {
+      return this._presentationOptions;
+    },
+    set: function set(value) {
+      if (value === null || value === undefined) {
+        value = Object.create(null);
+      }
+      this.clear();
+      this._presentationOptions = value;
+    }
+  }, {
+    key: "runOptions",
+    get: function get() {
+      return this._runOptions;
+    },
+    set: function set(value) {
+      if (value === null || value === undefined) {
+        value = Object.create(null);
+      }
+      this.clear();
+      this._runOptions = value;
+    }
+  }]);
+  return Task;
+}();
+Task.ExtensionCallbackType = 'customExecution';
+Task.ProcessType = 'process';
+Task.ShellType = 'shell';
+Task.EmptyType = '$empty';
+export var ProgressLocation = /*#__PURE__*/function (ProgressLocation) {
+  ProgressLocation[ProgressLocation["SourceControl"] = 1] = "SourceControl";
+  ProgressLocation[ProgressLocation["Window"] = 10] = "Window";
+  ProgressLocation[ProgressLocation["Notification"] = 15] = "Notification";
+  return ProgressLocation;
+}({});
+export var ViewBadge;
+(function (_ViewBadge) {
+  function isViewBadge(thing) {
+    var viewBadgeThing = thing;
+    if (!isNumber(viewBadgeThing.value)) {
+      console.log('INVALID view badge, invalid value', viewBadgeThing.value);
+      return false;
+    }
+    if (viewBadgeThing.tooltip && !isString(viewBadgeThing.tooltip)) {
+      console.log('INVALID view badge, invalid tooltip', viewBadgeThing.tooltip);
+      return false;
+    }
+    return true;
+  }
+  _ViewBadge.isViewBadge = isViewBadge;
+})(ViewBadge || (ViewBadge = {}));
+export var TreeItem = /*#__PURE__*/function () {
+  function TreeItem(arg1) {
+    var collapsibleState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TreeItemCollapsibleState.None;
+    _classCallCheck(this, TreeItem);
+    this.collapsibleState = collapsibleState;
+    if (URI.isUri(arg1)) {
+      this.resourceUri = arg1;
+    } else {
+      this.label = arg1;
+    }
+  }
+  _createClass(TreeItem, null, [{
+    key: "isTreeItem",
+    value: function isTreeItem(thing) {
+      var _treeItemThing$label, _treeItemThing$access;
+      var treeItemThing = thing;
+      if (treeItemThing.checkboxState !== undefined) {
+        var checkbox = isNumber(treeItemThing.checkboxState) ? treeItemThing.checkboxState : isObject(treeItemThing.checkboxState) && isNumber(treeItemThing.checkboxState.state) ? treeItemThing.checkboxState.state : undefined;
+        var _tooltip = !isNumber(treeItemThing.checkboxState) && isObject(treeItemThing.checkboxState) ? treeItemThing.checkboxState.tooltip : undefined;
+        if (checkbox === undefined || checkbox !== TreeItemCheckboxState.Checked && checkbox !== TreeItemCheckboxState.Unchecked || _tooltip !== undefined && !isString(_tooltip)) {
+          console.log('INVALID tree item, invalid checkboxState', treeItemThing.checkboxState);
+          return false;
+        }
+      }
+      if (thing instanceof TreeItem) {
+        return true;
+      }
+      if (treeItemThing.label !== undefined && !isString(treeItemThing.label) && !((_treeItemThing$label = treeItemThing.label) !== null && _treeItemThing$label !== void 0 && _treeItemThing$label.label)) {
+        console.log('INVALID tree item, invalid label', treeItemThing.label);
+        return false;
+      }
+      if (treeItemThing.id !== undefined && !isString(treeItemThing.id)) {
+        console.log('INVALID tree item, invalid id', treeItemThing.id);
+        return false;
+      }
+      if (treeItemThing.iconPath !== undefined && !isString(treeItemThing.iconPath) && !URI.isUri(treeItemThing.iconPath) && (!treeItemThing.iconPath || !isString(treeItemThing.iconPath.id))) {
+        var asLightAndDarkThing = treeItemThing.iconPath;
+        if (!asLightAndDarkThing || !isString(asLightAndDarkThing.light) && !URI.isUri(asLightAndDarkThing.light) && !isString(asLightAndDarkThing.dark) && !URI.isUri(asLightAndDarkThing.dark)) {
+          console.log('INVALID tree item, invalid iconPath', treeItemThing.iconPath);
+          return false;
+        }
+      }
+      if (treeItemThing.description !== undefined && !isString(treeItemThing.description) && typeof treeItemThing.description !== 'boolean') {
+        console.log('INVALID tree item, invalid description', treeItemThing.description);
+        return false;
+      }
+      if (treeItemThing.resourceUri !== undefined && !URI.isUri(treeItemThing.resourceUri)) {
+        console.log('INVALID tree item, invalid resourceUri', treeItemThing.resourceUri);
+        return false;
+      }
+      if (treeItemThing.tooltip !== undefined && !isString(treeItemThing.tooltip) && !(treeItemThing.tooltip instanceof MarkdownString)) {
+        console.log('INVALID tree item, invalid tooltip', treeItemThing.tooltip);
+        return false;
+      }
+      if (treeItemThing.command !== undefined && !treeItemThing.command.command) {
+        console.log('INVALID tree item, invalid command', treeItemThing.command);
+        return false;
+      }
+      if (treeItemThing.collapsibleState !== undefined && treeItemThing.collapsibleState < TreeItemCollapsibleState.None && treeItemThing.collapsibleState > TreeItemCollapsibleState.Expanded) {
+        console.log('INVALID tree item, invalid collapsibleState', treeItemThing.collapsibleState);
+        return false;
+      }
+      if (treeItemThing.contextValue !== undefined && !isString(treeItemThing.contextValue)) {
+        console.log('INVALID tree item, invalid contextValue', treeItemThing.contextValue);
+        return false;
+      }
+      if (treeItemThing.accessibilityInformation !== undefined && !((_treeItemThing$access = treeItemThing.accessibilityInformation) !== null && _treeItemThing$access !== void 0 && _treeItemThing$access.label)) {
+        console.log('INVALID tree item, invalid accessibilityInformation', treeItemThing.accessibilityInformation);
+        return false;
+      }
+      return true;
+    }
+  }]);
+  return TreeItem;
+}();
+export var TreeItemCollapsibleState = /*#__PURE__*/function (TreeItemCollapsibleState) {
+  TreeItemCollapsibleState[TreeItemCollapsibleState["None"] = 0] = "None";
+  TreeItemCollapsibleState[TreeItemCollapsibleState["Collapsed"] = 1] = "Collapsed";
+  TreeItemCollapsibleState[TreeItemCollapsibleState["Expanded"] = 2] = "Expanded";
+  return TreeItemCollapsibleState;
+}({});
+export var TreeItemCheckboxState = /*#__PURE__*/function (TreeItemCheckboxState) {
+  TreeItemCheckboxState[TreeItemCheckboxState["Unchecked"] = 0] = "Unchecked";
+  TreeItemCheckboxState[TreeItemCheckboxState["Checked"] = 1] = "Checked";
+  return TreeItemCheckboxState;
+}({});
+export var DataTransferItem = /*#__PURE__*/function () {
+  function DataTransferItem(value) {
+    _classCallCheck(this, DataTransferItem);
+    this.value = value;
+  }
+  _createClass(DataTransferItem, [{
+    key: "asString",
+    value: function () {
+      var _asString = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", typeof this.value === 'string' ? this.value : JSON.stringify(this.value));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function asString() {
+        return _asString.apply(this, arguments);
+      }
+      return asString;
+    }()
+  }, {
+    key: "asFile",
+    value: function asFile() {
+      return undefined;
+    }
+  }]);
+  return DataTransferItem;
+}();
+
+/**
+ * A data transfer item that has been created by VS Code instead of by a extension.
+ *
+ * Intentionally not exported to extensions.
+ */
+export var InternalDataTransferItem = /*#__PURE__*/function (_DataTransferItem) {
+  _inherits(InternalDataTransferItem, _DataTransferItem);
+  var _super2 = _createSuper(InternalDataTransferItem);
+  function InternalDataTransferItem() {
+    _classCallCheck(this, InternalDataTransferItem);
+    return _super2.apply(this, arguments);
+  }
+  return _createClass(InternalDataTransferItem);
+}(DataTransferItem);
+
+/**
+ * A data transfer item for a file.
+ *
+ * Intentionally not exported to extensions as only we can create these.
+ */
+var _file = /*#__PURE__*/_classPrivateFieldLooseKey("file");
+export var InternalFileDataTransferItem = /*#__PURE__*/function (_InternalDataTransfer) {
+  _inherits(InternalFileDataTransferItem, _InternalDataTransfer);
+  var _super3 = _createSuper(InternalFileDataTransferItem);
+  function InternalFileDataTransferItem(file) {
+    var _this2;
+    _classCallCheck(this, InternalFileDataTransferItem);
+    _this2 = _super3.call(this, '');
+    Object.defineProperty(_assertThisInitialized(_this2), _file, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(_assertThisInitialized(_this2), _file)[_file] = file;
+    return _this2;
+  }
+  _createClass(InternalFileDataTransferItem, [{
+    key: "asFile",
+    value: function asFile() {
+      return _classPrivateFieldLooseBase(this, _file)[_file];
+    }
+  }]);
+  return InternalFileDataTransferItem;
+}(InternalDataTransferItem);
+
+/**
+ * Intentionally not exported to extensions
+ */
+export var DataTransferFile = /*#__PURE__*/function () {
+  function DataTransferFile(name, uri, itemId, getData) {
+    _classCallCheck(this, DataTransferFile);
+    this.name = name;
+    this.uri = uri;
+    this._itemId = itemId;
+    this._getData = getData;
+  }
+  _createClass(DataTransferFile, [{
+    key: "data",
+    value: function data() {
+      return this._getData();
+    }
+  }]);
+  return DataTransferFile;
+}();
+var _items = /*#__PURE__*/_classPrivateFieldLooseKey("items");
+var _normalizeMime = /*#__PURE__*/_classPrivateFieldLooseKey("normalizeMime");
+_Symbol$iterator = Symbol.iterator;
+export var DataTransfer = /*#__PURE__*/function () {
+  function DataTransfer(init) {
+    _classCallCheck(this, DataTransfer);
+    Object.defineProperty(this, _normalizeMime, {
+      value: _normalizeMime2
+    });
+    Object.defineProperty(this, _items, {
+      writable: true,
+      value: new Map()
+    });
+    var _iterator6 = _createForOfIteratorHelper(init !== null && init !== void 0 ? init : []),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var _step6$value = _slicedToArray(_step6.value, 2),
+          _mime = _step6$value[0],
+          _item2 = _step6$value[1];
+        var existing = _classPrivateFieldLooseBase(this, _items)[_items].get(_classPrivateFieldLooseBase(this, _normalizeMime)[_normalizeMime](_mime));
+        if (existing) {
+          existing.push(_item2);
+        } else {
+          _classPrivateFieldLooseBase(this, _items)[_items].set(_classPrivateFieldLooseBase(this, _normalizeMime)[_normalizeMime](_mime), [_item2]);
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+  }
+  _createClass(DataTransfer, [{
+    key: "get",
+    value: function get(mimeType) {
+      var _classPrivateFieldLoo;
+      return (_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _items)[_items].get(_classPrivateFieldLooseBase(this, _normalizeMime)[_normalizeMime](mimeType))) === null || _classPrivateFieldLoo === void 0 ? void 0 : _classPrivateFieldLoo[0];
+    }
+  }, {
+    key: "set",
+    value: function set(mimeType, value) {
+      // This intentionally overwrites all entries for a given mimetype.
+      // This is similar to how the DOM DataTransfer type works
+      _classPrivateFieldLooseBase(this, _items)[_items].set(_classPrivateFieldLooseBase(this, _normalizeMime)[_normalizeMime](mimeType), [value]);
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callbackfn, thisArg) {
+      var _iterator7 = _createForOfIteratorHelper(_classPrivateFieldLooseBase(this, _items)[_items]),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _step7$value = _slicedToArray(_step7.value, 2),
+            _mime2 = _step7$value[0],
+            items = _step7$value[1];
+          var _iterator8 = _createForOfIteratorHelper(items),
+            _step8;
+          try {
+            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+              var _item3 = _step8.value;
+              callbackfn.call(thisArg, _item3, _mime2, this);
+            }
+          } catch (err) {
+            _iterator8.e(err);
+          } finally {
+            _iterator8.f();
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+  }, {
+    key: _Symbol$iterator,
+    value: /*#__PURE__*/_regeneratorRuntime().mark(function value() {
+      var _iterator9, _step9, _step9$value, _mime3, items, _iterator10, _step10, _item4;
+      return _regeneratorRuntime().wrap(function value$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _iterator9 = _createForOfIteratorHelper(_classPrivateFieldLooseBase(this, _items)[_items]);
+            _context2.prev = 1;
+            _iterator9.s();
+          case 3:
+            if ((_step9 = _iterator9.n()).done) {
+              _context2.next = 24;
+              break;
+            }
+            _step9$value = _slicedToArray(_step9.value, 2), _mime3 = _step9$value[0], items = _step9$value[1];
+            _iterator10 = _createForOfIteratorHelper(items);
+            _context2.prev = 6;
+            _iterator10.s();
+          case 8:
+            if ((_step10 = _iterator10.n()).done) {
+              _context2.next = 14;
+              break;
+            }
+            _item4 = _step10.value;
+            _context2.next = 12;
+            return [_mime3, _item4];
+          case 12:
+            _context2.next = 8;
+            break;
+          case 14:
+            _context2.next = 19;
+            break;
+          case 16:
+            _context2.prev = 16;
+            _context2.t0 = _context2["catch"](6);
+            _iterator10.e(_context2.t0);
+          case 19:
+            _context2.prev = 19;
+            _iterator10.f();
+            return _context2.finish(19);
+          case 22:
+            _context2.next = 3;
+            break;
+          case 24:
+            _context2.next = 29;
+            break;
+          case 26:
+            _context2.prev = 26;
+            _context2.t1 = _context2["catch"](1);
+            _iterator9.e(_context2.t1);
+          case 29:
+            _context2.prev = 29;
+            _iterator9.f();
+            return _context2.finish(29);
+          case 32:
+          case "end":
+            return _context2.stop();
+        }
+      }, value, this, [[1, 26, 29, 32], [6, 16, 19, 22]]);
+    })
+  }]);
+  return DataTransfer;
+}();
+function _normalizeMime2(mimeType) {
+  return mimeType.toLowerCase();
+}
+export var DocumentDropEdit = /*#__PURE__*/_createClass(function DocumentDropEdit(insertText) {
+  _classCallCheck(this, DocumentDropEdit);
+  this.insertText = insertText;
+});
+export var DocumentPasteEdit = /*#__PURE__*/_createClass(function DocumentPasteEdit(insertText, label) {
+  _classCallCheck(this, DocumentPasteEdit);
+  this.label = label;
+  this.insertText = insertText;
+});
+export var ThemeIcon = /*#__PURE__*/function () {
+  function ThemeIcon(id, color) {
+    _classCallCheck(this, ThemeIcon);
+    this.id = id;
+    this.color = color;
+  }
+  _createClass(ThemeIcon, null, [{
+    key: "isThemeIcon",
+    value: function isThemeIcon(thing) {
+      if (typeof thing.id !== 'string') {
+        console.log('INVALID ThemeIcon, invalid id', thing.id);
+        return false;
+      }
+      return true;
+    }
+  }]);
+  return ThemeIcon;
+}();
+ThemeIcon.File = new ThemeIcon('file');
+ThemeIcon.Folder = new ThemeIcon('folder');
+export var ThemeColor = /*#__PURE__*/_createClass(function ThemeColor(id) {
+  _classCallCheck(this, ThemeColor);
+  this.id = id;
+});
+export var ConfigurationTarget = /*#__PURE__*/function (ConfigurationTarget) {
+  ConfigurationTarget[ConfigurationTarget["Global"] = 1] = "Global";
+  ConfigurationTarget[ConfigurationTarget["Workspace"] = 2] = "Workspace";
+  ConfigurationTarget[ConfigurationTarget["WorkspaceFolder"] = 3] = "WorkspaceFolder";
+  return ConfigurationTarget;
+}({});
+export var RelativePattern = /*#__PURE__*/function () {
+  function RelativePattern(base, pattern) {
+    _classCallCheck(this, RelativePattern);
+    if (typeof base !== 'string') {
+      if (!base || !URI.isUri(base) && !URI.isUri(base.uri)) {
+        throw illegalArgument('base');
+      }
+    }
+    if (typeof pattern !== 'string') {
+      throw illegalArgument('pattern');
+    }
+    if (typeof base === 'string') {
+      this.baseUri = URI.file(base);
+    } else if (URI.isUri(base)) {
+      this.baseUri = base;
+    } else {
+      this.baseUri = base.uri;
+    }
+    this.pattern = pattern;
+  }
+  _createClass(RelativePattern, [{
+    key: "base",
+    get: function get() {
+      return this._base;
+    },
+    set: function set(base) {
+      this._base = base;
+      this._baseUri = URI.file(base);
+    }
+  }, {
+    key: "baseUri",
+    get: function get() {
+      return this._baseUri;
+    },
+    set: function set(baseUri) {
+      this._baseUri = baseUri;
+      this._base = baseUri.fsPath;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        pattern: this.pattern,
+        base: this.base,
+        baseUri: this.baseUri.toJSON()
+      };
+    }
+  }]);
+  return RelativePattern;
+}();
+var breakpointIds = new WeakMap();
+
+/**
+ * We want to be able to construct Breakpoints internally that have a particular id, but we don't want extensions to be
+ * able to do this with the exposed Breakpoint classes in extension API.
+ * We also want "instanceof" to work with debug.breakpoints and the exposed breakpoint classes.
+ * And private members will be renamed in the built js, so casting to any and setting a private member is not safe.
+ * So, we store internal breakpoint IDs in a WeakMap. This function must be called after constructing a Breakpoint
+ * with a known id.
+ */
+export function setBreakpointId(bp, id) {
+  breakpointIds.set(bp, id);
+}
+export var Breakpoint = /*#__PURE__*/function () {
+  function Breakpoint(enabled, condition, hitCondition, logMessage) {
+    _classCallCheck(this, Breakpoint);
+    this.enabled = typeof enabled === 'boolean' ? enabled : true;
+    if (typeof condition === 'string') {
+      this.condition = condition;
+    }
+    if (typeof hitCondition === 'string') {
+      this.hitCondition = hitCondition;
+    }
+    if (typeof logMessage === 'string') {
+      this.logMessage = logMessage;
+    }
+  }
+  _createClass(Breakpoint, [{
+    key: "id",
+    get: function get() {
+      if (!this._id) {
+        var _breakpointIds$get;
+        this._id = (_breakpointIds$get = breakpointIds.get(this)) !== null && _breakpointIds$get !== void 0 ? _breakpointIds$get : generateUuid();
+      }
+      return this._id;
+    }
+  }]);
+  return Breakpoint;
+}();
+export var SourceBreakpoint = /*#__PURE__*/function (_Breakpoint) {
+  _inherits(SourceBreakpoint, _Breakpoint);
+  var _super4 = _createSuper(SourceBreakpoint);
+  function SourceBreakpoint(location, enabled, condition, hitCondition, logMessage) {
+    var _this3;
+    _classCallCheck(this, SourceBreakpoint);
+    _this3 = _super4.call(this, enabled, condition, hitCondition, logMessage);
+    if (location === null) {
+      throw illegalArgument('location');
+    }
+    _this3.location = location;
+    return _this3;
+  }
+  return _createClass(SourceBreakpoint);
+}(Breakpoint);
+export var FunctionBreakpoint = /*#__PURE__*/function (_Breakpoint2) {
+  _inherits(FunctionBreakpoint, _Breakpoint2);
+  var _super5 = _createSuper(FunctionBreakpoint);
+  function FunctionBreakpoint(functionName, enabled, condition, hitCondition, logMessage) {
+    var _this4;
+    _classCallCheck(this, FunctionBreakpoint);
+    _this4 = _super5.call(this, enabled, condition, hitCondition, logMessage);
+    _this4.functionName = functionName;
+    return _this4;
+  }
+  return _createClass(FunctionBreakpoint);
+}(Breakpoint);
+export var DataBreakpoint = /*#__PURE__*/function (_Breakpoint3) {
+  _inherits(DataBreakpoint, _Breakpoint3);
+  var _super6 = _createSuper(DataBreakpoint);
+  function DataBreakpoint(label, dataId, canPersist, enabled, condition, hitCondition, logMessage) {
+    var _this5;
+    _classCallCheck(this, DataBreakpoint);
+    _this5 = _super6.call(this, enabled, condition, hitCondition, logMessage);
+    if (!dataId) {
+      throw illegalArgument('dataId');
+    }
+    _this5.label = label;
+    _this5.dataId = dataId;
+    _this5.canPersist = canPersist;
+    return _this5;
+  }
+  return _createClass(DataBreakpoint);
+}(Breakpoint);
+export var DebugAdapterExecutable = /*#__PURE__*/_createClass(function DebugAdapterExecutable(command, args, options) {
+  _classCallCheck(this, DebugAdapterExecutable);
+  this.command = command;
+  this.args = args || [];
+  this.options = options;
+});
+export var DebugAdapterServer = /*#__PURE__*/_createClass(function DebugAdapterServer(port, host) {
+  _classCallCheck(this, DebugAdapterServer);
+  this.port = port;
+  this.host = host;
+});
+export var DebugAdapterNamedPipeServer = /*#__PURE__*/_createClass(function DebugAdapterNamedPipeServer(path) {
+  _classCallCheck(this, DebugAdapterNamedPipeServer);
+  this.path = path;
+});
+export var DebugAdapterInlineImplementation = /*#__PURE__*/_createClass(function DebugAdapterInlineImplementation(impl) {
+  _classCallCheck(this, DebugAdapterInlineImplementation);
+  this.implementation = impl;
+});
+export var StackFrameFocus = /*#__PURE__*/_createClass(function StackFrameFocus(session, threadId, frameId) {
+  _classCallCheck(this, StackFrameFocus);
+  this.session = session;
+  this.threadId = threadId;
+  this.frameId = frameId;
+});
+export var ThreadFocus = /*#__PURE__*/_createClass(function ThreadFocus(session, threadId) {
+  _classCallCheck(this, ThreadFocus);
+  this.session = session;
+  this.threadId = threadId;
+});
+export var EvaluatableExpression = /*#__PURE__*/_createClass(function EvaluatableExpression(range, expression) {
+  _classCallCheck(this, EvaluatableExpression);
+  this.range = range;
+  this.expression = expression;
+});
+export var InlineCompletionTriggerKind = /*#__PURE__*/function (InlineCompletionTriggerKind) {
+  InlineCompletionTriggerKind[InlineCompletionTriggerKind["Invoke"] = 0] = "Invoke";
+  InlineCompletionTriggerKind[InlineCompletionTriggerKind["Automatic"] = 1] = "Automatic";
+  return InlineCompletionTriggerKind;
+}({});
+export var InlineValueText = /*#__PURE__*/_createClass(function InlineValueText(range, text) {
+  _classCallCheck(this, InlineValueText);
+  this.range = range;
+  this.text = text;
+});
+export var InlineValueVariableLookup = /*#__PURE__*/_createClass(function InlineValueVariableLookup(range, variableName) {
+  var caseSensitiveLookup = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  _classCallCheck(this, InlineValueVariableLookup);
+  this.range = range;
+  this.variableName = variableName;
+  this.caseSensitiveLookup = caseSensitiveLookup;
+});
+export var InlineValueEvaluatableExpression = /*#__PURE__*/_createClass(function InlineValueEvaluatableExpression(range, expression) {
+  _classCallCheck(this, InlineValueEvaluatableExpression);
+  this.range = range;
+  this.expression = expression;
+});
+export var InlineValueContext = /*#__PURE__*/_createClass(function InlineValueContext(frameId, range) {
+  _classCallCheck(this, InlineValueContext);
+  this.frameId = frameId;
+  this.stoppedLocation = range;
+});
+
+//#region file api
+
+export var FileChangeType = /*#__PURE__*/function (FileChangeType) {
+  FileChangeType[FileChangeType["Changed"] = 1] = "Changed";
+  FileChangeType[FileChangeType["Created"] = 2] = "Created";
+  FileChangeType[FileChangeType["Deleted"] = 3] = "Deleted";
+  return FileChangeType;
+}({});
+export var FileSystemError = /*#__PURE__*/function (_Error) {
+  _inherits(FileSystemError, _Error);
+  var _super7 = _createSuper(FileSystemError);
+  function FileSystemError(uriOrMessage) {
+    var _terminator$name;
+    var _this6;
+    var code = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : FileSystemProviderErrorCode.Unknown;
+    var terminator = arguments.length > 2 ? arguments[2] : undefined;
+    _classCallCheck(this, FileSystemError);
+    _this6 = _super7.call(this, URI.isUri(uriOrMessage) ? uriOrMessage.toString(true) : uriOrMessage);
+    _this6.code = (_terminator$name = terminator === null || terminator === void 0 ? void 0 : terminator.name) !== null && _terminator$name !== void 0 ? _terminator$name : 'Unknown';
+
+    // mark the error as file system provider error so that
+    // we can extract the error code on the receiving side
+    markAsFileSystemProviderError(_assertThisInitialized(_this6), code);
+
+    // workaround when extending builtin objects and when compiling to ES5, see:
+    // https://github.com/microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    Object.setPrototypeOf(_assertThisInitialized(_this6), FileSystemError.prototype);
+    if (typeof Error.captureStackTrace === 'function' && typeof terminator === 'function') {
+      // nice stack traces
+      Error.captureStackTrace(_assertThisInitialized(_this6), terminator);
+    }
+    return _this6;
+  }
+  _createClass(FileSystemError, null, [{
+    key: "FileExists",
+    value: function FileExists(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.FileExists, FileSystemError.FileExists);
+    }
+  }, {
+    key: "FileNotFound",
+    value: function FileNotFound(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.FileNotFound, FileSystemError.FileNotFound);
+    }
+  }, {
+    key: "FileNotADirectory",
+    value: function FileNotADirectory(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.FileNotADirectory, FileSystemError.FileNotADirectory);
+    }
+  }, {
+    key: "FileIsADirectory",
+    value: function FileIsADirectory(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.FileIsADirectory, FileSystemError.FileIsADirectory);
+    }
+  }, {
+    key: "NoPermissions",
+    value: function NoPermissions(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.NoPermissions, FileSystemError.NoPermissions);
+    }
+  }, {
+    key: "Unavailable",
+    value: function Unavailable(messageOrUri) {
+      return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.Unavailable, FileSystemError.Unavailable);
+    }
+  }]);
+  return FileSystemError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+//#endregion
+
+//#region folding api
+
+export var FoldingRange = /*#__PURE__*/_createClass(function FoldingRange(start, end, kind) {
+  _classCallCheck(this, FoldingRange);
+  this.start = start;
+  this.end = end;
+  this.kind = kind;
+});
+export var FoldingRangeKind = /*#__PURE__*/function (FoldingRangeKind) {
+  FoldingRangeKind[FoldingRangeKind["Comment"] = 1] = "Comment";
+  FoldingRangeKind[FoldingRangeKind["Imports"] = 2] = "Imports";
+  FoldingRangeKind[FoldingRangeKind["Region"] = 3] = "Region";
+  return FoldingRangeKind;
+}({});
+
+//#endregion
+
+//#region Comment
+export var CommentThreadCollapsibleState = /*#__PURE__*/function (CommentThreadCollapsibleState) {
+  CommentThreadCollapsibleState[CommentThreadCollapsibleState["Collapsed"] = 0] = "Collapsed";
+  CommentThreadCollapsibleState[CommentThreadCollapsibleState["Expanded"] = 1] = "Expanded";
+  return CommentThreadCollapsibleState;
+}({});
+export var CommentMode = /*#__PURE__*/function (CommentMode) {
+  CommentMode[CommentMode["Editing"] = 0] = "Editing";
+  CommentMode[CommentMode["Preview"] = 1] = "Preview";
+  return CommentMode;
+}({});
+export var CommentState = /*#__PURE__*/function (CommentState) {
+  CommentState[CommentState["Published"] = 0] = "Published";
+  CommentState[CommentState["Draft"] = 1] = "Draft";
+  return CommentState;
+}({});
+export var CommentThreadState = /*#__PURE__*/function (CommentThreadState) {
+  CommentThreadState[CommentThreadState["Unresolved"] = 0] = "Unresolved";
+  CommentThreadState[CommentThreadState["Resolved"] = 1] = "Resolved";
+  return CommentThreadState;
+}({});
+
+//#endregion
+
+//#region Semantic Coloring
+
+export var SemanticTokensLegend = /*#__PURE__*/_createClass(function SemanticTokensLegend(tokenTypes) {
+  var tokenModifiers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  _classCallCheck(this, SemanticTokensLegend);
+  this.tokenTypes = tokenTypes;
+  this.tokenModifiers = tokenModifiers;
+});
+function isStrArrayOrUndefined(arg) {
+  return typeof arg === 'undefined' || isStringArray(arg);
+}
+export var SemanticTokensBuilder = /*#__PURE__*/function () {
+  function SemanticTokensBuilder(legend) {
+    _classCallCheck(this, SemanticTokensBuilder);
+    this._prevLine = 0;
+    this._prevChar = 0;
+    this._dataIsSortedAndDeltaEncoded = true;
+    this._data = [];
+    this._dataLen = 0;
+    this._tokenTypeStrToInt = new Map();
+    this._tokenModifierStrToInt = new Map();
+    this._hasLegend = false;
+    if (legend) {
+      this._hasLegend = true;
+      for (var i = 0, len = legend.tokenTypes.length; i < len; i++) {
+        this._tokenTypeStrToInt.set(legend.tokenTypes[i], i);
+      }
+      for (var _i2 = 0, _len2 = legend.tokenModifiers.length; _i2 < _len2; _i2++) {
+        this._tokenModifierStrToInt.set(legend.tokenModifiers[_i2], _i2);
+      }
+    }
+  }
+  _createClass(SemanticTokensBuilder, [{
+    key: "push",
+    value: function push(arg0, arg1, arg2, arg3, arg4) {
+      if (typeof arg0 === 'number' && typeof arg1 === 'number' && typeof arg2 === 'number' && typeof arg3 === 'number' && (typeof arg4 === 'number' || typeof arg4 === 'undefined')) {
+        if (typeof arg4 === 'undefined') {
+          arg4 = 0;
+        }
+        // 1st overload
+        return this._pushEncoded(arg0, arg1, arg2, arg3, arg4);
+      }
+      if (Range.isRange(arg0) && typeof arg1 === 'string' && isStrArrayOrUndefined(arg2)) {
+        // 2nd overload
+        return this._push(arg0, arg1, arg2);
+      }
+      throw illegalArgument();
+    }
+  }, {
+    key: "_push",
+    value: function _push(range, tokenType, tokenModifiers) {
+      if (!this._hasLegend) {
+        throw new Error('Legend must be provided in constructor');
+      }
+      if (range.start.line !== range.end.line) {
+        throw new Error('`range` cannot span multiple lines');
+      }
+      if (!this._tokenTypeStrToInt.has(tokenType)) {
+        throw new Error('`tokenType` is not in the provided legend');
+      }
+      var line = range.start.line;
+      var char = range.start.character;
+      var length = range.end.character - range.start.character;
+      var nTokenType = this._tokenTypeStrToInt.get(tokenType);
+      var nTokenModifiers = 0;
+      if (tokenModifiers) {
+        var _iterator11 = _createForOfIteratorHelper(tokenModifiers),
+          _step11;
+        try {
+          for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+            var tokenModifier = _step11.value;
+            if (!this._tokenModifierStrToInt.has(tokenModifier)) {
+              throw new Error('`tokenModifier` is not in the provided legend');
+            }
+            var nTokenModifier = this._tokenModifierStrToInt.get(tokenModifier);
+            nTokenModifiers |= 1 << nTokenModifier >>> 0;
+          }
+        } catch (err) {
+          _iterator11.e(err);
+        } finally {
+          _iterator11.f();
+        }
+      }
+      this._pushEncoded(line, char, length, nTokenType, nTokenModifiers);
+    }
+  }, {
+    key: "_pushEncoded",
+    value: function _pushEncoded(line, char, length, tokenType, tokenModifiers) {
+      if (this._dataIsSortedAndDeltaEncoded && (line < this._prevLine || line === this._prevLine && char < this._prevChar)) {
+        // push calls were ordered and are no longer ordered
+        this._dataIsSortedAndDeltaEncoded = false;
+
+        // Remove delta encoding from data
+        var tokenCount = this._data.length / 5 | 0;
+        var prevLine = 0;
+        var prevChar = 0;
+        for (var i = 0; i < tokenCount; i++) {
+          var _line = this._data[5 * i];
+          var _char = this._data[5 * i + 1];
+          if (_line === 0) {
+            // on the same line as previous token
+            _line = prevLine;
+            _char += prevChar;
+          } else {
+            // on a different line than previous token
+            _line += prevLine;
+          }
+          this._data[5 * i] = _line;
+          this._data[5 * i + 1] = _char;
+          prevLine = _line;
+          prevChar = _char;
+        }
+      }
+      var pushLine = line;
+      var pushChar = char;
+      if (this._dataIsSortedAndDeltaEncoded && this._dataLen > 0) {
+        pushLine -= this._prevLine;
+        if (pushLine === 0) {
+          pushChar -= this._prevChar;
+        }
+      }
+      this._data[this._dataLen++] = pushLine;
+      this._data[this._dataLen++] = pushChar;
+      this._data[this._dataLen++] = length;
+      this._data[this._dataLen++] = tokenType;
+      this._data[this._dataLen++] = tokenModifiers;
+      this._prevLine = line;
+      this._prevChar = char;
+    }
+  }, {
+    key: "build",
+    value: function build(resultId) {
+      if (!this._dataIsSortedAndDeltaEncoded) {
+        return new SemanticTokens(SemanticTokensBuilder._sortAndDeltaEncode(this._data), resultId);
+      }
+      return new SemanticTokens(new Uint32Array(this._data), resultId);
+    }
+  }], [{
+    key: "_sortAndDeltaEncode",
+    value: function _sortAndDeltaEncode(data) {
+      var pos = [];
+      var tokenCount = data.length / 5 | 0;
+      for (var i = 0; i < tokenCount; i++) {
+        pos[i] = i;
+      }
+      pos.sort(function (a, b) {
+        var aLine = data[5 * a];
+        var bLine = data[5 * b];
+        if (aLine === bLine) {
+          var aChar = data[5 * a + 1];
+          var bChar = data[5 * b + 1];
+          return aChar - bChar;
+        }
+        return aLine - bLine;
+      });
+      var result = new Uint32Array(data.length);
+      var prevLine = 0;
+      var prevChar = 0;
+      for (var _i3 = 0; _i3 < tokenCount; _i3++) {
+        var srcOffset = 5 * pos[_i3];
+        var _line2 = data[srcOffset + 0];
+        var _char2 = data[srcOffset + 1];
+        var _length = data[srcOffset + 2];
+        var _tokenType = data[srcOffset + 3];
+        var _tokenModifiers = data[srcOffset + 4];
+        var pushLine = _line2 - prevLine;
+        var pushChar = pushLine === 0 ? _char2 - prevChar : _char2;
+        var dstOffset = 5 * _i3;
+        result[dstOffset + 0] = pushLine;
+        result[dstOffset + 1] = pushChar;
+        result[dstOffset + 2] = _length;
+        result[dstOffset + 3] = _tokenType;
+        result[dstOffset + 4] = _tokenModifiers;
+        prevLine = _line2;
+        prevChar = _char2;
+      }
+      return result;
+    }
+  }]);
+  return SemanticTokensBuilder;
+}();
+export var SemanticTokens = /*#__PURE__*/_createClass(function SemanticTokens(data, resultId) {
+  _classCallCheck(this, SemanticTokens);
+  this.resultId = resultId;
+  this.data = data;
+});
+export var SemanticTokensEdit = /*#__PURE__*/_createClass(function SemanticTokensEdit(start, deleteCount, data) {
+  _classCallCheck(this, SemanticTokensEdit);
+  this.start = start;
+  this.deleteCount = deleteCount;
+  this.data = data;
+});
+export var SemanticTokensEdits = /*#__PURE__*/_createClass(function SemanticTokensEdits(edits, resultId) {
+  _classCallCheck(this, SemanticTokensEdits);
+  this.resultId = resultId;
+  this.edits = edits;
+});
+
+//#endregion
+
+//#region debug
+export var DebugConsoleMode = /*#__PURE__*/function (DebugConsoleMode) {
+  DebugConsoleMode[DebugConsoleMode["Separate"] = 0] = "Separate";
+  DebugConsoleMode[DebugConsoleMode["MergeWithParent"] = 1] = "MergeWithParent";
+  return DebugConsoleMode;
+}({});
+
+//#endregion
+
+export var QuickInputButtons = /*#__PURE__*/_createClass(function QuickInputButtons() {
+  _classCallCheck(this, QuickInputButtons);
+});
+QuickInputButtons.Back = {
+  iconPath: new ThemeIcon('arrow-left')
+};
+export var QuickPickItemKind = /*#__PURE__*/function (QuickPickItemKind) {
+  QuickPickItemKind[QuickPickItemKind["Separator"] = -1] = "Separator";
+  QuickPickItemKind[QuickPickItemKind["Default"] = 0] = "Default";
+  return QuickPickItemKind;
+}({});
+export var InputBoxValidationSeverity = /*#__PURE__*/function (InputBoxValidationSeverity) {
+  InputBoxValidationSeverity[InputBoxValidationSeverity["Info"] = 1] = "Info";
+  InputBoxValidationSeverity[InputBoxValidationSeverity["Warning"] = 2] = "Warning";
+  InputBoxValidationSeverity[InputBoxValidationSeverity["Error"] = 3] = "Error";
+  return InputBoxValidationSeverity;
+}({});
+export var ExtensionKind = /*#__PURE__*/function (ExtensionKind) {
+  ExtensionKind[ExtensionKind["UI"] = 1] = "UI";
+  ExtensionKind[ExtensionKind["Workspace"] = 2] = "Workspace";
+  return ExtensionKind;
+}({});
+
+// export class FileDecoration {
+//   static validate(d: FileDecoration): boolean {
+//     if (typeof d.badge === 'string') {
+//       let len = nextCharLength(d.badge, 0);
+//       if (len < d.badge.length) {
+//         len += nextCharLength(d.badge, len);
+//       }
+//       if (d.badge.length > len) {
+//         throw new Error(`The 'badge'-property must be undefined or a short character`);
+//       }
+//     } else if (d.badge) {
+//       if (!ThemeIcon.isThemeIcon(d.badge)) {
+//         throw new Error(`The 'badge'-property is not a valid ThemeIcon`);
+//       }
+//     }
+//     if (!d.color && !d.badge && !d.tooltip) {
+//       throw new Error(`The decoration is empty`);
+//     }
+//     return true;
+//   }
+
+//   badge?: string | vscode.ThemeIcon;
+//   tooltip?: string;
+//   color?: vscode.ThemeColor;
+//   propagate?: boolean;
+
+//   constructor(badge?: string | ThemeIcon, tooltip?: string, color?: ThemeColor) {
+//     this.badge = badge;
+//     this.tooltip = tooltip;
+//     this.color = color;
+//   }
+// }
+
+//#region Theming
+
+export var ColorTheme = /*#__PURE__*/_createClass(function ColorTheme(kind) {
+  _classCallCheck(this, ColorTheme);
+  this.kind = kind;
+});
+export var ColorThemeKind = /*#__PURE__*/function (ColorThemeKind) {
+  ColorThemeKind[ColorThemeKind["Light"] = 1] = "Light";
+  ColorThemeKind[ColorThemeKind["Dark"] = 2] = "Dark";
+  ColorThemeKind[ColorThemeKind["HighContrast"] = 3] = "HighContrast";
+  ColorThemeKind[ColorThemeKind["HighContrastLight"] = 4] = "HighContrastLight";
+  return ColorThemeKind;
+}({});
+
+//#endregion Theming
+
+//#region Notebook
+
+export var NotebookRange = /*#__PURE__*/function () {
+  function NotebookRange(start, end) {
+    _classCallCheck(this, NotebookRange);
+    if (start < 0) {
+      throw illegalArgument('start must be positive');
+    }
+    if (end < 0) {
+      throw illegalArgument('end must be positive');
+    }
+    if (start <= end) {
+      this._start = start;
+      this._end = end;
+    } else {
+      this._start = end;
+      this._end = start;
+    }
+  }
+  _createClass(NotebookRange, [{
+    key: "start",
+    get: function get() {
+      return this._start;
+    }
+  }, {
+    key: "end",
+    get: function get() {
+      return this._end;
+    }
+  }, {
+    key: "isEmpty",
+    get: function get() {
+      return this._start === this._end;
+    }
+  }, {
+    key: "with",
+    value: function _with(change) {
+      var start = this._start;
+      var end = this._end;
+      if (change.start !== undefined) {
+        start = change.start;
+      }
+      if (change.end !== undefined) {
+        end = change.end;
+      }
+      if (start === this._start && end === this._end) {
+        return this;
+      }
+      return new NotebookRange(start, end);
+    }
+  }], [{
+    key: "isNotebookRange",
+    value: function isNotebookRange(thing) {
+      if (thing instanceof NotebookRange) {
+        return true;
+      }
+      if (!thing) {
+        return false;
+      }
+      return typeof thing.start === 'number' && typeof thing.end === 'number';
+    }
+  }]);
+  return NotebookRange;
+}();
+export var NotebookCellData = /*#__PURE__*/function () {
+  function NotebookCellData(kind, value, languageId, mime, outputs, metadata, executionSummary) {
+    _classCallCheck(this, NotebookCellData);
+    this.kind = kind;
+    this.value = value;
+    this.languageId = languageId;
+    this.mime = mime;
+    this.outputs = outputs !== null && outputs !== void 0 ? outputs : [];
+    this.metadata = metadata;
+    this.executionSummary = executionSummary;
+    NotebookCellData.validate(this);
+  }
+  _createClass(NotebookCellData, null, [{
+    key: "validate",
+    value: function validate(data) {
+      if (typeof data.kind !== 'number') {
+        throw new Error("NotebookCellData MUST have 'kind' property");
+      }
+      if (typeof data.value !== 'string') {
+        throw new Error("NotebookCellData MUST have 'value' property");
+      }
+      if (typeof data.languageId !== 'string') {
+        throw new Error("NotebookCellData MUST have 'languageId' property");
+      }
+    }
+  }, {
+    key: "isNotebookCellDataArray",
+    value: function isNotebookCellDataArray(value) {
+      return Array.isArray(value) && value.every(function (elem) {
+        return NotebookCellData.isNotebookCellData(elem);
+      });
+    }
+  }, {
+    key: "isNotebookCellData",
+    value: function isNotebookCellData(value) {
+      // return value instanceof NotebookCellData;
+      return true;
+    }
+  }]);
+  return NotebookCellData;
+}();
+export var NotebookData = /*#__PURE__*/_createClass(function NotebookData(cells) {
+  _classCallCheck(this, NotebookData);
+  this.cells = cells;
+});
+var _encoder = /*#__PURE__*/_classPrivateFieldLooseKey("encoder");
+export var NotebookCellOutputItem = /*#__PURE__*/function () {
+  function NotebookCellOutputItem(data, mime) {
+    _classCallCheck(this, NotebookCellOutputItem);
+    this.data = data;
+    this.mime = mime;
+    var mimeNormalized = normalizeMimeType(mime, true);
+    if (!mimeNormalized) {
+      throw new Error("INVALID mime type: ".concat(mime, ". Must be in the format \"type/subtype[;optionalparameter]\""));
+    }
+    this.mime = mimeNormalized;
+  }
+  _createClass(NotebookCellOutputItem, null, [{
+    key: "isNotebookCellOutputItem",
+    value: function isNotebookCellOutputItem(obj) {
+      if (obj instanceof NotebookCellOutputItem) {
+        return true;
+      }
+      if (!obj) {
+        return false;
+      }
+      return typeof obj.mime === 'string' && obj.data instanceof Uint8Array;
+    }
+  }, {
+    key: "error",
+    value: function error(err) {
+      var obj = {
+        name: err.name,
+        message: err.message,
+        stack: err.stack
+      };
+      return NotebookCellOutputItem.json(obj, 'application/vnd.code.notebook.error');
+    }
+  }, {
+    key: "stdout",
+    value: function stdout(value) {
+      return NotebookCellOutputItem.text(value, 'application/vnd.code.notebook.stdout');
+    }
+  }, {
+    key: "stderr",
+    value: function stderr(value) {
+      return NotebookCellOutputItem.text(value, 'application/vnd.code.notebook.stderr');
+    }
+  }, {
+    key: "bytes",
+    value: function bytes(value) {
+      var mime = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'application/octet-stream';
+      return new NotebookCellOutputItem(value, mime);
+    }
+  }, {
+    key: "text",
+    value: function text(value) {
+      var mime = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Mimes.text;
+      var bytes = _classPrivateFieldLooseBase(NotebookCellOutputItem, _encoder)[_encoder].encode(String(value));
+      return new NotebookCellOutputItem(bytes, mime);
+    }
+  }, {
+    key: "json",
+    value: function json(value) {
+      var mime = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'text/x-json';
+      var rawStr = JSON.stringify(value, undefined, '\t');
+      return NotebookCellOutputItem.text(rawStr, mime);
+    }
+  }]);
+  return NotebookCellOutputItem;
+}();
+Object.defineProperty(NotebookCellOutputItem, _encoder, {
+  writable: true,
+  value: new TextEncoder()
+});
+export var NotebookCellOutput = /*#__PURE__*/function () {
+  function NotebookCellOutput(items, idOrMetadata, metadata) {
+    _classCallCheck(this, NotebookCellOutput);
+    this.items = NotebookCellOutput.ensureUniqueMimeTypes(items, true);
+    if (typeof idOrMetadata === 'string') {
+      this.id = idOrMetadata;
+      this.metadata = metadata;
+    } else {
+      this.id = generateUuid();
+      this.metadata = idOrMetadata !== null && idOrMetadata !== void 0 ? idOrMetadata : metadata;
+    }
+  }
+  _createClass(NotebookCellOutput, null, [{
+    key: "isNotebookCellOutput",
+    value: function isNotebookCellOutput(candidate) {
+      if (candidate instanceof NotebookCellOutput) {
+        return true;
+      }
+      if (!candidate || _typeof(candidate) !== 'object') {
+        return false;
+      }
+      return typeof candidate.id === 'string' && Array.isArray(candidate.items);
+    }
+  }, {
+    key: "ensureUniqueMimeTypes",
+    value: function ensureUniqueMimeTypes(items) {
+      var warn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var seen = new Set();
+      var removeIdx = new Set();
+      for (var i = 0; i < items.length; i++) {
+        var _item5 = items[i];
+        var normalMime = normalizeMimeType(_item5.mime);
+        // We can have multiple text stream mime types in the same output.
+        if (!seen.has(normalMime) || isTextStreamMime(normalMime)) {
+          seen.add(normalMime);
+          continue;
+        }
+        // duplicated mime types... first has won
+        removeIdx.add(i);
+        if (warn) {
+          console.warn("DUPLICATED mime type '".concat(_item5.mime, "' will be dropped"));
+        }
+      }
+      if (removeIdx.size === 0) {
+        return items;
+      }
+      return items.filter(function (_item, index) {
+        return !removeIdx.has(index);
+      });
+    }
+  }]);
+  return NotebookCellOutput;
+}();
+export var NotebookCellKind = /*#__PURE__*/function (NotebookCellKind) {
+  NotebookCellKind[NotebookCellKind["Markup"] = 1] = "Markup";
+  NotebookCellKind[NotebookCellKind["Code"] = 2] = "Code";
+  return NotebookCellKind;
+}({});
+export var NotebookCellExecutionState = /*#__PURE__*/function (NotebookCellExecutionState) {
+  NotebookCellExecutionState[NotebookCellExecutionState["Idle"] = 1] = "Idle";
+  NotebookCellExecutionState[NotebookCellExecutionState["Pending"] = 2] = "Pending";
+  NotebookCellExecutionState[NotebookCellExecutionState["Executing"] = 3] = "Executing";
+  return NotebookCellExecutionState;
+}({});
+export var NotebookCellStatusBarAlignment = /*#__PURE__*/function (NotebookCellStatusBarAlignment) {
+  NotebookCellStatusBarAlignment[NotebookCellStatusBarAlignment["Left"] = 1] = "Left";
+  NotebookCellStatusBarAlignment[NotebookCellStatusBarAlignment["Right"] = 2] = "Right";
+  return NotebookCellStatusBarAlignment;
+}({});
+export var NotebookEditorRevealType = /*#__PURE__*/function (NotebookEditorRevealType) {
+  NotebookEditorRevealType[NotebookEditorRevealType["Default"] = 0] = "Default";
+  NotebookEditorRevealType[NotebookEditorRevealType["InCenter"] = 1] = "InCenter";
+  NotebookEditorRevealType[NotebookEditorRevealType["InCenterIfOutsideViewport"] = 2] = "InCenterIfOutsideViewport";
+  NotebookEditorRevealType[NotebookEditorRevealType["AtTop"] = 3] = "AtTop";
+  return NotebookEditorRevealType;
+}({});
+export var NotebookCellStatusBarItem = /*#__PURE__*/_createClass(function NotebookCellStatusBarItem(text, alignment) {
+  _classCallCheck(this, NotebookCellStatusBarItem);
+  this.text = text;
+  this.alignment = alignment;
+});
+export var NotebookControllerAffinity = /*#__PURE__*/function (NotebookControllerAffinity) {
+  NotebookControllerAffinity[NotebookControllerAffinity["Default"] = 1] = "Default";
+  NotebookControllerAffinity[NotebookControllerAffinity["Preferred"] = 2] = "Preferred";
+  return NotebookControllerAffinity;
+}({});
+export var NotebookControllerAffinity2 = /*#__PURE__*/function (NotebookControllerAffinity2) {
+  NotebookControllerAffinity2[NotebookControllerAffinity2["Default"] = 1] = "Default";
+  NotebookControllerAffinity2[NotebookControllerAffinity2["Preferred"] = 2] = "Preferred";
+  NotebookControllerAffinity2[NotebookControllerAffinity2["Hidden"] = -1] = "Hidden";
+  return NotebookControllerAffinity2;
+}({});
+export var NotebookRendererScript = /*#__PURE__*/_createClass(function NotebookRendererScript(uri) {
+  var provides = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  _classCallCheck(this, NotebookRendererScript);
+  this.uri = uri;
+  this.provides = asArray(provides);
+});
+export var NotebookKernelSourceAction = /*#__PURE__*/_createClass(function NotebookKernelSourceAction(label) {
+  _classCallCheck(this, NotebookKernelSourceAction);
+  this.label = label;
+});
+export var NotebookVariablesRequestKind = /*#__PURE__*/function (NotebookVariablesRequestKind) {
+  NotebookVariablesRequestKind[NotebookVariablesRequestKind["Named"] = 1] = "Named";
+  NotebookVariablesRequestKind[NotebookVariablesRequestKind["Indexed"] = 2] = "Indexed";
+  return NotebookVariablesRequestKind;
+}({});
+
+//#endregion
+
+//#region Timeline
+
+// export class TimelineItem implements vscode.TimelineItem {
+//   constructor(
+//     public label: string,
+//     public timestamp: number,
+//   ) {}
+// }
+
+//#endregion Timeline
+
+//#region ExtensionContext
+
+export var ExtensionMode = /*#__PURE__*/function (ExtensionMode) {
+  ExtensionMode[ExtensionMode["Production"] = 1] = "Production";
+  ExtensionMode[ExtensionMode["Development"] = 2] = "Development";
+  ExtensionMode[ExtensionMode["Test"] = 3] = "Test";
+  return ExtensionMode;
+}({});
+export var ExtensionRuntime = /*#__PURE__*/function (ExtensionRuntime) {
+  ExtensionRuntime[ExtensionRuntime["Node"] = 1] = "Node";
+  ExtensionRuntime[ExtensionRuntime["Webworker"] = 2] = "Webworker";
+  return ExtensionRuntime;
+}({});
+
+//#endregion ExtensionContext
+
+export var StandardTokenType = /*#__PURE__*/function (StandardTokenType) {
+  StandardTokenType[StandardTokenType["Other"] = 0] = "Other";
+  StandardTokenType[StandardTokenType["Comment"] = 1] = "Comment";
+  StandardTokenType[StandardTokenType["String"] = 2] = "String";
+  StandardTokenType[StandardTokenType["RegEx"] = 3] = "RegEx";
+  return StandardTokenType;
+}({});
+export var LinkedEditingRanges = /*#__PURE__*/_createClass(function LinkedEditingRanges(ranges, wordPattern) {
+  _classCallCheck(this, LinkedEditingRanges);
+  this.ranges = ranges;
+  this.wordPattern = wordPattern;
+}
+
+/**
+ * A list of ranges that can be edited together. The ranges must have
+ * identical length and text content. The ranges cannot overlap.
+ */
+
+/**
+ * An optional word pattern that describes valid contents for the given ranges.
+ * If no pattern is provided, the language configuration's word pattern will be used.
+ */);
+
+//#region ports
+export var PortAttributes = /*#__PURE__*/function () {
+  function PortAttributes(autoForwardAction) {
+    _classCallCheck(this, PortAttributes);
+    this._autoForwardAction = autoForwardAction;
+  }
+  _createClass(PortAttributes, [{
+    key: "autoForwardAction",
+    get: function get() {
+      return this._autoForwardAction;
+    }
+  }]);
+  return PortAttributes;
+}();
+//#endregion ports
+
+//#region Testing
+export var TestResultState = /*#__PURE__*/function (TestResultState) {
+  TestResultState[TestResultState["Queued"] = 1] = "Queued";
+  TestResultState[TestResultState["Running"] = 2] = "Running";
+  TestResultState[TestResultState["Passed"] = 3] = "Passed";
+  TestResultState[TestResultState["Failed"] = 4] = "Failed";
+  TestResultState[TestResultState["Skipped"] = 5] = "Skipped";
+  TestResultState[TestResultState["Errored"] = 6] = "Errored";
+  return TestResultState;
+}({});
+export var TestRunProfileKind = /*#__PURE__*/function (TestRunProfileKind) {
+  TestRunProfileKind[TestRunProfileKind["Run"] = 1] = "Run";
+  TestRunProfileKind[TestRunProfileKind["Debug"] = 2] = "Debug";
+  TestRunProfileKind[TestRunProfileKind["Coverage"] = 3] = "Coverage";
+  return TestRunProfileKind;
+}({});
+export var TestRunRequest = /*#__PURE__*/_createClass(function TestRunRequest() {
+  var include = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
+  var exclude = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  var profile = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  var continuous = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  _classCallCheck(this, TestRunRequest);
+  this.include = include;
+  this.exclude = exclude;
+  this.profile = profile;
+  this.continuous = continuous;
+});
+export var TestMessage = /*#__PURE__*/function () {
+  function TestMessage(message) {
+    _classCallCheck(this, TestMessage);
+    this.message = message;
+  }
+  _createClass(TestMessage, null, [{
+    key: "diff",
+    value: /** proposed: */
+
+    function diff(message, expected, actual) {
+      var msg = new TestMessage(message);
+      msg.expectedOutput = expected;
+      msg.actualOutput = actual;
+      return msg;
+    }
+  }]);
+  return TestMessage;
+}();
+export var TestTag = /*#__PURE__*/_createClass(function TestTag(id) {
+  _classCallCheck(this, TestTag);
+  this.id = id;
+});
+
+//#endregion
+
+export var ExternalUriOpenerPriority = /*#__PURE__*/function (ExternalUriOpenerPriority) {
+  ExternalUriOpenerPriority[ExternalUriOpenerPriority["None"] = 0] = "None";
+  ExternalUriOpenerPriority[ExternalUriOpenerPriority["Option"] = 1] = "Option";
+  ExternalUriOpenerPriority[ExternalUriOpenerPriority["Default"] = 2] = "Default";
+  ExternalUriOpenerPriority[ExternalUriOpenerPriority["Preferred"] = 3] = "Preferred";
+  return ExternalUriOpenerPriority;
+}({});
+export var WorkspaceTrustState = /*#__PURE__*/function (WorkspaceTrustState) {
+  WorkspaceTrustState[WorkspaceTrustState["Untrusted"] = 0] = "Untrusted";
+  WorkspaceTrustState[WorkspaceTrustState["Trusted"] = 1] = "Trusted";
+  WorkspaceTrustState[WorkspaceTrustState["Unspecified"] = 2] = "Unspecified";
+  return WorkspaceTrustState;
+}({});
+export var PortAutoForwardAction = /*#__PURE__*/function (PortAutoForwardAction) {
+  PortAutoForwardAction[PortAutoForwardAction["Notify"] = 1] = "Notify";
+  PortAutoForwardAction[PortAutoForwardAction["OpenBrowser"] = 2] = "OpenBrowser";
+  PortAutoForwardAction[PortAutoForwardAction["OpenPreview"] = 3] = "OpenPreview";
+  PortAutoForwardAction[PortAutoForwardAction["Silent"] = 4] = "Silent";
+  PortAutoForwardAction[PortAutoForwardAction["Ignore"] = 5] = "Ignore";
+  PortAutoForwardAction[PortAutoForwardAction["OpenBrowserOnce"] = 6] = "OpenBrowserOnce";
+  return PortAutoForwardAction;
+}({});
+export var TypeHierarchyItem = /*#__PURE__*/_createClass(function TypeHierarchyItem(kind, name, detail, uri, range, selectionRange) {
+  _classCallCheck(this, TypeHierarchyItem);
+  this.kind = kind;
+  this.name = name;
+  this.detail = detail;
+  this.uri = uri;
+  this.range = range;
+  this.selectionRange = selectionRange;
+});
+
+//#region Tab Inputs
+
+export var TextTabInput = /*#__PURE__*/_createClass(function TextTabInput(uri) {
+  _classCallCheck(this, TextTabInput);
+  this.uri = uri;
+});
+export var TextDiffTabInput = /*#__PURE__*/_createClass(function TextDiffTabInput(original, modified) {
+  _classCallCheck(this, TextDiffTabInput);
+  this.original = original;
+  this.modified = modified;
+});
+export var TextMergeTabInput = /*#__PURE__*/_createClass(function TextMergeTabInput(base, input1, input2, result) {
+  _classCallCheck(this, TextMergeTabInput);
+  this.base = base;
+  this.input1 = input1;
+  this.input2 = input2;
+  this.result = result;
+});
+export var CustomEditorTabInput = /*#__PURE__*/_createClass(function CustomEditorTabInput(uri, viewType) {
+  _classCallCheck(this, CustomEditorTabInput);
+  this.uri = uri;
+  this.viewType = viewType;
+});
+export var WebviewEditorTabInput = /*#__PURE__*/_createClass(function WebviewEditorTabInput(viewType) {
+  _classCallCheck(this, WebviewEditorTabInput);
+  this.viewType = viewType;
+});
+export var NotebookEditorTabInput = /*#__PURE__*/_createClass(function NotebookEditorTabInput(uri, notebookType) {
+  _classCallCheck(this, NotebookEditorTabInput);
+  this.uri = uri;
+  this.notebookType = notebookType;
+});
+export var NotebookDiffEditorTabInput = /*#__PURE__*/_createClass(function NotebookDiffEditorTabInput(original, modified, notebookType) {
+  _classCallCheck(this, NotebookDiffEditorTabInput);
+  this.original = original;
+  this.modified = modified;
+  this.notebookType = notebookType;
+});
+export var TerminalEditorTabInput = /*#__PURE__*/_createClass(function TerminalEditorTabInput() {
+  _classCallCheck(this, TerminalEditorTabInput);
+});
+export var InteractiveWindowInput = /*#__PURE__*/_createClass(function InteractiveWindowInput(uri, inputBoxUri) {
+  _classCallCheck(this, InteractiveWindowInput);
+  this.uri = uri;
+  this.inputBoxUri = inputBoxUri;
+});
+export var ChatEditorTabInput = /*#__PURE__*/_createClass(function ChatEditorTabInput(providerId) {
+  _classCallCheck(this, ChatEditorTabInput);
+  this.providerId = providerId;
+});
+//#endregion
+
+//#region Chat
+
+export var InteractiveSessionVoteDirection = /*#__PURE__*/function (InteractiveSessionVoteDirection) {
+  InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 0] = "Down";
+  InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
+  return InteractiveSessionVoteDirection;
+}({});
+export var ChatAgentCopyKind = /*#__PURE__*/function (ChatAgentCopyKind) {
+  ChatAgentCopyKind[ChatAgentCopyKind["Action"] = 1] = "Action";
+  ChatAgentCopyKind[ChatAgentCopyKind["Toolbar"] = 2] = "Toolbar";
+  return ChatAgentCopyKind;
+}({});
+export var ChatVariableLevel = /*#__PURE__*/function (ChatVariableLevel) {
+  ChatVariableLevel[ChatVariableLevel["Short"] = 1] = "Short";
+  ChatVariableLevel[ChatVariableLevel["Medium"] = 2] = "Medium";
+  ChatVariableLevel[ChatVariableLevel["Full"] = 3] = "Full";
+  return ChatVariableLevel;
+}({});
+
+//#endregion
+
+//#region Interactive Editor
+
+export var InteractiveEditorResponseFeedbackKind = /*#__PURE__*/function (InteractiveEditorResponseFeedbackKind) {
+  InteractiveEditorResponseFeedbackKind[InteractiveEditorResponseFeedbackKind["Unhelpful"] = 0] = "Unhelpful";
+  InteractiveEditorResponseFeedbackKind[InteractiveEditorResponseFeedbackKind["Helpful"] = 1] = "Helpful";
+  InteractiveEditorResponseFeedbackKind[InteractiveEditorResponseFeedbackKind["Undone"] = 2] = "Undone";
+  InteractiveEditorResponseFeedbackKind[InteractiveEditorResponseFeedbackKind["Accepted"] = 3] = "Accepted";
+  InteractiveEditorResponseFeedbackKind[InteractiveEditorResponseFeedbackKind["Bug"] = 4] = "Bug";
+  return InteractiveEditorResponseFeedbackKind;
+}({});
+export var ChatMessageRole = /*#__PURE__*/function (ChatMessageRole) {
+  ChatMessageRole[ChatMessageRole["System"] = 0] = "System";
+  ChatMessageRole[ChatMessageRole["User"] = 1] = "User";
+  ChatMessageRole[ChatMessageRole["Assistant"] = 2] = "Assistant";
+  ChatMessageRole[ChatMessageRole["Function"] = 3] = "Function";
+  return ChatMessageRole;
+}({});
+export var ChatAgentResultFeedbackKind = /*#__PURE__*/function (ChatAgentResultFeedbackKind) {
+  ChatAgentResultFeedbackKind[ChatAgentResultFeedbackKind["Unhelpful"] = 0] = "Unhelpful";
+  ChatAgentResultFeedbackKind[ChatAgentResultFeedbackKind["Helpful"] = 1] = "Helpful";
+  return ChatAgentResultFeedbackKind;
+}({});
+
+//#endregion
+
+//#region ai
+
+export var RelatedInformationType = /*#__PURE__*/function (RelatedInformationType) {
+  RelatedInformationType[RelatedInformationType["SymbolInformation"] = 1] = "SymbolInformation";
+  RelatedInformationType[RelatedInformationType["CommandInformation"] = 2] = "CommandInformation";
+  RelatedInformationType[RelatedInformationType["SearchInformation"] = 3] = "SearchInformation";
+  RelatedInformationType[RelatedInformationType["SettingInformation"] = 4] = "SettingInformation";
+  return RelatedInformationType;
+}({});
+
+//#endregion
+
+//#region Speech
+
+export var SpeechToTextStatus = /*#__PURE__*/function (SpeechToTextStatus) {
+  SpeechToTextStatus[SpeechToTextStatus["Started"] = 1] = "Started";
+  SpeechToTextStatus[SpeechToTextStatus["Recognizing"] = 2] = "Recognizing";
+  SpeechToTextStatus[SpeechToTextStatus["Recognized"] = 3] = "Recognized";
+  SpeechToTextStatus[SpeechToTextStatus["Stopped"] = 4] = "Stopped";
+  return SpeechToTextStatus;
+}({});
+
+//#endregion