/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 89:
/*!*****************************************!*\
  !*** ./node_modules/process/browser.js ***!
  \*****************************************/
/***/ (function(module) {

// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
  throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout() {
  throw new Error('clearTimeout has not been defined');
}
(function () {
  try {
    if (typeof setTimeout === 'function') {
      cachedSetTimeout = setTimeout;
    } else {
      cachedSetTimeout = defaultSetTimout;
    }
  } catch (e) {
    cachedSetTimeout = defaultSetTimout;
  }
  try {
    if (typeof clearTimeout === 'function') {
      cachedClearTimeout = clearTimeout;
    } else {
      cachedClearTimeout = defaultClearTimeout;
    }
  } catch (e) {
    cachedClearTimeout = defaultClearTimeout;
  }
})();
function runTimeout(fun) {
  if (cachedSetTimeout === setTimeout) {
    //normal enviroments in sane situations
    return setTimeout(fun, 0);
  }
  // if setTimeout wasn't available but was latter defined
  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
    cachedSetTimeout = setTimeout;
    return setTimeout(fun, 0);
  }
  try {
    // when when somebody has screwed with setTimeout but no I.E. maddness
    return cachedSetTimeout(fun, 0);
  } catch (e) {
    try {
      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
      return cachedSetTimeout.call(null, fun, 0);
    } catch (e) {
      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
      return cachedSetTimeout.call(this, fun, 0);
    }
  }
}
function runClearTimeout(marker) {
  if (cachedClearTimeout === clearTimeout) {
    //normal enviroments in sane situations
    return clearTimeout(marker);
  }
  // if clearTimeout wasn't available but was latter defined
  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
    cachedClearTimeout = clearTimeout;
    return clearTimeout(marker);
  }
  try {
    // when when somebody has screwed with setTimeout but no I.E. maddness
    return cachedClearTimeout(marker);
  } catch (e) {
    try {
      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
      return cachedClearTimeout.call(null, marker);
    } catch (e) {
      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
      // Some versions of I.E. have different rules for clearTimeout vs setTimeout
      return cachedClearTimeout.call(this, marker);
    }
  }
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
  if (!draining || !currentQueue) {
    return;
  }
  draining = false;
  if (currentQueue.length) {
    queue = currentQueue.concat(queue);
  } else {
    queueIndex = -1;
  }
  if (queue.length) {
    drainQueue();
  }
}
function drainQueue() {
  if (draining) {
    return;
  }
  var timeout = runTimeout(cleanUpNextTick);
  draining = true;
  var len = queue.length;
  while (len) {
    currentQueue = queue;
    queue = [];
    while (++queueIndex < len) {
      if (currentQueue) {
        currentQueue[queueIndex].run();
      }
    }
    queueIndex = -1;
    len = queue.length;
  }
  currentQueue = null;
  draining = false;
  runClearTimeout(timeout);
}
process.nextTick = function (fun) {
  var args = new Array(arguments.length - 1);
  if (arguments.length > 1) {
    for (var i = 1; i < arguments.length; i++) {
      args[i - 1] = arguments[i];
    }
  }
  queue.push(new Item(fun, args));
  if (queue.length === 1 && !draining) {
    runTimeout(drainQueue);
  }
};

// v8 likes predictible objects
function Item(fun, array) {
  this.fun = fun;
  this.array = array;
}
Item.prototype.run = function () {
  this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) {
  return [];
};
process.binding = function (name) {
  throw new Error('process.binding is not supported');
};
process.cwd = function () {
  return '/';
};
process.chdir = function (dir) {
  throw new Error('process.chdir is not supported');
};
process.umask = function () {
  return 0;
};

/***/ }),

/***/ 154:
/*!*****************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/arrayLikeToArray.js ***!
  \*****************************************************************/
/***/ (function(module) {

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;
}
module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 462:
/*!***************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/arrayWithHoles.js ***!
  \***************************************************************/
/***/ (function(module) {

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}
module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 177:
/*!******************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js ***!
  \******************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray.js */ 154);
function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return arrayLikeToArray(arr);
}
module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 760:
/*!**********************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/assertThisInitialized.js ***!
  \**********************************************************************/
/***/ (function(module) {

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }
  return self;
}
module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 608:
/*!***************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/classCallCheck.js ***!
  \***************************************************************/
/***/ (function(module) {

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 702:
/*!**********************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/construct.js ***!
  \**********************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf.js */ 857);
var isNativeReflectConstruct = __webpack_require__(/*! ./isNativeReflectConstruct.js */ 856);
function _construct(Parent, args, Class) {
  if (isNativeReflectConstruct()) {
    module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports["default"] = module.exports;
  } else {
    module.exports = _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;
    }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  }
  return _construct.apply(null, arguments);
}
module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 218:
/*!************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/createClass.js ***!
  \************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var toPropertyKey = __webpack_require__(/*! ./toPropertyKey.js */ 108);
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;
}
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 706:
/*!**************************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js ***!
  \**************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ 237);
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;
      }
    }
  };
}
module.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 680:
/*!************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/createSuper.js ***!
  \************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf.js */ 569);
var isNativeReflectConstruct = __webpack_require__(/*! ./isNativeReflectConstruct.js */ 856);
var possibleConstructorReturn = __webpack_require__(/*! ./possibleConstructorReturn.js */ 460);
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);
  };
}
module.exports = _createSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 51:
/*!***************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/defineProperty.js ***!
  \***************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var toPropertyKey = __webpack_require__(/*! ./toPropertyKey.js */ 108);
function _defineProperty(obj, key, value) {
  key = toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 315:
/*!****************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/get.js ***!
  \****************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var superPropBase = __webpack_require__(/*! ./superPropBase.js */ 78);
function _get() {
  if (typeof Reflect !== "undefined" && Reflect.get) {
    module.exports = _get = Reflect.get.bind(), module.exports.__esModule = true, module.exports["default"] = module.exports;
  } else {
    module.exports = _get = function _get(target, property, receiver) {
      var base = superPropBase(target, property);
      if (!base) return;
      var desc = Object.getOwnPropertyDescriptor(base, property);
      if (desc.get) {
        return desc.get.call(arguments.length < 3 ? target : receiver);
      }
      return desc.value;
    }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  }
  return _get.apply(this, arguments);
}
module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 569:
/*!***************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/getPrototypeOf.js ***!
  \***************************************************************/
/***/ (function(module) {

function _getPrototypeOf(o) {
  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  return _getPrototypeOf(o);
}
module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 590:
/*!*********************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/inherits.js ***!
  \*********************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf.js */ 857);
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);
}
module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 494:
/*!*****************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/isNativeFunction.js ***!
  \*****************************************************************/
/***/ (function(module) {

function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 856:
/*!*************************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js ***!
  \*************************************************************************/
/***/ (function(module) {

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;
  }
}
module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 311:
/*!****************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/iterableToArray.js ***!
  \****************************************************************/
/***/ (function(module) {

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 449:
/*!*********************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js ***!
  \*********************************************************************/
/***/ (function(module) {

function _iterableToArrayLimit(arr, i) {
  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
  if (null != _i) {
    var _s,
      _e,
      _x,
      _r,
      _arr = [],
      _n = !0,
      _d = !1;
    try {
      if (_x = (_i = _i.call(arr)).next, 0 === i) {
        if (Object(_i) !== _i) return;
        _n = !1;
      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
    } catch (err) {
      _d = !0, _e = err;
    } finally {
      try {
        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
      } finally {
        if (_d) throw _e;
      }
    }
    return _arr;
  }
}
module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 431:
/*!****************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/nonIterableRest.js ***!
  \****************************************************************/
/***/ (function(module) {

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.");
}
module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 757:
/*!******************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/nonIterableSpread.js ***!
  \******************************************************************/
/***/ (function(module) {

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.");
}
module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 460:
/*!**************************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js ***!
  \**************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(/*! ./typeof.js */ 191)["default"]);
var assertThisInitialized = __webpack_require__(/*! ./assertThisInitialized.js */ 760);
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);
}
module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 15:
/*!*******************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/regeneratorRuntime.js ***!
  \*******************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(/*! ./typeof.js */ 191)["default"]);
function _regeneratorRuntime() {
  "use strict";

  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
    return exports;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  var exports = {},
    Op = Object.prototype,
    hasOwn = Op.hasOwnProperty,
    defineProperty = Object.defineProperty || function (obj, key, desc) {
      obj[key] = desc.value;
    },
    $Symbol = "function" == typeof Symbol ? Symbol : {},
    iteratorSymbol = $Symbol.iterator || "@@iterator",
    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
  function define(obj, key, value) {
    return Object.defineProperty(obj, key, {
      value: value,
      enumerable: !0,
      configurable: !0,
      writable: !0
    }), obj[key];
  }
  try {
    define({}, "");
  } catch (err) {
    define = function define(obj, key, value) {
      return obj[key] = value;
    };
  }
  function wrap(innerFn, outerFn, self, tryLocsList) {
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
      generator = Object.create(protoGenerator.prototype),
      context = new Context(tryLocsList || []);
    return defineProperty(generator, "_invoke", {
      value: makeInvokeMethod(innerFn, self, context)
    }), generator;
  }
  function tryCatch(fn, obj, arg) {
    try {
      return {
        type: "normal",
        arg: fn.call(obj, arg)
      };
    } catch (err) {
      return {
        type: "throw",
        arg: err
      };
    }
  }
  exports.wrap = wrap;
  var ContinueSentinel = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var IteratorPrototype = {};
  define(IteratorPrototype, iteratorSymbol, function () {
    return this;
  });
  var getProto = Object.getPrototypeOf,
    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function (method) {
      define(prototype, method, function (arg) {
        return this._invoke(method, arg);
      });
    });
  }
  function AsyncIterator(generator, PromiseImpl) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if ("throw" !== record.type) {
        var result = record.arg,
          value = result.value;
        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
          invoke("next", value, resolve, reject);
        }, function (err) {
          invoke("throw", err, resolve, reject);
        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
          result.value = unwrapped, resolve(result);
        }, function (error) {
          return invoke("throw", error, resolve, reject);
        });
      }
      reject(record.arg);
    }
    var previousPromise;
    defineProperty(this, "_invoke", {
      value: function value(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new PromiseImpl(function (resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }
        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(innerFn, self, context) {
    var state = "suspendedStart";
    return function (method, arg) {
      if ("executing" === state) throw new Error("Generator is already running");
      if ("completed" === state) {
        if ("throw" === method) throw arg;
        return doneResult();
      }
      for (context.method = method, context.arg = arg;;) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }
        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
          if ("suspendedStart" === state) throw state = "completed", context.arg;
          context.dispatchException(context.arg);
        } else "return" === context.method && context.abrupt("return", context.arg);
        state = "executing";
        var record = tryCatch(innerFn, self, context);
        if ("normal" === record.type) {
          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
          return {
            value: record.arg,
            done: context.done
          };
        }
        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
      }
    };
  }
  function maybeInvokeDelegate(delegate, context) {
    var methodName = context.method,
      method = delegate.iterator[methodName];
    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
    var record = tryCatch(method, delegate.iterator, context.arg);
    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
    var info = record.arg;
    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
  }
  function pushTryEntry(locs) {
    var entry = {
      tryLoc: locs[0]
    };
    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
  }
  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal", delete record.arg, entry.completion = record;
  }
  function Context(tryLocsList) {
    this.tryEntries = [{
      tryLoc: "root"
    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
  }
  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) return iteratorMethod.call(iterable);
      if ("function" == typeof iterable.next) return iterable;
      if (!isNaN(iterable.length)) {
        var i = -1,
          next = function next() {
            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
            return next.value = undefined, next.done = !0, next;
          };
        return next.next = next;
      }
    }
    return {
      next: doneResult
    };
  }
  function doneResult() {
    return {
      value: undefined,
      done: !0
    };
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: !0
  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: !0
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
    var ctor = "function" == typeof genFun && genFun.constructor;
    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
  }, exports.mark = function (genFun) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
  }, exports.awrap = function (arg) {
    return {
      __await: arg
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
    return this;
  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
    void 0 === PromiseImpl && (PromiseImpl = Promise);
    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
      return result.done ? result.value : iter.next();
    });
  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
    return this;
  }), define(Gp, "toString", function () {
    return "[object Generator]";
  }), exports.keys = function (val) {
    var object = Object(val),
      keys = [];
    for (var key in object) keys.push(key);
    return keys.reverse(), function next() {
      for (; keys.length;) {
        var key = keys.pop();
        if (key in object) return next.value = key, next.done = !1, next;
      }
      return next.done = !0, next;
    };
  }, exports.values = values, Context.prototype = {
    constructor: Context,
    reset: function reset(skipTempReset) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
    },
    stop: function stop() {
      this.done = !0;
      var rootRecord = this.tryEntries[0].completion;
      if ("throw" === rootRecord.type) throw rootRecord.arg;
      return this.rval;
    },
    dispatchException: function dispatchException(exception) {
      if (this.done) throw exception;
      var context = this;
      function handle(loc, caught) {
        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
      }
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i],
          record = entry.completion;
        if ("root" === entry.tryLoc) return handle("end");
        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc"),
            hasFinally = hasOwn.call(entry, "finallyLoc");
          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
          } else {
            if (!hasFinally) throw new Error("try statement without catch or finally");
            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
          }
        }
      }
    },
    abrupt: function abrupt(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }
      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
      var record = finallyEntry ? finallyEntry.completion : {};
      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
    },
    complete: function complete(record, afterLoc) {
      if ("throw" === record.type) throw record.arg;
      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
    },
    finish: function finish(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
      }
    },
    "catch": function _catch(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if ("throw" === record.type) {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }
      throw new Error("illegal catch attempt");
    },
    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
      return this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
    }
  }, exports;
}
module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 857:
/*!***************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/setPrototypeOf.js ***!
  \***************************************************************/
/***/ (function(module) {

function _setPrototypeOf(o, p) {
  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  return _setPrototypeOf(o, p);
}
module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 488:
/*!**************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/slicedToArray.js ***!
  \**************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayWithHoles = __webpack_require__(/*! ./arrayWithHoles.js */ 462);
var iterableToArrayLimit = __webpack_require__(/*! ./iterableToArrayLimit.js */ 449);
var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ 237);
var nonIterableRest = __webpack_require__(/*! ./nonIterableRest.js */ 431);
function _slicedToArray(arr, i) {
  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
}
module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 78:
/*!**************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/superPropBase.js ***!
  \**************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf.js */ 569);
function _superPropBase(object, property) {
  while (!Object.prototype.hasOwnProperty.call(object, property)) {
    object = getPrototypeOf(object);
    if (object === null) break;
  }
  return object;
}
module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 235:
/*!******************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/toConsumableArray.js ***!
  \******************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayWithoutHoles = __webpack_require__(/*! ./arrayWithoutHoles.js */ 177);
var iterableToArray = __webpack_require__(/*! ./iterableToArray.js */ 311);
var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ 237);
var nonIterableSpread = __webpack_require__(/*! ./nonIterableSpread.js */ 757);
function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
}
module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 875:
/*!************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/toPrimitive.js ***!
  \************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(/*! ./typeof.js */ 191)["default"]);
function _toPrimitive(input, hint) {
  if (_typeof(input) !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (_typeof(res) !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 108:
/*!**************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/toPropertyKey.js ***!
  \**************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var _typeof = (__webpack_require__(/*! ./typeof.js */ 191)["default"]);
var toPrimitive = __webpack_require__(/*! ./toPrimitive.js */ 875);
function _toPropertyKey(arg) {
  var key = toPrimitive(arg, "string");
  return _typeof(key) === "symbol" ? key : String(key);
}
module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 191:
/*!*******************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/typeof.js ***!
  \*******************************************************/
/***/ (function(module) {

function _typeof(obj) {
  "@babel/helpers - typeof";

  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 237:
/*!***************************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js ***!
  \***************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray.js */ 154);
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);
}
module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ 929:
/*!****************************************************************!*\
  !*** ./node_modules/@babel/runtime/helpers/wrapNativeSuper.js ***!
  \****************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

var getPrototypeOf = __webpack_require__(/*! ./getPrototypeOf.js */ 569);
var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf.js */ 857);
var isNativeFunction = __webpack_require__(/*! ./isNativeFunction.js */ 494);
var construct = __webpack_require__(/*! ./construct.js */ 702);
function _wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;
  module.exports = _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);
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  return _wrapNativeSuper(Class);
}
module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	!function() {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
"use strict";
/*!*************************************************************************************!*\
  !*** ./node_modules/monaco-editor/esm/vs/language/json/json.worker.js + 62 modules ***!
  \*************************************************************************************/

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/typeof.js
var helpers_typeof = __webpack_require__(191);
var typeof_default = /*#__PURE__*/__webpack_require__.n(helpers_typeof);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
var createForOfIteratorHelper = __webpack_require__(706);
var createForOfIteratorHelper_default = /*#__PURE__*/__webpack_require__.n(createForOfIteratorHelper);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/inherits.js
var inherits = __webpack_require__(590);
var inherits_default = /*#__PURE__*/__webpack_require__.n(inherits);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/createSuper.js
var createSuper = __webpack_require__(680);
var createSuper_default = /*#__PURE__*/__webpack_require__.n(createSuper);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/createClass.js
var createClass = __webpack_require__(218);
var createClass_default = /*#__PURE__*/__webpack_require__.n(createClass);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/classCallCheck.js
var classCallCheck = __webpack_require__(608);
var classCallCheck_default = /*#__PURE__*/__webpack_require__.n(classCallCheck);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/wrapNativeSuper.js
var wrapNativeSuper = __webpack_require__(929);
var wrapNativeSuper_default = /*#__PURE__*/__webpack_require__.n(wrapNativeSuper);
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/errors.js





// Avoid circular dependency on EventEmitter by implementing a subset of the interface.
var ErrorHandler = /*#__PURE__*/function () {
  function ErrorHandler() {
    classCallCheck_default()(this, ErrorHandler);
    this.listeners = [];
    this.unexpectedErrorHandler = function (e) {
      setTimeout(function () {
        if (e.stack) {
          throw new Error(e.message + '\n\n' + e.stack);
        }
        throw e;
      }, 0);
    };
  }
  createClass_default()(ErrorHandler, [{
    key: "emit",
    value: function emit(e) {
      this.listeners.forEach(function (listener) {
        listener(e);
      });
    }
  }, {
    key: "onUnexpectedError",
    value: function onUnexpectedError(e) {
      this.unexpectedErrorHandler(e);
      this.emit(e);
    }
    // For external errors, we don't want the listeners to be called
  }, {
    key: "onUnexpectedExternalError",
    value: function onUnexpectedExternalError(e) {
      this.unexpectedErrorHandler(e);
    }
  }]);
  return ErrorHandler;
}();
var errorHandler = new ErrorHandler();
function onUnexpectedError(e) {
  // ignore errors from cancelled promises
  if (!isPromiseCanceledError(e)) {
    errorHandler.onUnexpectedError(e);
  }
  return undefined;
}
function onUnexpectedExternalError(e) {
  // ignore errors from cancelled promises
  if (!isPromiseCanceledError(e)) {
    errorHandler.onUnexpectedExternalError(e);
  }
  return undefined;
}
function transformErrorForSerialization(error) {
  if (error instanceof Error) {
    var name = error.name,
      message = error.message;
    var stack = error.stacktrace || error.stack;
    return {
      $isError: true,
      name: name,
      message: message,
      stack: stack
    };
  }
  // return as is
  return error;
}
var canceledName = 'Canceled';
/**
 * Checks if the given error is a promise in canceled state
 */
function isPromiseCanceledError(error) {
  return error instanceof Error && error.name === canceledName && error.message === canceledName;
}
/**
 * Returns an error that signals cancellation.
 */
function canceled() {
  var error = new Error(canceledName);
  error.name = error.message;
  return error;
}
function illegalArgument(name) {
  if (name) {
    return new Error("Illegal argument: ".concat(name));
  } else {
    return new Error('Illegal argument');
  }
}
function illegalState(name) {
  if (name) {
    return new Error("Illegal state: ".concat(name));
  } else {
    return new Error('Illegal state');
  }
}
var NotSupportedError = /*#__PURE__*/function (_Error) {
  inherits_default()(NotSupportedError, _Error);
  var _super = createSuper_default()(NotSupportedError);
  function NotSupportedError(message) {
    var _this;
    classCallCheck_default()(this, NotSupportedError);
    _this = _super.call(this, 'NotSupported');
    if (message) {
      _this.message = message;
    }
    return _this;
  }
  return createClass_default()(NotSupportedError);
}( /*#__PURE__*/wrapNativeSuper_default()(Error));
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/get.js
var get = __webpack_require__(315);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/getPrototypeOf.js
var getPrototypeOf = __webpack_require__(569);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/slicedToArray.js
var slicedToArray = __webpack_require__(488);
var slicedToArray_default = /*#__PURE__*/__webpack_require__.n(slicedToArray);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/toConsumableArray.js
var toConsumableArray = __webpack_require__(235);
var toConsumableArray_default = /*#__PURE__*/__webpack_require__.n(toConsumableArray);
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/functional.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function once(fn) {
  var _this = this;
  var didCall = false;
  var result;
  return function () {
    if (didCall) {
      return result;
    }
    didCall = true;
    result = fn.apply(_this, arguments);
    return result;
  };
}
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/defineProperty.js
var defineProperty = __webpack_require__(51);
var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/regeneratorRuntime.js
var regeneratorRuntime = __webpack_require__(15);
var regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(regeneratorRuntime);
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/iterator.js




/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var Iterable;
(function (Iterable) {
  var _marked = /*#__PURE__*/regeneratorRuntime_default()().mark(single),
    _marked2 = /*#__PURE__*/regeneratorRuntime_default()().mark(filter),
    _marked3 = /*#__PURE__*/regeneratorRuntime_default()().mark(map),
    _marked4 = /*#__PURE__*/regeneratorRuntime_default()().mark(concat),
    _marked5 = /*#__PURE__*/regeneratorRuntime_default()().mark(concatNested);
  function is(thing) {
    return thing && typeof_default()(thing) === 'object' && typeof thing[Symbol.iterator] === 'function';
  }
  Iterable.is = is;
  var _empty = Object.freeze([]);
  function empty() {
    return _empty;
  }
  Iterable.empty = empty;
  function single(element) {
    return regeneratorRuntime_default()().wrap(function single$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          _context.next = 2;
          return element;
        case 2:
        case "end":
          return _context.stop();
      }
    }, _marked);
  }
  Iterable.single = single;
  function from(iterable) {
    return iterable || _empty;
  }
  Iterable.from = from;
  function isEmpty(iterable) {
    return !iterable || iterable[Symbol.iterator]().next().done === true;
  }
  Iterable.isEmpty = isEmpty;
  function first(iterable) {
    return iterable[Symbol.iterator]().next().value;
  }
  Iterable.first = first;
  function some(iterable, predicate) {
    var _iterator = createForOfIteratorHelper_default()(iterable),
      _step;
    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var element = _step.value;
        if (predicate(element)) {
          return true;
        }
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
    return false;
  }
  Iterable.some = some;
  function find(iterable, predicate) {
    var _iterator2 = createForOfIteratorHelper_default()(iterable),
      _step2;
    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var element = _step2.value;
        if (predicate(element)) {
          return element;
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
    return undefined;
  }
  Iterable.find = find;
  function filter(iterable, predicate) {
    var _iterator3, _step3, element;
    return regeneratorRuntime_default()().wrap(function filter$(_context2) {
      while (1) switch (_context2.prev = _context2.next) {
        case 0:
          _iterator3 = createForOfIteratorHelper_default()(iterable);
          _context2.prev = 1;
          _iterator3.s();
        case 3:
          if ((_step3 = _iterator3.n()).done) {
            _context2.next = 10;
            break;
          }
          element = _step3.value;
          if (!predicate(element)) {
            _context2.next = 8;
            break;
          }
          _context2.next = 8;
          return element;
        case 8:
          _context2.next = 3;
          break;
        case 10:
          _context2.next = 15;
          break;
        case 12:
          _context2.prev = 12;
          _context2.t0 = _context2["catch"](1);
          _iterator3.e(_context2.t0);
        case 15:
          _context2.prev = 15;
          _iterator3.f();
          return _context2.finish(15);
        case 18:
        case "end":
          return _context2.stop();
      }
    }, _marked2, null, [[1, 12, 15, 18]]);
  }
  Iterable.filter = filter;
  function map(iterable, fn) {
    var index, _iterator4, _step4, element;
    return regeneratorRuntime_default()().wrap(function map$(_context3) {
      while (1) switch (_context3.prev = _context3.next) {
        case 0:
          index = 0;
          _iterator4 = createForOfIteratorHelper_default()(iterable);
          _context3.prev = 2;
          _iterator4.s();
        case 4:
          if ((_step4 = _iterator4.n()).done) {
            _context3.next = 10;
            break;
          }
          element = _step4.value;
          _context3.next = 8;
          return fn(element, index++);
        case 8:
          _context3.next = 4;
          break;
        case 10:
          _context3.next = 15;
          break;
        case 12:
          _context3.prev = 12;
          _context3.t0 = _context3["catch"](2);
          _iterator4.e(_context3.t0);
        case 15:
          _context3.prev = 15;
          _iterator4.f();
          return _context3.finish(15);
        case 18:
        case "end":
          return _context3.stop();
      }
    }, _marked3, null, [[2, 12, 15, 18]]);
  }
  Iterable.map = map;
  function concat() {
    var _len,
      iterables,
      _key,
      _i,
      _iterables,
      iterable,
      _iterator5,
      _step5,
      element,
      _args4 = arguments;
    return regeneratorRuntime_default()().wrap(function concat$(_context4) {
      while (1) switch (_context4.prev = _context4.next) {
        case 0:
          for (_len = _args4.length, iterables = new Array(_len), _key = 0; _key < _len; _key++) {
            iterables[_key] = _args4[_key];
          }
          _i = 0, _iterables = iterables;
        case 2:
          if (!(_i < _iterables.length)) {
            _context4.next = 24;
            break;
          }
          iterable = _iterables[_i];
          _iterator5 = createForOfIteratorHelper_default()(iterable);
          _context4.prev = 5;
          _iterator5.s();
        case 7:
          if ((_step5 = _iterator5.n()).done) {
            _context4.next = 13;
            break;
          }
          element = _step5.value;
          _context4.next = 11;
          return element;
        case 11:
          _context4.next = 7;
          break;
        case 13:
          _context4.next = 18;
          break;
        case 15:
          _context4.prev = 15;
          _context4.t0 = _context4["catch"](5);
          _iterator5.e(_context4.t0);
        case 18:
          _context4.prev = 18;
          _iterator5.f();
          return _context4.finish(18);
        case 21:
          _i++;
          _context4.next = 2;
          break;
        case 24:
        case "end":
          return _context4.stop();
      }
    }, _marked4, null, [[5, 15, 18, 21]]);
  }
  Iterable.concat = concat;
  function concatNested(iterables) {
    var _iterator6, _step6, iterable, _iterator7, _step7, element;
    return regeneratorRuntime_default()().wrap(function concatNested$(_context5) {
      while (1) switch (_context5.prev = _context5.next) {
        case 0:
          _iterator6 = createForOfIteratorHelper_default()(iterables);
          _context5.prev = 1;
          _iterator6.s();
        case 3:
          if ((_step6 = _iterator6.n()).done) {
            _context5.next = 24;
            break;
          }
          iterable = _step6.value;
          _iterator7 = createForOfIteratorHelper_default()(iterable);
          _context5.prev = 6;
          _iterator7.s();
        case 8:
          if ((_step7 = _iterator7.n()).done) {
            _context5.next = 14;
            break;
          }
          element = _step7.value;
          _context5.next = 12;
          return element;
        case 12:
          _context5.next = 8;
          break;
        case 14:
          _context5.next = 19;
          break;
        case 16:
          _context5.prev = 16;
          _context5.t0 = _context5["catch"](6);
          _iterator7.e(_context5.t0);
        case 19:
          _context5.prev = 19;
          _iterator7.f();
          return _context5.finish(19);
        case 22:
          _context5.next = 3;
          break;
        case 24:
          _context5.next = 29;
          break;
        case 26:
          _context5.prev = 26;
          _context5.t1 = _context5["catch"](1);
          _iterator6.e(_context5.t1);
        case 29:
          _context5.prev = 29;
          _iterator6.f();
          return _context5.finish(29);
        case 32:
        case "end":
          return _context5.stop();
      }
    }, _marked5, null, [[1, 26, 29, 32], [6, 16, 19, 22]]);
  }
  Iterable.concatNested = concatNested;
  function reduce(iterable, reducer, initialValue) {
    var value = initialValue;
    var _iterator8 = createForOfIteratorHelper_default()(iterable),
      _step8;
    try {
      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
        var element = _step8.value;
        value = reducer(value, element);
      }
    } catch (err) {
      _iterator8.e(err);
    } finally {
      _iterator8.f();
    }
    return value;
  }
  Iterable.reduce = reduce;
  /**
   * Returns an iterable slice of the array, with the same semantics as `array.slice()`.
   */
  function slice(arr, from) {
    var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : arr.length;
    return /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee() {
      return regeneratorRuntime_default()().wrap(function _callee$(_context6) {
        while (1) switch (_context6.prev = _context6.next) {
          case 0:
            if (from < 0) {
              from += arr.length;
            }
            if (to < 0) {
              to += arr.length;
            } else if (to > arr.length) {
              to = arr.length;
            }
          case 2:
            if (!(from < to)) {
              _context6.next = 8;
              break;
            }
            _context6.next = 5;
            return arr[from];
          case 5:
            from++;
            _context6.next = 2;
            break;
          case 8:
          case "end":
            return _context6.stop();
        }
      }, _callee);
    })();
  }
  Iterable.slice = slice;
  /**
   * Consumes `atMost` elements from iterable and returns the consumed elements,
   * and an iterable for the rest of the elements.
   */
  function consume(iterable) {
    var atMost = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.POSITIVE_INFINITY;
    var consumed = [];
    if (atMost === 0) {
      return [consumed, iterable];
    }
    var iterator = iterable[Symbol.iterator]();
    for (var i = 0; i < atMost; i++) {
      var next = iterator.next();
      if (next.done) {
        return [consumed, Iterable.empty()];
      }
      consumed.push(next.value);
    }
    return [consumed, defineProperty_default()({}, Symbol.iterator, function () {
      return iterator;
    })];
  }
  Iterable.consume = consume;
  /**
   * Returns whether the iterables are the same length and all items are
   * equal using the comparator function.
   */
  function equals(a, b) {
    var comparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (at, bt) {
      return at === bt;
    };
    var ai = a[Symbol.iterator]();
    var bi = b[Symbol.iterator]();
    while (true) {
      var an = ai.next();
      var bn = bi.next();
      if (an.done !== bn.done) {
        return false;
      } else if (an.done) {
        return true;
      } else if (!comparator(an.value, bn.value)) {
        return false;
      }
    }
  }
  Iterable.equals = equals;
})(Iterable || (Iterable = {}));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js






/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


/**
 * Enables logging of potentially leaked disposables.
 *
 * A disposable is considered leaked if it is not disposed or not registered as the child of
 * another disposable. This tracking is very simple an only works for classes that either
 * extend Disposable or use a DisposableStore. This means there are a lot of false positives.
 */
var TRACK_DISPOSABLES = false;
var disposableTracker = null;
function setDisposableTracker(tracker) {
  disposableTracker = tracker;
}
if (TRACK_DISPOSABLES) {
  var __is_disposable_tracked__ = '__is_disposable_tracked__';
  setDisposableTracker(new ( /*#__PURE__*/function () {
    function _class() {
      classCallCheck_default()(this, _class);
    }
    createClass_default()(_class, [{
      key: "trackDisposable",
      value: function trackDisposable(x) {
        var stack = new Error('Potentially leaked disposable').stack;
        setTimeout(function () {
          if (!x[__is_disposable_tracked__]) {
            console.log(stack);
          }
        }, 3000);
      }
    }, {
      key: "setParent",
      value: function setParent(child, parent) {
        if (child && child !== lifecycle_Disposable.None) {
          try {
            child[__is_disposable_tracked__] = true;
          } catch (_a) {
            // noop
          }
        }
      }
    }, {
      key: "markAsDisposed",
      value: function markAsDisposed(disposable) {
        if (disposable && disposable !== lifecycle_Disposable.None) {
          try {
            disposable[__is_disposable_tracked__] = true;
          } catch (_a) {
            // noop
          }
        }
      }
    }, {
      key: "markAsSingleton",
      value: function markAsSingleton(disposable) {}
    }]);
    return _class;
  }())());
}
function trackDisposable(x) {
  disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.trackDisposable(x);
  return x;
}
function markAsDisposed(disposable) {
  disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsDisposed(disposable);
}
function setParentOfDisposable(child, parent) {
  disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.setParent(child, parent);
}
function setParentOfDisposables(children, parent) {
  if (!disposableTracker) {
    return;
  }
  var _iterator = createForOfIteratorHelper_default()(children),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var child = _step.value;
      disposableTracker.setParent(child, parent);
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
}
/**
 * Indicates that the given object is a singleton which does not need to be disposed.
*/
function markAsSingleton(singleton) {
  disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsSingleton(singleton);
  return singleton;
}
var MultiDisposeError = /*#__PURE__*/function (_Error) {
  inherits_default()(MultiDisposeError, _Error);
  var _super = createSuper_default()(MultiDisposeError);
  function MultiDisposeError(errors) {
    var _this;
    classCallCheck_default()(this, MultiDisposeError);
    _this = _super.call(this, "Encountered errors while disposing of store. Errors: [".concat(errors.join(', '), "]"));
    _this.errors = errors;
    return _this;
  }
  return createClass_default()(MultiDisposeError);
}( /*#__PURE__*/wrapNativeSuper_default()(Error));
function isDisposable(thing) {
  return typeof thing.dispose === 'function' && thing.dispose.length === 0;
}
function dispose(arg) {
  if (Iterable.is(arg)) {
    var errors = [];
    var _iterator2 = createForOfIteratorHelper_default()(arg),
      _step2;
    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var d = _step2.value;
        if (d) {
          try {
            d.dispose();
          } catch (e) {
            errors.push(e);
          }
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
    if (errors.length === 1) {
      throw errors[0];
    } else if (errors.length > 1) {
      throw new MultiDisposeError(errors);
    }
    return Array.isArray(arg) ? [] : arg;
  } else if (arg) {
    arg.dispose();
    return arg;
  }
}
function combinedDisposable() {
  for (var _len = arguments.length, disposables = new Array(_len), _key = 0; _key < _len; _key++) {
    disposables[_key] = arguments[_key];
  }
  var parent = toDisposable(function () {
    return dispose(disposables);
  });
  setParentOfDisposables(disposables, parent);
  return parent;
}
function toDisposable(fn) {
  var self = trackDisposable({
    dispose: once(function () {
      markAsDisposed(self);
      fn();
    })
  });
  return self;
}
var DisposableStore = /*#__PURE__*/function () {
  function DisposableStore() {
    classCallCheck_default()(this, DisposableStore);
    this._toDispose = new Set();
    this._isDisposed = false;
    trackDisposable(this);
  }
  /**
   * Dispose of all registered disposables and mark this object as disposed.
   *
   * Any future disposables added to this object will be disposed of on `add`.
   */
  createClass_default()(DisposableStore, [{
    key: "dispose",
    value: function dispose() {
      if (this._isDisposed) {
        return;
      }
      markAsDisposed(this);
      this._isDisposed = true;
      this.clear();
    }
    /**
     * Dispose of all registered disposables but do not mark this object as disposed.
     */
  }, {
    key: "clear",
    value: function clear() {
      try {
        dispose(this._toDispose.values());
      } finally {
        this._toDispose.clear();
      }
    }
  }, {
    key: "add",
    value: function add(o) {
      if (!o) {
        return o;
      }
      if (o === this) {
        throw new Error('Cannot register a disposable on itself!');
      }
      setParentOfDisposable(o, this);
      if (this._isDisposed) {
        if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
          console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);
        }
      } else {
        this._toDispose.add(o);
      }
      return o;
    }
  }]);
  return DisposableStore;
}();
DisposableStore.DISABLE_DISPOSED_WARNING = false;
var lifecycle_Disposable = /*#__PURE__*/function () {
  function Disposable() {
    classCallCheck_default()(this, Disposable);
    this._store = new DisposableStore();
    trackDisposable(this);
    setParentOfDisposable(this._store, this);
  }
  createClass_default()(Disposable, [{
    key: "dispose",
    value: function dispose() {
      markAsDisposed(this);
      this._store.dispose();
    }
  }, {
    key: "_register",
    value: function _register(o) {
      if (o === this) {
        throw new Error('Cannot register a disposable on itself!');
      }
      return this._store.add(o);
    }
  }]);
  return Disposable;
}();
lifecycle_Disposable.None = Object.freeze({
  dispose: function dispose() {}
});
/**
 * Manages the lifecycle of a disposable value that may be changed.
 *
 * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
 * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
 */
var MutableDisposable = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
  function MutableDisposable() {
    _classCallCheck(this, MutableDisposable);
    this._isDisposed = false;
    trackDisposable(this);
  }
  _createClass(MutableDisposable, [{
    key: "value",
    get: function get() {
      return this._isDisposed ? undefined : this._value;
    },
    set: function set(value) {
      var _a;
      if (this._isDisposed || value === this._value) {
        return;
      }
      (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();
      if (value) {
        setParentOfDisposable(value, this);
      }
      this._value = value;
    }
  }, {
    key: "clear",
    value: function clear() {
      this.value = undefined;
    }
  }, {
    key: "dispose",
    value: function dispose() {
      var _a;
      this._isDisposed = true;
      markAsDisposed(this);
      (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();
      this._value = undefined;
    }
    /**
     * Clears the value, but does not dispose it.
     * The old value is returned.
    */
  }, {
    key: "clearAndLeak",
    value: function clearAndLeak() {
      var oldValue = this._value;
      this._value = undefined;
      if (oldValue) {
        setParentOfDisposable(oldValue, null);
      }
      return oldValue;
    }
  }]);
  return MutableDisposable;
}()));
var ImmortalReference = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
  function ImmortalReference(object) {
    _classCallCheck(this, ImmortalReference);
    this.object = object;
  }
  _createClass(ImmortalReference, [{
    key: "dispose",
    value: function dispose() {}
  }]);
  return ImmortalReference;
}()));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/linkedList.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var Node = /*#__PURE__*/createClass_default()(function Node(element) {
  classCallCheck_default()(this, Node);
  this.element = element;
  this.next = Node.Undefined;
  this.prev = Node.Undefined;
});
Node.Undefined = new Node(undefined);
var linkedList_LinkedList = /*#__PURE__*/function (_Symbol$iterator) {
  function LinkedList() {
    classCallCheck_default()(this, LinkedList);
    this._first = Node.Undefined;
    this._last = Node.Undefined;
    this._size = 0;
  }
  createClass_default()(LinkedList, [{
    key: "size",
    get: function get() {
      return this._size;
    }
  }, {
    key: "isEmpty",
    value: function isEmpty() {
      return this._first === Node.Undefined;
    }
  }, {
    key: "clear",
    value: function clear() {
      var node = this._first;
      while (node !== Node.Undefined) {
        var next = node.next;
        node.prev = Node.Undefined;
        node.next = Node.Undefined;
        node = next;
      }
      this._first = Node.Undefined;
      this._last = Node.Undefined;
      this._size = 0;
    }
  }, {
    key: "unshift",
    value: function unshift(element) {
      return this._insert(element, false);
    }
  }, {
    key: "push",
    value: function push(element) {
      return this._insert(element, true);
    }
  }, {
    key: "_insert",
    value: function _insert(element, atTheEnd) {
      var _this = this;
      var newNode = new Node(element);
      if (this._first === Node.Undefined) {
        this._first = newNode;
        this._last = newNode;
      } else if (atTheEnd) {
        // push
        var oldLast = this._last;
        this._last = newNode;
        newNode.prev = oldLast;
        oldLast.next = newNode;
      } else {
        // unshift
        var oldFirst = this._first;
        this._first = newNode;
        newNode.next = oldFirst;
        oldFirst.prev = newNode;
      }
      this._size += 1;
      var didRemove = false;
      return function () {
        if (!didRemove) {
          didRemove = true;
          _this._remove(newNode);
        }
      };
    }
  }, {
    key: "shift",
    value: function shift() {
      if (this._first === Node.Undefined) {
        return undefined;
      } else {
        var res = this._first.element;
        this._remove(this._first);
        return res;
      }
    }
  }, {
    key: "pop",
    value: function pop() {
      if (this._last === Node.Undefined) {
        return undefined;
      } else {
        var res = this._last.element;
        this._remove(this._last);
        return res;
      }
    }
  }, {
    key: "_remove",
    value: function _remove(node) {
      if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
        // middle
        var anchor = node.prev;
        anchor.next = node.next;
        node.next.prev = anchor;
      } else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
        // only node
        this._first = Node.Undefined;
        this._last = Node.Undefined;
      } else if (node.next === Node.Undefined) {
        // last
        this._last = this._last.prev;
        this._last.next = Node.Undefined;
      } else if (node.prev === Node.Undefined) {
        // first
        this._first = this._first.next;
        this._first.prev = Node.Undefined;
      }
      // done
      this._size -= 1;
    }
  }, {
    key: _Symbol$iterator,
    value: /*#__PURE__*/regeneratorRuntime_default()().mark(function value() {
      var node;
      return regeneratorRuntime_default()().wrap(function value$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            node = this._first;
          case 1:
            if (!(node !== Node.Undefined)) {
              _context.next = 7;
              break;
            }
            _context.next = 4;
            return node.element;
          case 4:
            node = node.next;
            _context.next = 1;
            break;
          case 7:
          case "end":
            return _context.stop();
        }
      }, value, this);
    })
  }]);
  return LinkedList;
}(Symbol.iterator);
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/platform.js
/* provided dependency */ var process = __webpack_require__(/*! ./node_modules/process/browser.js */ 89);

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var _a;
var LANGUAGE_DEFAULT = 'en';
var _isWindows = false;
var _isMacintosh = false;
var _isLinux = false;
var _isLinuxSnap = false;
var _isNative = false;
var _isWeb = false;
var _isIOS = false;
var _locale = undefined;
var _language = (/* unused pure expression or super */ null && (LANGUAGE_DEFAULT));
var _translationsConfigFile = (/* unused pure expression or super */ null && (undefined));
var _userAgent = undefined;
var platform_globals = (typeof self === "undefined" ? "undefined" : typeof_default()(self)) === 'object' ? self : (typeof __webpack_require__.g === "undefined" ? "undefined" : typeof_default()(__webpack_require__.g)) === 'object' ? __webpack_require__.g : {};
var nodeProcess = undefined;
if (typeof platform_globals.vscode !== 'undefined' && typeof platform_globals.vscode.process !== 'undefined') {
  // Native environment (sandboxed)
  nodeProcess = platform_globals.vscode.process;
} else if (typeof process !== 'undefined') {
  // Native environment (non-sandboxed)
  nodeProcess = process;
}
var isElectronRenderer = typeof ((_a = nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.versions) === null || _a === void 0 ? void 0 : _a.electron) === 'string' && nodeProcess.type === 'renderer';
// Web environment
if ((typeof navigator === "undefined" ? "undefined" : typeof_default()(navigator)) === 'object' && !isElectronRenderer) {
  _userAgent = navigator.userAgent;
  _isWindows = _userAgent.indexOf('Windows') >= 0;
  _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;
  _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
  _isLinux = _userAgent.indexOf('Linux') >= 0;
  _isWeb = true;
  _locale = navigator.language;
  _language = _locale;
}
// Native environment
else if (typeof_default()(nodeProcess) === 'object') {
  _isWindows = nodeProcess.platform === 'win32';
  _isMacintosh = nodeProcess.platform === 'darwin';
  _isLinux = nodeProcess.platform === 'linux';
  _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];
  _locale = LANGUAGE_DEFAULT;
  _language = LANGUAGE_DEFAULT;
  var rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];
  if (rawNlsConfig) {
    try {
      var nlsConfig = JSON.parse(rawNlsConfig);
      var resolved = nlsConfig.availableLanguages['*'];
      _locale = nlsConfig.locale;
      // VSCode's default language is 'en'
      _language = resolved ? resolved : LANGUAGE_DEFAULT;
      _translationsConfigFile = nlsConfig._translationsConfigFile;
    } catch (e) {}
  }
  _isNative = true;
}
// Unknown environment
else {
  console.error('Unable to resolve platform.');
}
var _platform = 0 /* Web */;
if (_isMacintosh) {
  _platform = 1 /* Mac */;
} else if (_isWindows) {
  _platform = 3 /* Windows */;
} else if (_isLinux) {
  _platform = 2 /* Linux */;
}

var isWindows = _isWindows;
var isMacintosh = _isMacintosh;
var isLinux = (/* unused pure expression or super */ null && (_isLinux));
var isNative = (/* unused pure expression or super */ null && (_isNative));
var platform_isWeb = (/* unused pure expression or super */ null && (_isWeb));
var isIOS = (/* unused pure expression or super */ null && (_isIOS));
var userAgent = (/* unused pure expression or super */ null && (_userAgent));
var setImmediate = function defineSetImmediate() {
  if (platform_globals.setImmediate) {
    return platform_globals.setImmediate.bind(platform_globals);
  }
  if (typeof platform_globals.postMessage === 'function' && !platform_globals.importScripts) {
    var pending = [];
    platform_globals.addEventListener('message', function (e) {
      if (e.data && e.data.vscodeSetImmediateId) {
        for (var i = 0, len = pending.length; i < len; i++) {
          var candidate = pending[i];
          if (candidate.id === e.data.vscodeSetImmediateId) {
            pending.splice(i, 1);
            candidate.callback();
            return;
          }
        }
      }
    });
    var lastId = 0;
    return function (callback) {
      var myId = ++lastId;
      pending.push({
        id: myId,
        callback: callback
      });
      platform_globals.postMessage({
        vscodeSetImmediateId: myId
      }, '*');
    };
  }
  if (typeof (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.nextTick) === 'function') {
    return nodeProcess.nextTick.bind(nodeProcess);
  }
  var _promise = Promise.resolve();
  return function (callback) {
    return _promise.then(callback);
  };
}();
var OS = _isMacintosh || _isIOS ? 2 /* Macintosh */ : _isWindows ? 1 /* Windows */ : 3 /* Linux */;
var _isLittleEndian = true;
var _isLittleEndianComputed = false;
function isLittleEndian() {
  if (!_isLittleEndianComputed) {
    _isLittleEndianComputed = true;
    var test = new Uint8Array(2);
    test[0] = 1;
    test[1] = 2;
    var view = new Uint16Array(test.buffer);
    _isLittleEndian = view[0] === (2 << 8) + 1;
  }
  return _isLittleEndian;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var hasPerformanceNow = platform_globals.performance && typeof platform_globals.performance.now === 'function';
var StopWatch = /*#__PURE__*/function () {
  function StopWatch(highResolution) {
    classCallCheck_default()(this, StopWatch);
    this._highResolution = hasPerformanceNow && highResolution;
    this._startTime = this._now();
    this._stopTime = -1;
  }
  createClass_default()(StopWatch, [{
    key: "stop",
    value: function stop() {
      this._stopTime = this._now();
    }
  }, {
    key: "elapsed",
    value: function elapsed() {
      if (this._stopTime !== -1) {
        return this._stopTime - this._startTime;
      }
      return this._now() - this._startTime;
    }
  }, {
    key: "_now",
    value: function _now() {
      return this._highResolution ? platform_globals.performance.now() : Date.now();
    }
  }], [{
    key: "create",
    value: function create() {
      var highResolution = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
      return new StopWatch(highResolution);
    }
  }]);
  return StopWatch;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/event.js













var Event;
(function (Event) {
  Event.None = function () {
    return lifecycle_Disposable.None;
  };
  /**
   * Given an event, returns another event which only fires once.
   */
  function _once(event) {
    return function (listener) {
      var thisArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var disposables = arguments.length > 2 ? arguments[2] : undefined;
      // we need this, in case the event fires during the listener call
      var didFire = false;
      var result;
      result = event(function (e) {
        if (didFire) {
          return;
        } else if (result) {
          result.dispose();
        } else {
          didFire = true;
        }
        return listener.call(thisArgs, e);
      }, null, disposables);
      if (didFire) {
        result.dispose();
      }
      return result;
    };
  }
  Event.once = _once;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function _map(event, map) {
    return snapshot(function (listener) {
      var thisArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var disposables = arguments.length > 2 ? arguments[2] : undefined;
      return event(function (i) {
        return listener.call(thisArgs, map(i));
      }, null, disposables);
    });
  }
  Event.map = _map;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function _forEach(event, each) {
    return snapshot(function (listener) {
      var thisArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var disposables = arguments.length > 2 ? arguments[2] : undefined;
      return event(function (i) {
        each(i);
        listener.call(thisArgs, i);
      }, null, disposables);
    });
  }
  Event.forEach = _forEach;
  function _filter(event, filter) {
    return snapshot(function (listener) {
      var thisArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var disposables = arguments.length > 2 ? arguments[2] : undefined;
      return event(function (e) {
        return filter(e) && listener.call(thisArgs, e);
      }, null, disposables);
    });
  }
  Event.filter = _filter;
  /**
   * Given an event, returns the same event but typed as `Event<void>`.
   */
  function signal(event) {
    return event;
  }
  Event.signal = signal;
  function any() {
    for (var _len = arguments.length, events = new Array(_len), _key = 0; _key < _len; _key++) {
      events[_key] = arguments[_key];
    }
    return function (listener) {
      var thisArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var disposables = arguments.length > 2 ? arguments[2] : undefined;
      return combinedDisposable.apply(void 0, toConsumableArray_default()(events.map(function (event) {
        return event(function (e) {
          return listener.call(thisArgs, e);
        }, null, disposables);
      })));
    };
  }
  Event.any = any;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function _reduce(event, merge, initial) {
    var output = initial;
    return _map(event, function (e) {
      output = merge(output, e);
      return output;
    });
  }
  Event.reduce = _reduce;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function snapshot(event) {
    var listener;
    var emitter = new Emitter({
      onFirstListenerAdd: function onFirstListenerAdd() {
        listener = event(emitter.fire, emitter);
      },
      onLastListenerRemove: function onLastListenerRemove() {
        listener.dispose();
      }
    });
    return emitter.event;
  }
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function _debounce(event, merge) {
    var delay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
    var leading = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    var leakWarningThreshold = arguments.length > 4 ? arguments[4] : undefined;
    var subscription;
    var output = undefined;
    var handle = undefined;
    var numDebouncedCalls = 0;
    var emitter = new Emitter({
      leakWarningThreshold: leakWarningThreshold,
      onFirstListenerAdd: function onFirstListenerAdd() {
        subscription = event(function (cur) {
          numDebouncedCalls++;
          output = merge(output, cur);
          if (leading && !handle) {
            emitter.fire(output);
            output = undefined;
          }
          clearTimeout(handle);
          handle = setTimeout(function () {
            var _output = output;
            output = undefined;
            handle = undefined;
            if (!leading || numDebouncedCalls > 1) {
              emitter.fire(_output);
            }
            numDebouncedCalls = 0;
          }, delay);
        });
      },
      onLastListenerRemove: function onLastListenerRemove() {
        subscription.dispose();
      }
    });
    return emitter.event;
  }
  Event.debounce = _debounce;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function _latch(event) {
    var equals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (a, b) {
      return a === b;
    };
    var firstCall = true;
    var cache;
    return _filter(event, function (value) {
      var shouldEmit = firstCall || !equals(value, cache);
      firstCall = false;
      cache = value;
      return shouldEmit;
    });
  }
  Event.latch = _latch;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function split(event, isT) {
    return [Event.filter(event, isT), Event.filter(event, function (e) {
      return !isT(e);
    })];
  }
  Event.split = split;
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function buffer(event) {
    var nextTick = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var _buffer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
    var buffer = _buffer.slice();
    var listener = event(function (e) {
      if (buffer) {
        buffer.push(e);
      } else {
        emitter.fire(e);
      }
    });
    var flush = function flush() {
      if (buffer) {
        buffer.forEach(function (e) {
          return emitter.fire(e);
        });
      }
      buffer = null;
    };
    var emitter = new Emitter({
      onFirstListenerAdd: function onFirstListenerAdd() {
        if (!listener) {
          listener = event(function (e) {
            return emitter.fire(e);
          });
        }
      },
      onFirstListenerDidAdd: function onFirstListenerDidAdd() {
        if (buffer) {
          if (nextTick) {
            setTimeout(flush);
          } else {
            flush();
          }
        }
      },
      onLastListenerRemove: function onLastListenerRemove() {
        if (listener) {
          listener.dispose();
        }
        listener = null;
      }
    });
    return emitter.event;
  }
  Event.buffer = buffer;
  var ChainableEvent = /*#__PURE__*/function () {
    function ChainableEvent(event) {
      classCallCheck_default()(this, ChainableEvent);
      this.event = event;
    }
    createClass_default()(ChainableEvent, [{
      key: "map",
      value: function map(fn) {
        return new ChainableEvent(_map(this.event, fn));
      }
    }, {
      key: "forEach",
      value: function forEach(fn) {
        return new ChainableEvent(_forEach(this.event, fn));
      }
    }, {
      key: "filter",
      value: function filter(fn) {
        return new ChainableEvent(_filter(this.event, fn));
      }
    }, {
      key: "reduce",
      value: function reduce(merge, initial) {
        return new ChainableEvent(_reduce(this.event, merge, initial));
      }
    }, {
      key: "latch",
      value: function latch() {
        return new ChainableEvent(_latch(this.event));
      }
    }, {
      key: "debounce",
      value: function debounce(merge) {
        var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
        var leading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
        var leakWarningThreshold = arguments.length > 3 ? arguments[3] : undefined;
        return new ChainableEvent(_debounce(this.event, merge, delay, leading, leakWarningThreshold));
      }
    }, {
      key: "on",
      value: function on(listener, thisArgs, disposables) {
        return this.event(listener, thisArgs, disposables);
      }
    }, {
      key: "once",
      value: function once(listener, thisArgs, disposables) {
        return _once(this.event)(listener, thisArgs, disposables);
      }
    }]);
    return ChainableEvent;
  }();
  /**
   * @deprecated DO NOT use, this leaks memory
   */
  function chain(event) {
    return new ChainableEvent(event);
  }
  Event.chain = chain;
  function fromNodeEventEmitter(emitter, eventName) {
    var map = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (id) {
      return id;
    };
    var fn = function fn() {
      return result.fire(map.apply(void 0, arguments));
    };
    var onFirstListenerAdd = function onFirstListenerAdd() {
      return emitter.on(eventName, fn);
    };
    var onLastListenerRemove = function onLastListenerRemove() {
      return emitter.removeListener(eventName, fn);
    };
    var result = new Emitter({
      onFirstListenerAdd: onFirstListenerAdd,
      onLastListenerRemove: onLastListenerRemove
    });
    return result.event;
  }
  Event.fromNodeEventEmitter = fromNodeEventEmitter;
  function fromDOMEventEmitter(emitter, eventName) {
    var map = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (id) {
      return id;
    };
    var fn = function fn() {
      return result.fire(map.apply(void 0, arguments));
    };
    var onFirstListenerAdd = function onFirstListenerAdd() {
      return emitter.addEventListener(eventName, fn);
    };
    var onLastListenerRemove = function onLastListenerRemove() {
      return emitter.removeEventListener(eventName, fn);
    };
    var result = new Emitter({
      onFirstListenerAdd: onFirstListenerAdd,
      onLastListenerRemove: onLastListenerRemove
    });
    return result.event;
  }
  Event.fromDOMEventEmitter = fromDOMEventEmitter;
  function toPromise(event) {
    return new Promise(function (resolve) {
      return _once(event)(resolve);
    });
  }
  Event.toPromise = toPromise;
})(Event || (Event = {}));
var EventProfiling = /*#__PURE__*/function () {
  function EventProfiling(name) {
    classCallCheck_default()(this, EventProfiling);
    this._listenerCount = 0;
    this._invocationCount = 0;
    this._elapsedOverall = 0;
    this._name = "".concat(name, "_").concat(EventProfiling._idPool++);
  }
  createClass_default()(EventProfiling, [{
    key: "start",
    value: function start(listenerCount) {
      this._stopWatch = new StopWatch(true);
      this._listenerCount = listenerCount;
    }
  }, {
    key: "stop",
    value: function stop() {
      if (this._stopWatch) {
        var elapsed = this._stopWatch.elapsed();
        this._elapsedOverall += elapsed;
        this._invocationCount += 1;
        console.info("did FIRE ".concat(this._name, ": elapsed_ms: ").concat(elapsed.toFixed(5), ", listener: ").concat(this._listenerCount, " (elapsed_overall: ").concat(this._elapsedOverall.toFixed(2), ", invocations: ").concat(this._invocationCount, ")"));
        this._stopWatch = undefined;
      }
    }
  }]);
  return EventProfiling;
}();
EventProfiling._idPool = 0;
var _globalLeakWarningThreshold = -1;
var LeakageMonitor = /*#__PURE__*/function () {
  function LeakageMonitor(customThreshold) {
    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Math.random().toString(18).slice(2, 5);
    classCallCheck_default()(this, LeakageMonitor);
    this.customThreshold = customThreshold;
    this.name = name;
    this._warnCountdown = 0;
  }
  createClass_default()(LeakageMonitor, [{
    key: "dispose",
    value: function dispose() {
      if (this._stacks) {
        this._stacks.clear();
      }
    }
  }, {
    key: "check",
    value: function check(listenerCount) {
      var _this = this;
      var threshold = _globalLeakWarningThreshold;
      if (typeof this.customThreshold === 'number') {
        threshold = this.customThreshold;
      }
      if (threshold <= 0 || listenerCount < threshold) {
        return undefined;
      }
      if (!this._stacks) {
        this._stacks = new Map();
      }
      var stack = new Error().stack.split('\n').slice(3).join('\n');
      var count = this._stacks.get(stack) || 0;
      this._stacks.set(stack, count + 1);
      this._warnCountdown -= 1;
      if (this._warnCountdown <= 0) {
        // only warn on first exceed and then every time the limit
        // is exceeded by 50% again
        this._warnCountdown = threshold * 0.5;
        // find most frequent listener and print warning
        var topStack;
        var topCount = 0;
        var _iterator = createForOfIteratorHelper_default()(this._stacks),
          _step;
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var _step$value = slicedToArray_default()(_step.value, 2),
              _stack = _step$value[0],
              _count = _step$value[1];
            if (!topStack || topCount < _count) {
              topStack = _stack;
              topCount = _count;
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
        console.warn("[".concat(this.name, "] potential listener LEAK detected, having ").concat(listenerCount, " listeners already. MOST frequent listener (").concat(topCount, "):"));
        console.warn(topStack);
      }
      return function () {
        var count = _this._stacks.get(stack) || 0;
        _this._stacks.set(stack, count - 1);
      };
    }
  }]);
  return LeakageMonitor;
}();
/**
 * The Emitter can be used to expose an Event to the public
 * to fire it from the insides.
 * Sample:
    class Document {

        private readonly _onDidChange = new Emitter<(value:string)=>any>();

        public onDidChange = this._onDidChange.event;

        // getter-style
        // get onDidChange(): Event<(value:string)=>any> {
        // 	return this._onDidChange.event;
        // }

        private _doIt() {
            //...
            this._onDidChange.fire(value);
        }
    }
 */
var Emitter = /*#__PURE__*/function () {
  function Emitter(options) {
    classCallCheck_default()(this, Emitter);
    var _a;
    this._disposed = false;
    this._options = options;
    this._leakageMon = _globalLeakWarningThreshold > 0 ? new LeakageMonitor(this._options && this._options.leakWarningThreshold) : undefined;
    this._perfMon = ((_a = this._options) === null || _a === void 0 ? void 0 : _a._profName) ? new EventProfiling(this._options._profName) : undefined;
  }
  /**
   * For the public to allow to subscribe
   * to events from this Emitter
   */
  createClass_default()(Emitter, [{
    key: "event",
    get: function get() {
      var _this2 = this;
      if (!this._event) {
        this._event = function (listener, thisArgs, disposables) {
          var _a;
          if (!_this2._listeners) {
            _this2._listeners = new linkedList_LinkedList();
          }
          var firstListener = _this2._listeners.isEmpty();
          if (firstListener && _this2._options && _this2._options.onFirstListenerAdd) {
            _this2._options.onFirstListenerAdd(_this2);
          }
          var remove = _this2._listeners.push(!thisArgs ? listener : [listener, thisArgs]);
          if (firstListener && _this2._options && _this2._options.onFirstListenerDidAdd) {
            _this2._options.onFirstListenerDidAdd(_this2);
          }
          if (_this2._options && _this2._options.onListenerDidAdd) {
            _this2._options.onListenerDidAdd(_this2, listener, thisArgs);
          }
          // check and record this emitter for potential leakage
          var removeMonitor = (_a = _this2._leakageMon) === null || _a === void 0 ? void 0 : _a.check(_this2._listeners.size);
          var result = toDisposable(function () {
            if (removeMonitor) {
              removeMonitor();
            }
            if (!_this2._disposed) {
              remove();
              if (_this2._options && _this2._options.onLastListenerRemove) {
                var hasListeners = _this2._listeners && !_this2._listeners.isEmpty();
                if (!hasListeners) {
                  _this2._options.onLastListenerRemove(_this2);
                }
              }
            }
          });
          if (disposables instanceof DisposableStore) {
            disposables.add(result);
          } else if (Array.isArray(disposables)) {
            disposables.push(result);
          }
          return result;
        };
      }
      return this._event;
    }
    /**
     * To be kept private to fire an event to
     * subscribers
     */
  }, {
    key: "fire",
    value: function fire(event) {
      var _a, _b;
      if (this._listeners) {
        // put all [listener,event]-pairs into delivery queue
        // then emit all event. an inner/nested event might be
        // the driver of this
        if (!this._deliveryQueue) {
          this._deliveryQueue = new linkedList_LinkedList();
        }
        var _iterator2 = createForOfIteratorHelper_default()(this._listeners),
          _step2;
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var _listener = _step2.value;
            this._deliveryQueue.push([_listener, event]);
          }
          // start/stop performance insight collection
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
        (_a = this._perfMon) === null || _a === void 0 ? void 0 : _a.start(this._deliveryQueue.size);
        while (this._deliveryQueue.size > 0) {
          var _this$_deliveryQueue$ = this._deliveryQueue.shift(),
            _this$_deliveryQueue$2 = slicedToArray_default()(_this$_deliveryQueue$, 2),
            listener = _this$_deliveryQueue$2[0],
            _event = _this$_deliveryQueue$2[1];
          try {
            if (typeof listener === 'function') {
              listener.call(undefined, _event);
            } else {
              listener[0].call(listener[1], _event);
            }
          } catch (e) {
            onUnexpectedError(e);
          }
        }
        (_b = this._perfMon) === null || _b === void 0 ? void 0 : _b.stop();
      }
    }
  }, {
    key: "dispose",
    value: function dispose() {
      var _a, _b, _c, _d, _e;
      if (!this._disposed) {
        this._disposed = true;
        (_a = this._listeners) === null || _a === void 0 ? void 0 : _a.clear();
        (_b = this._deliveryQueue) === null || _b === void 0 ? void 0 : _b.clear();
        (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onLastListenerRemove) === null || _d === void 0 ? void 0 : _d.call(_c);
        (_e = this._leakageMon) === null || _e === void 0 ? void 0 : _e.dispose();
      }
    }
  }]);
  return Emitter;
}();
var PauseableEmitter = /*#__PURE__*/(/* unused pure expression or super */ null && (function (_Emitter) {
  _inherits(PauseableEmitter, _Emitter);
  var _super = _createSuper(PauseableEmitter);
  function PauseableEmitter(options) {
    var _this3;
    _classCallCheck(this, PauseableEmitter);
    _this3 = _super.call(this, options);
    _this3._isPaused = 0;
    _this3._eventQueue = new LinkedList();
    _this3._mergeFn = options === null || options === void 0 ? void 0 : options.merge;
    return _this3;
  }
  _createClass(PauseableEmitter, [{
    key: "pause",
    value: function pause() {
      this._isPaused++;
    }
  }, {
    key: "resume",
    value: function resume() {
      if (this._isPaused !== 0 && --this._isPaused === 0) {
        if (this._mergeFn) {
          // use the merge function to create a single composite
          // event. make a copy in case firing pauses this emitter
          var events = Array.from(this._eventQueue);
          this._eventQueue.clear();
          _get(_getPrototypeOf(PauseableEmitter.prototype), "fire", this).call(this, this._mergeFn(events));
        } else {
          // no merging, fire each event individually and test
          // that this emitter isn't paused halfway through
          while (!this._isPaused && this._eventQueue.size !== 0) {
            _get(_getPrototypeOf(PauseableEmitter.prototype), "fire", this).call(this, this._eventQueue.shift());
          }
        }
      }
    }
  }, {
    key: "fire",
    value: function fire(event) {
      if (this._listeners) {
        if (this._isPaused !== 0) {
          this._eventQueue.push(event);
        } else {
          _get(_getPrototypeOf(PauseableEmitter.prototype), "fire", this).call(this, event);
        }
      }
    }
  }]);
  return PauseableEmitter;
}(Emitter)));
var DebounceEmitter = /*#__PURE__*/(/* unused pure expression or super */ null && (function (_PauseableEmitter) {
  _inherits(DebounceEmitter, _PauseableEmitter);
  var _super2 = _createSuper(DebounceEmitter);
  function DebounceEmitter(options) {
    var _this4;
    _classCallCheck(this, DebounceEmitter);
    var _a;
    _this4 = _super2.call(this, options);
    _this4._delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 100;
    return _this4;
  }
  _createClass(DebounceEmitter, [{
    key: "fire",
    value: function fire(event) {
      var _this5 = this;
      if (!this._handle) {
        this.pause();
        this._handle = setTimeout(function () {
          _this5._handle = undefined;
          _this5.resume();
        }, this._delay);
      }
      _get(_getPrototypeOf(DebounceEmitter.prototype), "fire", this).call(this, event);
    }
  }]);
  return DebounceEmitter;
}(PauseableEmitter)));
/**
 * The EventBufferer is useful in situations in which you want
 * to delay firing your events during some code.
 * You can wrap that code and be sure that the event will not
 * be fired during that wrap.
 *
 * ```
 * const emitter: Emitter;
 * const delayer = new EventDelayer();
 * const delayedEvent = delayer.wrapEvent(emitter.event);
 *
 * delayedEvent(console.log);
 *
 * delayer.bufferEvents(() => {
 *   emitter.fire(); // event will not be fired yet
 * });
 *
 * // event will only be fired at this point
 * ```
 */
var EventBufferer = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
  function EventBufferer() {
    _classCallCheck(this, EventBufferer);
    this.buffers = [];
  }
  _createClass(EventBufferer, [{
    key: "wrapEvent",
    value: function wrapEvent(event) {
      var _this6 = this;
      return function (listener, thisArgs, disposables) {
        return event(function (i) {
          var buffer = _this6.buffers[_this6.buffers.length - 1];
          if (buffer) {
            buffer.push(function () {
              return listener.call(thisArgs, i);
            });
          } else {
            listener.call(thisArgs, i);
          }
        }, undefined, disposables);
      };
    }
  }, {
    key: "bufferEvents",
    value: function bufferEvents(fn) {
      var buffer = [];
      this.buffers.push(buffer);
      var r = fn();
      this.buffers.pop();
      buffer.forEach(function (flush) {
        return flush();
      });
      return r;
    }
  }]);
  return EventBufferer;
}()));
/**
 * A Relay is an event forwarder which functions as a replugabble event pipe.
 * Once created, you can connect an input event to it and it will simply forward
 * events from that input event through its own `event` property. The `input`
 * can be changed at any point in time.
 */
var Relay = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
  function Relay() {
    var _this7 = this;
    _classCallCheck(this, Relay);
    this.listening = false;
    this.inputEvent = Event.None;
    this.inputEventListener = Disposable.None;
    this.emitter = new Emitter({
      onFirstListenerDidAdd: function onFirstListenerDidAdd() {
        _this7.listening = true;
        _this7.inputEventListener = _this7.inputEvent(_this7.emitter.fire, _this7.emitter);
      },
      onLastListenerRemove: function onLastListenerRemove() {
        _this7.listening = false;
        _this7.inputEventListener.dispose();
      }
    });
    this.event = this.emitter.event;
  }
  _createClass(Relay, [{
    key: "input",
    set: function set(event) {
      this.inputEvent = event;
      if (this.listening) {
        this.inputEventListener.dispose();
        this.inputEventListener = event(this.emitter.fire, this.emitter);
      }
    }
  }, {
    key: "dispose",
    value: function dispose() {
      this.inputEventListener.dispose();
      this.emitter.dispose();
    }
  }]);
  return Relay;
}()));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/types.js


/**
 * @returns whether the provided parameter is a JavaScript Array or not.
 */
function isArray(array) {
  return Array.isArray(array);
}
/**
 * @returns whether the provided parameter is a JavaScript String or not.
 */
function isString(str) {
  return typeof str === 'string';
}
/**
 *
 * @returns whether the provided parameter is of type `object` but **not**
 *	`null`, an `array`, a `regexp`, nor a `date`.
 */
function isObject(obj) {
  // The method can't do a type cast since there are type (like strings) which
  // are subclasses of any put not positvely matched by the function. Hence type
  // narrowing results in wrong results.
  return _typeof(obj) === 'object' && obj !== null && !Array.isArray(obj) && !(obj instanceof RegExp) && !(obj instanceof Date);
}
/**
 * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
 * @returns whether the provided parameter is a JavaScript Number or not.
 */
function isNumber(obj) {
  return typeof obj === 'number' && !isNaN(obj);
}
/**
 * @returns whether the provided parameter is a JavaScript Boolean or not.
 */
function isBoolean(obj) {
  return obj === true || obj === false;
}
/**
 * @returns whether the provided parameter is undefined.
 */
function isUndefined(obj) {
  return typeof obj === 'undefined';
}
/**
 * @returns whether the provided parameter is defined.
 */
function isDefined(arg) {
  return !isUndefinedOrNull(arg);
}
/**
 * @returns whether the provided parameter is undefined or null.
 */
function isUndefinedOrNull(obj) {
  return isUndefined(obj) || obj === null;
}
function assertType(condition, type) {
  if (!condition) {
    throw new Error(type ? "Unexpected type, expected '".concat(type, "'") : 'Unexpected type');
  }
}
/**
 * Asserts that the argument passed in is neither undefined nor null.
 */
function assertIsDefined(arg) {
  if (isUndefinedOrNull(arg)) {
    throw new Error('Assertion Failed: argument is undefined or null');
  }
  return arg;
}
/**
 * @returns whether the provided parameter is a JavaScript Function or not.
 */
function isFunction(obj) {
  return typeof obj === 'function';
}
function validateConstraints(args, constraints) {
  var len = Math.min(args.length, constraints.length);
  for (var i = 0; i < len; i++) {
    validateConstraint(args[i], constraints[i]);
  }
}
function validateConstraint(arg, constraint) {
  if (isString(constraint)) {
    if (_typeof(arg) !== constraint) {
      throw new Error("argument does not match constraint: typeof ".concat(constraint));
    }
  } else if (isFunction(constraint)) {
    try {
      if (arg instanceof constraint) {
        return;
      }
    } catch (_a) {
      // ignore
    }
    if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {
      return;
    }
    if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
      return;
    }
    throw new Error("argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true");
  }
}
function getAllPropertyNames(obj) {
  var res = [];
  var proto = Object.getPrototypeOf(obj);
  while (Object.prototype !== proto) {
    res = res.concat(Object.getOwnPropertyNames(proto));
    proto = Object.getPrototypeOf(proto);
  }
  return res;
}
function getAllMethodNames(obj) {
  var methods = [];
  var _iterator = createForOfIteratorHelper_default()(getAllPropertyNames(obj)),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var prop = _step.value;
      if (typeof obj[prop] === 'function') {
        methods.push(prop);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return methods;
}
function createProxyObject(methodNames, invoke) {
  var createProxyMethod = function createProxyMethod(method) {
    return function () {
      var args = Array.prototype.slice.call(arguments, 0);
      return invoke(method, args);
    };
  };
  var result = {};
  var _iterator2 = createForOfIteratorHelper_default()(methodNames),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var methodName = _step2.value;
      result[methodName] = createProxyMethod(methodName);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return result;
}
/**
 * Converts null to undefined, passes all other values through.
 */
function withNullAsUndefined(x) {
  return x === null ? undefined : x;
}
function assertNever(value) {
  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Unreachable';
  throw new Error(message);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/strings.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function isFalsyOrWhitespace(str) {
  if (!str || typeof str !== 'string') {
    return true;
  }
  return str.trim().length === 0;
}
var _formatRegexp = /{(\d+)}/g;
/**
 * Helper to produce a string with a variable number of arguments. Insert variable segments
 * into the string using the {n} notation where N is the index of the argument following the string.
 * @param value string to which formatting is applied
 * @param args replacements for {n}-entries
 */
function strings_format(value) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }
  if (args.length === 0) {
    return value;
  }
  return value.replace(_formatRegexp, function (match, group) {
    var idx = parseInt(group, 10);
    return isNaN(idx) || idx < 0 || idx >= args.length ? match : args[idx];
  });
}
/**
 * Converts HTML characters inside the string to use entities instead. Makes the string safe from
 * being used e.g. in HTMLElement.innerHTML.
 */
function strings_escape(html) {
  return html.replace(/[<>&]/g, function (match) {
    switch (match) {
      case '<':
        return '&lt;';
      case '>':
        return '&gt;';
      case '&':
        return '&amp;';
      default:
        return match;
    }
  });
}
/**
 * Escapes regular expression characters in a given string
 */
function escapeRegExpCharacters(value) {
  return value.replace(/[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g, '\\$&');
}
/**
 * Removes all occurrences of needle from the beginning and end of haystack.
 * @param haystack string to trim
 * @param needle the thing to trim (default is a blank)
 */
function trim(haystack) {
  var needle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' ';
  var trimmed = ltrim(haystack, needle);
  return rtrim(trimmed, needle);
}
/**
 * Removes all occurrences of needle from the beginning of haystack.
 * @param haystack string to trim
 * @param needle the thing to trim
 */
function ltrim(haystack, needle) {
  if (!haystack || !needle) {
    return haystack;
  }
  var needleLen = needle.length;
  if (needleLen === 0 || haystack.length === 0) {
    return haystack;
  }
  var offset = 0;
  while (haystack.indexOf(needle, offset) === offset) {
    offset = offset + needleLen;
  }
  return haystack.substring(offset);
}
/**
 * Removes all occurrences of needle from the end of haystack.
 * @param haystack string to trim
 * @param needle the thing to trim
 */
function rtrim(haystack, needle) {
  if (!haystack || !needle) {
    return haystack;
  }
  var needleLen = needle.length,
    haystackLen = haystack.length;
  if (needleLen === 0 || haystackLen === 0) {
    return haystack;
  }
  var offset = haystackLen,
    idx = -1;
  while (true) {
    idx = haystack.lastIndexOf(needle, offset - 1);
    if (idx === -1 || idx + needleLen !== offset) {
      break;
    }
    if (idx === 0) {
      return '';
    }
    offset = idx;
  }
  return haystack.substring(0, offset);
}
function convertSimple2RegExpPattern(pattern) {
  return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
}
function stripWildcards(pattern) {
  return pattern.replace(/\*/g, '');
}
function createRegExp(searchString, isRegex) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  if (!searchString) {
    throw new Error('Cannot create regex from empty string');
  }
  if (!isRegex) {
    searchString = escapeRegExpCharacters(searchString);
  }
  if (options.wholeWord) {
    if (!/\B/.test(searchString.charAt(0))) {
      searchString = '\\b' + searchString;
    }
    if (!/\B/.test(searchString.charAt(searchString.length - 1))) {
      searchString = searchString + '\\b';
    }
  }
  var modifiers = '';
  if (options.global) {
    modifiers += 'g';
  }
  if (!options.matchCase) {
    modifiers += 'i';
  }
  if (options.multiline) {
    modifiers += 'm';
  }
  if (options.unicode) {
    modifiers += 'u';
  }
  return new RegExp(searchString, modifiers);
}
function regExpLeadsToEndlessLoop(regexp) {
  // Exit early if it's one of these special cases which are meant to match
  // against an empty string
  if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\s*$') {
    return false;
  }
  // We check against an empty string. If the regular expression doesn't advance
  // (e.g. ends in an endless loop) it will match an empty string.
  var match = regexp.exec('');
  return !!(match && regexp.lastIndex === 0);
}
function regExpFlags(regexp) {
  return (regexp.global ? 'g' : '') + (regexp.ignoreCase ? 'i' : '') + (regexp.multiline ? 'm' : '') + (regexp /* standalone editor compilation */.unicode ? 'u' : '');
}
function splitLines(str) {
  return str.split(/\r\n|\r|\n/);
}
/**
 * Returns first index of the string that is not whitespace.
 * If string is empty or contains only whitespaces, returns -1
 */
function firstNonWhitespaceIndex(str) {
  for (var i = 0, len = str.length; i < len; i++) {
    var chCode = str.charCodeAt(i);
    if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
      return i;
    }
  }
  return -1;
}
/**
 * Returns the leading whitespace of the string.
 * If the string contains only whitespaces, returns entire string
 */
function getLeadingWhitespace(str) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : str.length;
  for (var i = start; i < end; i++) {
    var chCode = str.charCodeAt(i);
    if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
      return str.substring(start, i);
    }
  }
  return str.substring(start, end);
}
/**
 * Returns last index of the string that is not whitespace.
 * If string is empty or contains only whitespaces, returns -1
 */
function lastNonWhitespaceIndex(str) {
  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : str.length - 1;
  for (var i = startIndex; i >= 0; i--) {
    var chCode = str.charCodeAt(i);
    if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
      return i;
    }
  }
  return -1;
}
function compare(a, b) {
  if (a < b) {
    return -1;
  } else if (a > b) {
    return 1;
  } else {
    return 0;
  }
}
function compareSubstring(a, b) {
  var aStart = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  var aEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : a.length;
  var bStart = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
  var bEnd = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : b.length;
  for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {
    var codeA = a.charCodeAt(aStart);
    var codeB = b.charCodeAt(bStart);
    if (codeA < codeB) {
      return -1;
    } else if (codeA > codeB) {
      return 1;
    }
  }
  var aLen = aEnd - aStart;
  var bLen = bEnd - bStart;
  if (aLen < bLen) {
    return -1;
  } else if (aLen > bLen) {
    return 1;
  }
  return 0;
}
function compareIgnoreCase(a, b) {
  return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length);
}
function compareSubstringIgnoreCase(a, b) {
  var aStart = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  var aEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : a.length;
  var bStart = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
  var bEnd = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : b.length;
  for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {
    var codeA = a.charCodeAt(aStart);
    var codeB = b.charCodeAt(bStart);
    if (codeA === codeB) {
      // equal
      continue;
    }
    if (codeA >= 128 || codeB >= 128) {
      // not ASCII letters -> fallback to lower-casing strings
      return compareSubstring(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd);
    }
    // mapper lower-case ascii letter onto upper-case varinats
    // [97-122] (lower ascii) --> [65-90] (upper ascii)
    if (isLowerAsciiLetter(codeA)) {
      codeA -= 32;
    }
    if (isLowerAsciiLetter(codeB)) {
      codeB -= 32;
    }
    // compare both code points
    var diff = codeA - codeB;
    if (diff === 0) {
      continue;
    }
    return diff;
  }
  var aLen = aEnd - aStart;
  var bLen = bEnd - bStart;
  if (aLen < bLen) {
    return -1;
  } else if (aLen > bLen) {
    return 1;
  }
  return 0;
}
function isLowerAsciiLetter(code) {
  return code >= 97 /* a */ && code <= 122 /* z */;
}

function isUpperAsciiLetter(code) {
  return code >= 65 /* A */ && code <= 90 /* Z */;
}

function equalsIgnoreCase(a, b) {
  return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;
}
function startsWithIgnoreCase(str, candidate) {
  var candidateLength = candidate.length;
  if (candidate.length > str.length) {
    return false;
  }
  return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0;
}
/**
 * @returns the length of the common prefix of the two strings.
 */
function commonPrefixLength(a, b) {
  var i,
    len = Math.min(a.length, b.length);
  for (i = 0; i < len; i++) {
    if (a.charCodeAt(i) !== b.charCodeAt(i)) {
      return i;
    }
  }
  return len;
}
/**
 * @returns the length of the common suffix of the two strings.
 */
function commonSuffixLength(a, b) {
  var i,
    len = Math.min(a.length, b.length);
  var aLastIndex = a.length - 1;
  var bLastIndex = b.length - 1;
  for (i = 0; i < len; i++) {
    if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {
      return i;
    }
  }
  return len;
}
/**
 * See http://en.wikipedia.org/wiki/Surrogate_pair
 */
function isHighSurrogate(charCode) {
  return 0xD800 <= charCode && charCode <= 0xDBFF;
}
/**
 * See http://en.wikipedia.org/wiki/Surrogate_pair
 */
function isLowSurrogate(charCode) {
  return 0xDC00 <= charCode && charCode <= 0xDFFF;
}
/**
 * See http://en.wikipedia.org/wiki/Surrogate_pair
 */
function computeCodePoint(highSurrogate, lowSurrogate) {
  return (highSurrogate - 0xD800 << 10) + (lowSurrogate - 0xDC00) + 0x10000;
}
/**
 * get the code point that begins at offset `offset`
 */
function getNextCodePoint(str, len, offset) {
  var charCode = str.charCodeAt(offset);
  if (isHighSurrogate(charCode) && offset + 1 < len) {
    var nextCharCode = str.charCodeAt(offset + 1);
    if (isLowSurrogate(nextCharCode)) {
      return computeCodePoint(charCode, nextCharCode);
    }
  }
  return charCode;
}
/**
 * get the code point that ends right before offset `offset`
 */
function getPrevCodePoint(str, offset) {
  var charCode = str.charCodeAt(offset - 1);
  if (isLowSurrogate(charCode) && offset > 1) {
    var prevCharCode = str.charCodeAt(offset - 2);
    if (isHighSurrogate(prevCharCode)) {
      return computeCodePoint(prevCharCode, charCode);
    }
  }
  return charCode;
}
function nextCharLength(str, offset) {
  var graphemeBreakTree = GraphemeBreakTree.getInstance();
  var initialOffset = offset;
  var len = str.length;
  var initialCodePoint = getNextCodePoint(str, len, offset);
  offset += initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;
  var graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);
  while (offset < len) {
    var nextCodePoint = getNextCodePoint(str, len, offset);
    var nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(nextCodePoint);
    if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {
      break;
    }
    offset += nextCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;
    graphemeBreakType = nextGraphemeBreakType;
  }
  return offset - initialOffset;
}
function prevCharLength(str, offset) {
  var graphemeBreakTree = GraphemeBreakTree.getInstance();
  var initialOffset = offset;
  var initialCodePoint = getPrevCodePoint(str, offset);
  offset -= initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;
  var graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);
  while (offset > 0) {
    var prevCodePoint = getPrevCodePoint(str, offset);
    var prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(prevCodePoint);
    if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {
      break;
    }
    offset -= prevCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;
    graphemeBreakType = prevGraphemeBreakType;
  }
  return initialOffset - offset;
}
/**
 * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-rtl-test.js
 */
var CONTAINS_RTL = /(?:[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05F4\u0608\u060B\u060D\u061B-\u064A\u066D-\u066F\u0671-\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u0710\u0712-\u072F\u074D-\u07A5\u07B1-\u07EA\u07F4\u07F5\u07FA-\u0815\u081A\u0824\u0828\u0830-\u0858\u085E-\u08BD\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFD3D\uFD50-\uFDFC\uFE70-\uFEFC]|\uD802[\uDC00-\uDD1B\uDD20-\uDE00\uDE10-\uDE33\uDE40-\uDEE4\uDEEB-\uDF35\uDF40-\uDFFF]|\uD803[\uDC00-\uDCFF]|\uD83A[\uDC00-\uDCCF\uDD00-\uDD43\uDD50-\uDFFF]|\uD83B[\uDC00-\uDEBB])/;
/**
 * Returns true if `str` contains any Unicode character that is classified as "R" or "AL".
 */
function containsRTL(str) {
  return CONTAINS_RTL.test(str);
}
/**
 * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-emoji-test.js
 */
var CONTAINS_EMOJI = /(?:[\u231A\u231B\u23F0\u23F3\u2600-\u27BF\u2B50\u2B55]|\uD83C[\uDDE6-\uDDFF\uDF00-\uDFFF]|\uD83D[\uDC00-\uDE4F\uDE80-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD00-\uDDFF\uDE70-\uDED6])/;
function containsEmoji(str) {
  return CONTAINS_EMOJI.test(str);
}
var IS_BASIC_ASCII = /^[\t\n\r\x20-\x7E]*$/;
/**
 * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t
 */
function isBasicASCII(str) {
  return IS_BASIC_ASCII.test(str);
}
var UNUSUAL_LINE_TERMINATORS = /[\u2028\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)
/**
 * Returns true if `str` contains unusual line terminators, like LS or PS
 */
function containsUnusualLineTerminators(str) {
  return UNUSUAL_LINE_TERMINATORS.test(str);
}
function containsFullWidthCharacter(str) {
  for (var i = 0, len = str.length; i < len; i++) {
    if (isFullWidthCharacter(str.charCodeAt(i))) {
      return true;
    }
  }
  return false;
}
function isFullWidthCharacter(charCode) {
  // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns
  // http://jrgraphix.net/research/unicode_blocks.php
  //          2E80 — 2EFF   CJK Radicals Supplement
  //          2F00 — 2FDF   Kangxi Radicals
  //          2FF0 — 2FFF   Ideographic Description Characters
  //          3000 — 303F   CJK Symbols and Punctuation
  //          3040 — 309F   Hiragana
  //          30A0 — 30FF   Katakana
  //          3100 — 312F   Bopomofo
  //          3130 — 318F   Hangul Compatibility Jamo
  //          3190 — 319F   Kanbun
  //          31A0 — 31BF   Bopomofo Extended
  //          31F0 — 31FF   Katakana Phonetic Extensions
  //          3200 — 32FF   Enclosed CJK Letters and Months
  //          3300 — 33FF   CJK Compatibility
  //          3400 — 4DBF   CJK Unified Ideographs Extension A
  //          4DC0 — 4DFF   Yijing Hexagram Symbols
  //          4E00 — 9FFF   CJK Unified Ideographs
  //          A000 — A48F   Yi Syllables
  //          A490 — A4CF   Yi Radicals
  //          AC00 — D7AF   Hangul Syllables
  // [IGNORE] D800 — DB7F   High Surrogates
  // [IGNORE] DB80 — DBFF   High Private Use Surrogates
  // [IGNORE] DC00 — DFFF   Low Surrogates
  // [IGNORE] E000 — F8FF   Private Use Area
  //          F900 — FAFF   CJK Compatibility Ideographs
  // [IGNORE] FB00 — FB4F   Alphabetic Presentation Forms
  // [IGNORE] FB50 — FDFF   Arabic Presentation Forms-A
  // [IGNORE] FE00 — FE0F   Variation Selectors
  // [IGNORE] FE20 — FE2F   Combining Half Marks
  // [IGNORE] FE30 — FE4F   CJK Compatibility Forms
  // [IGNORE] FE50 — FE6F   Small Form Variants
  // [IGNORE] FE70 — FEFF   Arabic Presentation Forms-B
  //          FF00 — FFEF   Halfwidth and Fullwidth Forms
  //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]
  //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E
  // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul
  // [IGNORE] FFF0 — FFFF   Specials
  charCode = +charCode; // @perf
  return charCode >= 0x2E80 && charCode <= 0xD7AF || charCode >= 0xF900 && charCode <= 0xFAFF || charCode >= 0xFF01 && charCode <= 0xFF5E;
}
/**
 * A fast function (therefore imprecise) to check if code points are emojis.
 * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-emoji-test.js
 */
function isEmojiImprecise(x) {
  return x >= 0x1F1E6 && x <= 0x1F1FF || x === 8986 || x === 8987 || x === 9200 || x === 9203 || x >= 9728 && x <= 10175 || x === 11088 || x === 11093 || x >= 127744 && x <= 128591 || x >= 128640 && x <= 128764 || x >= 128992 && x <= 129003 || x >= 129280 && x <= 129535 || x >= 129648 && x <= 129750;
}
// -- UTF-8 BOM
var UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);
function startsWithUTF8BOM(str) {
  return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);
}

function containsUppercaseCharacter(target) {
  var ignoreEscapedChars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  if (!target) {
    return false;
  }
  if (ignoreEscapedChars) {
    target = target.replace(/\\./g, '');
  }
  return target.toLowerCase() !== target;
}
/**
 * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.
 */
function singleLetterHash(n) {
  var LETTERS_CNT = 90 /* Z */ - 65 /* A */ + 1;
  n = n % (2 * LETTERS_CNT);
  if (n < LETTERS_CNT) {
    return String.fromCharCode(97 /* a */ + n);
  }
  return String.fromCharCode(65 /* A */ + n - LETTERS_CNT);
}
//#region Unicode Grapheme Break
function getGraphemeBreakType(codePoint) {
  var graphemeBreakTree = GraphemeBreakTree.getInstance();
  return graphemeBreakTree.getGraphemeBreakType(codePoint);
}
function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {
  // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules
  // !!! Let's make the common case a bit faster
  if (breakTypeA === 0 /* Other */) {
    // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table
    return breakTypeB !== 5 /* Extend */ && breakTypeB !== 7 /* SpacingMark */;
  }
  // Do not break between a CR and LF. Otherwise, break before and after controls.
  // GB3                                        CR × LF
  // GB4                       (Control | CR | LF) ÷
  // GB5                                           ÷ (Control | CR | LF)
  if (breakTypeA === 2 /* CR */) {
    if (breakTypeB === 3 /* LF */) {
      return false; // GB3
    }
  }

  if (breakTypeA === 4 /* Control */ || breakTypeA === 2 /* CR */ || breakTypeA === 3 /* LF */) {
    return true; // GB4
  }

  if (breakTypeB === 4 /* Control */ || breakTypeB === 2 /* CR */ || breakTypeB === 3 /* LF */) {
    return true; // GB5
  }
  // Do not break Hangul syllable sequences.
  // GB6                                         L × (L | V | LV | LVT)
  // GB7                                  (LV | V) × (V | T)
  // GB8                                 (LVT | T) × T
  if (breakTypeA === 8 /* L */) {
    if (breakTypeB === 8 /* L */ || breakTypeB === 9 /* V */ || breakTypeB === 11 /* LV */ || breakTypeB === 12 /* LVT */) {
      return false; // GB6
    }
  }

  if (breakTypeA === 11 /* LV */ || breakTypeA === 9 /* V */) {
    if (breakTypeB === 9 /* V */ || breakTypeB === 10 /* T */) {
      return false; // GB7
    }
  }

  if (breakTypeA === 12 /* LVT */ || breakTypeA === 10 /* T */) {
    if (breakTypeB === 10 /* T */) {
      return false; // GB8
    }
  }
  // Do not break before extending characters or ZWJ.
  // GB9                                           × (Extend | ZWJ)
  if (breakTypeB === 5 /* Extend */ || breakTypeB === 13 /* ZWJ */) {
    return false; // GB9
  }
  // The GB9a and GB9b rules only apply to extended grapheme clusters:
  // Do not break before SpacingMarks, or after Prepend characters.
  // GB9a                                          × SpacingMark
  // GB9b                                  Prepend ×
  if (breakTypeB === 7 /* SpacingMark */) {
    return false; // GB9a
  }

  if (breakTypeA === 1 /* Prepend */) {
    return false; // GB9b
  }
  // Do not break within emoji modifier sequences or emoji zwj sequences.
  // GB11    \p{Extended_Pictographic} Extend* ZWJ × \p{Extended_Pictographic}
  if (breakTypeA === 13 /* ZWJ */ && breakTypeB === 14 /* Extended_Pictographic */) {
    // Note: we are not implementing the rule entirely here to avoid introducing states
    return false; // GB11
  }
  // GB12                          sot (RI RI)* RI × RI
  // GB13                        [^RI] (RI RI)* RI × RI
  if (breakTypeA === 6 /* Regional_Indicator */ && breakTypeB === 6 /* Regional_Indicator */) {
    // Note: we are not implementing the rule entirely here to avoid introducing states
    return false; // GB12 & GB13
  }
  // GB999                                     Any ÷ Any
  return true;
}
var GraphemeBreakTree = /*#__PURE__*/function () {
  function GraphemeBreakTree() {
    classCallCheck_default()(this, GraphemeBreakTree);
    this._data = getGraphemeBreakRawData();
  }
  createClass_default()(GraphemeBreakTree, [{
    key: "getGraphemeBreakType",
    value: function getGraphemeBreakType(codePoint) {
      // !!! Let's make 7bit ASCII a bit faster: 0..31
      if (codePoint < 32) {
        if (codePoint === 10 /* LineFeed */) {
          return 3 /* LF */;
        }

        if (codePoint === 13 /* CarriageReturn */) {
          return 2 /* CR */;
        }

        return 4 /* Control */;
      }
      // !!! Let's make 7bit ASCII a bit faster: 32..126
      if (codePoint < 127) {
        return 0 /* Other */;
      }

      var data = this._data;
      var nodeCount = data.length / 3;
      var nodeIndex = 1;
      while (nodeIndex <= nodeCount) {
        if (codePoint < data[3 * nodeIndex]) {
          // go left
          nodeIndex = 2 * nodeIndex;
        } else if (codePoint > data[3 * nodeIndex + 1]) {
          // go right
          nodeIndex = 2 * nodeIndex + 1;
        } else {
          // hit
          return data[3 * nodeIndex + 2];
        }
      }
      return 0 /* Other */;
    }
  }], [{
    key: "getInstance",
    value: function getInstance() {
      if (!GraphemeBreakTree._INSTANCE) {
        GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();
      }
      return GraphemeBreakTree._INSTANCE;
    }
  }]);
  return GraphemeBreakTree;
}();
GraphemeBreakTree._INSTANCE = null;
function getGraphemeBreakRawData() {
  // generated using https://github.com/alexdima/unicode-utils/blob/master/generate-grapheme-break.js
  return JSON.parse('[0,0,0,51592,51592,11,44424,44424,11,72251,72254,5,7150,7150,7,48008,48008,11,55176,55176,11,128420,128420,14,3276,3277,5,9979,9980,14,46216,46216,11,49800,49800,11,53384,53384,11,70726,70726,5,122915,122916,5,129320,129327,14,2558,2558,5,5906,5908,5,9762,9763,14,43360,43388,8,45320,45320,11,47112,47112,11,48904,48904,11,50696,50696,11,52488,52488,11,54280,54280,11,70082,70083,1,71350,71350,7,73111,73111,5,127892,127893,14,128726,128727,14,129473,129474,14,2027,2035,5,2901,2902,5,3784,3789,5,6754,6754,5,8418,8420,5,9877,9877,14,11088,11088,14,44008,44008,5,44872,44872,11,45768,45768,11,46664,46664,11,47560,47560,11,48456,48456,11,49352,49352,11,50248,50248,11,51144,51144,11,52040,52040,11,52936,52936,11,53832,53832,11,54728,54728,11,69811,69814,5,70459,70460,5,71096,71099,7,71998,71998,5,72874,72880,5,119149,119149,7,127374,127374,14,128335,128335,14,128482,128482,14,128765,128767,14,129399,129400,14,129680,129685,14,1476,1477,5,2377,2380,7,2759,2760,5,3137,3140,7,3458,3459,7,4153,4154,5,6432,6434,5,6978,6978,5,7675,7679,5,9723,9726,14,9823,9823,14,9919,9923,14,10035,10036,14,42736,42737,5,43596,43596,5,44200,44200,11,44648,44648,11,45096,45096,11,45544,45544,11,45992,45992,11,46440,46440,11,46888,46888,11,47336,47336,11,47784,47784,11,48232,48232,11,48680,48680,11,49128,49128,11,49576,49576,11,50024,50024,11,50472,50472,11,50920,50920,11,51368,51368,11,51816,51816,11,52264,52264,11,52712,52712,11,53160,53160,11,53608,53608,11,54056,54056,11,54504,54504,11,54952,54952,11,68108,68111,5,69933,69940,5,70197,70197,7,70498,70499,7,70845,70845,5,71229,71229,5,71727,71735,5,72154,72155,5,72344,72345,5,73023,73029,5,94095,94098,5,121403,121452,5,126981,127182,14,127538,127546,14,127990,127990,14,128391,128391,14,128445,128449,14,128500,128505,14,128752,128752,14,129160,129167,14,129356,129356,14,129432,129442,14,129648,129651,14,129751,131069,14,173,173,4,1757,1757,1,2274,2274,1,2494,2494,5,2641,2641,5,2876,2876,5,3014,3016,7,3262,3262,7,3393,3396,5,3570,3571,7,3968,3972,5,4228,4228,7,6086,6086,5,6679,6680,5,6912,6915,5,7080,7081,5,7380,7392,5,8252,8252,14,9096,9096,14,9748,9749,14,9784,9786,14,9833,9850,14,9890,9894,14,9938,9938,14,9999,9999,14,10085,10087,14,12349,12349,14,43136,43137,7,43454,43456,7,43755,43755,7,44088,44088,11,44312,44312,11,44536,44536,11,44760,44760,11,44984,44984,11,45208,45208,11,45432,45432,11,45656,45656,11,45880,45880,11,46104,46104,11,46328,46328,11,46552,46552,11,46776,46776,11,47000,47000,11,47224,47224,11,47448,47448,11,47672,47672,11,47896,47896,11,48120,48120,11,48344,48344,11,48568,48568,11,48792,48792,11,49016,49016,11,49240,49240,11,49464,49464,11,49688,49688,11,49912,49912,11,50136,50136,11,50360,50360,11,50584,50584,11,50808,50808,11,51032,51032,11,51256,51256,11,51480,51480,11,51704,51704,11,51928,51928,11,52152,52152,11,52376,52376,11,52600,52600,11,52824,52824,11,53048,53048,11,53272,53272,11,53496,53496,11,53720,53720,11,53944,53944,11,54168,54168,11,54392,54392,11,54616,54616,11,54840,54840,11,55064,55064,11,65438,65439,5,69633,69633,5,69837,69837,1,70018,70018,7,70188,70190,7,70368,70370,7,70465,70468,7,70712,70719,5,70835,70840,5,70850,70851,5,71132,71133,5,71340,71340,7,71458,71461,5,71985,71989,7,72002,72002,7,72193,72202,5,72281,72283,5,72766,72766,7,72885,72886,5,73104,73105,5,92912,92916,5,113824,113827,4,119173,119179,5,121505,121519,5,125136,125142,5,127279,127279,14,127489,127490,14,127570,127743,14,127900,127901,14,128254,128254,14,128369,128370,14,128400,128400,14,128425,128432,14,128468,128475,14,128489,128494,14,128715,128720,14,128745,128745,14,128759,128760,14,129004,129023,14,129296,129304,14,129340,129342,14,129388,129392,14,129404,129407,14,129454,129455,14,129485,129487,14,129659,129663,14,129719,129727,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2363,2363,7,2402,2403,5,2507,2508,7,2622,2624,7,2691,2691,7,2786,2787,5,2881,2884,5,3006,3006,5,3072,3072,5,3170,3171,5,3267,3268,7,3330,3331,7,3406,3406,1,3538,3540,5,3655,3662,5,3897,3897,5,4038,4038,5,4184,4185,5,4352,4447,8,6068,6069,5,6155,6157,5,6448,6449,7,6742,6742,5,6783,6783,5,6966,6970,5,7042,7042,7,7143,7143,7,7212,7219,5,7412,7412,5,8206,8207,4,8294,8303,4,8596,8601,14,9410,9410,14,9742,9742,14,9757,9757,14,9770,9770,14,9794,9794,14,9828,9828,14,9855,9855,14,9882,9882,14,9900,9903,14,9929,9933,14,9963,9967,14,9987,9988,14,10006,10006,14,10062,10062,14,10175,10175,14,11744,11775,5,42607,42607,5,43043,43044,7,43263,43263,5,43444,43445,7,43569,43570,5,43698,43700,5,43766,43766,5,44032,44032,11,44144,44144,11,44256,44256,11,44368,44368,11,44480,44480,11,44592,44592,11,44704,44704,11,44816,44816,11,44928,44928,11,45040,45040,11,45152,45152,11,45264,45264,11,45376,45376,11,45488,45488,11,45600,45600,11,45712,45712,11,45824,45824,11,45936,45936,11,46048,46048,11,46160,46160,11,46272,46272,11,46384,46384,11,46496,46496,11,46608,46608,11,46720,46720,11,46832,46832,11,46944,46944,11,47056,47056,11,47168,47168,11,47280,47280,11,47392,47392,11,47504,47504,11,47616,47616,11,47728,47728,11,47840,47840,11,47952,47952,11,48064,48064,11,48176,48176,11,48288,48288,11,48400,48400,11,48512,48512,11,48624,48624,11,48736,48736,11,48848,48848,11,48960,48960,11,49072,49072,11,49184,49184,11,49296,49296,11,49408,49408,11,49520,49520,11,49632,49632,11,49744,49744,11,49856,49856,11,49968,49968,11,50080,50080,11,50192,50192,11,50304,50304,11,50416,50416,11,50528,50528,11,50640,50640,11,50752,50752,11,50864,50864,11,50976,50976,11,51088,51088,11,51200,51200,11,51312,51312,11,51424,51424,11,51536,51536,11,51648,51648,11,51760,51760,11,51872,51872,11,51984,51984,11,52096,52096,11,52208,52208,11,52320,52320,11,52432,52432,11,52544,52544,11,52656,52656,11,52768,52768,11,52880,52880,11,52992,52992,11,53104,53104,11,53216,53216,11,53328,53328,11,53440,53440,11,53552,53552,11,53664,53664,11,53776,53776,11,53888,53888,11,54000,54000,11,54112,54112,11,54224,54224,11,54336,54336,11,54448,54448,11,54560,54560,11,54672,54672,11,54784,54784,11,54896,54896,11,55008,55008,11,55120,55120,11,64286,64286,5,66272,66272,5,68900,68903,5,69762,69762,7,69817,69818,5,69927,69931,5,70003,70003,5,70070,70078,5,70094,70094,7,70194,70195,7,70206,70206,5,70400,70401,5,70463,70463,7,70475,70477,7,70512,70516,5,70722,70724,5,70832,70832,5,70842,70842,5,70847,70848,5,71088,71089,7,71102,71102,7,71219,71226,5,71231,71232,5,71342,71343,7,71453,71455,5,71463,71467,5,71737,71738,5,71995,71996,5,72000,72000,7,72145,72147,7,72160,72160,5,72249,72249,7,72273,72278,5,72330,72342,5,72752,72758,5,72850,72871,5,72882,72883,5,73018,73018,5,73031,73031,5,73109,73109,5,73461,73462,7,94031,94031,5,94192,94193,7,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,126976,126979,14,127184,127231,14,127344,127345,14,127405,127461,14,127514,127514,14,127561,127567,14,127778,127779,14,127896,127896,14,127985,127986,14,127995,127999,5,128326,128328,14,128360,128366,14,128378,128378,14,128394,128397,14,128405,128406,14,128422,128423,14,128435,128443,14,128453,128464,14,128479,128480,14,128484,128487,14,128496,128498,14,128640,128709,14,128723,128724,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129096,129103,14,129292,129292,14,129311,129311,14,129329,129330,14,129344,129349,14,129360,129374,14,129394,129394,14,129402,129402,14,129413,129425,14,129445,129450,14,129466,129471,14,129483,129483,14,129511,129535,14,129653,129655,14,129667,129670,14,129705,129711,14,129731,129743,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2307,2307,7,2366,2368,7,2382,2383,7,2434,2435,7,2497,2500,5,2519,2519,5,2563,2563,7,2631,2632,5,2677,2677,5,2750,2752,7,2763,2764,7,2817,2817,5,2879,2879,5,2891,2892,7,2914,2915,5,3008,3008,5,3021,3021,5,3076,3076,5,3146,3149,5,3202,3203,7,3264,3265,7,3271,3272,7,3298,3299,5,3390,3390,5,3402,3404,7,3426,3427,5,3535,3535,5,3544,3550,7,3635,3635,7,3763,3763,7,3893,3893,5,3953,3966,5,3981,3991,5,4145,4145,7,4157,4158,5,4209,4212,5,4237,4237,5,4520,4607,10,5970,5971,5,6071,6077,5,6089,6099,5,6277,6278,5,6439,6440,5,6451,6456,7,6683,6683,5,6744,6750,5,6765,6770,7,6846,6846,5,6964,6964,5,6972,6972,5,7019,7027,5,7074,7077,5,7083,7085,5,7146,7148,7,7154,7155,7,7222,7223,5,7394,7400,5,7416,7417,5,8204,8204,5,8233,8233,4,8288,8292,4,8413,8416,5,8482,8482,14,8986,8987,14,9193,9203,14,9654,9654,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9775,14,9792,9792,14,9800,9811,14,9825,9826,14,9831,9831,14,9852,9853,14,9872,9873,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9936,9936,14,9941,9960,14,9974,9974,14,9982,9985,14,9992,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10145,10145,14,11013,11015,14,11503,11505,5,12334,12335,5,12951,12951,14,42612,42621,5,43014,43014,5,43047,43047,7,43204,43205,5,43335,43345,5,43395,43395,7,43450,43451,7,43561,43566,5,43573,43574,5,43644,43644,5,43710,43711,5,43758,43759,7,44005,44005,5,44012,44012,7,44060,44060,11,44116,44116,11,44172,44172,11,44228,44228,11,44284,44284,11,44340,44340,11,44396,44396,11,44452,44452,11,44508,44508,11,44564,44564,11,44620,44620,11,44676,44676,11,44732,44732,11,44788,44788,11,44844,44844,11,44900,44900,11,44956,44956,11,45012,45012,11,45068,45068,11,45124,45124,11,45180,45180,11,45236,45236,11,45292,45292,11,45348,45348,11,45404,45404,11,45460,45460,11,45516,45516,11,45572,45572,11,45628,45628,11,45684,45684,11,45740,45740,11,45796,45796,11,45852,45852,11,45908,45908,11,45964,45964,11,46020,46020,11,46076,46076,11,46132,46132,11,46188,46188,11,46244,46244,11,46300,46300,11,46356,46356,11,46412,46412,11,46468,46468,11,46524,46524,11,46580,46580,11,46636,46636,11,46692,46692,11,46748,46748,11,46804,46804,11,46860,46860,11,46916,46916,11,46972,46972,11,47028,47028,11,47084,47084,11,47140,47140,11,47196,47196,11,47252,47252,11,47308,47308,11,47364,47364,11,47420,47420,11,47476,47476,11,47532,47532,11,47588,47588,11,47644,47644,11,47700,47700,11,47756,47756,11,47812,47812,11,47868,47868,11,47924,47924,11,47980,47980,11,48036,48036,11,48092,48092,11,48148,48148,11,48204,48204,11,48260,48260,11,48316,48316,11,48372,48372,11,48428,48428,11,48484,48484,11,48540,48540,11,48596,48596,11,48652,48652,11,48708,48708,11,48764,48764,11,48820,48820,11,48876,48876,11,48932,48932,11,48988,48988,11,49044,49044,11,49100,49100,11,49156,49156,11,49212,49212,11,49268,49268,11,49324,49324,11,49380,49380,11,49436,49436,11,49492,49492,11,49548,49548,11,49604,49604,11,49660,49660,11,49716,49716,11,49772,49772,11,49828,49828,11,49884,49884,11,49940,49940,11,49996,49996,11,50052,50052,11,50108,50108,11,50164,50164,11,50220,50220,11,50276,50276,11,50332,50332,11,50388,50388,11,50444,50444,11,50500,50500,11,50556,50556,11,50612,50612,11,50668,50668,11,50724,50724,11,50780,50780,11,50836,50836,11,50892,50892,11,50948,50948,11,51004,51004,11,51060,51060,11,51116,51116,11,51172,51172,11,51228,51228,11,51284,51284,11,51340,51340,11,51396,51396,11,51452,51452,11,51508,51508,11,51564,51564,11,51620,51620,11,51676,51676,11,51732,51732,11,51788,51788,11,51844,51844,11,51900,51900,11,51956,51956,11,52012,52012,11,52068,52068,11,52124,52124,11,52180,52180,11,52236,52236,11,52292,52292,11,52348,52348,11,52404,52404,11,52460,52460,11,52516,52516,11,52572,52572,11,52628,52628,11,52684,52684,11,52740,52740,11,52796,52796,11,52852,52852,11,52908,52908,11,52964,52964,11,53020,53020,11,53076,53076,11,53132,53132,11,53188,53188,11,53244,53244,11,53300,53300,11,53356,53356,11,53412,53412,11,53468,53468,11,53524,53524,11,53580,53580,11,53636,53636,11,53692,53692,11,53748,53748,11,53804,53804,11,53860,53860,11,53916,53916,11,53972,53972,11,54028,54028,11,54084,54084,11,54140,54140,11,54196,54196,11,54252,54252,11,54308,54308,11,54364,54364,11,54420,54420,11,54476,54476,11,54532,54532,11,54588,54588,11,54644,54644,11,54700,54700,11,54756,54756,11,54812,54812,11,54868,54868,11,54924,54924,11,54980,54980,11,55036,55036,11,55092,55092,11,55148,55148,11,55216,55238,9,65056,65071,5,65529,65531,4,68097,68099,5,68159,68159,5,69446,69456,5,69688,69702,5,69808,69810,7,69815,69816,7,69821,69821,1,69888,69890,5,69932,69932,7,69957,69958,7,70016,70017,5,70067,70069,7,70079,70080,7,70089,70092,5,70095,70095,5,70191,70193,5,70196,70196,5,70198,70199,5,70367,70367,5,70371,70378,5,70402,70403,7,70462,70462,5,70464,70464,5,70471,70472,7,70487,70487,5,70502,70508,5,70709,70711,7,70720,70721,7,70725,70725,7,70750,70750,5,70833,70834,7,70841,70841,7,70843,70844,7,70846,70846,7,70849,70849,7,71087,71087,5,71090,71093,5,71100,71101,5,71103,71104,5,71216,71218,7,71227,71228,7,71230,71230,7,71339,71339,5,71341,71341,5,71344,71349,5,71351,71351,5,71456,71457,7,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123628,123631,5,125252,125258,5,126980,126980,14,127183,127183,14,127245,127247,14,127340,127343,14,127358,127359,14,127377,127386,14,127462,127487,6,127491,127503,14,127535,127535,14,127548,127551,14,127568,127569,14,127744,127777,14,127780,127891,14,127894,127895,14,127897,127899,14,127902,127984,14,127987,127989,14,127991,127994,14,128000,128253,14,128255,128317,14,128329,128334,14,128336,128359,14,128367,128368,14,128371,128377,14,128379,128390,14,128392,128393,14,128398,128399,14,128401,128404,14,128407,128419,14,128421,128421,14,128424,128424,14,128433,128434,14,128444,128444,14,128450,128452,14,128465,128467,14,128476,128478,14,128481,128481,14,128483,128483,14,128488,128488,14,128495,128495,14,128499,128499,14,128506,128591,14,128710,128714,14,128721,128722,14,128725,128725,14,128728,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129664,129666,14,129671,129679,14,129686,129704,14,129712,129718,14,129728,129730,14,129744,129750,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2259,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3134,3136,5,3142,3144,5,3157,3158,5,3201,3201,5,3260,3260,5,3263,3263,5,3266,3266,5,3270,3270,5,3274,3275,7,3285,3286,5,3328,3329,5,3387,3388,5,3391,3392,7,3398,3400,7,3405,3405,5,3415,3415,5,3457,3457,5,3530,3530,5,3536,3537,7,3542,3542,5,3551,3551,5,3633,3633,5,3636,3642,5,3761,3761,5,3764,3772,5,3864,3865,5,3895,3895,5,3902,3903,7,3967,3967,7,3974,3975,5,3993,4028,5,4141,4144,5,4146,4151,5,4155,4156,7,4182,4183,7,4190,4192,5,4226,4226,5,4229,4230,5,4253,4253,5,4448,4519,9,4957,4959,5,5938,5940,5,6002,6003,5,6070,6070,7,6078,6085,7,6087,6088,7,6109,6109,5,6158,6158,4,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6848,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7673,5,8203,8203,4,8205,8205,13,8232,8232,4,8234,8238,4,8265,8265,14,8293,8293,4,8400,8412,5,8417,8417,5,8421,8432,5,8505,8505,14,8617,8618,14,9000,9000,14,9167,9167,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9776,9783,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9935,14,9937,9937,14,9939,9940,14,9961,9962,14,9968,9973,14,9975,9978,14,9981,9981,14,9986,9986,14,9989,9989,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10084,14,10133,10135,14,10160,10160,14,10548,10549,14,11035,11036,14,11093,11093,14,11647,11647,5,12330,12333,5,12336,12336,14,12441,12442,5,12953,12953,14,42608,42610,5,42654,42655,5,43010,43010,5,43019,43019,5,43045,43046,5,43052,43052,5,43188,43203,7,43232,43249,5,43302,43309,5,43346,43347,7,43392,43394,5,43443,43443,5,43446,43449,5,43452,43453,5,43493,43493,5,43567,43568,7,43571,43572,7,43587,43587,5,43597,43597,7,43696,43696,5,43703,43704,5,43713,43713,5,43756,43757,5,43765,43765,7,44003,44004,7,44006,44007,7,44009,44010,7,44013,44013,5,44033,44059,12,44061,44087,12,44089,44115,12,44117,44143,12,44145,44171,12,44173,44199,12,44201,44227,12,44229,44255,12,44257,44283,12,44285,44311,12,44313,44339,12,44341,44367,12,44369,44395,12,44397,44423,12,44425,44451,12,44453,44479,12,44481,44507,12,44509,44535,12,44537,44563,12,44565,44591,12,44593,44619,12,44621,44647,12,44649,44675,12,44677,44703,12,44705,44731,12,44733,44759,12,44761,44787,12,44789,44815,12,44817,44843,12,44845,44871,12,44873,44899,12,44901,44927,12,44929,44955,12,44957,44983,12,44985,45011,12,45013,45039,12,45041,45067,12,45069,45095,12,45097,45123,12,45125,45151,12,45153,45179,12,45181,45207,12,45209,45235,12,45237,45263,12,45265,45291,12,45293,45319,12,45321,45347,12,45349,45375,12,45377,45403,12,45405,45431,12,45433,45459,12,45461,45487,12,45489,45515,12,45517,45543,12,45545,45571,12,45573,45599,12,45601,45627,12,45629,45655,12,45657,45683,12,45685,45711,12,45713,45739,12,45741,45767,12,45769,45795,12,45797,45823,12,45825,45851,12,45853,45879,12,45881,45907,12,45909,45935,12,45937,45963,12,45965,45991,12,45993,46019,12,46021,46047,12,46049,46075,12,46077,46103,12,46105,46131,12,46133,46159,12,46161,46187,12,46189,46215,12,46217,46243,12,46245,46271,12,46273,46299,12,46301,46327,12,46329,46355,12,46357,46383,12,46385,46411,12,46413,46439,12,46441,46467,12,46469,46495,12,46497,46523,12,46525,46551,12,46553,46579,12,46581,46607,12,46609,46635,12,46637,46663,12,46665,46691,12,46693,46719,12,46721,46747,12,46749,46775,12,46777,46803,12,46805,46831,12,46833,46859,12,46861,46887,12,46889,46915,12,46917,46943,12,46945,46971,12,46973,46999,12,47001,47027,12,47029,47055,12,47057,47083,12,47085,47111,12,47113,47139,12,47141,47167,12,47169,47195,12,47197,47223,12,47225,47251,12,47253,47279,12,47281,47307,12,47309,47335,12,47337,47363,12,47365,47391,12,47393,47419,12,47421,47447,12,47449,47475,12,47477,47503,12,47505,47531,12,47533,47559,12,47561,47587,12,47589,47615,12,47617,47643,12,47645,47671,12,47673,47699,12,47701,47727,12,47729,47755,12,47757,47783,12,47785,47811,12,47813,47839,12,47841,47867,12,47869,47895,12,47897,47923,12,47925,47951,12,47953,47979,12,47981,48007,12,48009,48035,12,48037,48063,12,48065,48091,12,48093,48119,12,48121,48147,12,48149,48175,12,48177,48203,12,48205,48231,12,48233,48259,12,48261,48287,12,48289,48315,12,48317,48343,12,48345,48371,12,48373,48399,12,48401,48427,12,48429,48455,12,48457,48483,12,48485,48511,12,48513,48539,12,48541,48567,12,48569,48595,12,48597,48623,12,48625,48651,12,48653,48679,12,48681,48707,12,48709,48735,12,48737,48763,12,48765,48791,12,48793,48819,12,48821,48847,12,48849,48875,12,48877,48903,12,48905,48931,12,48933,48959,12,48961,48987,12,48989,49015,12,49017,49043,12,49045,49071,12,49073,49099,12,49101,49127,12,49129,49155,12,49157,49183,12,49185,49211,12,49213,49239,12,49241,49267,12,49269,49295,12,49297,49323,12,49325,49351,12,49353,49379,12,49381,49407,12,49409,49435,12,49437,49463,12,49465,49491,12,49493,49519,12,49521,49547,12,49549,49575,12,49577,49603,12,49605,49631,12,49633,49659,12,49661,49687,12,49689,49715,12,49717,49743,12,49745,49771,12,49773,49799,12,49801,49827,12,49829,49855,12,49857,49883,12,49885,49911,12,49913,49939,12,49941,49967,12,49969,49995,12,49997,50023,12,50025,50051,12,50053,50079,12,50081,50107,12,50109,50135,12,50137,50163,12,50165,50191,12,50193,50219,12,50221,50247,12,50249,50275,12,50277,50303,12,50305,50331,12,50333,50359,12,50361,50387,12,50389,50415,12,50417,50443,12,50445,50471,12,50473,50499,12,50501,50527,12,50529,50555,12,50557,50583,12,50585,50611,12,50613,50639,12,50641,50667,12,50669,50695,12,50697,50723,12,50725,50751,12,50753,50779,12,50781,50807,12,50809,50835,12,50837,50863,12,50865,50891,12,50893,50919,12,50921,50947,12,50949,50975,12,50977,51003,12,51005,51031,12,51033,51059,12,51061,51087,12,51089,51115,12,51117,51143,12,51145,51171,12,51173,51199,12,51201,51227,12,51229,51255,12,51257,51283,12,51285,51311,12,51313,51339,12,51341,51367,12,51369,51395,12,51397,51423,12,51425,51451,12,51453,51479,12,51481,51507,12,51509,51535,12,51537,51563,12,51565,51591,12,51593,51619,12,51621,51647,12,51649,51675,12,51677,51703,12,51705,51731,12,51733,51759,12,51761,51787,12,51789,51815,12,51817,51843,12,51845,51871,12,51873,51899,12,51901,51927,12,51929,51955,12,51957,51983,12,51985,52011,12,52013,52039,12,52041,52067,12,52069,52095,12,52097,52123,12,52125,52151,12,52153,52179,12,52181,52207,12,52209,52235,12,52237,52263,12,52265,52291,12,52293,52319,12,52321,52347,12,52349,52375,12,52377,52403,12,52405,52431,12,52433,52459,12,52461,52487,12,52489,52515,12,52517,52543,12,52545,52571,12,52573,52599,12,52601,52627,12,52629,52655,12,52657,52683,12,52685,52711,12,52713,52739,12,52741,52767,12,52769,52795,12,52797,52823,12,52825,52851,12,52853,52879,12,52881,52907,12,52909,52935,12,52937,52963,12,52965,52991,12,52993,53019,12,53021,53047,12,53049,53075,12,53077,53103,12,53105,53131,12,53133,53159,12,53161,53187,12,53189,53215,12,53217,53243,12,53245,53271,12,53273,53299,12,53301,53327,12,53329,53355,12,53357,53383,12,53385,53411,12,53413,53439,12,53441,53467,12,53469,53495,12,53497,53523,12,53525,53551,12,53553,53579,12,53581,53607,12,53609,53635,12,53637,53663,12,53665,53691,12,53693,53719,12,53721,53747,12,53749,53775,12,53777,53803,12,53805,53831,12,53833,53859,12,53861,53887,12,53889,53915,12,53917,53943,12,53945,53971,12,53973,53999,12,54001,54027,12,54029,54055,12,54057,54083,12,54085,54111,12,54113,54139,12,54141,54167,12,54169,54195,12,54197,54223,12,54225,54251,12,54253,54279,12,54281,54307,12,54309,54335,12,54337,54363,12,54365,54391,12,54393,54419,12,54421,54447,12,54449,54475,12,54477,54503,12,54505,54531,12,54533,54559,12,54561,54587,12,54589,54615,12,54617,54643,12,54645,54671,12,54673,54699,12,54701,54727,12,54729,54755,12,54757,54783,12,54785,54811,12,54813,54839,12,54841,54867,12,54869,54895,12,54897,54923,12,54925,54951,12,54953,54979,12,54981,55007,12,55009,55035,12,55037,55063,12,55065,55091,12,55093,55119,12,55121,55147,12,55149,55175,12,55177,55203,12,55243,55291,10,65024,65039,5,65279,65279,4,65520,65528,4,66045,66045,5,66422,66426,5,68101,68102,5,68152,68154,5,68325,68326,5,69291,69292,5,69632,69632,7,69634,69634,7,69759,69761,5]');
}
//#endregion
/**
 * Computes the offset after performing a left delete on the given string,
 * while considering unicode grapheme/emoji rules.
*/
function getLeftDeleteOffset(offset, str) {
  if (offset === 0) {
    return 0;
  }
  // Try to delete emoji part.
  var emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str);
  if (emojiOffset !== undefined) {
    return emojiOffset;
  }
  // Otherwise, just skip a single code point.
  var codePoint = getPrevCodePoint(str, offset);
  offset -= getUTF16Length(codePoint);
  return offset;
}
function getOffsetBeforeLastEmojiComponent(offset, str) {
  // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the
  // structure of emojis.
  var codePoint = getPrevCodePoint(str, offset);
  offset -= getUTF16Length(codePoint);
  // Skip modifiers
  while (isEmojiModifier(codePoint) || codePoint === 65039 /* emojiVariantSelector */ || codePoint === 8419 /* enclosingKeyCap */) {
    if (offset === 0) {
      // Cannot skip modifier, no preceding emoji base.
      return undefined;
    }
    codePoint = getPrevCodePoint(str, offset);
    offset -= getUTF16Length(codePoint);
  }
  // Expect base emoji
  if (!isEmojiImprecise(codePoint)) {
    // Unexpected code point, not a valid emoji.
    return undefined;
  }
  if (offset >= 0) {
    // Skip optional ZWJ code points that combine multiple emojis.
    // In theory, we should check if that ZWJ actually combines multiple emojis
    // to prevent deleting ZWJs in situations we didn't account for.
    var optionalZwjCodePoint = getPrevCodePoint(str, offset);
    if (optionalZwjCodePoint === 8205 /* zwj */) {
      offset -= getUTF16Length(optionalZwjCodePoint);
    }
  }
  return offset;
}
function getUTF16Length(codePoint) {
  return codePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;
}
function isEmojiModifier(codePoint) {
  return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js






/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/






var INITIALIZE = '$initialize';
var webWorkerWarningLogged = false;
function logOnceWebWorkerWarning(err) {
  if (!isWeb) {
    // running tests
    return;
  }
  if (!webWorkerWarningLogged) {
    webWorkerWarningLogged = true;
    console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq');
  }
  console.warn(err.message);
}
var RequestMessage = /*#__PURE__*/createClass_default()(function RequestMessage(vsWorker, req, method, args) {
  classCallCheck_default()(this, RequestMessage);
  this.vsWorker = vsWorker;
  this.req = req;
  this.method = method;
  this.args = args;
  this.type = 0 /* Request */;
});
var ReplyMessage = /*#__PURE__*/createClass_default()(function ReplyMessage(vsWorker, seq, res, err) {
  classCallCheck_default()(this, ReplyMessage);
  this.vsWorker = vsWorker;
  this.seq = seq;
  this.res = res;
  this.err = err;
  this.type = 1 /* Reply */;
});
var SubscribeEventMessage = /*#__PURE__*/createClass_default()(function SubscribeEventMessage(vsWorker, req, eventName, arg) {
  classCallCheck_default()(this, SubscribeEventMessage);
  this.vsWorker = vsWorker;
  this.req = req;
  this.eventName = eventName;
  this.arg = arg;
  this.type = 2 /* SubscribeEvent */;
});
var EventMessage = /*#__PURE__*/createClass_default()(function EventMessage(vsWorker, req, event) {
  classCallCheck_default()(this, EventMessage);
  this.vsWorker = vsWorker;
  this.req = req;
  this.event = event;
  this.type = 3 /* Event */;
});
var UnsubscribeEventMessage = /*#__PURE__*/createClass_default()(function UnsubscribeEventMessage(vsWorker, req) {
  classCallCheck_default()(this, UnsubscribeEventMessage);
  this.vsWorker = vsWorker;
  this.req = req;
  this.type = 4 /* UnsubscribeEvent */;
});
var SimpleWorkerProtocol = /*#__PURE__*/function () {
  function SimpleWorkerProtocol(handler) {
    classCallCheck_default()(this, SimpleWorkerProtocol);
    this._workerId = -1;
    this._handler = handler;
    this._lastSentReq = 0;
    this._pendingReplies = Object.create(null);
    this._pendingEmitters = new Map();
    this._pendingEvents = new Map();
  }
  createClass_default()(SimpleWorkerProtocol, [{
    key: "setWorkerId",
    value: function setWorkerId(workerId) {
      this._workerId = workerId;
    }
  }, {
    key: "sendMessage",
    value: function sendMessage(method, args) {
      var _this = this;
      var req = String(++this._lastSentReq);
      return new Promise(function (resolve, reject) {
        _this._pendingReplies[req] = {
          resolve: resolve,
          reject: reject
        };
        _this._send(new RequestMessage(_this._workerId, req, method, args));
      });
    }
  }, {
    key: "listen",
    value: function listen(eventName, arg) {
      var _this2 = this;
      var req = null;
      var emitter = new Emitter({
        onFirstListenerAdd: function onFirstListenerAdd() {
          req = String(++_this2._lastSentReq);
          _this2._pendingEmitters.set(req, emitter);
          _this2._send(new SubscribeEventMessage(_this2._workerId, req, eventName, arg));
        },
        onLastListenerRemove: function onLastListenerRemove() {
          _this2._pendingEmitters["delete"](req);
          _this2._send(new UnsubscribeEventMessage(_this2._workerId, req));
          req = null;
        }
      });
      return emitter.event;
    }
  }, {
    key: "handleMessage",
    value: function handleMessage(message) {
      if (!message || !message.vsWorker) {
        return;
      }
      if (this._workerId !== -1 && message.vsWorker !== this._workerId) {
        return;
      }
      this._handleMessage(message);
    }
  }, {
    key: "_handleMessage",
    value: function _handleMessage(msg) {
      switch (msg.type) {
        case 1 /* Reply */:
          return this._handleReplyMessage(msg);
        case 0 /* Request */:
          return this._handleRequestMessage(msg);
        case 2 /* SubscribeEvent */:
          return this._handleSubscribeEventMessage(msg);
        case 3 /* Event */:
          return this._handleEventMessage(msg);
        case 4 /* UnsubscribeEvent */:
          return this._handleUnsubscribeEventMessage(msg);
      }
    }
  }, {
    key: "_handleReplyMessage",
    value: function _handleReplyMessage(replyMessage) {
      if (!this._pendingReplies[replyMessage.seq]) {
        console.warn('Got reply to unknown seq');
        return;
      }
      var reply = this._pendingReplies[replyMessage.seq];
      delete this._pendingReplies[replyMessage.seq];
      if (replyMessage.err) {
        var err = replyMessage.err;
        if (replyMessage.err.$isError) {
          err = new Error();
          err.name = replyMessage.err.name;
          err.message = replyMessage.err.message;
          err.stack = replyMessage.err.stack;
        }
        reply.reject(err);
        return;
      }
      reply.resolve(replyMessage.res);
    }
  }, {
    key: "_handleRequestMessage",
    value: function _handleRequestMessage(requestMessage) {
      var _this3 = this;
      var req = requestMessage.req;
      var result = this._handler.handleMessage(requestMessage.method, requestMessage.args);
      result.then(function (r) {
        _this3._send(new ReplyMessage(_this3._workerId, req, r, undefined));
      }, function (e) {
        if (e.detail instanceof Error) {
          // Loading errors have a detail property that points to the actual error
          e.detail = transformErrorForSerialization(e.detail);
        }
        _this3._send(new ReplyMessage(_this3._workerId, req, undefined, transformErrorForSerialization(e)));
      });
    }
  }, {
    key: "_handleSubscribeEventMessage",
    value: function _handleSubscribeEventMessage(msg) {
      var _this4 = this;
      var req = msg.req;
      var disposable = this._handler.handleEvent(msg.eventName, msg.arg)(function (event) {
        _this4._send(new EventMessage(_this4._workerId, req, event));
      });
      this._pendingEvents.set(req, disposable);
    }
  }, {
    key: "_handleEventMessage",
    value: function _handleEventMessage(msg) {
      if (!this._pendingEmitters.has(msg.req)) {
        console.warn('Got event for unknown req');
        return;
      }
      this._pendingEmitters.get(msg.req).fire(msg.event);
    }
  }, {
    key: "_handleUnsubscribeEventMessage",
    value: function _handleUnsubscribeEventMessage(msg) {
      if (!this._pendingEvents.has(msg.req)) {
        console.warn('Got unsubscribe for unknown req');
        return;
      }
      this._pendingEvents.get(msg.req).dispose();
      this._pendingEvents["delete"](msg.req);
    }
  }, {
    key: "_send",
    value: function _send(msg) {
      var transfer = [];
      if (msg.type === 0 /* Request */) {
        for (var i = 0; i < msg.args.length; i++) {
          if (msg.args[i] instanceof ArrayBuffer) {
            transfer.push(msg.args[i]);
          }
        }
      } else if (msg.type === 1 /* Reply */) {
        if (msg.res instanceof ArrayBuffer) {
          transfer.push(msg.res);
        }
      }
      this._handler.sendMessage(msg, transfer);
    }
  }]);
  return SimpleWorkerProtocol;
}();
/**
 * Main thread side
 */
var SimpleWorkerClient = /*#__PURE__*/(/* unused pure expression or super */ null && (function (_Disposable) {
  _inherits(SimpleWorkerClient, _Disposable);
  var _super = _createSuper(SimpleWorkerClient);
  function SimpleWorkerClient(workerFactory, moduleId, host) {
    var _this5;
    _classCallCheck(this, SimpleWorkerClient);
    _this5 = _super.call(this);
    var lazyProxyReject = null;
    _this5._worker = _this5._register(workerFactory.create('vs/base/common/worker/simpleWorker', function (msg) {
      _this5._protocol.handleMessage(msg);
    }, function (err) {
      // in Firefox, web workers fail lazily :(
      // we will reject the proxy
      if (lazyProxyReject) {
        lazyProxyReject(err);
      }
    }));
    _this5._protocol = new SimpleWorkerProtocol({
      sendMessage: function sendMessage(msg, transfer) {
        _this5._worker.postMessage(msg, transfer);
      },
      handleMessage: function handleMessage(method, args) {
        if (typeof host[method] !== 'function') {
          return Promise.reject(new Error('Missing method ' + method + ' on main thread host.'));
        }
        try {
          return Promise.resolve(host[method].apply(host, args));
        } catch (e) {
          return Promise.reject(e);
        }
      },
      handleEvent: function handleEvent(eventName, arg) {
        if (propertyIsDynamicEvent(eventName)) {
          var event = host[eventName].call(host, arg);
          if (typeof event !== 'function') {
            throw new Error("Missing dynamic event ".concat(eventName, " on main thread host."));
          }
          return event;
        }
        if (propertyIsEvent(eventName)) {
          var _event = host[eventName];
          if (typeof _event !== 'function') {
            throw new Error("Missing event ".concat(eventName, " on main thread host."));
          }
          return _event;
        }
        throw new Error("Malformed event name ".concat(eventName));
      }
    });
    _this5._protocol.setWorkerId(_this5._worker.getId());
    // Gather loader configuration
    var loaderConfiguration = null;
    if (typeof globals.require !== 'undefined' && typeof globals.require.getConfig === 'function') {
      // Get the configuration from the Monaco AMD Loader
      loaderConfiguration = globals.require.getConfig();
    } else if (typeof globals.requirejs !== 'undefined') {
      // Get the configuration from requirejs
      loaderConfiguration = globals.requirejs.s.contexts._.config;
    }
    var hostMethods = types.getAllMethodNames(host);
    // Send initialize message
    _this5._onModuleLoaded = _this5._protocol.sendMessage(INITIALIZE, [_this5._worker.getId(), JSON.parse(JSON.stringify(loaderConfiguration)), moduleId, hostMethods]);
    // Create proxy to loaded code
    var proxyMethodRequest = function proxyMethodRequest(method, args) {
      return _this5._request(method, args);
    };
    var proxyListen = function proxyListen(eventName, arg) {
      return _this5._protocol.listen(eventName, arg);
    };
    _this5._lazyProxy = new Promise(function (resolve, reject) {
      lazyProxyReject = reject;
      _this5._onModuleLoaded.then(function (availableMethods) {
        resolve(simpleWorker_createProxyObject(availableMethods, proxyMethodRequest, proxyListen));
      }, function (e) {
        reject(e);
        _this5._onError('Worker failed to load ' + moduleId, e);
      });
    });
    return _this5;
  }
  _createClass(SimpleWorkerClient, [{
    key: "getProxyObject",
    value: function getProxyObject() {
      return this._lazyProxy;
    }
  }, {
    key: "_request",
    value: function _request(method, args) {
      var _this6 = this;
      return new Promise(function (resolve, reject) {
        _this6._onModuleLoaded.then(function () {
          _this6._protocol.sendMessage(method, args).then(resolve, reject);
        }, reject);
      });
    }
  }, {
    key: "_onError",
    value: function _onError(message, error) {
      console.error(message);
      console.info(error);
    }
  }]);
  return SimpleWorkerClient;
}(Disposable)));
function propertyIsEvent(name) {
  // Assume a property is an event if it has a form of "onSomething"
  return name[0] === 'o' && name[1] === 'n' && isUpperAsciiLetter(name.charCodeAt(2));
}
function propertyIsDynamicEvent(name) {
  // Assume a property is a dynamic event (a method that returns an event) if it has a form of "onDynamicSomething"
  return /^onDynamic/.test(name) && isUpperAsciiLetter(name.charCodeAt(9));
}
function simpleWorker_createProxyObject(methodNames, invoke, proxyListen) {
  var createProxyMethod = function createProxyMethod(method) {
    return function () {
      var args = Array.prototype.slice.call(arguments, 0);
      return invoke(method, args);
    };
  };
  var createProxyDynamicEvent = function createProxyDynamicEvent(eventName) {
    return function (arg) {
      return proxyListen(eventName, arg);
    };
  };
  var result = {};
  var _iterator = createForOfIteratorHelper_default()(methodNames),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var methodName = _step.value;
      if (propertyIsDynamicEvent(methodName)) {
        result[methodName] = createProxyDynamicEvent(methodName);
        continue;
      }
      if (propertyIsEvent(methodName)) {
        result[methodName] = proxyListen(methodName, undefined);
        continue;
      }
      result[methodName] = createProxyMethod(methodName);
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return result;
}
/**
 * Worker side
 */
var SimpleWorkerServer = /*#__PURE__*/function () {
  function SimpleWorkerServer(postMessage, requestHandlerFactory) {
    var _this7 = this;
    classCallCheck_default()(this, SimpleWorkerServer);
    this._requestHandlerFactory = requestHandlerFactory;
    this._requestHandler = null;
    this._protocol = new SimpleWorkerProtocol({
      sendMessage: function sendMessage(msg, transfer) {
        postMessage(msg, transfer);
      },
      handleMessage: function handleMessage(method, args) {
        return _this7._handleMessage(method, args);
      },
      handleEvent: function handleEvent(eventName, arg) {
        return _this7._handleEvent(eventName, arg);
      }
    });
  }
  createClass_default()(SimpleWorkerServer, [{
    key: "onmessage",
    value: function onmessage(msg) {
      this._protocol.handleMessage(msg);
    }
  }, {
    key: "_handleMessage",
    value: function _handleMessage(method, args) {
      if (method === INITIALIZE) {
        return this.initialize(args[0], args[1], args[2], args[3]);
      }
      if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
        return Promise.reject(new Error('Missing requestHandler or method: ' + method));
      }
      try {
        return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));
      } catch (e) {
        return Promise.reject(e);
      }
    }
  }, {
    key: "_handleEvent",
    value: function _handleEvent(eventName, arg) {
      if (!this._requestHandler) {
        throw new Error("Missing requestHandler");
      }
      if (propertyIsDynamicEvent(eventName)) {
        var event = this._requestHandler[eventName].call(this._requestHandler, arg);
        if (typeof event !== 'function') {
          throw new Error("Missing dynamic event ".concat(eventName, " on request handler."));
        }
        return event;
      }
      if (propertyIsEvent(eventName)) {
        var _event2 = this._requestHandler[eventName];
        if (typeof _event2 !== 'function') {
          throw new Error("Missing event ".concat(eventName, " on request handler."));
        }
        return _event2;
      }
      throw new Error("Malformed event name ".concat(eventName));
    }
  }, {
    key: "initialize",
    value: function initialize(workerId, loaderConfig, moduleId, hostMethods) {
      var _this8 = this;
      this._protocol.setWorkerId(workerId);
      var proxyMethodRequest = function proxyMethodRequest(method, args) {
        return _this8._protocol.sendMessage(method, args);
      };
      var proxyListen = function proxyListen(eventName, arg) {
        return _this8._protocol.listen(eventName, arg);
      };
      var hostProxy = simpleWorker_createProxyObject(hostMethods, proxyMethodRequest, proxyListen);
      if (this._requestHandlerFactory) {
        // static request handler
        this._requestHandler = this._requestHandlerFactory(hostProxy);
        return Promise.resolve(getAllMethodNames(this._requestHandler));
      }
      if (loaderConfig) {
        // Remove 'baseUrl', handling it is beyond scope for now
        if (typeof loaderConfig.baseUrl !== 'undefined') {
          delete loaderConfig['baseUrl'];
        }
        if (typeof loaderConfig.paths !== 'undefined') {
          if (typeof loaderConfig.paths.vs !== 'undefined') {
            delete loaderConfig.paths['vs'];
          }
        }
        if (typeof_default()(loaderConfig.trustedTypesPolicy) !== undefined) {
          // don't use, it has been destroyed during serialize
          delete loaderConfig['trustedTypesPolicy'];
        }
        // Since this is in a web worker, enable catching errors
        loaderConfig.catchError = true;
        platform_globals.require.config(loaderConfig);
      }
      return new Promise(function (resolve, reject) {
        // Use the global require to be sure to get the global config
        // ESM-comment-begin
        // 			const req = (globals.require || require);
        // ESM-comment-end
        // ESM-uncomment-begin
        var req = platform_globals.require;
        // ESM-uncomment-end
        req([moduleId], function (module) {
          _this8._requestHandler = module.create(hostProxy);
          if (!_this8._requestHandler) {
            reject(new Error("No RequestHandler!"));
            return;
          }
          resolve(getAllMethodNames(_this8._requestHandler));
        }, reject);
      });
    }
  }]);
  return SimpleWorkerServer;
}();
/**
 * Called on the worker side
 */
function create(postMessage) {
  return new SimpleWorkerServer(postMessage, null);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
/**
 * Represents information about a specific difference between two sequences.
 */
var DiffChange = /*#__PURE__*/function () {
  /**
   * Constructs a new DiffChange with the given sequence information
   * and content.
   */
  function DiffChange(originalStart, originalLength, modifiedStart, modifiedLength) {
    classCallCheck_default()(this, DiffChange);
    //Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");
    this.originalStart = originalStart;
    this.originalLength = originalLength;
    this.modifiedStart = modifiedStart;
    this.modifiedLength = modifiedLength;
  }
  /**
   * The end point (exclusive) of the change in the original sequence.
   */
  createClass_default()(DiffChange, [{
    key: "getOriginalEnd",
    value: function getOriginalEnd() {
      return this.originalStart + this.originalLength;
    }
    /**
     * The end point (exclusive) of the change in the modified sequence.
     */
  }, {
    key: "getModifiedEnd",
    value: function getModifiedEnd() {
      return this.modifiedStart + this.modifiedLength;
    }
  }]);
  return DiffChange;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/hash.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

/**
 * Return a hash value for an object.
 */
function hash(obj) {
  return doHash(obj, 0);
}
function doHash(obj, hashVal) {
  switch (_typeof(obj)) {
    case 'object':
      if (obj === null) {
        return numberHash(349, hashVal);
      } else if (Array.isArray(obj)) {
        return arrayHash(obj, hashVal);
      }
      return objectHash(obj, hashVal);
    case 'string':
      return stringHash(obj, hashVal);
    case 'boolean':
      return booleanHash(obj, hashVal);
    case 'number':
      return numberHash(obj, hashVal);
    case 'undefined':
      return numberHash(937, hashVal);
    default:
      return numberHash(617, hashVal);
  }
}
function numberHash(val, initialHashVal) {
  return (initialHashVal << 5) - initialHashVal + val | 0; // hashVal * 31 + ch, keep as int32
}

function booleanHash(b, initialHashVal) {
  return numberHash(b ? 433 : 863, initialHashVal);
}
function stringHash(s, hashVal) {
  hashVal = numberHash(149417, hashVal);
  for (var i = 0, length = s.length; i < length; i++) {
    hashVal = numberHash(s.charCodeAt(i), hashVal);
  }
  return hashVal;
}
function arrayHash(arr, initialHashVal) {
  initialHashVal = numberHash(104579, initialHashVal);
  return arr.reduce(function (hashVal, item) {
    return doHash(item, hashVal);
  }, initialHashVal);
}
function objectHash(obj, initialHashVal) {
  initialHashVal = numberHash(181387, initialHashVal);
  return Object.keys(obj).sort().reduce(function (hashVal, key) {
    hashVal = stringHash(key, hashVal);
    return doHash(obj[key], hashVal);
  }, initialHashVal);
}
function leftRotate(value, bits) {
  var totalBits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 32;
  // delta + bits = totalBits
  var delta = totalBits - bits;
  // All ones, expect `delta` zeros aligned to the right
  var mask = ~((1 << delta) - 1);
  // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
  return (value << bits | (mask & value) >>> delta) >>> 0;
}
function fill(dest) {
  var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  var count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : dest.byteLength;
  var value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
  for (var i = 0; i < count; i++) {
    dest[index + i] = value;
  }
}
function leftPad(value, length) {
  var _char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
  while (value.length < length) {
    value = _char + value;
  }
  return value;
}
function toHexString(bufferOrValue) {
  var bitsize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 32;
  if (bufferOrValue instanceof ArrayBuffer) {
    return Array.from(new Uint8Array(bufferOrValue)).map(function (b) {
      return b.toString(16).padStart(2, '0');
    }).join('');
  }
  return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);
}
/**
 * A SHA1 implementation that works with strings and does not allocate.
 */
var StringSHA1 = /*#__PURE__*/function () {
  function StringSHA1() {
    classCallCheck_default()(this, StringSHA1);
    this._h0 = 0x67452301;
    this._h1 = 0xEFCDAB89;
    this._h2 = 0x98BADCFE;
    this._h3 = 0x10325476;
    this._h4 = 0xC3D2E1F0;
    this._buff = new Uint8Array(64 /* BLOCK_SIZE */ + 3 /* to fit any utf-8 */);
    this._buffDV = new DataView(this._buff.buffer);
    this._buffLen = 0;
    this._totalLen = 0;
    this._leftoverHighSurrogate = 0;
    this._finished = false;
  }
  createClass_default()(StringSHA1, [{
    key: "update",
    value: function update(str) {
      var strLen = str.length;
      if (strLen === 0) {
        return;
      }
      var buff = this._buff;
      var buffLen = this._buffLen;
      var leftoverHighSurrogate = this._leftoverHighSurrogate;
      var charCode;
      var offset;
      if (leftoverHighSurrogate !== 0) {
        charCode = leftoverHighSurrogate;
        offset = -1;
        leftoverHighSurrogate = 0;
      } else {
        charCode = str.charCodeAt(0);
        offset = 0;
      }
      while (true) {
        var codePoint = charCode;
        if (isHighSurrogate(charCode)) {
          if (offset + 1 < strLen) {
            var nextCharCode = str.charCodeAt(offset + 1);
            if (isLowSurrogate(nextCharCode)) {
              offset++;
              codePoint = computeCodePoint(charCode, nextCharCode);
            } else {
              // illegal => unicode replacement character
              codePoint = 65533 /* UNICODE_REPLACEMENT */;
            }
          } else {
            // last character is a surrogate pair
            leftoverHighSurrogate = charCode;
            break;
          }
        } else if (isLowSurrogate(charCode)) {
          // illegal => unicode replacement character
          codePoint = 65533 /* UNICODE_REPLACEMENT */;
        }

        buffLen = this._push(buff, buffLen, codePoint);
        offset++;
        if (offset < strLen) {
          charCode = str.charCodeAt(offset);
        } else {
          break;
        }
      }
      this._buffLen = buffLen;
      this._leftoverHighSurrogate = leftoverHighSurrogate;
    }
  }, {
    key: "_push",
    value: function _push(buff, buffLen, codePoint) {
      if (codePoint < 0x0080) {
        buff[buffLen++] = codePoint;
      } else if (codePoint < 0x0800) {
        buff[buffLen++] = 192 | (codePoint & 1984) >>> 6;
        buff[buffLen++] = 128 | (codePoint & 63) >>> 0;
      } else if (codePoint < 0x10000) {
        buff[buffLen++] = 224 | (codePoint & 61440) >>> 12;
        buff[buffLen++] = 128 | (codePoint & 4032) >>> 6;
        buff[buffLen++] = 128 | (codePoint & 63) >>> 0;
      } else {
        buff[buffLen++] = 240 | (codePoint & 1835008) >>> 18;
        buff[buffLen++] = 128 | (codePoint & 258048) >>> 12;
        buff[buffLen++] = 128 | (codePoint & 4032) >>> 6;
        buff[buffLen++] = 128 | (codePoint & 63) >>> 0;
      }
      if (buffLen >= 64 /* BLOCK_SIZE */) {
        this._step();
        buffLen -= 64 /* BLOCK_SIZE */;
        this._totalLen += 64 /* BLOCK_SIZE */;
        // take last 3 in case of UTF8 overflow
        buff[0] = buff[64 /* BLOCK_SIZE */ + 0];
        buff[1] = buff[64 /* BLOCK_SIZE */ + 1];
        buff[2] = buff[64 /* BLOCK_SIZE */ + 2];
      }
      return buffLen;
    }
  }, {
    key: "digest",
    value: function digest() {
      if (!this._finished) {
        this._finished = true;
        if (this._leftoverHighSurrogate) {
          // illegal => unicode replacement character
          this._leftoverHighSurrogate = 0;
          this._buffLen = this._push(this._buff, this._buffLen, 65533 /* UNICODE_REPLACEMENT */);
        }

        this._totalLen += this._buffLen;
        this._wrapUp();
      }
      return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);
    }
  }, {
    key: "_wrapUp",
    value: function _wrapUp() {
      this._buff[this._buffLen++] = 0x80;
      fill(this._buff, this._buffLen);
      if (this._buffLen > 56) {
        this._step();
        fill(this._buff);
      }
      // this will fit because the mantissa can cover up to 52 bits
      var ml = 8 * this._totalLen;
      this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);
      this._buffDV.setUint32(60, ml % 4294967296, false);
      this._step();
    }
  }, {
    key: "_step",
    value: function _step() {
      var bigBlock32 = StringSHA1._bigBlock32;
      var data = this._buffDV;
      for (var j = 0; j < 64 /* 16*4 */; j += 4) {
        bigBlock32.setUint32(j, data.getUint32(j, false), false);
      }
      for (var _j = 64; _j < 320 /* 80*4 */; _j += 4) {
        bigBlock32.setUint32(_j, leftRotate(bigBlock32.getUint32(_j - 12, false) ^ bigBlock32.getUint32(_j - 32, false) ^ bigBlock32.getUint32(_j - 56, false) ^ bigBlock32.getUint32(_j - 64, false), 1), false);
      }
      var a = this._h0;
      var b = this._h1;
      var c = this._h2;
      var d = this._h3;
      var e = this._h4;
      var f, k;
      var temp;
      for (var _j2 = 0; _j2 < 80; _j2++) {
        if (_j2 < 20) {
          f = b & c | ~b & d;
          k = 0x5A827999;
        } else if (_j2 < 40) {
          f = b ^ c ^ d;
          k = 0x6ED9EBA1;
        } else if (_j2 < 60) {
          f = b & c | b & d | c & d;
          k = 0x8F1BBCDC;
        } else {
          f = b ^ c ^ d;
          k = 0xCA62C1D6;
        }
        temp = leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(_j2 * 4, false) & 0xffffffff;
        e = d;
        d = c;
        c = leftRotate(b, 30);
        b = a;
        a = temp;
      }
      this._h0 = this._h0 + a & 0xffffffff;
      this._h1 = this._h1 + b & 0xffffffff;
      this._h2 = this._h2 + c & 0xffffffff;
      this._h3 = this._h3 + d & 0xffffffff;
      this._h4 = this._h4 + e & 0xffffffff;
    }
  }]);
  return StringSHA1;
}();
StringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


var StringDiffSequence = /*#__PURE__*/function () {
  function StringDiffSequence(source) {
    classCallCheck_default()(this, StringDiffSequence);
    this.source = source;
  }
  createClass_default()(StringDiffSequence, [{
    key: "getElements",
    value: function getElements() {
      var source = this.source;
      var characters = new Int32Array(source.length);
      for (var i = 0, len = source.length; i < len; i++) {
        characters[i] = source.charCodeAt(i);
      }
      return characters;
    }
  }]);
  return StringDiffSequence;
}();
function stringDiff(original, modified, pretty) {
  return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;
}
//
// The code below has been ported from a C# implementation in VS
//
var Debug = /*#__PURE__*/function () {
  function Debug() {
    classCallCheck_default()(this, Debug);
  }
  createClass_default()(Debug, null, [{
    key: "Assert",
    value: function Assert(condition, message) {
      if (!condition) {
        throw new Error(message);
      }
    }
  }]);
  return Debug;
}();
var MyArray = /*#__PURE__*/function () {
  function MyArray() {
    classCallCheck_default()(this, MyArray);
  }
  createClass_default()(MyArray, null, [{
    key: "Copy",
    value:
    /**
     * Copies a range of elements from an Array starting at the specified source index and pastes
     * them to another Array starting at the specified destination index. The length and the indexes
     * are specified as 64-bit integers.
     * sourceArray:
     *		The Array that contains the data to copy.
     * sourceIndex:
     *		A 64-bit integer that represents the index in the sourceArray at which copying begins.
     * destinationArray:
     *		The Array that receives the data.
     * destinationIndex:
     *		A 64-bit integer that represents the index in the destinationArray at which storing begins.
     * length:
     *		A 64-bit integer that represents the number of elements to copy.
     */
    function Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
      for (var i = 0; i < length; i++) {
        destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
      }
    }
  }, {
    key: "Copy2",
    value: function Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
      for (var i = 0; i < length; i++) {
        destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
      }
    }
  }]);
  return MyArray;
}();
/**
 * A utility class which helps to create the set of DiffChanges from
 * a difference operation. This class accepts original DiffElements and
 * modified DiffElements that are involved in a particular change. The
 * MarkNextChange() method can be called to mark the separation between
 * distinct changes. At the end, the Changes property can be called to retrieve
 * the constructed changes.
 */
var DiffChangeHelper = /*#__PURE__*/function () {
  /**
   * Constructs a new DiffChangeHelper for the given DiffSequences.
   */
  function DiffChangeHelper() {
    classCallCheck_default()(this, DiffChangeHelper);
    this.m_changes = [];
    this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;
    this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;
    this.m_originalCount = 0;
    this.m_modifiedCount = 0;
  }
  /**
   * Marks the beginning of the next change in the set of differences.
   */
  createClass_default()(DiffChangeHelper, [{
    key: "MarkNextChange",
    value: function MarkNextChange() {
      // Only add to the list if there is something to add
      if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
        // Add the new change to our list
        this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));
      }
      // Reset for the next change
      this.m_originalCount = 0;
      this.m_modifiedCount = 0;
      this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;
      this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;
    }
    /**
     * Adds the original element at the given position to the elements
     * affected by the current change. The modified index gives context
     * to the change position with respect to the original sequence.
     * @param originalIndex The index of the original element to add.
     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.
     */
  }, {
    key: "AddOriginalElement",
    value: function AddOriginalElement(originalIndex, modifiedIndex) {
      // The 'true' start index is the smallest of the ones we've seen
      this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
      this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
      this.m_originalCount++;
    }
    /**
     * Adds the modified element at the given position to the elements
     * affected by the current change. The original index gives context
     * to the change position with respect to the modified sequence.
     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.
     * @param modifiedIndex The index of the modified element to add.
     */
  }, {
    key: "AddModifiedElement",
    value: function AddModifiedElement(originalIndex, modifiedIndex) {
      // The 'true' start index is the smallest of the ones we've seen
      this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
      this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
      this.m_modifiedCount++;
    }
    /**
     * Retrieves all of the changes marked by the class.
     */
  }, {
    key: "getChanges",
    value: function getChanges() {
      if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
        // Finish up on whatever is left
        this.MarkNextChange();
      }
      return this.m_changes;
    }
    /**
     * Retrieves all of the changes marked by the class in the reverse order
     */
  }, {
    key: "getReverseChanges",
    value: function getReverseChanges() {
      if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
        // Finish up on whatever is left
        this.MarkNextChange();
      }
      this.m_changes.reverse();
      return this.m_changes;
    }
  }]);
  return DiffChangeHelper;
}();
/**
 * An implementation of the difference algorithm described in
 * "An O(ND) Difference Algorithm and its variations" by Eugene W. Myers
 */
var LcsDiff = /*#__PURE__*/function () {
  /**
   * Constructs the DiffFinder
   */
  function LcsDiff(originalSequence, modifiedSequence) {
    var continueProcessingPredicate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
    classCallCheck_default()(this, LcsDiff);
    this.ContinueProcessingPredicate = continueProcessingPredicate;
    this._originalSequence = originalSequence;
    this._modifiedSequence = modifiedSequence;
    var _LcsDiff$_getElements = LcsDiff._getElements(originalSequence),
      _LcsDiff$_getElements2 = slicedToArray_default()(_LcsDiff$_getElements, 3),
      originalStringElements = _LcsDiff$_getElements2[0],
      originalElementsOrHash = _LcsDiff$_getElements2[1],
      originalHasStrings = _LcsDiff$_getElements2[2];
    var _LcsDiff$_getElements3 = LcsDiff._getElements(modifiedSequence),
      _LcsDiff$_getElements4 = slicedToArray_default()(_LcsDiff$_getElements3, 3),
      modifiedStringElements = _LcsDiff$_getElements4[0],
      modifiedElementsOrHash = _LcsDiff$_getElements4[1],
      modifiedHasStrings = _LcsDiff$_getElements4[2];
    this._hasStrings = originalHasStrings && modifiedHasStrings;
    this._originalStringElements = originalStringElements;
    this._originalElementsOrHash = originalElementsOrHash;
    this._modifiedStringElements = modifiedStringElements;
    this._modifiedElementsOrHash = modifiedElementsOrHash;
    this.m_forwardHistory = [];
    this.m_reverseHistory = [];
  }
  createClass_default()(LcsDiff, [{
    key: "ElementsAreEqual",
    value: function ElementsAreEqual(originalIndex, newIndex) {
      if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {
        return false;
      }
      return this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true;
    }
  }, {
    key: "ElementsAreStrictEqual",
    value: function ElementsAreStrictEqual(originalIndex, newIndex) {
      if (!this.ElementsAreEqual(originalIndex, newIndex)) {
        return false;
      }
      var originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);
      var modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);
      return originalElement === modifiedElement;
    }
  }, {
    key: "OriginalElementsAreEqual",
    value: function OriginalElementsAreEqual(index1, index2) {
      if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {
        return false;
      }
      return this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true;
    }
  }, {
    key: "ModifiedElementsAreEqual",
    value: function ModifiedElementsAreEqual(index1, index2) {
      if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {
        return false;
      }
      return this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true;
    }
  }, {
    key: "ComputeDiff",
    value: function ComputeDiff(pretty) {
      return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);
    }
    /**
     * Computes the differences between the original and modified input
     * sequences on the bounded range.
     * @returns An array of the differences between the two input sequences.
     */
  }, {
    key: "_ComputeDiff",
    value: function _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {
      var quitEarlyArr = [false];
      var changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);
      if (pretty) {
        // We have to clean up the computed diff to be more intuitive
        // but it turns out this cannot be done correctly until the entire set
        // of diffs have been computed
        changes = this.PrettifyChanges(changes);
      }
      return {
        quitEarly: quitEarlyArr[0],
        changes: changes
      };
    }
    /**
     * Private helper method which computes the differences on the bounded range
     * recursively.
     * @returns An array of the differences between the two input sequences.
     */
  }, {
    key: "ComputeDiffRecursive",
    value: function ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {
      quitEarlyArr[0] = false;
      // Find the start of the differences
      while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {
        originalStart++;
        modifiedStart++;
      }
      // Find the end of the differences
      while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {
        originalEnd--;
        modifiedEnd--;
      }
      // In the special case where we either have all insertions or all deletions or the sequences are identical
      if (originalStart > originalEnd || modifiedStart > modifiedEnd) {
        var changes;
        if (modifiedStart <= modifiedEnd) {
          Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
          // All insertions
          changes = [new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)];
        } else if (originalStart <= originalEnd) {
          Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
          // All deletions
          changes = [new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)];
        } else {
          Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
          Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
          // Identical sequences - No differences
          changes = [];
        }
        return changes;
      }
      // This problem can be solved using the Divide-And-Conquer technique.
      var midOriginalArr = [0];
      var midModifiedArr = [0];
      var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
      var midOriginal = midOriginalArr[0];
      var midModified = midModifiedArr[0];
      if (result !== null) {
        // Result is not-null when there was enough memory to compute the changes while
        // searching for the recursion point
        return result;
      } else if (!quitEarlyArr[0]) {
        // We can break the problem down recursively by finding the changes in the
        // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)
        // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)
        // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point
        var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
        var rightChanges = [];
        if (!quitEarlyArr[0]) {
          rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);
        } else {
          // We didn't have time to finish the first half, so we don't have time to compute this half.
          // Consider the entire rest of the sequence different.
          rightChanges = [new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)];
        }
        return this.ConcatenateChanges(leftChanges, rightChanges);
      }
      // If we hit here, we quit early, and so can't return anything meaningful
      return [new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)];
    }
  }, {
    key: "WALKTRACE",
    value: function WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {
      var forwardChanges = null;
      var reverseChanges = null;
      // First, walk backward through the forward diagonals history
      var changeHelper = new DiffChangeHelper();
      var diagonalMin = diagonalForwardStart;
      var diagonalMax = diagonalForwardEnd;
      var diagonalRelative = midOriginalArr[0] - midModifiedArr[0] - diagonalForwardOffset;
      var lastOriginalIndex = -1073741824 /* MIN_SAFE_SMALL_INTEGER */;
      var historyIndex = this.m_forwardHistory.length - 1;
      do {
        // Get the diagonal index from the relative diagonal number
        var diagonal = diagonalRelative + diagonalForwardBase;
        // Figure out where we came from
        if (diagonal === diagonalMin || diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1]) {
          // Vertical line (the element is an insert)
          originalIndex = forwardPoints[diagonal + 1];
          modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
          if (originalIndex < lastOriginalIndex) {
            changeHelper.MarkNextChange();
          }
          lastOriginalIndex = originalIndex;
          changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);
          diagonalRelative = diagonal + 1 - diagonalForwardBase; //Setup for the next iteration
        } else {
          // Horizontal line (the element is a deletion)
          originalIndex = forwardPoints[diagonal - 1] + 1;
          modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
          if (originalIndex < lastOriginalIndex) {
            changeHelper.MarkNextChange();
          }
          lastOriginalIndex = originalIndex - 1;
          changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);
          diagonalRelative = diagonal - 1 - diagonalForwardBase; //Setup for the next iteration
        }

        if (historyIndex >= 0) {
          forwardPoints = this.m_forwardHistory[historyIndex];
          diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot
          diagonalMin = 1;
          diagonalMax = forwardPoints.length - 1;
        }
      } while (--historyIndex >= -1);
      // Ironically, we get the forward changes as the reverse of the
      // order we added them since we technically added them backwards
      forwardChanges = changeHelper.getReverseChanges();
      if (quitEarlyArr[0]) {
        // TODO: Calculate a partial from the reverse diagonals.
        //       For now, just assume everything after the midOriginal/midModified point is a diff
        var originalStartPoint = midOriginalArr[0] + 1;
        var modifiedStartPoint = midModifiedArr[0] + 1;
        if (forwardChanges !== null && forwardChanges.length > 0) {
          var lastForwardChange = forwardChanges[forwardChanges.length - 1];
          originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());
          modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());
        }
        reverseChanges = [new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)];
      } else {
        // Now walk backward through the reverse diagonals history
        changeHelper = new DiffChangeHelper();
        diagonalMin = diagonalReverseStart;
        diagonalMax = diagonalReverseEnd;
        diagonalRelative = midOriginalArr[0] - midModifiedArr[0] - diagonalReverseOffset;
        lastOriginalIndex = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;
        historyIndex = deltaIsEven ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;
        do {
          // Get the diagonal index from the relative diagonal number
          var _diagonal = diagonalRelative + diagonalReverseBase;
          // Figure out where we came from
          if (_diagonal === diagonalMin || _diagonal < diagonalMax && reversePoints[_diagonal - 1] >= reversePoints[_diagonal + 1]) {
            // Horizontal line (the element is a deletion))
            originalIndex = reversePoints[_diagonal + 1] - 1;
            modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
            if (originalIndex > lastOriginalIndex) {
              changeHelper.MarkNextChange();
            }
            lastOriginalIndex = originalIndex + 1;
            changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);
            diagonalRelative = _diagonal + 1 - diagonalReverseBase; //Setup for the next iteration
          } else {
            // Vertical line (the element is an insertion)
            originalIndex = reversePoints[_diagonal - 1];
            modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
            if (originalIndex > lastOriginalIndex) {
              changeHelper.MarkNextChange();
            }
            lastOriginalIndex = originalIndex;
            changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);
            diagonalRelative = _diagonal - 1 - diagonalReverseBase; //Setup for the next iteration
          }

          if (historyIndex >= 0) {
            reversePoints = this.m_reverseHistory[historyIndex];
            diagonalReverseBase = reversePoints[0]; //We stored this in the first spot
            diagonalMin = 1;
            diagonalMax = reversePoints.length - 1;
          }
        } while (--historyIndex >= -1);
        // There are cases where the reverse history will find diffs that
        // are correct, but not intuitive, so we need shift them.
        reverseChanges = changeHelper.getChanges();
      }
      return this.ConcatenateChanges(forwardChanges, reverseChanges);
    }
    /**
     * Given the range to compute the diff on, this method finds the point:
     * (midOriginal, midModified)
     * that exists in the middle of the LCS of the two sequences and
     * is the point at which the LCS problem may be broken down recursively.
     * This method will try to keep the LCS trace in memory. If the LCS recursion
     * point is calculated and the full trace is available in memory, then this method
     * will return the change list.
     * @param originalStart The start bound of the original sequence range
     * @param originalEnd The end bound of the original sequence range
     * @param modifiedStart The start bound of the modified sequence range
     * @param modifiedEnd The end bound of the modified sequence range
     * @param midOriginal The middle point of the original sequence range
     * @param midModified The middle point of the modified sequence range
     * @returns The diff changes, if available, otherwise null
     */
  }, {
    key: "ComputeRecursionPoint",
    value: function ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {
      var originalIndex = 0,
        modifiedIndex = 0;
      var diagonalForwardStart = 0,
        diagonalForwardEnd = 0;
      var diagonalReverseStart = 0,
        diagonalReverseEnd = 0;
      // To traverse the edit graph and produce the proper LCS, our actual
      // start position is just outside the given boundary
      originalStart--;
      modifiedStart--;
      // We set these up to make the compiler happy, but they will
      // be replaced before we return with the actual recursion point
      midOriginalArr[0] = 0;
      midModifiedArr[0] = 0;
      // Clear out the history
      this.m_forwardHistory = [];
      this.m_reverseHistory = [];
      // Each cell in the two arrays corresponds to a diagonal in the edit graph.
      // The integer value in the cell represents the originalIndex of the furthest
      // reaching point found so far that ends in that diagonal.
      // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.
      var maxDifferences = originalEnd - originalStart + (modifiedEnd - modifiedStart);
      var numDiagonals = maxDifferences + 1;
      var forwardPoints = new Int32Array(numDiagonals);
      var reversePoints = new Int32Array(numDiagonals);
      // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)
      // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)
      var diagonalForwardBase = modifiedEnd - modifiedStart;
      var diagonalReverseBase = originalEnd - originalStart;
      // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
      //    diagonal number (relative to diagonalForwardBase)
      // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
      //    diagonal number (relative to diagonalReverseBase)
      var diagonalForwardOffset = originalStart - modifiedStart;
      var diagonalReverseOffset = originalEnd - modifiedEnd;
      // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers
      //   relative to the start diagonal with diagonal numbers relative to the end diagonal.
      // The Even/Oddn-ness of this delta is important for determining when we should check for overlap
      var delta = diagonalReverseBase - diagonalForwardBase;
      var deltaIsEven = delta % 2 === 0;
      // Here we set up the start and end points as the furthest points found so far
      // in both the forward and reverse directions, respectively
      forwardPoints[diagonalForwardBase] = originalStart;
      reversePoints[diagonalReverseBase] = originalEnd;
      // Remember if we quit early, and thus need to do a best-effort result instead of a real result.
      quitEarlyArr[0] = false;
      // A couple of points:
      // --With this method, we iterate on the number of differences between the two sequences.
      //   The more differences there actually are, the longer this will take.
      // --Also, as the number of differences increases, we have to search on diagonals further
      //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).
      // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences
      //   is even and odd diagonals only when numDifferences is odd.
      for (var numDifferences = 1; numDifferences <= maxDifferences / 2 + 1; numDifferences++) {
        var furthestOriginalIndex = 0;
        var furthestModifiedIndex = 0;
        // Run the algorithm in the forward direction
        diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
        diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
        for (var diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {
          // STEP 1: We extend the furthest reaching point in the present diagonal
          // by looking at the diagonals above and below and picking the one whose point
          // is further away from the start point (originalStart, modifiedStart)
          if (diagonal === diagonalForwardStart || diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1]) {
            originalIndex = forwardPoints[diagonal + 1];
          } else {
            originalIndex = forwardPoints[diagonal - 1] + 1;
          }
          modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;
          // Save the current originalIndex so we can test for false overlap in step 3
          var tempOriginalIndex = originalIndex;
          // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
          // so long as the elements are equal.
          while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {
            originalIndex++;
            modifiedIndex++;
          }
          forwardPoints[diagonal] = originalIndex;
          if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {
            furthestOriginalIndex = originalIndex;
            furthestModifiedIndex = modifiedIndex;
          }
          // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)
          // and diagonal is in the range of reverse diagonals computed for numDifferences-1
          // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)
          // then check for overlap.
          if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= numDifferences - 1) {
            if (originalIndex >= reversePoints[diagonal]) {
              midOriginalArr[0] = originalIndex;
              midModifiedArr[0] = modifiedIndex;
              if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= 1447 /* MaxDifferencesHistory */ + 1) {
                // BINGO! We overlapped, and we have the full trace in memory!
                return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
              } else {
                // Either false overlap, or we didn't have enough memory for the full trace
                // Just return the recursion point
                return null;
              }
            }
          }
        }
        // Check to see if we should be quitting early, before moving on to the next iteration.
        var matchLengthOfLongest = (furthestOriginalIndex - originalStart + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
        if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {
          // We can't finish, so skip ahead to generating a result from what we have.
          quitEarlyArr[0] = true;
          // Use the furthest distance we got in the forward direction.
          midOriginalArr[0] = furthestOriginalIndex;
          midModifiedArr[0] = furthestModifiedIndex;
          if (matchLengthOfLongest > 0 && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= 1447 /* MaxDifferencesHistory */ + 1) {
            // Enough of the history is in memory to walk it backwards
            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
          } else {
            // We didn't actually remember enough of the history.
            //Since we are quitting the diff early, we need to shift back the originalStart and modified start
            //back into the boundary limits since we decremented their value above beyond the boundary limit.
            originalStart++;
            modifiedStart++;
            return [new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)];
          }
        }
        // Run the algorithm in the reverse direction
        diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
        diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
        for (var _diagonal2 = diagonalReverseStart; _diagonal2 <= diagonalReverseEnd; _diagonal2 += 2) {
          // STEP 1: We extend the furthest reaching point in the present diagonal
          // by looking at the diagonals above and below and picking the one whose point
          // is further away from the start point (originalEnd, modifiedEnd)
          if (_diagonal2 === diagonalReverseStart || _diagonal2 < diagonalReverseEnd && reversePoints[_diagonal2 - 1] >= reversePoints[_diagonal2 + 1]) {
            originalIndex = reversePoints[_diagonal2 + 1] - 1;
          } else {
            originalIndex = reversePoints[_diagonal2 - 1];
          }
          modifiedIndex = originalIndex - (_diagonal2 - diagonalReverseBase) - diagonalReverseOffset;
          // Save the current originalIndex so we can test for false overlap
          var _tempOriginalIndex = originalIndex;
          // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
          // as long as the elements are equal.
          while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {
            originalIndex--;
            modifiedIndex--;
          }
          reversePoints[_diagonal2] = originalIndex;
          // STEP 4: If delta is even (overlap first happens on reverse when delta is even)
          // and diagonal is in the range of forward diagonals computed for numDifferences
          // then check for overlap.
          if (deltaIsEven && Math.abs(_diagonal2 - diagonalForwardBase) <= numDifferences) {
            if (originalIndex <= forwardPoints[_diagonal2]) {
              midOriginalArr[0] = originalIndex;
              midModifiedArr[0] = modifiedIndex;
              if (_tempOriginalIndex >= forwardPoints[_diagonal2] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= 1447 /* MaxDifferencesHistory */ + 1) {
                // BINGO! We overlapped, and we have the full trace in memory!
                return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
              } else {
                // Either false overlap, or we didn't have enough memory for the full trace
                // Just return the recursion point
                return null;
              }
            }
          }
        }
        // Save current vectors to history before the next iteration
        if (numDifferences <= 1447 /* MaxDifferencesHistory */) {
          // We are allocating space for one extra int, which we fill with
          // the index of the diagonal base index
          var temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);
          temp[0] = diagonalForwardBase - diagonalForwardStart + 1;
          MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);
          this.m_forwardHistory.push(temp);
          temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);
          temp[0] = diagonalReverseBase - diagonalReverseStart + 1;
          MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);
          this.m_reverseHistory.push(temp);
        }
      }
      // If we got here, then we have the full trace in history. We just have to convert it to a change list
      // NOTE: This part is a bit messy
      return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
    }
    /**
     * Shifts the given changes to provide a more intuitive diff.
     * While the first element in a diff matches the first element after the diff,
     * we shift the diff down.
     *
     * @param changes The list of changes to shift
     * @returns The shifted changes
     */
  }, {
    key: "PrettifyChanges",
    value: function PrettifyChanges(changes) {
      // Shift all the changes down first
      for (var i = 0; i < changes.length; i++) {
        var change = changes[i];
        var originalStop = i < changes.length - 1 ? changes[i + 1].originalStart : this._originalElementsOrHash.length;
        var modifiedStop = i < changes.length - 1 ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;
        var checkOriginal = change.originalLength > 0;
        var checkModified = change.modifiedLength > 0;
        while (change.originalStart + change.originalLength < originalStop && change.modifiedStart + change.modifiedLength < modifiedStop && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {
          var startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);
          var endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);
          if (endStrictEqual && !startStrictEqual) {
            // moving the change down would create an equal change, but the elements are not strict equal
            break;
          }
          change.originalStart++;
          change.modifiedStart++;
        }
        var mergedChangeArr = [null];
        if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {
          changes[i] = mergedChangeArr[0];
          changes.splice(i + 1, 1);
          i--;
          continue;
        }
      }
      // Shift changes back up until we hit empty or whitespace-only lines
      for (var _i = changes.length - 1; _i >= 0; _i--) {
        var _change = changes[_i];
        var _originalStop = 0;
        var _modifiedStop = 0;
        if (_i > 0) {
          var prevChange = changes[_i - 1];
          _originalStop = prevChange.originalStart + prevChange.originalLength;
          _modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;
        }
        var _checkOriginal = _change.originalLength > 0;
        var _checkModified = _change.modifiedLength > 0;
        var bestDelta = 0;
        var bestScore = this._boundaryScore(_change.originalStart, _change.originalLength, _change.modifiedStart, _change.modifiedLength);
        for (var delta = 1;; delta++) {
          var originalStart = _change.originalStart - delta;
          var modifiedStart = _change.modifiedStart - delta;
          if (originalStart < _originalStop || modifiedStart < _modifiedStop) {
            break;
          }
          if (_checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + _change.originalLength)) {
            break;
          }
          if (_checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + _change.modifiedLength)) {
            break;
          }
          var touchingPreviousChange = originalStart === _originalStop && modifiedStart === _modifiedStop;
          var score = (touchingPreviousChange ? 5 : 0) + this._boundaryScore(originalStart, _change.originalLength, modifiedStart, _change.modifiedLength);
          if (score > bestScore) {
            bestScore = score;
            bestDelta = delta;
          }
        }
        _change.originalStart -= bestDelta;
        _change.modifiedStart -= bestDelta;
        var _mergedChangeArr = [null];
        if (_i > 0 && this.ChangesOverlap(changes[_i - 1], changes[_i], _mergedChangeArr)) {
          changes[_i - 1] = _mergedChangeArr[0];
          changes.splice(_i, 1);
          _i++;
          continue;
        }
      }
      // There could be multiple longest common substrings.
      // Give preference to the ones containing longer lines
      if (this._hasStrings) {
        for (var _i2 = 1, len = changes.length; _i2 < len; _i2++) {
          var aChange = changes[_i2 - 1];
          var bChange = changes[_i2];
          var matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;
          var aOriginalStart = aChange.originalStart;
          var bOriginalEnd = bChange.originalStart + bChange.originalLength;
          var abOriginalLength = bOriginalEnd - aOriginalStart;
          var aModifiedStart = aChange.modifiedStart;
          var bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;
          var abModifiedLength = bModifiedEnd - aModifiedStart;
          // Avoid wasting a lot of time with these searches
          if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {
            var t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);
            if (t) {
              var _t = slicedToArray_default()(t, 2),
                originalMatchStart = _t[0],
                modifiedMatchStart = _t[1];
              if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {
                // switch to another sequence that has a better score
                aChange.originalLength = originalMatchStart - aChange.originalStart;
                aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;
                bChange.originalStart = originalMatchStart + matchedLength;
                bChange.modifiedStart = modifiedMatchStart + matchedLength;
                bChange.originalLength = bOriginalEnd - bChange.originalStart;
                bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;
              }
            }
          }
        }
      }
      return changes;
    }
  }, {
    key: "_findBetterContiguousSequence",
    value: function _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {
      if (originalLength < desiredLength || modifiedLength < desiredLength) {
        return null;
      }
      var originalMax = originalStart + originalLength - desiredLength + 1;
      var modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;
      var bestScore = 0;
      var bestOriginalStart = 0;
      var bestModifiedStart = 0;
      for (var i = originalStart; i < originalMax; i++) {
        for (var j = modifiedStart; j < modifiedMax; j++) {
          var score = this._contiguousSequenceScore(i, j, desiredLength);
          if (score > 0 && score > bestScore) {
            bestScore = score;
            bestOriginalStart = i;
            bestModifiedStart = j;
          }
        }
      }
      if (bestScore > 0) {
        return [bestOriginalStart, bestModifiedStart];
      }
      return null;
    }
  }, {
    key: "_contiguousSequenceScore",
    value: function _contiguousSequenceScore(originalStart, modifiedStart, length) {
      var score = 0;
      for (var l = 0; l < length; l++) {
        if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {
          return 0;
        }
        score += this._originalStringElements[originalStart + l].length;
      }
      return score;
    }
  }, {
    key: "_OriginalIsBoundary",
    value: function _OriginalIsBoundary(index) {
      if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {
        return true;
      }
      return this._hasStrings && /^\s*$/.test(this._originalStringElements[index]);
    }
  }, {
    key: "_OriginalRegionIsBoundary",
    value: function _OriginalRegionIsBoundary(originalStart, originalLength) {
      if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {
        return true;
      }
      if (originalLength > 0) {
        var originalEnd = originalStart + originalLength;
        if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {
          return true;
        }
      }
      return false;
    }
  }, {
    key: "_ModifiedIsBoundary",
    value: function _ModifiedIsBoundary(index) {
      if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {
        return true;
      }
      return this._hasStrings && /^\s*$/.test(this._modifiedStringElements[index]);
    }
  }, {
    key: "_ModifiedRegionIsBoundary",
    value: function _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {
      if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {
        return true;
      }
      if (modifiedLength > 0) {
        var modifiedEnd = modifiedStart + modifiedLength;
        if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {
          return true;
        }
      }
      return false;
    }
  }, {
    key: "_boundaryScore",
    value: function _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {
      var originalScore = this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0;
      var modifiedScore = this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0;
      return originalScore + modifiedScore;
    }
    /**
     * Concatenates the two input DiffChange lists and returns the resulting
     * list.
     * @param The left changes
     * @param The right changes
     * @returns The concatenated list
     */
  }, {
    key: "ConcatenateChanges",
    value: function ConcatenateChanges(left, right) {
      var mergedChangeArr = [];
      if (left.length === 0 || right.length === 0) {
        return right.length > 0 ? right : left;
      } else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {
        // Since we break the problem down recursively, it is possible that we
        // might recurse in the middle of a change thereby splitting it into
        // two changes. Here in the combining stage, we detect and fuse those
        // changes back together
        var result = new Array(left.length + right.length - 1);
        MyArray.Copy(left, 0, result, 0, left.length - 1);
        result[left.length - 1] = mergedChangeArr[0];
        MyArray.Copy(right, 1, result, left.length, right.length - 1);
        return result;
      } else {
        var _result = new Array(left.length + right.length);
        MyArray.Copy(left, 0, _result, 0, left.length);
        MyArray.Copy(right, 0, _result, left.length, right.length);
        return _result;
      }
    }
    /**
     * Returns true if the two changes overlap and can be merged into a single
     * change
     * @param left The left change
     * @param right The right change
     * @param mergedChange The merged change if the two overlap, null otherwise
     * @returns True if the two changes overlap
     */
  }, {
    key: "ChangesOverlap",
    value: function ChangesOverlap(left, right, mergedChangeArr) {
      Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');
      Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');
      if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
        var originalStart = left.originalStart;
        var originalLength = left.originalLength;
        var modifiedStart = left.modifiedStart;
        var modifiedLength = left.modifiedLength;
        if (left.originalStart + left.originalLength >= right.originalStart) {
          originalLength = right.originalStart + right.originalLength - left.originalStart;
        }
        if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
          modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;
        }
        mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);
        return true;
      } else {
        mergedChangeArr[0] = null;
        return false;
      }
    }
    /**
     * Helper method used to clip a diagonal index to the range of valid
     * diagonals. This also decides whether or not the diagonal index,
     * if it exceeds the boundary, should be clipped to the boundary or clipped
     * one inside the boundary depending on the Even/Odd status of the boundary
     * and numDifferences.
     * @param diagonal The index of the diagonal to clip.
     * @param numDifferences The current number of differences being iterated upon.
     * @param diagonalBaseIndex The base reference diagonal.
     * @param numDiagonals The total number of diagonals.
     * @returns The clipped diagonal index.
     */
  }, {
    key: "ClipDiagonalBound",
    value: function ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {
      if (diagonal >= 0 && diagonal < numDiagonals) {
        // Nothing to clip, its in range
        return diagonal;
      }
      // diagonalsBelow: The number of diagonals below the reference diagonal
      // diagonalsAbove: The number of diagonals above the reference diagonal
      var diagonalsBelow = diagonalBaseIndex;
      var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
      var diffEven = numDifferences % 2 === 0;
      if (diagonal < 0) {
        var lowerBoundEven = diagonalsBelow % 2 === 0;
        return diffEven === lowerBoundEven ? 0 : 1;
      } else {
        var upperBoundEven = diagonalsAbove % 2 === 0;
        return diffEven === upperBoundEven ? numDiagonals - 1 : numDiagonals - 2;
      }
    }
  }], [{
    key: "_isStringArray",
    value: function _isStringArray(arr) {
      return arr.length > 0 && typeof arr[0] === 'string';
    }
  }, {
    key: "_getElements",
    value: function _getElements(sequence) {
      var elements = sequence.getElements();
      if (LcsDiff._isStringArray(elements)) {
        var hashes = new Int32Array(elements.length);
        for (var i = 0, len = elements.length; i < len; i++) {
          hashes[i] = stringHash(elements[i], 0);
        }
        return [elements, hashes, true];
      }
      if (elements instanceof Int32Array) {
        return [[], elements, false];
      }
      return [[], new Int32Array(elements), false];
    }
  }, {
    key: "_getStrictElement",
    value: function _getStrictElement(sequence, index) {
      if (typeof sequence.getStrictElement === 'function') {
        return sequence.getStrictElement(index);
      }
      return null;
    }
  }]);
  return LcsDiff;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/process.js
/* provided dependency */ var process_process = __webpack_require__(/*! ./node_modules/process/browser.js */ 89);
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var safeProcess;
// Native sandbox environment
if (typeof platform_globals.vscode !== 'undefined' && typeof platform_globals.vscode.process !== 'undefined') {
  var sandboxProcess = platform_globals.vscode.process;
  safeProcess = {
    get platform() {
      return sandboxProcess.platform;
    },
    get arch() {
      return sandboxProcess.arch;
    },
    get env() {
      return sandboxProcess.env;
    },
    cwd: function cwd() {
      return sandboxProcess.cwd();
    },
    nextTick: function nextTick(callback) {
      return setImmediate(callback);
    }
  };
}
// Native node.js environment
else if (typeof process_process !== 'undefined') {
  safeProcess = {
    get platform() {
      return process_process.platform;
    },
    get arch() {
      return process_process.arch;
    },
    get env() {
      return ({"NODE_ENV":"production","PUBLIC_PATH":"https://www-cdn.educoder.net/"});
    },
    cwd: function cwd() {
      return ({"NODE_ENV":"production","PUBLIC_PATH":"https://www-cdn.educoder.net/"})['VSCODE_CWD'] || process_process.cwd();
    },
    nextTick: function nextTick(callback) {
      return process_process.nextTick(callback);
    }
  };
}
// Web environment
else {
  safeProcess = {
    // Supported
    get platform() {
      return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux';
    },
    get arch() {
      return undefined; /* arch is undefined in web */
    },
    nextTick: function nextTick(callback) {
      return setImmediate(callback);
    },
    // Unsupported
    get env() {
      return {};
    },
    cwd: function cwd() {
      return '/';
    }
  };
}
/**
 * Provides safe access to the `cwd` property in node.js, sandboxed or web
 * environments.
 *
 * Note: in web, this property is hardcoded to be `/`.
 */
var cwd = safeProcess.cwd;
/**
 * Provides safe access to the `env` property in node.js, sandboxed or web
 * environments.
 *
 * Note: in web, this property is hardcoded to be `{}`.
 */
var env = safeProcess.env;
/**
 * Provides safe access to the `platform` property in node.js, sandboxed or web
 * environments.
 */
var platform = safeProcess.platform;
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/path.js






/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace
// Copied from: https://github.com/nodejs/node/blob/v14.16.0/lib/path.js
/**
 * Copyright Joyent, Inc. and other Node contributors.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit
 * persons to whom the Software is furnished to do so, subject to the
 * following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

var CHAR_UPPERCASE_A = 65; /* A */
var CHAR_LOWERCASE_A = 97; /* a */
var CHAR_UPPERCASE_Z = 90; /* Z */
var CHAR_LOWERCASE_Z = 122; /* z */
var CHAR_DOT = 46; /* . */
var CHAR_FORWARD_SLASH = 47; /* / */
var CHAR_BACKWARD_SLASH = 92; /* \ */
var CHAR_COLON = 58; /* : */
var CHAR_QUESTION_MARK = 63; /* ? */
var ErrorInvalidArgType = /*#__PURE__*/function (_Error) {
  inherits_default()(ErrorInvalidArgType, _Error);
  var _super = createSuper_default()(ErrorInvalidArgType);
  function ErrorInvalidArgType(name, expected, actual) {
    var _this;
    classCallCheck_default()(this, ErrorInvalidArgType);
    // determiner: 'must be' or 'must not be'
    var determiner;
    if (typeof expected === 'string' && expected.indexOf('not ') === 0) {
      determiner = 'must not be';
      expected = expected.replace(/^not /, '');
    } else {
      determiner = 'must be';
    }
    var type = name.indexOf('.') !== -1 ? 'property' : 'argument';
    var msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " of type ").concat(expected);
    msg += ". Received type ".concat(typeof_default()(actual));
    _this = _super.call(this, msg);
    _this.code = 'ERR_INVALID_ARG_TYPE';
    return _this;
  }
  return createClass_default()(ErrorInvalidArgType);
}( /*#__PURE__*/wrapNativeSuper_default()(Error));
function validateString(value, name) {
  if (typeof value !== 'string') {
    throw new ErrorInvalidArgType(name, 'string', value);
  }
}
function isPathSeparator(code) {
  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
}
function isPosixPathSeparator(code) {
  return code === CHAR_FORWARD_SLASH;
}
function isWindowsDeviceRoot(code) {
  return code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z || code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z;
}
// Resolves . and .. elements in a path with directory names
function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
  var res = '';
  var lastSegmentLength = 0;
  var lastSlash = -1;
  var dots = 0;
  var code = 0;
  for (var i = 0; i <= path.length; ++i) {
    if (i < path.length) {
      code = path.charCodeAt(i);
    } else if (isPathSeparator(code)) {
      break;
    } else {
      code = CHAR_FORWARD_SLASH;
    }
    if (isPathSeparator(code)) {
      if (lastSlash === i - 1 || dots === 1) {
        // NOOP
      } else if (dots === 2) {
        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
          if (res.length > 2) {
            var lastSlashIndex = res.lastIndexOf(separator);
            if (lastSlashIndex === -1) {
              res = '';
              lastSegmentLength = 0;
            } else {
              res = res.slice(0, lastSlashIndex);
              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
            }
            lastSlash = i;
            dots = 0;
            continue;
          } else if (res.length !== 0) {
            res = '';
            lastSegmentLength = 0;
            lastSlash = i;
            dots = 0;
            continue;
          }
        }
        if (allowAboveRoot) {
          res += res.length > 0 ? "".concat(separator, "..") : '..';
          lastSegmentLength = 2;
        }
      } else {
        if (res.length > 0) {
          res += "".concat(separator).concat(path.slice(lastSlash + 1, i));
        } else {
          res = path.slice(lastSlash + 1, i);
        }
        lastSegmentLength = i - lastSlash - 1;
      }
      lastSlash = i;
      dots = 0;
    } else if (code === CHAR_DOT && dots !== -1) {
      ++dots;
    } else {
      dots = -1;
    }
  }
  return res;
}
function _format(sep, pathObject) {
  if (pathObject === null || typeof_default()(pathObject) !== 'object') {
    throw new ErrorInvalidArgType('pathObject', 'Object', pathObject);
  }
  var dir = pathObject.dir || pathObject.root;
  var base = pathObject.base || "".concat(pathObject.name || '').concat(pathObject.ext || '');
  if (!dir) {
    return base;
  }
  return dir === pathObject.root ? "".concat(dir).concat(base) : "".concat(dir).concat(sep).concat(base);
}
var win32 = {
  // path.resolve([from ...], to)
  resolve: function resolve() {
    var resolvedDevice = '';
    var resolvedTail = '';
    var resolvedAbsolute = false;
    for (var i = arguments.length - 1; i >= -1; i--) {
      var path = void 0;
      if (i >= 0) {
        path = i < 0 || arguments.length <= i ? undefined : arguments[i];
        validateString(path, 'path');
        // Skip empty entries
        if (path.length === 0) {
          continue;
        }
      } else if (resolvedDevice.length === 0) {
        path = cwd();
      } else {
        // Windows has the concept of drive-specific current working
        // directories. If we've resolved a drive letter but not yet an
        // absolute path, get cwd for that drive, or the process cwd if
        // the drive cwd is not available. We're sure the device is not
        // a UNC path at this points, because UNC paths are always absolute.
        path = ({"NODE_ENV":"production","PUBLIC_PATH":"https://www-cdn.educoder.net/"})["=".concat(resolvedDevice)] || cwd();
        // Verify that a cwd was found and that it actually points
        // to our drive. If not, default to the drive's root.
        if (path === undefined || path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
          path = "".concat(resolvedDevice, "\\");
        }
      }
      var len = path.length;
      var rootEnd = 0;
      var device = '';
      var isAbsolute = false;
      var code = path.charCodeAt(0);
      // Try to match a root
      if (len === 1) {
        if (isPathSeparator(code)) {
          // `path` contains just a path separator
          rootEnd = 1;
          isAbsolute = true;
        }
      } else if (isPathSeparator(code)) {
        // Possible UNC root
        // If we started with a separator, we know we at least have an
        // absolute path of some kind (UNC or otherwise)
        isAbsolute = true;
        if (isPathSeparator(path.charCodeAt(1))) {
          // Matched double path separator at beginning
          var j = 2;
          var last = j;
          // Match 1 or more non-path separators
          while (j < len && !isPathSeparator(path.charCodeAt(j))) {
            j++;
          }
          if (j < len && j !== last) {
            var firstPart = path.slice(last, j);
            // Matched!
            last = j;
            // Match 1 or more path separators
            while (j < len && isPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j < len && j !== last) {
              // Matched!
              last = j;
              // Match 1 or more non-path separators
              while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                j++;
              }
              if (j === len || j !== last) {
                // We matched a UNC root
                device = "\\\\".concat(firstPart, "\\").concat(path.slice(last, j));
                rootEnd = j;
              }
            }
          }
        } else {
          rootEnd = 1;
        }
      } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
        // Possible device root
        device = path.slice(0, 2);
        rootEnd = 2;
        if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
          // Treat separator following drive name as an absolute path
          // indicator
          isAbsolute = true;
          rootEnd = 3;
        }
      }
      if (device.length > 0) {
        if (resolvedDevice.length > 0) {
          if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
            // This path points to another device so it is not applicable
            continue;
          }
        } else {
          resolvedDevice = device;
        }
      }
      if (resolvedAbsolute) {
        if (resolvedDevice.length > 0) {
          break;
        }
      } else {
        resolvedTail = "".concat(path.slice(rootEnd), "\\").concat(resolvedTail);
        resolvedAbsolute = isAbsolute;
        if (isAbsolute && resolvedDevice.length > 0) {
          break;
        }
      }
    }
    // At this point the path should be resolved to a full absolute path,
    // but handle relative paths to be safe (might happen when process.cwd()
    // fails)
    // Normalize the tail path
    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparator);
    return resolvedAbsolute ? "".concat(resolvedDevice, "\\").concat(resolvedTail) : "".concat(resolvedDevice).concat(resolvedTail) || '.';
  },
  normalize: function normalize(path) {
    validateString(path, 'path');
    var len = path.length;
    if (len === 0) {
      return '.';
    }
    var rootEnd = 0;
    var device;
    var isAbsolute = false;
    var code = path.charCodeAt(0);
    // Try to match a root
    if (len === 1) {
      // `path` contains just a single char, exit early to avoid
      // unnecessary work
      return isPosixPathSeparator(code) ? '\\' : path;
    }
    if (isPathSeparator(code)) {
      // Possible UNC root
      // If we started with a separator, we know we at least have an absolute
      // path of some kind (UNC or otherwise)
      isAbsolute = true;
      if (isPathSeparator(path.charCodeAt(1))) {
        // Matched double path separator at beginning
        var j = 2;
        var last = j;
        // Match 1 or more non-path separators
        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
          j++;
        }
        if (j < len && j !== last) {
          var firstPart = path.slice(last, j);
          // Matched!
          last = j;
          // Match 1 or more path separators
          while (j < len && isPathSeparator(path.charCodeAt(j))) {
            j++;
          }
          if (j < len && j !== last) {
            // Matched!
            last = j;
            // Match 1 or more non-path separators
            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j === len) {
              // We matched a UNC root only
              // Return the normalized version of the UNC root since there
              // is nothing left to process
              return "\\\\".concat(firstPart, "\\").concat(path.slice(last), "\\");
            }
            if (j !== last) {
              // We matched a UNC root with leftovers
              device = "\\\\".concat(firstPart, "\\").concat(path.slice(last, j));
              rootEnd = j;
            }
          }
        }
      } else {
        rootEnd = 1;
      }
    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
      // Possible device root
      device = path.slice(0, 2);
      rootEnd = 2;
      if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
        // Treat separator following drive name as an absolute path
        // indicator
        isAbsolute = true;
        rootEnd = 3;
      }
    }
    var tail = rootEnd < len ? normalizeString(path.slice(rootEnd), !isAbsolute, '\\', isPathSeparator) : '';
    if (tail.length === 0 && !isAbsolute) {
      tail = '.';
    }
    if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {
      tail += '\\';
    }
    if (device === undefined) {
      return isAbsolute ? "\\".concat(tail) : tail;
    }
    return isAbsolute ? "".concat(device, "\\").concat(tail) : "".concat(device).concat(tail);
  },
  isAbsolute: function isAbsolute(path) {
    validateString(path, 'path');
    var len = path.length;
    if (len === 0) {
      return false;
    }
    var code = path.charCodeAt(0);
    return isPathSeparator(code) ||
    // Possible device root
    len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isPathSeparator(path.charCodeAt(2));
  },
  join: function join() {
    if (arguments.length === 0) {
      return '.';
    }
    var joined;
    var firstPart;
    for (var i = 0; i < arguments.length; ++i) {
      var arg = i < 0 || arguments.length <= i ? undefined : arguments[i];
      validateString(arg, 'path');
      if (arg.length > 0) {
        if (joined === undefined) {
          joined = firstPart = arg;
        } else {
          joined += "\\".concat(arg);
        }
      }
    }
    if (joined === undefined) {
      return '.';
    }
    // Make sure that the joined path doesn't start with two slashes, because
    // normalize() will mistake it for a UNC path then.
    //
    // This step is skipped when it is very clear that the user actually
    // intended to point at a UNC path. This is assumed when the first
    // non-empty string arguments starts with exactly two slashes followed by
    // at least one more non-slash character.
    //
    // Note that for normalize() to treat a path as a UNC path it needs to
    // have at least 2 components, so we don't filter for that here.
    // This means that the user can use join to construct UNC paths from
    // a server name and a share name; for example:
    //   path.join('//server', 'share') -> '\\\\server\\share\\')
    var needsReplace = true;
    var slashCount = 0;
    if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) {
      ++slashCount;
      var firstLen = firstPart.length;
      if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {
        ++slashCount;
        if (firstLen > 2) {
          if (isPathSeparator(firstPart.charCodeAt(2))) {
            ++slashCount;
          } else {
            // We matched a UNC path in the first part
            needsReplace = false;
          }
        }
      }
    }
    if (needsReplace) {
      // Find any more consecutive slashes we need to replace
      while (slashCount < joined.length && isPathSeparator(joined.charCodeAt(slashCount))) {
        slashCount++;
      }
      // Replace the slashes if needed
      if (slashCount >= 2) {
        joined = "\\".concat(joined.slice(slashCount));
      }
    }
    return win32.normalize(joined);
  },
  // It will solve the relative path from `from` to `to`, for instance:
  //  from = 'C:\\orandea\\test\\aaa'
  //  to = 'C:\\orandea\\impl\\bbb'
  // The output of the function should be: '..\\..\\impl\\bbb'
  relative: function relative(from, to) {
    validateString(from, 'from');
    validateString(to, 'to');
    if (from === to) {
      return '';
    }
    var fromOrig = win32.resolve(from);
    var toOrig = win32.resolve(to);
    if (fromOrig === toOrig) {
      return '';
    }
    from = fromOrig.toLowerCase();
    to = toOrig.toLowerCase();
    if (from === to) {
      return '';
    }
    // Trim any leading backslashes
    var fromStart = 0;
    while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
      fromStart++;
    }
    // Trim trailing backslashes (applicable to UNC paths only)
    var fromEnd = from.length;
    while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
      fromEnd--;
    }
    var fromLen = fromEnd - fromStart;
    // Trim any leading backslashes
    var toStart = 0;
    while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
      toStart++;
    }
    // Trim trailing backslashes (applicable to UNC paths only)
    var toEnd = to.length;
    while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
      toEnd--;
    }
    var toLen = toEnd - toStart;
    // Compare paths to find the longest common path from root
    var length = fromLen < toLen ? fromLen : toLen;
    var lastCommonSep = -1;
    var i = 0;
    for (; i < length; i++) {
      var fromCode = from.charCodeAt(fromStart + i);
      if (fromCode !== to.charCodeAt(toStart + i)) {
        break;
      } else if (fromCode === CHAR_BACKWARD_SLASH) {
        lastCommonSep = i;
      }
    }
    // We found a mismatch before the first common path separator was seen, so
    // return the original `to`.
    if (i !== length) {
      if (lastCommonSep === -1) {
        return toOrig;
      }
    } else {
      if (toLen > length) {
        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
          // We get here if `from` is the exact base path for `to`.
          // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
          return toOrig.slice(toStart + i + 1);
        }
        if (i === 2) {
          // We get here if `from` is the device root.
          // For example: from='C:\\'; to='C:\\foo'
          return toOrig.slice(toStart + i);
        }
      }
      if (fromLen > length) {
        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
          // We get here if `to` is the exact base path for `from`.
          // For example: from='C:\\foo\\bar'; to='C:\\foo'
          lastCommonSep = i;
        } else if (i === 2) {
          // We get here if `to` is the device root.
          // For example: from='C:\\foo\\bar'; to='C:\\'
          lastCommonSep = 3;
        }
      }
      if (lastCommonSep === -1) {
        lastCommonSep = 0;
      }
    }
    var out = '';
    // Generate the relative path based on the path difference between `to` and
    // `from`
    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
      if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
        out += out.length === 0 ? '..' : '\\..';
      }
    }
    toStart += lastCommonSep;
    // Lastly, append the rest of the destination (`to`) path that comes after
    // the common path parts
    if (out.length > 0) {
      return "".concat(out).concat(toOrig.slice(toStart, toEnd));
    }
    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
      ++toStart;
    }
    return toOrig.slice(toStart, toEnd);
  },
  toNamespacedPath: function toNamespacedPath(path) {
    // Note: this will *probably* throw somewhere.
    if (typeof path !== 'string') {
      return path;
    }
    if (path.length === 0) {
      return '';
    }
    var resolvedPath = win32.resolve(path);
    if (resolvedPath.length <= 2) {
      return path;
    }
    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
      // Possible UNC root
      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
        var code = resolvedPath.charCodeAt(2);
        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
          // Matched non-long UNC root, convert the path to a long UNC path
          return "\\\\?\\UNC\\".concat(resolvedPath.slice(2));
        }
      }
    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
      // Matched device root, convert the path to a long UNC path
      return "\\\\?\\".concat(resolvedPath);
    }
    return path;
  },
  dirname: function dirname(path) {
    validateString(path, 'path');
    var len = path.length;
    if (len === 0) {
      return '.';
    }
    var rootEnd = -1;
    var offset = 0;
    var code = path.charCodeAt(0);
    if (len === 1) {
      // `path` contains just a path separator, exit early to avoid
      // unnecessary work or a dot.
      return isPathSeparator(code) ? path : '.';
    }
    // Try to match a root
    if (isPathSeparator(code)) {
      // Possible UNC root
      rootEnd = offset = 1;
      if (isPathSeparator(path.charCodeAt(1))) {
        // Matched double path separator at beginning
        var j = 2;
        var last = j;
        // Match 1 or more non-path separators
        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
          j++;
        }
        if (j < len && j !== last) {
          // Matched!
          last = j;
          // Match 1 or more path separators
          while (j < len && isPathSeparator(path.charCodeAt(j))) {
            j++;
          }
          if (j < len && j !== last) {
            // Matched!
            last = j;
            // Match 1 or more non-path separators
            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j === len) {
              // We matched a UNC root only
              return path;
            }
            if (j !== last) {
              // We matched a UNC root with leftovers
              // Offset by 1 to include the separator after the UNC root to
              // treat it as a "normal root" on top of a (UNC) root
              rootEnd = offset = j + 1;
            }
          }
        }
      }
      // Possible device root
    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
      rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;
      offset = rootEnd;
    }
    var end = -1;
    var matchedSlash = true;
    for (var i = len - 1; i >= offset; --i) {
      if (isPathSeparator(path.charCodeAt(i))) {
        if (!matchedSlash) {
          end = i;
          break;
        }
      } else {
        // We saw the first non-path separator
        matchedSlash = false;
      }
    }
    if (end === -1) {
      if (rootEnd === -1) {
        return '.';
      }
      end = rootEnd;
    }
    return path.slice(0, end);
  },
  basename: function basename(path, ext) {
    if (ext !== undefined) {
      validateString(ext, 'ext');
    }
    validateString(path, 'path');
    var start = 0;
    var end = -1;
    var matchedSlash = true;
    var i;
    // Check for a drive letter prefix so as not to mistake the following
    // path separator as an extra separator at the end of the path that can be
    // disregarded
    if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) {
      start = 2;
    }
    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
      if (ext === path) {
        return '';
      }
      var extIdx = ext.length - 1;
      var firstNonSlashEnd = -1;
      for (i = path.length - 1; i >= start; --i) {
        var code = path.charCodeAt(i);
        if (isPathSeparator(code)) {
          // If we reached a path separator that was not part of a set of path
          // separators at the end of the string, stop now
          if (!matchedSlash) {
            start = i + 1;
            break;
          }
        } else {
          if (firstNonSlashEnd === -1) {
            // We saw the first non-path separator, remember this index in case
            // we need it if the extension ends up not matching
            matchedSlash = false;
            firstNonSlashEnd = i + 1;
          }
          if (extIdx >= 0) {
            // Try to match the explicit extension
            if (code === ext.charCodeAt(extIdx)) {
              if (--extIdx === -1) {
                // We matched the extension, so mark this as the end of our path
                // component
                end = i;
              }
            } else {
              // Extension does not match, so our result is the entire path
              // component
              extIdx = -1;
              end = firstNonSlashEnd;
            }
          }
        }
      }
      if (start === end) {
        end = firstNonSlashEnd;
      } else if (end === -1) {
        end = path.length;
      }
      return path.slice(start, end);
    }
    for (i = path.length - 1; i >= start; --i) {
      if (isPathSeparator(path.charCodeAt(i))) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          start = i + 1;
          break;
        }
      } else if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // path component
        matchedSlash = false;
        end = i + 1;
      }
    }
    if (end === -1) {
      return '';
    }
    return path.slice(start, end);
  },
  extname: function extname(path) {
    validateString(path, 'path');
    var start = 0;
    var startDot = -1;
    var startPart = 0;
    var end = -1;
    var matchedSlash = true;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    var preDotState = 0;
    // Check for a drive letter prefix so as not to mistake the following
    // path separator as an extra separator at the end of the path that can be
    // disregarded
    if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) {
      start = startPart = 2;
    }
    for (var i = path.length - 1; i >= start; --i) {
      var code = path.charCodeAt(i);
      if (isPathSeparator(code)) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          startPart = i + 1;
          break;
        }
        continue;
      }
      if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // extension
        matchedSlash = false;
        end = i + 1;
      }
      if (code === CHAR_DOT) {
        // If this is our first dot, mark it as the start of our extension
        if (startDot === -1) {
          startDot = i;
        } else if (preDotState !== 1) {
          preDotState = 1;
        }
      } else if (startDot !== -1) {
        // We saw a non-dot and non-path separator before our dot, so we should
        // have a good chance at having a non-empty extension
        preDotState = -1;
      }
    }
    if (startDot === -1 || end === -1 ||
    // We saw a non-dot character immediately before the dot
    preDotState === 0 ||
    // The (right-most) trimmed path component is exactly '..'
    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
      return '';
    }
    return path.slice(startDot, end);
  },
  format: _format.bind(null, '\\'),
  parse: function parse(path) {
    validateString(path, 'path');
    var ret = {
      root: '',
      dir: '',
      base: '',
      ext: '',
      name: ''
    };
    if (path.length === 0) {
      return ret;
    }
    var len = path.length;
    var rootEnd = 0;
    var code = path.charCodeAt(0);
    if (len === 1) {
      if (isPathSeparator(code)) {
        // `path` contains just a path separator, exit early to avoid
        // unnecessary work
        ret.root = ret.dir = path;
        return ret;
      }
      ret.base = ret.name = path;
      return ret;
    }
    // Try to match a root
    if (isPathSeparator(code)) {
      // Possible UNC root
      rootEnd = 1;
      if (isPathSeparator(path.charCodeAt(1))) {
        // Matched double path separator at beginning
        var j = 2;
        var last = j;
        // Match 1 or more non-path separators
        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
          j++;
        }
        if (j < len && j !== last) {
          // Matched!
          last = j;
          // Match 1 or more path separators
          while (j < len && isPathSeparator(path.charCodeAt(j))) {
            j++;
          }
          if (j < len && j !== last) {
            // Matched!
            last = j;
            // Match 1 or more non-path separators
            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j === len) {
              // We matched a UNC root only
              rootEnd = j;
            } else if (j !== last) {
              // We matched a UNC root with leftovers
              rootEnd = j + 1;
            }
          }
        }
      }
    } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
      // Possible device root
      if (len <= 2) {
        // `path` contains just a drive root, exit early to avoid
        // unnecessary work
        ret.root = ret.dir = path;
        return ret;
      }
      rootEnd = 2;
      if (isPathSeparator(path.charCodeAt(2))) {
        if (len === 3) {
          // `path` contains just a drive root, exit early to avoid
          // unnecessary work
          ret.root = ret.dir = path;
          return ret;
        }
        rootEnd = 3;
      }
    }
    if (rootEnd > 0) {
      ret.root = path.slice(0, rootEnd);
    }
    var startDot = -1;
    var startPart = rootEnd;
    var end = -1;
    var matchedSlash = true;
    var i = path.length - 1;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    var preDotState = 0;
    // Get non-dir info
    for (; i >= rootEnd; --i) {
      code = path.charCodeAt(i);
      if (isPathSeparator(code)) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          startPart = i + 1;
          break;
        }
        continue;
      }
      if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // extension
        matchedSlash = false;
        end = i + 1;
      }
      if (code === CHAR_DOT) {
        // If this is our first dot, mark it as the start of our extension
        if (startDot === -1) {
          startDot = i;
        } else if (preDotState !== 1) {
          preDotState = 1;
        }
      } else if (startDot !== -1) {
        // We saw a non-dot and non-path separator before our dot, so we should
        // have a good chance at having a non-empty extension
        preDotState = -1;
      }
    }
    if (end !== -1) {
      if (startDot === -1 ||
      // We saw a non-dot character immediately before the dot
      preDotState === 0 ||
      // The (right-most) trimmed path component is exactly '..'
      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
        ret.base = ret.name = path.slice(startPart, end);
      } else {
        ret.name = path.slice(startPart, startDot);
        ret.base = path.slice(startPart, end);
        ret.ext = path.slice(startDot, end);
      }
    }
    // If the directory is the root, use the entire root as the `dir` including
    // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
    // trailing slash (`C:\abc\def` -> `C:\abc`).
    if (startPart > 0 && startPart !== rootEnd) {
      ret.dir = path.slice(0, startPart - 1);
    } else {
      ret.dir = ret.root;
    }
    return ret;
  },
  sep: '\\',
  delimiter: ';',
  win32: null,
  posix: null
};
var posix = {
  // path.resolve([from ...], to)
  resolve: function resolve() {
    var resolvedPath = '';
    var resolvedAbsolute = false;
    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
      var path = i >= 0 ? i < 0 || arguments.length <= i ? undefined : arguments[i] : cwd();
      validateString(path, 'path');
      // Skip empty entries
      if (path.length === 0) {
        continue;
      }
      resolvedPath = "".concat(path, "/").concat(resolvedPath);
      resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    }
    // At this point the path should be resolved to a full absolute path, but
    // handle relative paths to be safe (might happen when process.cwd() fails)
    // Normalize the path
    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);
    if (resolvedAbsolute) {
      return "/".concat(resolvedPath);
    }
    return resolvedPath.length > 0 ? resolvedPath : '.';
  },
  normalize: function normalize(path) {
    validateString(path, 'path');
    if (path.length === 0) {
      return '.';
    }
    var isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    var trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
    // Normalize the path
    path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);
    if (path.length === 0) {
      if (isAbsolute) {
        return '/';
      }
      return trailingSeparator ? './' : '.';
    }
    if (trailingSeparator) {
      path += '/';
    }
    return isAbsolute ? "/".concat(path) : path;
  },
  isAbsolute: function isAbsolute(path) {
    validateString(path, 'path');
    return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
  },
  join: function join() {
    if (arguments.length === 0) {
      return '.';
    }
    var joined;
    for (var i = 0; i < arguments.length; ++i) {
      var arg = i < 0 || arguments.length <= i ? undefined : arguments[i];
      validateString(arg, 'path');
      if (arg.length > 0) {
        if (joined === undefined) {
          joined = arg;
        } else {
          joined += "/".concat(arg);
        }
      }
    }
    if (joined === undefined) {
      return '.';
    }
    return posix.normalize(joined);
  },
  relative: function relative(from, to) {
    validateString(from, 'from');
    validateString(to, 'to');
    if (from === to) {
      return '';
    }
    // Trim leading forward slashes.
    from = posix.resolve(from);
    to = posix.resolve(to);
    if (from === to) {
      return '';
    }
    var fromStart = 1;
    var fromEnd = from.length;
    var fromLen = fromEnd - fromStart;
    var toStart = 1;
    var toLen = to.length - toStart;
    // Compare paths to find the longest common path from root
    var length = fromLen < toLen ? fromLen : toLen;
    var lastCommonSep = -1;
    var i = 0;
    for (; i < length; i++) {
      var fromCode = from.charCodeAt(fromStart + i);
      if (fromCode !== to.charCodeAt(toStart + i)) {
        break;
      } else if (fromCode === CHAR_FORWARD_SLASH) {
        lastCommonSep = i;
      }
    }
    if (i === length) {
      if (toLen > length) {
        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
          // We get here if `from` is the exact base path for `to`.
          // For example: from='/foo/bar'; to='/foo/bar/baz'
          return to.slice(toStart + i + 1);
        }
        if (i === 0) {
          // We get here if `from` is the root
          // For example: from='/'; to='/foo'
          return to.slice(toStart + i);
        }
      } else if (fromLen > length) {
        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
          // We get here if `to` is the exact base path for `from`.
          // For example: from='/foo/bar/baz'; to='/foo/bar'
          lastCommonSep = i;
        } else if (i === 0) {
          // We get here if `to` is the root.
          // For example: from='/foo/bar'; to='/'
          lastCommonSep = 0;
        }
      }
    }
    var out = '';
    // Generate the relative path based on the path difference between `to`
    // and `from`.
    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
      if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
        out += out.length === 0 ? '..' : '/..';
      }
    }
    // Lastly, append the rest of the destination (`to`) path that comes after
    // the common path parts.
    return "".concat(out).concat(to.slice(toStart + lastCommonSep));
  },
  toNamespacedPath: function toNamespacedPath(path) {
    // Non-op on posix systems
    return path;
  },
  dirname: function dirname(path) {
    validateString(path, 'path');
    if (path.length === 0) {
      return '.';
    }
    var hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    var end = -1;
    var matchedSlash = true;
    for (var i = path.length - 1; i >= 1; --i) {
      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
        if (!matchedSlash) {
          end = i;
          break;
        }
      } else {
        // We saw the first non-path separator
        matchedSlash = false;
      }
    }
    if (end === -1) {
      return hasRoot ? '/' : '.';
    }
    if (hasRoot && end === 1) {
      return '//';
    }
    return path.slice(0, end);
  },
  basename: function basename(path, ext) {
    if (ext !== undefined) {
      validateString(ext, 'ext');
    }
    validateString(path, 'path');
    var start = 0;
    var end = -1;
    var matchedSlash = true;
    var i;
    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
      if (ext === path) {
        return '';
      }
      var extIdx = ext.length - 1;
      var firstNonSlashEnd = -1;
      for (i = path.length - 1; i >= 0; --i) {
        var code = path.charCodeAt(i);
        if (code === CHAR_FORWARD_SLASH) {
          // If we reached a path separator that was not part of a set of path
          // separators at the end of the string, stop now
          if (!matchedSlash) {
            start = i + 1;
            break;
          }
        } else {
          if (firstNonSlashEnd === -1) {
            // We saw the first non-path separator, remember this index in case
            // we need it if the extension ends up not matching
            matchedSlash = false;
            firstNonSlashEnd = i + 1;
          }
          if (extIdx >= 0) {
            // Try to match the explicit extension
            if (code === ext.charCodeAt(extIdx)) {
              if (--extIdx === -1) {
                // We matched the extension, so mark this as the end of our path
                // component
                end = i;
              }
            } else {
              // Extension does not match, so our result is the entire path
              // component
              extIdx = -1;
              end = firstNonSlashEnd;
            }
          }
        }
      }
      if (start === end) {
        end = firstNonSlashEnd;
      } else if (end === -1) {
        end = path.length;
      }
      return path.slice(start, end);
    }
    for (i = path.length - 1; i >= 0; --i) {
      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          start = i + 1;
          break;
        }
      } else if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // path component
        matchedSlash = false;
        end = i + 1;
      }
    }
    if (end === -1) {
      return '';
    }
    return path.slice(start, end);
  },
  extname: function extname(path) {
    validateString(path, 'path');
    var startDot = -1;
    var startPart = 0;
    var end = -1;
    var matchedSlash = true;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    var preDotState = 0;
    for (var i = path.length - 1; i >= 0; --i) {
      var code = path.charCodeAt(i);
      if (code === CHAR_FORWARD_SLASH) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          startPart = i + 1;
          break;
        }
        continue;
      }
      if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // extension
        matchedSlash = false;
        end = i + 1;
      }
      if (code === CHAR_DOT) {
        // If this is our first dot, mark it as the start of our extension
        if (startDot === -1) {
          startDot = i;
        } else if (preDotState !== 1) {
          preDotState = 1;
        }
      } else if (startDot !== -1) {
        // We saw a non-dot and non-path separator before our dot, so we should
        // have a good chance at having a non-empty extension
        preDotState = -1;
      }
    }
    if (startDot === -1 || end === -1 ||
    // We saw a non-dot character immediately before the dot
    preDotState === 0 ||
    // The (right-most) trimmed path component is exactly '..'
    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
      return '';
    }
    return path.slice(startDot, end);
  },
  format: _format.bind(null, '/'),
  parse: function parse(path) {
    validateString(path, 'path');
    var ret = {
      root: '',
      dir: '',
      base: '',
      ext: '',
      name: ''
    };
    if (path.length === 0) {
      return ret;
    }
    var isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
    var start;
    if (isAbsolute) {
      ret.root = '/';
      start = 1;
    } else {
      start = 0;
    }
    var startDot = -1;
    var startPart = 0;
    var end = -1;
    var matchedSlash = true;
    var i = path.length - 1;
    // Track the state of characters (if any) we see before our first dot and
    // after any path separator we find
    var preDotState = 0;
    // Get non-dir info
    for (; i >= start; --i) {
      var code = path.charCodeAt(i);
      if (code === CHAR_FORWARD_SLASH) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          startPart = i + 1;
          break;
        }
        continue;
      }
      if (end === -1) {
        // We saw the first non-path separator, mark this as the end of our
        // extension
        matchedSlash = false;
        end = i + 1;
      }
      if (code === CHAR_DOT) {
        // If this is our first dot, mark it as the start of our extension
        if (startDot === -1) {
          startDot = i;
        } else if (preDotState !== 1) {
          preDotState = 1;
        }
      } else if (startDot !== -1) {
        // We saw a non-dot and non-path separator before our dot, so we should
        // have a good chance at having a non-empty extension
        preDotState = -1;
      }
    }
    if (end !== -1) {
      var _start = startPart === 0 && isAbsolute ? 1 : startPart;
      if (startDot === -1 ||
      // We saw a non-dot character immediately before the dot
      preDotState === 0 ||
      // The (right-most) trimmed path component is exactly '..'
      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
        ret.base = ret.name = path.slice(_start, end);
      } else {
        ret.name = path.slice(_start, startDot);
        ret.base = path.slice(_start, end);
        ret.ext = path.slice(startDot, end);
      }
    }
    if (startPart > 0) {
      ret.dir = path.slice(0, startPart - 1);
    } else if (isAbsolute) {
      ret.dir = '/';
    }
    return ret;
  },
  sep: '/',
  delimiter: ':',
  win32: null,
  posix: null
};
posix.win32 = win32.win32 = win32;
posix.posix = win32.posix = posix;
var normalize = platform === 'win32' ? win32.normalize : posix.normalize;
var resolve = platform === 'win32' ? win32.resolve : posix.resolve;
var relative = platform === 'win32' ? win32.relative : posix.relative;
var dirname = platform === 'win32' ? win32.dirname : posix.dirname;
var basename = platform === 'win32' ? win32.basename : posix.basename;
var extname = platform === 'win32' ? win32.extname : posix.extname;
var sep = platform === 'win32' ? win32.sep : posix.sep;
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/uri.js






var _encodeTable;
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


var _schemePattern = /^\w[\w\d+.-]*$/;
var _singleSlashStart = /^\//;
var _doubleSlashStart = /^\/\//;
function _validateUri(ret, _strict) {
  // scheme, must be set
  if (!ret.scheme && _strict) {
    throw new Error("[UriError]: Scheme is missing: {scheme: \"\", authority: \"".concat(ret.authority, "\", path: \"").concat(ret.path, "\", query: \"").concat(ret.query, "\", fragment: \"").concat(ret.fragment, "\"}"));
  }
  // scheme, https://tools.ietf.org/html/rfc3986#section-3.1
  // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
  if (ret.scheme && !_schemePattern.test(ret.scheme)) {
    throw new Error('[UriError]: Scheme contains illegal characters.');
  }
  // path, http://tools.ietf.org/html/rfc3986#section-3.3
  // If a URI contains an authority component, then the path component
  // must either be empty or begin with a slash ("/") character.  If a URI
  // does not contain an authority component, then the path cannot begin
  // with two slash characters ("//").
  if (ret.path) {
    if (ret.authority) {
      if (!_singleSlashStart.test(ret.path)) {
        throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character');
      }
    } else {
      if (_doubleSlashStart.test(ret.path)) {
        throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
      }
    }
  }
}
// for a while we allowed uris *without* schemes and this is the migration
// for them, e.g. an uri without scheme and without strict-mode warns and falls
// back to the file-scheme. that should cause the least carnage and still be a
// clear warning
function _schemeFix(scheme, _strict) {
  if (!scheme && !_strict) {
    return 'file';
  }
  return scheme;
}
// implements a bit of https://tools.ietf.org/html/rfc3986#section-5
function _referenceResolution(scheme, path) {
  // the slash-character is our 'default base' as we don't
  // support constructing URIs relative to other URIs. This
  // also means that we alter and potentially break paths.
  // see https://tools.ietf.org/html/rfc3986#section-5.1.4
  switch (scheme) {
    case 'https':
    case 'http':
    case 'file':
      if (!path) {
        path = _slash;
      } else if (path[0] !== _slash) {
        path = _slash + path;
      }
      break;
  }
  return path;
}
var _empty = '';
var _slash = '/';
var _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
/**
 * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
 * This class is a simple parser which creates the basic component parts
 * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
 * and encoding.
 *
 * ```txt
 *       foo://example.com:8042/over/there?name=ferret#nose
 *       \_/   \______________/\_________/ \_________/ \__/
 *        |           |            |            |        |
 *     scheme     authority       path        query   fragment
 *        |   _____________________|__
 *       / \ /                        \
 *       urn:example:animal:ferret:nose
 * ```
 */
var URI = /*#__PURE__*/function () {
  /**
   * @internal
   */
  function URI(schemeOrData, authority, path, query, fragment) {
    var _strict = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
    classCallCheck_default()(this, URI);
    if (typeof_default()(schemeOrData) === 'object') {
      this.scheme = schemeOrData.scheme || _empty;
      this.authority = schemeOrData.authority || _empty;
      this.path = schemeOrData.path || _empty;
      this.query = schemeOrData.query || _empty;
      this.fragment = schemeOrData.fragment || _empty;
      // no validation because it's this URI
      // that creates uri components.
      // _validateUri(this);
    } else {
      this.scheme = _schemeFix(schemeOrData, _strict);
      this.authority = authority || _empty;
      this.path = _referenceResolution(this.scheme, path || _empty);
      this.query = query || _empty;
      this.fragment = fragment || _empty;
      _validateUri(this, _strict);
    }
  }
  createClass_default()(URI, [{
    key: "fsPath",
    get:
    // ---- filesystem path -----------------------
    /**
     * Returns a string representing the corresponding file system path of this URI.
     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
     * platform specific path separator.
     *
     * * Will *not* validate the path for invalid characters and semantics.
     * * Will *not* look at the scheme of this URI.
     * * The result shall *not* be used for display purposes but for accessing a file on disk.
     *
     *
     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
     *
     * ```ts
        const u = URI.parse('file://server/c$/folder/file.txt')
        u.authority === 'server'
        u.path === '/shares/c$/file.txt'
        u.fsPath === '\\server\c$\folder\file.txt'
    ```
     *
     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
     * with URIs that represent files on disk (`file` scheme).
     */
    function get() {
      // if (this.scheme !== 'file') {
      // 	console.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);
      // }
      return uriToFsPath(this, false);
    }
    // ---- modify to new -------------------------
  }, {
    key: "with",
    value: function _with(change) {
      if (!change) {
        return this;
      }
      var scheme = change.scheme,
        authority = change.authority,
        path = change.path,
        query = change.query,
        fragment = change.fragment;
      if (scheme === undefined) {
        scheme = this.scheme;
      } else if (scheme === null) {
        scheme = _empty;
      }
      if (authority === undefined) {
        authority = this.authority;
      } else if (authority === null) {
        authority = _empty;
      }
      if (path === undefined) {
        path = this.path;
      } else if (path === null) {
        path = _empty;
      }
      if (query === undefined) {
        query = this.query;
      } else if (query === null) {
        query = _empty;
      }
      if (fragment === undefined) {
        fragment = this.fragment;
      } else if (fragment === null) {
        fragment = _empty;
      }
      if (scheme === this.scheme && authority === this.authority && path === this.path && query === this.query && fragment === this.fragment) {
        return this;
      }
      return new Uri(scheme, authority, path, query, fragment);
    }
    // ---- parse & validate ------------------------
    /**
     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,
     * `file:///usr/home`, or `scheme:with/path`.
     *
     * @param value A string which represents an URI (see `URI#toString`).
     */
  }, {
    key: "toString",
    value:
    // ---- printing/externalize ---------------------------
    /**
     * Creates a string representation for this URI. It's guaranteed that calling
     * `URI.parse` with the result of this function creates an URI which is equal
     * to this URI.
     *
     * * The result shall *not* be used for display purposes but for externalization or transport.
     * * The result will be encoded using the percentage encoding and encoding happens mostly
     * ignore the scheme-specific encoding rules.
     *
     * @param skipEncoding Do not encode the result, default is `false`
     */
    function toString() {
      var skipEncoding = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      return _asFormatted(this, skipEncoding);
    }
  }, {
    key: "toJSON",
    value: function toJSON() {
      return this;
    }
  }], [{
    key: "isUri",
    value: function isUri(thing) {
      if (thing instanceof URI) {
        return true;
      }
      if (!thing) {
        return false;
      }
      return typeof thing.authority === 'string' && typeof thing.fragment === 'string' && typeof thing.path === 'string' && typeof thing.query === 'string' && typeof thing.scheme === 'string' && typeof thing.fsPath === 'string' && typeof thing["with"] === 'function' && typeof thing.toString === 'function';
    }
  }, {
    key: "parse",
    value: function parse(value) {
      var _strict = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var match = _regexp.exec(value);
      if (!match) {
        return new Uri(_empty, _empty, _empty, _empty, _empty);
      }
      return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);
    }
    /**
     * Creates a new URI from a file system path, e.g. `c:\my\files`,
     * `/usr/home`, or `\\server\share\some\path`.
     *
     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
     * `URI.parse('file://' + path)` because the path might contain characters that are
     * interpreted (# and ?). See the following sample:
     * ```ts
    const good = URI.file('/coding/c#/project1');
    good.scheme === 'file';
    good.path === '/coding/c#/project1';
    good.fragment === '';
    const bad = URI.parse('file://' + '/coding/c#/project1');
    bad.scheme === 'file';
    bad.path === '/coding/c'; // path is now broken
    bad.fragment === '/project1';
    ```
     *
     * @param path A file system path (see `URI#fsPath`)
     */
  }, {
    key: "file",
    value: function file(path) {
      var authority = _empty;
      // normalize to fwd-slashes on windows,
      // on other systems bwd-slashes are valid
      // filename character, eg /f\oo/ba\r.txt
      if (isWindows) {
        path = path.replace(/\\/g, _slash);
      }
      // check for authority as used in UNC shares
      // or use the path as given
      if (path[0] === _slash && path[1] === _slash) {
        var idx = path.indexOf(_slash, 2);
        if (idx === -1) {
          authority = path.substring(2);
          path = _slash;
        } else {
          authority = path.substring(2, idx);
          path = path.substring(idx) || _slash;
        }
      }
      return new Uri('file', authority, path, _empty, _empty);
    }
  }, {
    key: "from",
    value: function from(components) {
      var result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment);
      _validateUri(result, true);
      return result;
    }
    /**
     * Join a URI path with path fragments and normalizes the resulting path.
     *
     * @param uri The input URI.
     * @param pathFragment The path fragment to add to the URI path.
     * @returns The resulting URI.
     */
  }, {
    key: "joinPath",
    value: function joinPath(uri) {
      if (!uri.path) {
        throw new Error("[UriError]: cannot call joinPath on URI without path");
      }
      var newPath;
      for (var _len = arguments.length, pathFragment = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        pathFragment[_key - 1] = arguments[_key];
      }
      if (isWindows && uri.scheme === 'file') {
        var _paths$win;
        newPath = URI.file((_paths$win = win32).join.apply(_paths$win, [uriToFsPath(uri, true)].concat(pathFragment))).path;
      } else {
        var _paths$posix;
        newPath = (_paths$posix = posix).join.apply(_paths$posix, [uri.path].concat(pathFragment));
      }
      return uri["with"]({
        path: newPath
      });
    }
  }, {
    key: "revive",
    value: function revive(data) {
      if (!data) {
        return data;
      } else if (data instanceof URI) {
        return data;
      } else {
        var result = new Uri(data);
        result._formatted = data.external;
        result._fsPath = data._sep === _pathSepMarker ? data.fsPath : null;
        return result;
      }
    }
  }]);
  return URI;
}();
var _pathSepMarker = isWindows ? 1 : undefined;
// This class exists so that URI is compatible with vscode.Uri (API).
var Uri = /*#__PURE__*/function (_URI) {
  inherits_default()(Uri, _URI);
  var _super = createSuper_default()(Uri);
  function Uri() {
    var _this;
    classCallCheck_default()(this, Uri);
    _this = _super.apply(this, arguments);
    _this._formatted = null;
    _this._fsPath = null;
    return _this;
  }
  createClass_default()(Uri, [{
    key: "fsPath",
    get: function get() {
      if (!this._fsPath) {
        this._fsPath = uriToFsPath(this, false);
      }
      return this._fsPath;
    }
  }, {
    key: "toString",
    value: function toString() {
      var skipEncoding = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      if (!skipEncoding) {
        if (!this._formatted) {
          this._formatted = _asFormatted(this, false);
        }
        return this._formatted;
      } else {
        // we don't cache that
        return _asFormatted(this, true);
      }
    }
  }, {
    key: "toJSON",
    value: function toJSON() {
      var res = {
        $mid: 1 /* Uri */
      };
      // cached state
      if (this._fsPath) {
        res.fsPath = this._fsPath;
        res._sep = _pathSepMarker;
      }
      if (this._formatted) {
        res.external = this._formatted;
      }
      // uri components
      if (this.path) {
        res.path = this.path;
      }
      if (this.scheme) {
        res.scheme = this.scheme;
      }
      if (this.authority) {
        res.authority = this.authority;
      }
      if (this.query) {
        res.query = this.query;
      }
      if (this.fragment) {
        res.fragment = this.fragment;
      }
      return res;
    }
  }]);
  return Uri;
}(URI); // reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2
var encodeTable = (_encodeTable = {}, defineProperty_default()(_encodeTable, 58 /* Colon */, '%3A'), defineProperty_default()(_encodeTable, 47 /* Slash */, '%2F'), defineProperty_default()(_encodeTable, 63 /* QuestionMark */, '%3F'), defineProperty_default()(_encodeTable, 35 /* Hash */, '%23'), defineProperty_default()(_encodeTable, 91 /* OpenSquareBracket */, '%5B'), defineProperty_default()(_encodeTable, 93 /* CloseSquareBracket */, '%5D'), defineProperty_default()(_encodeTable, 64 /* AtSign */, '%40'), defineProperty_default()(_encodeTable, 33 /* ExclamationMark */, '%21'), defineProperty_default()(_encodeTable, 36 /* DollarSign */, '%24'), defineProperty_default()(_encodeTable, 38 /* Ampersand */, '%26'), defineProperty_default()(_encodeTable, 39 /* SingleQuote */, '%27'), defineProperty_default()(_encodeTable, 40 /* OpenParen */, '%28'), defineProperty_default()(_encodeTable, 41 /* CloseParen */, '%29'), defineProperty_default()(_encodeTable, 42 /* Asterisk */, '%2A'), defineProperty_default()(_encodeTable, 43 /* Plus */, '%2B'), defineProperty_default()(_encodeTable, 44 /* Comma */, '%2C'), defineProperty_default()(_encodeTable, 59 /* Semicolon */, '%3B'), defineProperty_default()(_encodeTable, 61 /* Equals */, '%3D'), defineProperty_default()(_encodeTable, 32 /* Space */, '%20'), _encodeTable);
function encodeURIComponentFast(uriComponent, allowSlash) {
  var res = undefined;
  var nativeEncodePos = -1;
  for (var pos = 0; pos < uriComponent.length; pos++) {
    var code = uriComponent.charCodeAt(pos);
    // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3
    if (code >= 97 /* a */ && code <= 122 /* z */ || code >= 65 /* A */ && code <= 90 /* Z */ || code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */ || code === 45 /* Dash */ || code === 46 /* Period */ || code === 95 /* Underline */ || code === 126 /* Tilde */ || allowSlash && code === 47 /* Slash */) {
      // check if we are delaying native encode
      if (nativeEncodePos !== -1) {
        res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
        nativeEncodePos = -1;
      }
      // check if we write into a new string (by default we try to return the param)
      if (res !== undefined) {
        res += uriComponent.charAt(pos);
      }
    } else {
      // encoding needed, we need to allocate a new string
      if (res === undefined) {
        res = uriComponent.substr(0, pos);
      }
      // check with default table first
      var escaped = encodeTable[code];
      if (escaped !== undefined) {
        // check if we are delaying native encode
        if (nativeEncodePos !== -1) {
          res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
          nativeEncodePos = -1;
        }
        // append escaped variant to result
        res += escaped;
      } else if (nativeEncodePos === -1) {
        // use native encode only when needed
        nativeEncodePos = pos;
      }
    }
  }
  if (nativeEncodePos !== -1) {
    res += encodeURIComponent(uriComponent.substring(nativeEncodePos));
  }
  return res !== undefined ? res : uriComponent;
}
function encodeURIComponentMinimal(path) {
  var res = undefined;
  for (var pos = 0; pos < path.length; pos++) {
    var code = path.charCodeAt(pos);
    if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {
      if (res === undefined) {
        res = path.substr(0, pos);
      }
      res += encodeTable[code];
    } else {
      if (res !== undefined) {
        res += path[pos];
      }
    }
  }
  return res !== undefined ? res : path;
}
/**
 * Compute `fsPath` for the given uri
 */
function uriToFsPath(uri, keepDriveLetterCasing) {
  var value;
  if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {
    // unc path: file://shares/c$/far/boo
    value = "//".concat(uri.authority).concat(uri.path);
  } else if (uri.path.charCodeAt(0) === 47 /* Slash */ && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */) && uri.path.charCodeAt(2) === 58 /* Colon */) {
    if (!keepDriveLetterCasing) {
      // windows drive letter: file:///c:/far/boo
      value = uri.path[1].toLowerCase() + uri.path.substr(2);
    } else {
      value = uri.path.substr(1);
    }
  } else {
    // other path
    value = uri.path;
  }
  if (isWindows) {
    value = value.replace(/\//g, '\\');
  }
  return value;
}
/**
 * Create the external version of a uri
 */
function _asFormatted(uri, skipEncoding) {
  var encoder = !skipEncoding ? encodeURIComponentFast : encodeURIComponentMinimal;
  var res = '';
  var scheme = uri.scheme,
    authority = uri.authority,
    path = uri.path,
    query = uri.query,
    fragment = uri.fragment;
  if (scheme) {
    res += scheme;
    res += ':';
  }
  if (authority || scheme === 'file') {
    res += _slash;
    res += _slash;
  }
  if (authority) {
    var idx = authority.indexOf('@');
    if (idx !== -1) {
      // <user>@<auth>
      var userinfo = authority.substr(0, idx);
      authority = authority.substr(idx + 1);
      idx = userinfo.indexOf(':');
      if (idx === -1) {
        res += encoder(userinfo, false);
      } else {
        // <user>:<pass>@<auth>
        res += encoder(userinfo.substr(0, idx), false);
        res += ':';
        res += encoder(userinfo.substr(idx + 1), false);
      }
      res += '@';
    }
    authority = authority.toLowerCase();
    idx = authority.indexOf(':');
    if (idx === -1) {
      res += encoder(authority, false);
    } else {
      // <auth>:<port>
      res += encoder(authority.substr(0, idx), false);
      res += authority.substr(idx);
    }
  }
  if (path) {
    // lower-case windows drive letters in /C:/fff or C:/fff
    if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {
      var code = path.charCodeAt(1);
      if (code >= 65 /* A */ && code <= 90 /* Z */) {
        path = "/".concat(String.fromCharCode(code + 32), ":").concat(path.substr(3)); // "/c:".length === 3
      }
    } else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {
      var _code = path.charCodeAt(0);
      if (_code >= 65 /* A */ && _code <= 90 /* Z */) {
        path = "".concat(String.fromCharCode(_code + 32), ":").concat(path.substr(2)); // "/c:".length === 3
      }
    }
    // encode the rest of the path
    res += encoder(path, true);
  }
  if (query) {
    res += '?';
    res += encoder(query, false);
  }
  if (fragment) {
    res += '#';
    res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;
  }
  return res;
}
// --- decode
function decodeURIComponentGraceful(str) {
  try {
    return decodeURIComponent(str);
  } catch (_a) {
    if (str.length > 3) {
      return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));
    } else {
      return str;
    }
  }
}
var _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;
function percentDecode(str) {
  if (!str.match(_rEncodedAsHex)) {
    return str;
  }
  return str.replace(_rEncodedAsHex, function (match) {
    return decodeURIComponentGraceful(match);
  });
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/core/position.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
/**
 * A position in the editor.
 */
var Position = /*#__PURE__*/function () {
  function Position(lineNumber, column) {
    classCallCheck_default()(this, Position);
    this.lineNumber = lineNumber;
    this.column = column;
  }
  /**
   * Create a new position from this position.
   *
   * @param newLineNumber new line number
   * @param newColumn new column
   */
  createClass_default()(Position, [{
    key: "with",
    value: function _with() {
      var newLineNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.lineNumber;
      var newColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.column;
      if (newLineNumber === this.lineNumber && newColumn === this.column) {
        return this;
      } else {
        return new Position(newLineNumber, newColumn);
      }
    }
    /**
     * Derive a new position from this position.
     *
     * @param deltaLineNumber line number delta
     * @param deltaColumn column delta
     */
  }, {
    key: "delta",
    value: function delta() {
      var deltaLineNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
      var deltaColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
      return this["with"](this.lineNumber + deltaLineNumber, this.column + deltaColumn);
    }
    /**
     * Test if this position equals other position
     */
  }, {
    key: "equals",
    value: function equals(other) {
      return Position.equals(this, other);
    }
    /**
     * Test if position `a` equals position `b`
     */
  }, {
    key: "isBefore",
    value:
    /**
     * Test if this position is before other position.
     * If the two positions are equal, the result will be false.
     */
    function isBefore(other) {
      return Position.isBefore(this, other);
    }
    /**
     * Test if position `a` is before position `b`.
     * If the two positions are equal, the result will be false.
     */
  }, {
    key: "isBeforeOrEqual",
    value:
    /**
     * Test if this position is before other position.
     * If the two positions are equal, the result will be true.
     */
    function isBeforeOrEqual(other) {
      return Position.isBeforeOrEqual(this, other);
    }
    /**
     * Test if position `a` is before position `b`.
     * If the two positions are equal, the result will be true.
     */
  }, {
    key: "clone",
    value:
    /**
     * Clone this position.
     */
    function clone() {
      return new Position(this.lineNumber, this.column);
    }
    /**
     * Convert to a human-readable representation.
     */
  }, {
    key: "toString",
    value: function toString() {
      return '(' + this.lineNumber + ',' + this.column + ')';
    }
    // ---
    /**
     * Create a `Position` from an `IPosition`.
     */
  }], [{
    key: "equals",
    value: function equals(a, b) {
      if (!a && !b) {
        return true;
      }
      return !!a && !!b && a.lineNumber === b.lineNumber && a.column === b.column;
    }
  }, {
    key: "isBefore",
    value: function isBefore(a, b) {
      if (a.lineNumber < b.lineNumber) {
        return true;
      }
      if (b.lineNumber < a.lineNumber) {
        return false;
      }
      return a.column < b.column;
    }
  }, {
    key: "isBeforeOrEqual",
    value: function isBeforeOrEqual(a, b) {
      if (a.lineNumber < b.lineNumber) {
        return true;
      }
      if (b.lineNumber < a.lineNumber) {
        return false;
      }
      return a.column <= b.column;
    }
    /**
     * A function that compares positions, useful for sorting
     */
  }, {
    key: "compare",
    value: function compare(a, b) {
      var aLineNumber = a.lineNumber | 0;
      var bLineNumber = b.lineNumber | 0;
      if (aLineNumber === bLineNumber) {
        var aColumn = a.column | 0;
        var bColumn = b.column | 0;
        return aColumn - bColumn;
      }
      return aLineNumber - bLineNumber;
    }
  }, {
    key: "lift",
    value: function lift(pos) {
      return new Position(pos.lineNumber, pos.column);
    }
    /**
     * Test if `obj` is an `IPosition`.
     */
  }, {
    key: "isIPosition",
    value: function isIPosition(obj) {
      return obj && typeof obj.lineNumber === 'number' && typeof obj.column === 'number';
    }
  }]);
  return Position;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/core/range.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

/**
 * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
 */
var Range = /*#__PURE__*/function () {
  function Range(startLineNumber, startColumn, endLineNumber, endColumn) {
    classCallCheck_default()(this, Range);
    if (startLineNumber > endLineNumber || startLineNumber === endLineNumber && startColumn > endColumn) {
      this.startLineNumber = endLineNumber;
      this.startColumn = endColumn;
      this.endLineNumber = startLineNumber;
      this.endColumn = startColumn;
    } else {
      this.startLineNumber = startLineNumber;
      this.startColumn = startColumn;
      this.endLineNumber = endLineNumber;
      this.endColumn = endColumn;
    }
  }
  /**
   * Test if this range is empty.
   */
  createClass_default()(Range, [{
    key: "isEmpty",
    value: function isEmpty() {
      return Range.isEmpty(this);
    }
    /**
     * Test if `range` is empty.
     */
  }, {
    key: "containsPosition",
    value:
    /**
     * Test if position is in this range. If the position is at the edges, will return true.
     */
    function containsPosition(position) {
      return Range.containsPosition(this, position);
    }
    /**
     * Test if `position` is in `range`. If the position is at the edges, will return true.
     */
  }, {
    key: "containsRange",
    value:
    /**
     * Test if range is in this range. If the range is equal to this range, will return true.
     */
    function containsRange(range) {
      return Range.containsRange(this, range);
    }
    /**
     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
     */
  }, {
    key: "strictContainsRange",
    value:
    /**
     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
     */
    function strictContainsRange(range) {
      return Range.strictContainsRange(this, range);
    }
    /**
     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
     */
  }, {
    key: "plusRange",
    value:
    /**
     * A reunion of the two ranges.
     * The smallest position will be used as the start point, and the largest one as the end point.
     */
    function plusRange(range) {
      return Range.plusRange(this, range);
    }
    /**
     * A reunion of the two ranges.
     * The smallest position will be used as the start point, and the largest one as the end point.
     */
  }, {
    key: "intersectRanges",
    value:
    /**
     * A intersection of the two ranges.
     */
    function intersectRanges(range) {
      return Range.intersectRanges(this, range);
    }
    /**
     * A intersection of the two ranges.
     */
  }, {
    key: "equalsRange",
    value:
    /**
     * Test if this range equals other.
     */
    function equalsRange(other) {
      return Range.equalsRange(this, other);
    }
    /**
     * Test if range `a` equals `b`.
     */
  }, {
    key: "getEndPosition",
    value:
    /**
     * Return the end position (which will be after or equal to the start position)
     */
    function getEndPosition() {
      return Range.getEndPosition(this);
    }
    /**
     * Return the end position (which will be after or equal to the start position)
     */
  }, {
    key: "getStartPosition",
    value:
    /**
     * Return the start position (which will be before or equal to the end position)
     */
    function getStartPosition() {
      return Range.getStartPosition(this);
    }
    /**
     * Return the start position (which will be before or equal to the end position)
     */
  }, {
    key: "toString",
    value:
    /**
     * Transform to a user presentable string representation.
     */
    function toString() {
      return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';
    }
    /**
     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
     */
  }, {
    key: "setEndPosition",
    value: function setEndPosition(endLineNumber, endColumn) {
      return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
    }
    /**
     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
     */
  }, {
    key: "setStartPosition",
    value: function setStartPosition(startLineNumber, startColumn) {
      return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
    }
    /**
     * Create a new empty range using this range's start position.
     */
  }, {
    key: "collapseToStart",
    value: function collapseToStart() {
      return Range.collapseToStart(this);
    }
    /**
     * Create a new empty range using this range's start position.
     */
  }], [{
    key: "isEmpty",
    value: function isEmpty(range) {
      return range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn;
    }
  }, {
    key: "containsPosition",
    value: function containsPosition(range, position) {
      if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
        return false;
      }
      if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
        return false;
      }
      if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {
        return false;
      }
      return true;
    }
  }, {
    key: "containsRange",
    value: function containsRange(range, otherRange) {
      if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
        return false;
      }
      if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
        return false;
      }
      if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {
        return false;
      }
      if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {
        return false;
      }
      return true;
    }
  }, {
    key: "strictContainsRange",
    value: function strictContainsRange(range, otherRange) {
      if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
        return false;
      }
      if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
        return false;
      }
      if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {
        return false;
      }
      if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {
        return false;
      }
      return true;
    }
  }, {
    key: "plusRange",
    value: function plusRange(a, b) {
      var startLineNumber;
      var startColumn;
      var endLineNumber;
      var endColumn;
      if (b.startLineNumber < a.startLineNumber) {
        startLineNumber = b.startLineNumber;
        startColumn = b.startColumn;
      } else if (b.startLineNumber === a.startLineNumber) {
        startLineNumber = b.startLineNumber;
        startColumn = Math.min(b.startColumn, a.startColumn);
      } else {
        startLineNumber = a.startLineNumber;
        startColumn = a.startColumn;
      }
      if (b.endLineNumber > a.endLineNumber) {
        endLineNumber = b.endLineNumber;
        endColumn = b.endColumn;
      } else if (b.endLineNumber === a.endLineNumber) {
        endLineNumber = b.endLineNumber;
        endColumn = Math.max(b.endColumn, a.endColumn);
      } else {
        endLineNumber = a.endLineNumber;
        endColumn = a.endColumn;
      }
      return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
    }
  }, {
    key: "intersectRanges",
    value: function intersectRanges(a, b) {
      var resultStartLineNumber = a.startLineNumber;
      var resultStartColumn = a.startColumn;
      var resultEndLineNumber = a.endLineNumber;
      var resultEndColumn = a.endColumn;
      var otherStartLineNumber = b.startLineNumber;
      var otherStartColumn = b.startColumn;
      var otherEndLineNumber = b.endLineNumber;
      var otherEndColumn = b.endColumn;
      if (resultStartLineNumber < otherStartLineNumber) {
        resultStartLineNumber = otherStartLineNumber;
        resultStartColumn = otherStartColumn;
      } else if (resultStartLineNumber === otherStartLineNumber) {
        resultStartColumn = Math.max(resultStartColumn, otherStartColumn);
      }
      if (resultEndLineNumber > otherEndLineNumber) {
        resultEndLineNumber = otherEndLineNumber;
        resultEndColumn = otherEndColumn;
      } else if (resultEndLineNumber === otherEndLineNumber) {
        resultEndColumn = Math.min(resultEndColumn, otherEndColumn);
      }
      // Check if selection is now empty
      if (resultStartLineNumber > resultEndLineNumber) {
        return null;
      }
      if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {
        return null;
      }
      return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);
    }
  }, {
    key: "equalsRange",
    value: function equalsRange(a, b) {
      return !!a && !!b && a.startLineNumber === b.startLineNumber && a.startColumn === b.startColumn && a.endLineNumber === b.endLineNumber && a.endColumn === b.endColumn;
    }
  }, {
    key: "getEndPosition",
    value: function getEndPosition(range) {
      return new Position(range.endLineNumber, range.endColumn);
    }
  }, {
    key: "getStartPosition",
    value: function getStartPosition(range) {
      return new Position(range.startLineNumber, range.startColumn);
    }
  }, {
    key: "collapseToStart",
    value: function collapseToStart(range) {
      return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);
    }
    // ---
  }, {
    key: "fromPositions",
    value: function fromPositions(start) {
      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : start;
      return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
    }
  }, {
    key: "lift",
    value: function lift(range) {
      if (!range) {
        return null;
      }
      return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
    }
    /**
     * Test if `obj` is an `IRange`.
     */
  }, {
    key: "isIRange",
    value: function isIRange(obj) {
      return obj && typeof obj.startLineNumber === 'number' && typeof obj.startColumn === 'number' && typeof obj.endLineNumber === 'number' && typeof obj.endColumn === 'number';
    }
    /**
     * Test if the two ranges are touching in any way.
     */
  }, {
    key: "areIntersectingOrTouching",
    value: function areIntersectingOrTouching(a, b) {
      // Check if `a` is before `b`
      if (a.endLineNumber < b.startLineNumber || a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn) {
        return false;
      }
      // Check if `b` is before `a`
      if (b.endLineNumber < a.startLineNumber || b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn) {
        return false;
      }
      // These ranges must intersect
      return true;
    }
    /**
     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
     */
  }, {
    key: "areIntersecting",
    value: function areIntersecting(a, b) {
      // Check if `a` is before `b`
      if (a.endLineNumber < b.startLineNumber || a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn) {
        return false;
      }
      // Check if `b` is before `a`
      if (b.endLineNumber < a.startLineNumber || b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn) {
        return false;
      }
      // These ranges must intersect
      return true;
    }
    /**
     * A function that compares ranges, useful for sorting ranges
     * It will first compare ranges on the startPosition and then on the endPosition
     */
  }, {
    key: "compareRangesUsingStarts",
    value: function compareRangesUsingStarts(a, b) {
      if (a && b) {
        var aStartLineNumber = a.startLineNumber | 0;
        var bStartLineNumber = b.startLineNumber | 0;
        if (aStartLineNumber === bStartLineNumber) {
          var aStartColumn = a.startColumn | 0;
          var bStartColumn = b.startColumn | 0;
          if (aStartColumn === bStartColumn) {
            var aEndLineNumber = a.endLineNumber | 0;
            var bEndLineNumber = b.endLineNumber | 0;
            if (aEndLineNumber === bEndLineNumber) {
              var aEndColumn = a.endColumn | 0;
              var bEndColumn = b.endColumn | 0;
              return aEndColumn - bEndColumn;
            }
            return aEndLineNumber - bEndLineNumber;
          }
          return aStartColumn - bStartColumn;
        }
        return aStartLineNumber - bStartLineNumber;
      }
      var aExists = a ? 1 : 0;
      var bExists = b ? 1 : 0;
      return aExists - bExists;
    }
    /**
     * A function that compares ranges, useful for sorting ranges
     * It will first compare ranges on the endPosition and then on the startPosition
     */
  }, {
    key: "compareRangesUsingEnds",
    value: function compareRangesUsingEnds(a, b) {
      if (a.endLineNumber === b.endLineNumber) {
        if (a.endColumn === b.endColumn) {
          if (a.startLineNumber === b.startLineNumber) {
            return a.startColumn - b.startColumn;
          }
          return a.startLineNumber - b.startLineNumber;
        }
        return a.endColumn - b.endColumn;
      }
      return a.endLineNumber - b.endLineNumber;
    }
    /**
     * Test if the range spans multiple lines.
     */
  }, {
    key: "spansMultipleLines",
    value: function spansMultipleLines(range) {
      return range.endLineNumber > range.startLineNumber;
    }
  }]);
  return Range;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/diff/diffComputer.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


var MINIMUM_MATCHING_CHARACTER_LENGTH = 3;
function _computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {
  var diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);
  return diffAlgo.ComputeDiff(pretty);
}
var LineSequence = /*#__PURE__*/function () {
  function LineSequence(lines) {
    classCallCheck_default()(this, LineSequence);
    var startColumns = [];
    var endColumns = [];
    for (var i = 0, length = lines.length; i < length; i++) {
      startColumns[i] = getFirstNonBlankColumn(lines[i], 1);
      endColumns[i] = getLastNonBlankColumn(lines[i], 1);
    }
    this.lines = lines;
    this._startColumns = startColumns;
    this._endColumns = endColumns;
  }
  createClass_default()(LineSequence, [{
    key: "getElements",
    value: function getElements() {
      var elements = [];
      for (var i = 0, len = this.lines.length; i < len; i++) {
        elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);
      }
      return elements;
    }
  }, {
    key: "getStrictElement",
    value: function getStrictElement(index) {
      return this.lines[index];
    }
  }, {
    key: "getStartLineNumber",
    value: function getStartLineNumber(i) {
      return i + 1;
    }
  }, {
    key: "getEndLineNumber",
    value: function getEndLineNumber(i) {
      return i + 1;
    }
  }, {
    key: "createCharSequence",
    value: function createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {
      var charCodes = [];
      var lineNumbers = [];
      var columns = [];
      var len = 0;
      for (var index = startIndex; index <= endIndex; index++) {
        var lineContent = this.lines[index];
        var startColumn = shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1;
        var endColumn = shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1;
        for (var col = startColumn; col < endColumn; col++) {
          charCodes[len] = lineContent.charCodeAt(col - 1);
          lineNumbers[len] = index + 1;
          columns[len] = col;
          len++;
        }
      }
      return new CharSequence(charCodes, lineNumbers, columns);
    }
  }]);
  return LineSequence;
}();
var CharSequence = /*#__PURE__*/function () {
  function CharSequence(charCodes, lineNumbers, columns) {
    classCallCheck_default()(this, CharSequence);
    this._charCodes = charCodes;
    this._lineNumbers = lineNumbers;
    this._columns = columns;
  }
  createClass_default()(CharSequence, [{
    key: "getElements",
    value: function getElements() {
      return this._charCodes;
    }
  }, {
    key: "getStartLineNumber",
    value: function getStartLineNumber(i) {
      return this._lineNumbers[i];
    }
  }, {
    key: "getStartColumn",
    value: function getStartColumn(i) {
      return this._columns[i];
    }
  }, {
    key: "getEndLineNumber",
    value: function getEndLineNumber(i) {
      return this._lineNumbers[i];
    }
  }, {
    key: "getEndColumn",
    value: function getEndColumn(i) {
      return this._columns[i] + 1;
    }
  }]);
  return CharSequence;
}();
var CharChange = /*#__PURE__*/function () {
  function CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {
    classCallCheck_default()(this, CharChange);
    this.originalStartLineNumber = originalStartLineNumber;
    this.originalStartColumn = originalStartColumn;
    this.originalEndLineNumber = originalEndLineNumber;
    this.originalEndColumn = originalEndColumn;
    this.modifiedStartLineNumber = modifiedStartLineNumber;
    this.modifiedStartColumn = modifiedStartColumn;
    this.modifiedEndLineNumber = modifiedEndLineNumber;
    this.modifiedEndColumn = modifiedEndColumn;
  }
  createClass_default()(CharChange, null, [{
    key: "createFromDiffChange",
    value: function createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {
      var originalStartLineNumber;
      var originalStartColumn;
      var originalEndLineNumber;
      var originalEndColumn;
      var modifiedStartLineNumber;
      var modifiedStartColumn;
      var modifiedEndLineNumber;
      var modifiedEndColumn;
      if (diffChange.originalLength === 0) {
        originalStartLineNumber = 0;
        originalStartColumn = 0;
        originalEndLineNumber = 0;
        originalEndColumn = 0;
      } else {
        originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);
        originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);
        originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
        originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);
      }
      if (diffChange.modifiedLength === 0) {
        modifiedStartLineNumber = 0;
        modifiedStartColumn = 0;
        modifiedEndLineNumber = 0;
        modifiedEndColumn = 0;
      } else {
        modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);
        modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);
        modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
        modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);
      }
      return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);
    }
  }]);
  return CharChange;
}();
function postProcessCharChanges(rawChanges) {
  if (rawChanges.length <= 1) {
    return rawChanges;
  }
  var result = [rawChanges[0]];
  var prevChange = result[0];
  for (var i = 1, len = rawChanges.length; i < len; i++) {
    var currChange = rawChanges[i];
    var originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);
    var modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);
    // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true
    var matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);
    if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {
      // Merge the current change into the previous one
      prevChange.originalLength = currChange.originalStart + currChange.originalLength - prevChange.originalStart;
      prevChange.modifiedLength = currChange.modifiedStart + currChange.modifiedLength - prevChange.modifiedStart;
    } else {
      // Add the current change
      result.push(currChange);
      prevChange = currChange;
    }
  }
  return result;
}
var LineChange = /*#__PURE__*/function () {
  function LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {
    classCallCheck_default()(this, LineChange);
    this.originalStartLineNumber = originalStartLineNumber;
    this.originalEndLineNumber = originalEndLineNumber;
    this.modifiedStartLineNumber = modifiedStartLineNumber;
    this.modifiedEndLineNumber = modifiedEndLineNumber;
    this.charChanges = charChanges;
  }
  createClass_default()(LineChange, null, [{
    key: "createFromDiffResult",
    value: function createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {
      var originalStartLineNumber;
      var originalEndLineNumber;
      var modifiedStartLineNumber;
      var modifiedEndLineNumber;
      var charChanges = undefined;
      if (diffChange.originalLength === 0) {
        originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;
        originalEndLineNumber = 0;
      } else {
        originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);
        originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
      }
      if (diffChange.modifiedLength === 0) {
        modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;
        modifiedEndLineNumber = 0;
      } else {
        modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);
        modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
      }
      if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {
        // Compute character changes for diff chunks of at most 20 lines...
        var originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);
        var modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);
        var rawChanges = _computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;
        if (shouldPostProcessCharChanges) {
          rawChanges = postProcessCharChanges(rawChanges);
        }
        charChanges = [];
        for (var i = 0, length = rawChanges.length; i < length; i++) {
          charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));
        }
      }
      return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);
    }
  }]);
  return LineChange;
}();
var DiffComputer = /*#__PURE__*/function () {
  function DiffComputer(originalLines, modifiedLines, opts) {
    classCallCheck_default()(this, DiffComputer);
    this.shouldComputeCharChanges = opts.shouldComputeCharChanges;
    this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;
    this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;
    this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;
    this.originalLines = originalLines;
    this.modifiedLines = modifiedLines;
    this.original = new LineSequence(originalLines);
    this.modified = new LineSequence(modifiedLines);
    this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);
    this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...
  }
  createClass_default()(DiffComputer, [{
    key: "computeDiff",
    value: function computeDiff() {
      if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {
        // empty original => fast path
        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {
          return {
            quitEarly: false,
            changes: []
          };
        }
        return {
          quitEarly: false,
          changes: [{
            originalStartLineNumber: 1,
            originalEndLineNumber: 1,
            modifiedStartLineNumber: 1,
            modifiedEndLineNumber: this.modified.lines.length,
            charChanges: [{
              modifiedEndColumn: 0,
              modifiedEndLineNumber: 0,
              modifiedStartColumn: 0,
              modifiedStartLineNumber: 0,
              originalEndColumn: 0,
              originalEndLineNumber: 0,
              originalStartColumn: 0,
              originalStartLineNumber: 0
            }]
          }]
        };
      }
      if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {
        // empty modified => fast path
        return {
          quitEarly: false,
          changes: [{
            originalStartLineNumber: 1,
            originalEndLineNumber: this.original.lines.length,
            modifiedStartLineNumber: 1,
            modifiedEndLineNumber: 1,
            charChanges: [{
              modifiedEndColumn: 0,
              modifiedEndLineNumber: 0,
              modifiedStartColumn: 0,
              modifiedStartLineNumber: 0,
              originalEndColumn: 0,
              originalEndLineNumber: 0,
              originalStartColumn: 0,
              originalStartLineNumber: 0
            }]
          }]
        };
      }
      var diffResult = _computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);
      var rawChanges = diffResult.changes;
      var quitEarly = diffResult.quitEarly;
      // The diff is always computed with ignoring trim whitespace
      // This ensures we get the prettiest diff
      if (this.shouldIgnoreTrimWhitespace) {
        var lineChanges = [];
        for (var i = 0, length = rawChanges.length; i < length; i++) {
          lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));
        }
        return {
          quitEarly: quitEarly,
          changes: lineChanges
        };
      }
      // Need to post-process and introduce changes where the trim whitespace is different
      // Note that we are looping starting at -1 to also cover the lines before the first change
      var result = [];
      var originalLineIndex = 0;
      var modifiedLineIndex = 0;
      for (var _i = -1 /* !!!! */, len = rawChanges.length; _i < len; _i++) {
        var nextChange = _i + 1 < len ? rawChanges[_i + 1] : null;
        var originalStop = nextChange ? nextChange.originalStart : this.originalLines.length;
        var modifiedStop = nextChange ? nextChange.modifiedStart : this.modifiedLines.length;
        while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {
          var originalLine = this.originalLines[originalLineIndex];
          var modifiedLine = this.modifiedLines[modifiedLineIndex];
          if (originalLine !== modifiedLine) {
            // These lines differ only in trim whitespace
            // Check the leading whitespace
            {
              var originalStartColumn = getFirstNonBlankColumn(originalLine, 1);
              var modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);
              while (originalStartColumn > 1 && modifiedStartColumn > 1) {
                var originalChar = originalLine.charCodeAt(originalStartColumn - 2);
                var modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);
                if (originalChar !== modifiedChar) {
                  break;
                }
                originalStartColumn--;
                modifiedStartColumn--;
              }
              if (originalStartColumn > 1 || modifiedStartColumn > 1) {
                this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);
              }
            }
            // Check the trailing whitespace
            {
              var originalEndColumn = getLastNonBlankColumn(originalLine, 1);
              var modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);
              var originalMaxColumn = originalLine.length + 1;
              var modifiedMaxColumn = modifiedLine.length + 1;
              while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {
                var _originalChar = originalLine.charCodeAt(originalEndColumn - 1);
                var _modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);
                if (_originalChar !== _modifiedChar) {
                  break;
                }
                originalEndColumn++;
                modifiedEndColumn++;
              }
              if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {
                this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);
              }
            }
          }
          originalLineIndex++;
          modifiedLineIndex++;
        }
        if (nextChange) {
          // Emit the actual change
          result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));
          originalLineIndex += nextChange.originalLength;
          modifiedLineIndex += nextChange.modifiedLength;
        }
      }
      return {
        quitEarly: quitEarly,
        changes: result
      };
    }
  }, {
    key: "_pushTrimWhitespaceCharChange",
    value: function _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {
      if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {
        // Merged into previous
        return;
      }
      var charChanges = undefined;
      if (this.shouldComputeCharChanges) {
        charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];
      }
      result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));
    }
  }, {
    key: "_mergeTrimWhitespaceCharChange",
    value: function _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {
      var len = result.length;
      if (len === 0) {
        return false;
      }
      var prevChange = result[len - 1];
      if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {
        // Don't merge with inserts/deletes
        return false;
      }
      if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {
        prevChange.originalEndLineNumber = originalLineNumber;
        prevChange.modifiedEndLineNumber = modifiedLineNumber;
        if (this.shouldComputeCharChanges && prevChange.charChanges) {
          prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));
        }
        return true;
      }
      return false;
    }
  }]);
  return DiffComputer;
}();
function getFirstNonBlankColumn(txt, defaultValue) {
  var r = firstNonWhitespaceIndex(txt);
  if (r === -1) {
    return defaultValue;
  }
  return r + 1;
}
function getLastNonBlankColumn(txt, defaultValue) {
  var r = lastNonWhitespaceIndex(txt);
  if (r === -1) {
    return defaultValue;
  }
  return r + 2;
}
function createContinueProcessingPredicate(maximumRuntime) {
  if (maximumRuntime === 0) {
    return function () {
      return true;
    };
  }
  var startTime = Date.now();
  return function () {
    return Date.now() - startTime < maximumRuntime;
  };
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/uint.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function toUint8(v) {
  if (v < 0) {
    return 0;
  }
  if (v > 255 /* MAX_UINT_8 */) {
    return 255 /* MAX_UINT_8 */;
  }

  return v | 0;
}
function toUint32(v) {
  if (v < 0) {
    return 0;
  }
  if (v > 4294967295 /* MAX_UINT_32 */) {
    return 4294967295 /* MAX_UINT_32 */;
  }

  return v | 0;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var PrefixSumIndexOfResult = /*#__PURE__*/createClass_default()(function PrefixSumIndexOfResult(index, remainder) {
  classCallCheck_default()(this, PrefixSumIndexOfResult);
  this._prefixSumIndexOfResultBrand = undefined;
  this.index = index;
  this.remainder = remainder;
});
var PrefixSumComputer = /*#__PURE__*/function () {
  function PrefixSumComputer(values) {
    classCallCheck_default()(this, PrefixSumComputer);
    this.values = values;
    this.prefixSum = new Uint32Array(values.length);
    this.prefixSumValidIndex = new Int32Array(1);
    this.prefixSumValidIndex[0] = -1;
  }
  createClass_default()(PrefixSumComputer, [{
    key: "insertValues",
    value: function insertValues(insertIndex, _insertValues) {
      insertIndex = toUint32(insertIndex);
      var oldValues = this.values;
      var oldPrefixSum = this.prefixSum;
      var insertValuesLen = _insertValues.length;
      if (insertValuesLen === 0) {
        return false;
      }
      this.values = new Uint32Array(oldValues.length + insertValuesLen);
      this.values.set(oldValues.subarray(0, insertIndex), 0);
      this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);
      this.values.set(_insertValues, insertIndex);
      if (insertIndex - 1 < this.prefixSumValidIndex[0]) {
        this.prefixSumValidIndex[0] = insertIndex - 1;
      }
      this.prefixSum = new Uint32Array(this.values.length);
      if (this.prefixSumValidIndex[0] >= 0) {
        this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
      }
      return true;
    }
  }, {
    key: "changeValue",
    value: function changeValue(index, value) {
      index = toUint32(index);
      value = toUint32(value);
      if (this.values[index] === value) {
        return false;
      }
      this.values[index] = value;
      if (index - 1 < this.prefixSumValidIndex[0]) {
        this.prefixSumValidIndex[0] = index - 1;
      }
      return true;
    }
  }, {
    key: "removeValues",
    value: function removeValues(startIndex, count) {
      startIndex = toUint32(startIndex);
      count = toUint32(count);
      var oldValues = this.values;
      var oldPrefixSum = this.prefixSum;
      if (startIndex >= oldValues.length) {
        return false;
      }
      var maxCount = oldValues.length - startIndex;
      if (count >= maxCount) {
        count = maxCount;
      }
      if (count === 0) {
        return false;
      }
      this.values = new Uint32Array(oldValues.length - count);
      this.values.set(oldValues.subarray(0, startIndex), 0);
      this.values.set(oldValues.subarray(startIndex + count), startIndex);
      this.prefixSum = new Uint32Array(this.values.length);
      if (startIndex - 1 < this.prefixSumValidIndex[0]) {
        this.prefixSumValidIndex[0] = startIndex - 1;
      }
      if (this.prefixSumValidIndex[0] >= 0) {
        this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
      }
      return true;
    }
  }, {
    key: "getTotalSum",
    value: function getTotalSum() {
      if (this.values.length === 0) {
        return 0;
      }
      return this._getPrefixSum(this.values.length - 1);
    }
  }, {
    key: "getPrefixSum",
    value: function getPrefixSum(index) {
      if (index < 0) {
        return 0;
      }
      index = toUint32(index);
      return this._getPrefixSum(index);
    }
  }, {
    key: "_getPrefixSum",
    value: function _getPrefixSum(index) {
      if (index <= this.prefixSumValidIndex[0]) {
        return this.prefixSum[index];
      }
      var startIndex = this.prefixSumValidIndex[0] + 1;
      if (startIndex === 0) {
        this.prefixSum[0] = this.values[0];
        startIndex++;
      }
      if (index >= this.values.length) {
        index = this.values.length - 1;
      }
      for (var i = startIndex; i <= index; i++) {
        this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];
      }
      this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);
      return this.prefixSum[index];
    }
  }, {
    key: "getIndexOf",
    value: function getIndexOf(sum) {
      sum = Math.floor(sum); //@perf
      // Compute all sums (to get a fully valid prefixSum)
      this.getTotalSum();
      var low = 0;
      var high = this.values.length - 1;
      var mid = 0;
      var midStop = 0;
      var midStart = 0;
      while (low <= high) {
        mid = low + (high - low) / 2 | 0;
        midStop = this.prefixSum[mid];
        midStart = midStop - this.values[mid];
        if (sum < midStart) {
          high = mid - 1;
        } else if (sum >= midStop) {
          low = mid + 1;
        } else {
          break;
        }
      }
      return new PrefixSumIndexOfResult(mid, sum - midStart);
    }
  }]);
  return PrefixSumComputer;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/



var MirrorTextModel = /*#__PURE__*/function () {
  function MirrorTextModel(uri, lines, eol, versionId) {
    classCallCheck_default()(this, MirrorTextModel);
    this._uri = uri;
    this._lines = lines;
    this._eol = eol;
    this._versionId = versionId;
    this._lineStarts = null;
    this._cachedTextValue = null;
  }
  createClass_default()(MirrorTextModel, [{
    key: "dispose",
    value: function dispose() {
      this._lines.length = 0;
    }
  }, {
    key: "version",
    get: function get() {
      return this._versionId;
    }
  }, {
    key: "getText",
    value: function getText() {
      if (this._cachedTextValue === null) {
        this._cachedTextValue = this._lines.join(this._eol);
      }
      return this._cachedTextValue;
    }
  }, {
    key: "onEvents",
    value: function onEvents(e) {
      if (e.eol && e.eol !== this._eol) {
        this._eol = e.eol;
        this._lineStarts = null;
      }
      // Update my lines
      var changes = e.changes;
      var _iterator = createForOfIteratorHelper_default()(changes),
        _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var change = _step.value;
          this._acceptDeleteRange(change.range);
          this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      this._versionId = e.versionId;
      this._cachedTextValue = null;
    }
  }, {
    key: "_ensureLineStarts",
    value: function _ensureLineStarts() {
      if (!this._lineStarts) {
        var eolLength = this._eol.length;
        var linesLength = this._lines.length;
        var lineStartValues = new Uint32Array(linesLength);
        for (var i = 0; i < linesLength; i++) {
          lineStartValues[i] = this._lines[i].length + eolLength;
        }
        this._lineStarts = new PrefixSumComputer(lineStartValues);
      }
    }
    /**
     * All changes to a line's text go through this method
     */
  }, {
    key: "_setLineText",
    value: function _setLineText(lineIndex, newValue) {
      this._lines[lineIndex] = newValue;
      if (this._lineStarts) {
        // update prefix sum
        this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);
      }
    }
  }, {
    key: "_acceptDeleteRange",
    value: function _acceptDeleteRange(range) {
      if (range.startLineNumber === range.endLineNumber) {
        if (range.startColumn === range.endColumn) {
          // Nothing to delete
          return;
        }
        // Delete text on the affected line
        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1) + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));
        return;
      }
      // Take remaining text on last line and append it to remaining text on first line
      this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1) + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));
      // Delete middle lines
      this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);
      if (this._lineStarts) {
        // update prefix sum
        this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);
      }
    }
  }, {
    key: "_acceptInsertText",
    value: function _acceptInsertText(position, insertText) {
      if (insertText.length === 0) {
        // Nothing to insert
        return;
      }
      var insertLines = splitLines(insertText);
      if (insertLines.length === 1) {
        // Inserting text on one line
        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1) + insertLines[0] + this._lines[position.lineNumber - 1].substring(position.column - 1));
        return;
      }
      // Append overflowing text from first line to the end of text to insert
      insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);
      // Delete overflowing text from first line and insert text on first line
      this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1) + insertLines[0]);
      // Insert new lines & store lengths
      var newLengths = new Uint32Array(insertLines.length - 1);
      for (var i = 1; i < insertLines.length; i++) {
        this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);
        newLengths[i - 1] = insertLines[i].length + this._eol.length;
      }
      if (this._lineStarts) {
        // update prefix sum
        this._lineStarts.insertValues(position.lineNumber, newLengths);
      }
    }
  }]);
  return MirrorTextModel;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/model/wordHelper.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
/**
 * Create a word definition regular expression based on default word separators.
 * Optionally provide allowed separators that should be included in words.
 *
 * The default would look like this:
 * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
 */
function createWordRegExp() {
  var allowInWords = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  var source = '(-?\\d*\\.\\d\\w*)|([^';
  var _iterator = createForOfIteratorHelper_default()(USUAL_WORD_SEPARATORS),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var sep = _step.value;
      if (allowInWords.indexOf(sep) >= 0) {
        continue;
      }
      source += '\\' + sep;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  source += '\\s]+)';
  return new RegExp(source, 'g');
}
// catches numbers (including floating numbers) in the first group, and alphanum in the second
var DEFAULT_WORD_REGEXP = createWordRegExp();
function ensureValidWordDefinition(wordDefinition) {
  var result = DEFAULT_WORD_REGEXP;
  if (wordDefinition && wordDefinition instanceof RegExp) {
    if (!wordDefinition.global) {
      var flags = 'g';
      if (wordDefinition.ignoreCase) {
        flags += 'i';
      }
      if (wordDefinition.multiline) {
        flags += 'm';
      }
      if (wordDefinition.unicode) {
        flags += 'u';
      }
      result = new RegExp(wordDefinition.source, flags);
    } else {
      result = wordDefinition;
    }
  }
  result.lastIndex = 0;
  return result;
}
var _defaultConfig = {
  maxLen: 1000,
  windowSize: 15,
  timeBudget: 150
};
function getWordAtText(column, wordDefinition, text, textOffset) {
  var config = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _defaultConfig;
  if (text.length > config.maxLen) {
    // don't throw strings that long at the regexp
    // but use a sub-string in which a word must occur
    var start = column - config.maxLen / 2;
    if (start < 0) {
      start = 0;
    } else {
      textOffset += start;
    }
    text = text.substring(start, column + config.maxLen / 2);
    return getWordAtText(column, wordDefinition, text, textOffset, config);
  }
  var t1 = Date.now();
  var pos = column - 1 - textOffset;
  var prevRegexIndex = -1;
  var match = null;
  for (var i = 1;; i++) {
    // check time budget
    if (Date.now() - t1 >= config.timeBudget) {
      break;
    }
    // reset the index at which the regexp should start matching, also know where it
    // should stop so that subsequent search don't repeat previous searches
    var regexIndex = pos - config.windowSize * i;
    wordDefinition.lastIndex = Math.max(0, regexIndex);
    var thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);
    if (!thisMatch && match) {
      // stop: we have something
      break;
    }
    match = thisMatch;
    // stop: searched at start
    if (regexIndex <= 0) {
      break;
    }
    prevRegexIndex = regexIndex;
  }
  if (match) {
    var result = {
      word: match[0],
      startColumn: textOffset + 1 + match.index,
      endColumn: textOffset + 1 + match.index + match[0].length
    };
    wordDefinition.lastIndex = 0;
    return result;
  }
  return null;
}
function _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {
  var match;
  while (match = wordDefinition.exec(text)) {
    var matchIndex = match.index || 0;
    if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {
      return match;
    } else if (stopPos > 0 && matchIndex > stopPos) {
      return null;
    }
  }
  return null;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

/**
 * A fast character classifier that uses a compact array for ASCII values.
 */
var CharacterClassifier = /*#__PURE__*/function () {
  function CharacterClassifier(_defaultValue) {
    classCallCheck_default()(this, CharacterClassifier);
    var defaultValue = toUint8(_defaultValue);
    this._defaultValue = defaultValue;
    this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
    this._map = new Map();
  }
  createClass_default()(CharacterClassifier, [{
    key: "set",
    value: function set(charCode, _value) {
      var value = toUint8(_value);
      if (charCode >= 0 && charCode < 256) {
        this._asciiMap[charCode] = value;
      } else {
        this._map.set(charCode, value);
      }
    }
  }, {
    key: "get",
    value: function get(charCode) {
      if (charCode >= 0 && charCode < 256) {
        return this._asciiMap[charCode];
      } else {
        return this._map.get(charCode) || this._defaultValue;
      }
    }
  }], [{
    key: "_createAsciiMap",
    value: function _createAsciiMap(defaultValue) {
      var asciiMap = new Uint8Array(256);
      for (var i = 0; i < 256; i++) {
        asciiMap[i] = defaultValue;
      }
      return asciiMap;
    }
  }]);
  return CharacterClassifier;
}();
var CharacterSet = /*#__PURE__*/(/* unused pure expression or super */ null && (function () {
  function CharacterSet() {
    _classCallCheck(this, CharacterSet);
    this._actual = new CharacterClassifier(0 /* False */);
  }
  _createClass(CharacterSet, [{
    key: "add",
    value: function add(charCode) {
      this._actual.set(charCode, 1 /* True */);
    }
  }, {
    key: "has",
    value: function has(charCode) {
      return this._actual.get(charCode) === 1 /* True */;
    }
  }]);
  return CharacterSet;
}()));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/modes/linkComputer.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var Uint8Matrix = /*#__PURE__*/function () {
  function Uint8Matrix(rows, cols, defaultValue) {
    classCallCheck_default()(this, Uint8Matrix);
    var data = new Uint8Array(rows * cols);
    for (var i = 0, len = rows * cols; i < len; i++) {
      data[i] = defaultValue;
    }
    this._data = data;
    this.rows = rows;
    this.cols = cols;
  }
  createClass_default()(Uint8Matrix, [{
    key: "get",
    value: function get(row, col) {
      return this._data[row * this.cols + col];
    }
  }, {
    key: "set",
    value: function set(row, col, value) {
      this._data[row * this.cols + col] = value;
    }
  }]);
  return Uint8Matrix;
}();
var StateMachine = /*#__PURE__*/function () {
  function StateMachine(edges) {
    classCallCheck_default()(this, StateMachine);
    var maxCharCode = 0;
    var maxState = 0 /* Invalid */;
    for (var i = 0, len = edges.length; i < len; i++) {
      var _edges$i = slicedToArray_default()(edges[i], 3),
        from = _edges$i[0],
        chCode = _edges$i[1],
        to = _edges$i[2];
      if (chCode > maxCharCode) {
        maxCharCode = chCode;
      }
      if (from > maxState) {
        maxState = from;
      }
      if (to > maxState) {
        maxState = to;
      }
    }
    maxCharCode++;
    maxState++;
    var states = new Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);
    for (var _i = 0, _len = edges.length; _i < _len; _i++) {
      var _edges$_i = slicedToArray_default()(edges[_i], 3),
        _from = _edges$_i[0],
        _chCode = _edges$_i[1],
        _to = _edges$_i[2];
      states.set(_from, _chCode, _to);
    }
    this._states = states;
    this._maxCharCode = maxCharCode;
  }
  createClass_default()(StateMachine, [{
    key: "nextState",
    value: function nextState(currentState, chCode) {
      if (chCode < 0 || chCode >= this._maxCharCode) {
        return 0 /* Invalid */;
      }

      return this._states.get(currentState, chCode);
    }
  }]);
  return StateMachine;
}();
// State machine for http:// or https:// or file://
var _stateMachine = null;
function getStateMachine() {
  if (_stateMachine === null) {
    _stateMachine = new StateMachine([[1 /* Start */, 104 /* h */, 2 /* H */], [1 /* Start */, 72 /* H */, 2 /* H */], [1 /* Start */, 102 /* f */, 6 /* F */], [1 /* Start */, 70 /* F */, 6 /* F */], [2 /* H */, 116 /* t */, 3 /* HT */], [2 /* H */, 84 /* T */, 3 /* HT */], [3 /* HT */, 116 /* t */, 4 /* HTT */], [3 /* HT */, 84 /* T */, 4 /* HTT */], [4 /* HTT */, 112 /* p */, 5 /* HTTP */], [4 /* HTT */, 80 /* P */, 5 /* HTTP */], [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */], [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */], [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */], [6 /* F */, 105 /* i */, 7 /* FI */], [6 /* F */, 73 /* I */, 7 /* FI */], [7 /* FI */, 108 /* l */, 8 /* FIL */], [7 /* FI */, 76 /* L */, 8 /* FIL */], [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */], [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */], [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */], [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */], [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */]]);
  }

  return _stateMachine;
}
var _classifier = null;
function getClassifier() {
  if (_classifier === null) {
    _classifier = new CharacterClassifier(0 /* None */);
    var FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';
    for (var i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
      _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);
    }

    var CANNOT_END_WITH_CHARACTERS = '.,;';
    for (var _i2 = 0; _i2 < CANNOT_END_WITH_CHARACTERS.length; _i2++) {
      _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(_i2), 2 /* CannotEndIn */);
    }
  }

  return _classifier;
}
var LinkComputer = /*#__PURE__*/function () {
  function LinkComputer() {
    classCallCheck_default()(this, LinkComputer);
  }
  createClass_default()(LinkComputer, null, [{
    key: "_createLink",
    value: function _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {
      // Do not allow to end link in certain characters...
      var lastIncludedCharIndex = linkEndIndex - 1;
      do {
        var chCode = line.charCodeAt(lastIncludedCharIndex);
        var chClass = classifier.get(chCode);
        if (chClass !== 2 /* CannotEndIn */) {
          break;
        }
        lastIncludedCharIndex--;
      } while (lastIncludedCharIndex > linkBeginIndex);
      // Handle links enclosed in parens, square brackets and curlys.
      if (linkBeginIndex > 0) {
        var charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);
        var lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);
        if (charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */ || charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */ || charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */) {
          // Do not end in ) if ( is before the link start
          // Do not end in ] if [ is before the link start
          // Do not end in } if { is before the link start
          lastIncludedCharIndex--;
        }
      }
      return {
        range: {
          startLineNumber: lineNumber,
          startColumn: linkBeginIndex + 1,
          endLineNumber: lineNumber,
          endColumn: lastIncludedCharIndex + 2
        },
        url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)
      };
    }
  }, {
    key: "computeLinks",
    value: function computeLinks(model) {
      var stateMachine = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getStateMachine();
      var classifier = getClassifier();
      var result = [];
      for (var i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {
        var line = model.getLineContent(i);
        var len = line.length;
        var j = 0;
        var linkBeginIndex = 0;
        var linkBeginChCode = 0;
        var state = 1 /* Start */;
        var hasOpenParens = false;
        var hasOpenSquareBracket = false;
        var inSquareBrackets = false;
        var hasOpenCurlyBracket = false;
        while (j < len) {
          var resetStateMachine = false;
          var chCode = line.charCodeAt(j);
          if (state === 13 /* Accept */) {
            var chClass = void 0;
            switch (chCode) {
              case 40 /* OpenParen */:
                hasOpenParens = true;
                chClass = 0 /* None */;
                break;
              case 41 /* CloseParen */:
                chClass = hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              case 91 /* OpenSquareBracket */:
                inSquareBrackets = true;
                hasOpenSquareBracket = true;
                chClass = 0 /* None */;
                break;
              case 93 /* CloseSquareBracket */:
                inSquareBrackets = false;
                chClass = hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              case 123 /* OpenCurlyBrace */:
                hasOpenCurlyBracket = true;
                chClass = 0 /* None */;
                break;
              case 125 /* CloseCurlyBrace */:
                chClass = hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              /* The following three rules make it that ' or " or ` are allowed inside links if the link began with a different one */
              case 39 /* SingleQuote */:
                chClass = linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */ ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              case 34 /* DoubleQuote */:
                chClass = linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */ ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              case 96 /* BackTick */:
                chClass = linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */ ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              case 42 /* Asterisk */:
                // `*` terminates a link if the link began with `*`
                chClass = linkBeginChCode === 42 /* Asterisk */ ? 1 /* ForceTermination */ : 0 /* None */;
                break;
              case 124 /* Pipe */:
                // `|` terminates a link if the link began with `|`
                chClass = linkBeginChCode === 124 /* Pipe */ ? 1 /* ForceTermination */ : 0 /* None */;
                break;
              case 32 /* Space */:
                // ` ` allow space in between [ and ]
                chClass = inSquareBrackets ? 0 /* None */ : 1 /* ForceTermination */;
                break;
              default:
                chClass = classifier.get(chCode);
            }
            // Check if character terminates link
            if (chClass === 1 /* ForceTermination */) {
              result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));
              resetStateMachine = true;
            }
          } else if (state === 12 /* End */) {
            var _chClass = void 0;
            if (chCode === 91 /* OpenSquareBracket */) {
              // Allow for the authority part to contain ipv6 addresses which contain [ and ]
              hasOpenSquareBracket = true;
              _chClass = 0 /* None */;
            } else {
              _chClass = classifier.get(chCode);
            }
            // Check if character terminates link
            if (_chClass === 1 /* ForceTermination */) {
              resetStateMachine = true;
            } else {
              state = 13 /* Accept */;
            }
          } else {
            state = stateMachine.nextState(state, chCode);
            if (state === 0 /* Invalid */) {
              resetStateMachine = true;
            }
          }
          if (resetStateMachine) {
            state = 1 /* Start */;
            hasOpenParens = false;
            hasOpenSquareBracket = false;
            hasOpenCurlyBracket = false;
            // Record where the link started
            linkBeginIndex = j + 1;
            linkBeginChCode = chCode;
          }
          j++;
        }
        if (state === 13 /* Accept */) {
          result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));
        }
      }
      return result;
    }
  }]);
  return LinkComputer;
}();
/**
 * Returns an array of all links contains in the provided
 * document. *Note* that this operation is computational
 * expensive and should not run in the UI thread.
 */
function linkComputer_computeLinks(model) {
  if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {
    // Unknown caller!
    return [];
  }
  return LinkComputer.computeLinks(model);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var BasicInplaceReplace = /*#__PURE__*/function () {
  function BasicInplaceReplace() {
    classCallCheck_default()(this, BasicInplaceReplace);
    this._defaultValueSet = [['true', 'false'], ['True', 'False'], ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'], ['public', 'protected', 'private']];
  }
  createClass_default()(BasicInplaceReplace, [{
    key: "navigateValueSet",
    value: function navigateValueSet(range1, text1, range2, text2, up) {
      if (range1 && text1) {
        var result = this.doNavigateValueSet(text1, up);
        if (result) {
          return {
            range: range1,
            value: result
          };
        }
      }
      if (range2 && text2) {
        var _result = this.doNavigateValueSet(text2, up);
        if (_result) {
          return {
            range: range2,
            value: _result
          };
        }
      }
      return null;
    }
  }, {
    key: "doNavigateValueSet",
    value: function doNavigateValueSet(text, up) {
      var numberResult = this.numberReplace(text, up);
      if (numberResult !== null) {
        return numberResult;
      }
      return this.textReplace(text, up);
    }
  }, {
    key: "numberReplace",
    value: function numberReplace(value, up) {
      var precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));
      var n1 = Number(value);
      var n2 = parseFloat(value);
      if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {
        if (n1 === 0 && !up) {
          return null; // don't do negative
          //			} else if(n1 === 9 && up) {
          //				return null; // don't insert 10 into a number
        } else {
          n1 = Math.floor(n1 * precision);
          n1 += up ? precision : -precision;
          return String(n1 / precision);
        }
      }
      return null;
    }
  }, {
    key: "textReplace",
    value: function textReplace(value, up) {
      return this.valueSetsReplace(this._defaultValueSet, value, up);
    }
  }, {
    key: "valueSetsReplace",
    value: function valueSetsReplace(valueSets, value, up) {
      var result = null;
      for (var i = 0, len = valueSets.length; result === null && i < len; i++) {
        result = this.valueSetReplace(valueSets[i], value, up);
      }
      return result;
    }
  }, {
    key: "valueSetReplace",
    value: function valueSetReplace(valueSet, value, up) {
      var idx = valueSet.indexOf(value);
      if (idx >= 0) {
        idx += up ? +1 : -1;
        if (idx < 0) {
          idx = valueSet.length - 1;
        } else {
          idx %= valueSet.length;
        }
        return valueSet[idx];
      }
      return null;
    }
  }]);
  return BasicInplaceReplace;
}();
BasicInplaceReplace.INSTANCE = new BasicInplaceReplace();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/cancellation.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var shortcutEvent = Object.freeze(function (callback, context) {
  var handle = setTimeout(callback.bind(context), 0);
  return {
    dispose: function dispose() {
      clearTimeout(handle);
    }
  };
});
var CancellationToken;
(function (CancellationToken) {
  function isCancellationToken(thing) {
    if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {
      return true;
    }
    if (thing instanceof MutableToken) {
      return true;
    }
    if (!thing || typeof_default()(thing) !== 'object') {
      return false;
    }
    return typeof thing.isCancellationRequested === 'boolean' && typeof thing.onCancellationRequested === 'function';
  }
  CancellationToken.isCancellationToken = isCancellationToken;
  CancellationToken.None = Object.freeze({
    isCancellationRequested: false,
    onCancellationRequested: Event.None
  });
  CancellationToken.Cancelled = Object.freeze({
    isCancellationRequested: true,
    onCancellationRequested: shortcutEvent
  });
})(CancellationToken || (CancellationToken = {}));
var MutableToken = /*#__PURE__*/function () {
  function MutableToken() {
    classCallCheck_default()(this, MutableToken);
    this._isCancelled = false;
    this._emitter = null;
  }
  createClass_default()(MutableToken, [{
    key: "cancel",
    value: function cancel() {
      if (!this._isCancelled) {
        this._isCancelled = true;
        if (this._emitter) {
          this._emitter.fire(undefined);
          this.dispose();
        }
      }
    }
  }, {
    key: "isCancellationRequested",
    get: function get() {
      return this._isCancelled;
    }
  }, {
    key: "onCancellationRequested",
    get: function get() {
      if (this._isCancelled) {
        return shortcutEvent;
      }
      if (!this._emitter) {
        this._emitter = new Emitter();
      }
      return this._emitter.event;
    }
  }, {
    key: "dispose",
    value: function dispose() {
      if (this._emitter) {
        this._emitter.dispose();
        this._emitter = null;
      }
    }
  }]);
  return MutableToken;
}();
var CancellationTokenSource = /*#__PURE__*/function () {
  function CancellationTokenSource(parent) {
    classCallCheck_default()(this, CancellationTokenSource);
    this._token = undefined;
    this._parentListener = undefined;
    this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);
  }
  createClass_default()(CancellationTokenSource, [{
    key: "token",
    get: function get() {
      if (!this._token) {
        // be lazy and create the token only when
        // actually needed
        this._token = new MutableToken();
      }
      return this._token;
    }
  }, {
    key: "cancel",
    value: function cancel() {
      if (!this._token) {
        // save an object by returning the default
        // cancelled token when cancellation happens
        // before someone asks for the token
        this._token = CancellationToken.Cancelled;
      } else if (this._token instanceof MutableToken) {
        // actually cancel
        this._token.cancel();
      }
    }
  }, {
    key: "dispose",
    value: function dispose() {
      var cancel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      if (cancel) {
        this.cancel();
      }
      if (this._parentListener) {
        this._parentListener.dispose();
      }
      if (!this._token) {
        // ensure to initialize with an empty token if we had none
        this._token = CancellationToken.None;
      } else if (this._token instanceof MutableToken) {
        // actually dispose
        this._token.dispose();
      }
    }
  }]);
  return CancellationTokenSource;
}();
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js



/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var KeyCodeStrMap = /*#__PURE__*/function () {
  function KeyCodeStrMap() {
    classCallCheck_default()(this, KeyCodeStrMap);
    this._keyCodeToStr = [];
    this._strToKeyCode = Object.create(null);
  }
  createClass_default()(KeyCodeStrMap, [{
    key: "define",
    value: function define(keyCode, str) {
      this._keyCodeToStr[keyCode] = str;
      this._strToKeyCode[str.toLowerCase()] = keyCode;
    }
  }, {
    key: "keyCodeToStr",
    value: function keyCodeToStr(keyCode) {
      return this._keyCodeToStr[keyCode];
    }
  }, {
    key: "strToKeyCode",
    value: function strToKeyCode(str) {
      return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;
    }
  }]);
  return KeyCodeStrMap;
}();
var uiMap = new KeyCodeStrMap();
var userSettingsUSMap = new KeyCodeStrMap();
var userSettingsGeneralMap = new KeyCodeStrMap();
var EVENT_KEY_CODE_MAP = new Array(230);
var NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {};
var scanCodeIntToStr = [];
var scanCodeStrToInt = Object.create(null);
var scanCodeLowerCaseStrToInt = Object.create(null);
/**
 * -1 if a ScanCode => KeyCode mapping depends on kb layout.
 */
var IMMUTABLE_CODE_TO_KEY_CODE = [];
/**
 * -1 if a KeyCode => ScanCode mapping depends on kb layout.
 */
var IMMUTABLE_KEY_CODE_TO_CODE = [];
for (var i = 0; i <= 193 /* MAX_VALUE */; i++) {
  IMMUTABLE_CODE_TO_KEY_CODE[i] = -1 /* DependsOnKbLayout */;
}

for (var _i = 0; _i <= 126 /* MAX_VALUE */; _i++) {
  IMMUTABLE_KEY_CODE_TO_CODE[_i] = -1 /* DependsOnKbLayout */;
}

(function () {
  // See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
  // See https://github.com/microsoft/node-native-keymap/blob/master/deps/chromium/keyboard_codes_win.h
  var empty = '';
  var mappings = [
  // keyCodeOrd, immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel
  [0, 1, 0 /* None */, 'None', 0 /* Unknown */, 'unknown', 0, 'VK_UNKNOWN', empty, empty], [0, 1, 1 /* Hyper */, 'Hyper', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 2 /* Super */, 'Super', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 3 /* Fn */, 'Fn', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 4 /* FnLock */, 'FnLock', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 5 /* Suspend */, 'Suspend', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 6 /* Resume */, 'Resume', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 7 /* Turbo */, 'Turbo', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 8 /* Sleep */, 'Sleep', 0 /* Unknown */, empty, 0, 'VK_SLEEP', empty, empty], [0, 1, 9 /* WakeUp */, 'WakeUp', 0 /* Unknown */, empty, 0, empty, empty, empty], [31, 0, 10 /* KeyA */, 'KeyA', 31 /* KeyA */, 'A', 65, 'VK_A', empty, empty], [32, 0, 11 /* KeyB */, 'KeyB', 32 /* KeyB */, 'B', 66, 'VK_B', empty, empty], [33, 0, 12 /* KeyC */, 'KeyC', 33 /* KeyC */, 'C', 67, 'VK_C', empty, empty], [34, 0, 13 /* KeyD */, 'KeyD', 34 /* KeyD */, 'D', 68, 'VK_D', empty, empty], [35, 0, 14 /* KeyE */, 'KeyE', 35 /* KeyE */, 'E', 69, 'VK_E', empty, empty], [36, 0, 15 /* KeyF */, 'KeyF', 36 /* KeyF */, 'F', 70, 'VK_F', empty, empty], [37, 0, 16 /* KeyG */, 'KeyG', 37 /* KeyG */, 'G', 71, 'VK_G', empty, empty], [38, 0, 17 /* KeyH */, 'KeyH', 38 /* KeyH */, 'H', 72, 'VK_H', empty, empty], [39, 0, 18 /* KeyI */, 'KeyI', 39 /* KeyI */, 'I', 73, 'VK_I', empty, empty], [40, 0, 19 /* KeyJ */, 'KeyJ', 40 /* KeyJ */, 'J', 74, 'VK_J', empty, empty], [41, 0, 20 /* KeyK */, 'KeyK', 41 /* KeyK */, 'K', 75, 'VK_K', empty, empty], [42, 0, 21 /* KeyL */, 'KeyL', 42 /* KeyL */, 'L', 76, 'VK_L', empty, empty], [43, 0, 22 /* KeyM */, 'KeyM', 43 /* KeyM */, 'M', 77, 'VK_M', empty, empty], [44, 0, 23 /* KeyN */, 'KeyN', 44 /* KeyN */, 'N', 78, 'VK_N', empty, empty], [45, 0, 24 /* KeyO */, 'KeyO', 45 /* KeyO */, 'O', 79, 'VK_O', empty, empty], [46, 0, 25 /* KeyP */, 'KeyP', 46 /* KeyP */, 'P', 80, 'VK_P', empty, empty], [47, 0, 26 /* KeyQ */, 'KeyQ', 47 /* KeyQ */, 'Q', 81, 'VK_Q', empty, empty], [48, 0, 27 /* KeyR */, 'KeyR', 48 /* KeyR */, 'R', 82, 'VK_R', empty, empty], [49, 0, 28 /* KeyS */, 'KeyS', 49 /* KeyS */, 'S', 83, 'VK_S', empty, empty], [50, 0, 29 /* KeyT */, 'KeyT', 50 /* KeyT */, 'T', 84, 'VK_T', empty, empty], [51, 0, 30 /* KeyU */, 'KeyU', 51 /* KeyU */, 'U', 85, 'VK_U', empty, empty], [52, 0, 31 /* KeyV */, 'KeyV', 52 /* KeyV */, 'V', 86, 'VK_V', empty, empty], [53, 0, 32 /* KeyW */, 'KeyW', 53 /* KeyW */, 'W', 87, 'VK_W', empty, empty], [54, 0, 33 /* KeyX */, 'KeyX', 54 /* KeyX */, 'X', 88, 'VK_X', empty, empty], [55, 0, 34 /* KeyY */, 'KeyY', 55 /* KeyY */, 'Y', 89, 'VK_Y', empty, empty], [56, 0, 35 /* KeyZ */, 'KeyZ', 56 /* KeyZ */, 'Z', 90, 'VK_Z', empty, empty], [22, 0, 36 /* Digit1 */, 'Digit1', 22 /* Digit1 */, '1', 49, 'VK_1', empty, empty], [23, 0, 37 /* Digit2 */, 'Digit2', 23 /* Digit2 */, '2', 50, 'VK_2', empty, empty], [24, 0, 38 /* Digit3 */, 'Digit3', 24 /* Digit3 */, '3', 51, 'VK_3', empty, empty], [25, 0, 39 /* Digit4 */, 'Digit4', 25 /* Digit4 */, '4', 52, 'VK_4', empty, empty], [26, 0, 40 /* Digit5 */, 'Digit5', 26 /* Digit5 */, '5', 53, 'VK_5', empty, empty], [27, 0, 41 /* Digit6 */, 'Digit6', 27 /* Digit6 */, '6', 54, 'VK_6', empty, empty], [28, 0, 42 /* Digit7 */, 'Digit7', 28 /* Digit7 */, '7', 55, 'VK_7', empty, empty], [29, 0, 43 /* Digit8 */, 'Digit8', 29 /* Digit8 */, '8', 56, 'VK_8', empty, empty], [30, 0, 44 /* Digit9 */, 'Digit9', 30 /* Digit9 */, '9', 57, 'VK_9', empty, empty], [21, 0, 45 /* Digit0 */, 'Digit0', 21 /* Digit0 */, '0', 48, 'VK_0', empty, empty], [3, 1, 46 /* Enter */, 'Enter', 3 /* Enter */, 'Enter', 13, 'VK_RETURN', empty, empty], [9, 1, 47 /* Escape */, 'Escape', 9 /* Escape */, 'Escape', 27, 'VK_ESCAPE', empty, empty], [1, 1, 48 /* Backspace */, 'Backspace', 1 /* Backspace */, 'Backspace', 8, 'VK_BACK', empty, empty], [2, 1, 49 /* Tab */, 'Tab', 2 /* Tab */, 'Tab', 9, 'VK_TAB', empty, empty], [10, 1, 50 /* Space */, 'Space', 10 /* Space */, 'Space', 32, 'VK_SPACE', empty, empty], [83, 0, 51 /* Minus */, 'Minus', 83 /* Minus */, '-', 189, 'VK_OEM_MINUS', '-', 'OEM_MINUS'], [81, 0, 52 /* Equal */, 'Equal', 81 /* Equal */, '=', 187, 'VK_OEM_PLUS', '=', 'OEM_PLUS'], [87, 0, 53 /* BracketLeft */, 'BracketLeft', 87 /* BracketLeft */, '[', 219, 'VK_OEM_4', '[', 'OEM_4'], [89, 0, 54 /* BracketRight */, 'BracketRight', 89 /* BracketRight */, ']', 221, 'VK_OEM_6', ']', 'OEM_6'], [88, 0, 55 /* Backslash */, 'Backslash', 88 /* Backslash */, '\\', 220, 'VK_OEM_5', '\\', 'OEM_5'], [0, 0, 56 /* IntlHash */, 'IntlHash', 0 /* Unknown */, empty, 0, empty, empty, empty], [80, 0, 57 /* Semicolon */, 'Semicolon', 80 /* Semicolon */, ';', 186, 'VK_OEM_1', ';', 'OEM_1'], [90, 0, 58 /* Quote */, 'Quote', 90 /* Quote */, '\'', 222, 'VK_OEM_7', '\'', 'OEM_7'], [86, 0, 59 /* Backquote */, 'Backquote', 86 /* Backquote */, '`', 192, 'VK_OEM_3', '`', 'OEM_3'], [82, 0, 60 /* Comma */, 'Comma', 82 /* Comma */, ',', 188, 'VK_OEM_COMMA', ',', 'OEM_COMMA'], [84, 0, 61 /* Period */, 'Period', 84 /* Period */, '.', 190, 'VK_OEM_PERIOD', '.', 'OEM_PERIOD'], [85, 0, 62 /* Slash */, 'Slash', 85 /* Slash */, '/', 191, 'VK_OEM_2', '/', 'OEM_2'], [8, 1, 63 /* CapsLock */, 'CapsLock', 8 /* CapsLock */, 'CapsLock', 20, 'VK_CAPITAL', empty, empty], [59, 1, 64 /* F1 */, 'F1', 59 /* F1 */, 'F1', 112, 'VK_F1', empty, empty], [60, 1, 65 /* F2 */, 'F2', 60 /* F2 */, 'F2', 113, 'VK_F2', empty, empty], [61, 1, 66 /* F3 */, 'F3', 61 /* F3 */, 'F3', 114, 'VK_F3', empty, empty], [62, 1, 67 /* F4 */, 'F4', 62 /* F4 */, 'F4', 115, 'VK_F4', empty, empty], [63, 1, 68 /* F5 */, 'F5', 63 /* F5 */, 'F5', 116, 'VK_F5', empty, empty], [64, 1, 69 /* F6 */, 'F6', 64 /* F6 */, 'F6', 117, 'VK_F6', empty, empty], [65, 1, 70 /* F7 */, 'F7', 65 /* F7 */, 'F7', 118, 'VK_F7', empty, empty], [66, 1, 71 /* F8 */, 'F8', 66 /* F8 */, 'F8', 119, 'VK_F8', empty, empty], [67, 1, 72 /* F9 */, 'F9', 67 /* F9 */, 'F9', 120, 'VK_F9', empty, empty], [68, 1, 73 /* F10 */, 'F10', 68 /* F10 */, 'F10', 121, 'VK_F10', empty, empty], [69, 1, 74 /* F11 */, 'F11', 69 /* F11 */, 'F11', 122, 'VK_F11', empty, empty], [70, 1, 75 /* F12 */, 'F12', 70 /* F12 */, 'F12', 123, 'VK_F12', empty, empty], [0, 1, 76 /* PrintScreen */, 'PrintScreen', 0 /* Unknown */, empty, 0, empty, empty, empty], [79, 1, 77 /* ScrollLock */, 'ScrollLock', 79 /* ScrollLock */, 'ScrollLock', 145, 'VK_SCROLL', empty, empty], [7, 1, 78 /* Pause */, 'Pause', 7 /* PauseBreak */, 'PauseBreak', 19, 'VK_PAUSE', empty, empty], [19, 1, 79 /* Insert */, 'Insert', 19 /* Insert */, 'Insert', 45, 'VK_INSERT', empty, empty], [14, 1, 80 /* Home */, 'Home', 14 /* Home */, 'Home', 36, 'VK_HOME', empty, empty], [11, 1, 81 /* PageUp */, 'PageUp', 11 /* PageUp */, 'PageUp', 33, 'VK_PRIOR', empty, empty], [20, 1, 82 /* Delete */, 'Delete', 20 /* Delete */, 'Delete', 46, 'VK_DELETE', empty, empty], [13, 1, 83 /* End */, 'End', 13 /* End */, 'End', 35, 'VK_END', empty, empty], [12, 1, 84 /* PageDown */, 'PageDown', 12 /* PageDown */, 'PageDown', 34, 'VK_NEXT', empty, empty], [17, 1, 85 /* ArrowRight */, 'ArrowRight', 17 /* RightArrow */, 'RightArrow', 39, 'VK_RIGHT', 'Right', empty], [15, 1, 86 /* ArrowLeft */, 'ArrowLeft', 15 /* LeftArrow */, 'LeftArrow', 37, 'VK_LEFT', 'Left', empty], [18, 1, 87 /* ArrowDown */, 'ArrowDown', 18 /* DownArrow */, 'DownArrow', 40, 'VK_DOWN', 'Down', empty], [16, 1, 88 /* ArrowUp */, 'ArrowUp', 16 /* UpArrow */, 'UpArrow', 38, 'VK_UP', 'Up', empty], [78, 1, 89 /* NumLock */, 'NumLock', 78 /* NumLock */, 'NumLock', 144, 'VK_NUMLOCK', empty, empty], [108, 1, 90 /* NumpadDivide */, 'NumpadDivide', 108 /* NumpadDivide */, 'NumPad_Divide', 111, 'VK_DIVIDE', empty, empty], [103, 1, 91 /* NumpadMultiply */, 'NumpadMultiply', 103 /* NumpadMultiply */, 'NumPad_Multiply', 106, 'VK_MULTIPLY', empty, empty], [106, 1, 92 /* NumpadSubtract */, 'NumpadSubtract', 106 /* NumpadSubtract */, 'NumPad_Subtract', 109, 'VK_SUBTRACT', empty, empty], [104, 1, 93 /* NumpadAdd */, 'NumpadAdd', 104 /* NumpadAdd */, 'NumPad_Add', 107, 'VK_ADD', empty, empty], [3, 1, 94 /* NumpadEnter */, 'NumpadEnter', 3 /* Enter */, empty, 0, empty, empty, empty], [94, 1, 95 /* Numpad1 */, 'Numpad1', 94 /* Numpad1 */, 'NumPad1', 97, 'VK_NUMPAD1', empty, empty], [95, 1, 96 /* Numpad2 */, 'Numpad2', 95 /* Numpad2 */, 'NumPad2', 98, 'VK_NUMPAD2', empty, empty], [96, 1, 97 /* Numpad3 */, 'Numpad3', 96 /* Numpad3 */, 'NumPad3', 99, 'VK_NUMPAD3', empty, empty], [97, 1, 98 /* Numpad4 */, 'Numpad4', 97 /* Numpad4 */, 'NumPad4', 100, 'VK_NUMPAD4', empty, empty], [98, 1, 99 /* Numpad5 */, 'Numpad5', 98 /* Numpad5 */, 'NumPad5', 101, 'VK_NUMPAD5', empty, empty], [99, 1, 100 /* Numpad6 */, 'Numpad6', 99 /* Numpad6 */, 'NumPad6', 102, 'VK_NUMPAD6', empty, empty], [100, 1, 101 /* Numpad7 */, 'Numpad7', 100 /* Numpad7 */, 'NumPad7', 103, 'VK_NUMPAD7', empty, empty], [101, 1, 102 /* Numpad8 */, 'Numpad8', 101 /* Numpad8 */, 'NumPad8', 104, 'VK_NUMPAD8', empty, empty], [102, 1, 103 /* Numpad9 */, 'Numpad9', 102 /* Numpad9 */, 'NumPad9', 105, 'VK_NUMPAD9', empty, empty], [93, 1, 104 /* Numpad0 */, 'Numpad0', 93 /* Numpad0 */, 'NumPad0', 96, 'VK_NUMPAD0', empty, empty], [107, 1, 105 /* NumpadDecimal */, 'NumpadDecimal', 107 /* NumpadDecimal */, 'NumPad_Decimal', 110, 'VK_DECIMAL', empty, empty], [92, 0, 106 /* IntlBackslash */, 'IntlBackslash', 92 /* IntlBackslash */, 'OEM_102', 226, 'VK_OEM_102', empty, empty], [58, 1, 107 /* ContextMenu */, 'ContextMenu', 58 /* ContextMenu */, 'ContextMenu', 93, empty, empty, empty], [0, 1, 108 /* Power */, 'Power', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 109 /* NumpadEqual */, 'NumpadEqual', 0 /* Unknown */, empty, 0, empty, empty, empty], [71, 1, 110 /* F13 */, 'F13', 71 /* F13 */, 'F13', 124, 'VK_F13', empty, empty], [72, 1, 111 /* F14 */, 'F14', 72 /* F14 */, 'F14', 125, 'VK_F14', empty, empty], [73, 1, 112 /* F15 */, 'F15', 73 /* F15 */, 'F15', 126, 'VK_F15', empty, empty], [74, 1, 113 /* F16 */, 'F16', 74 /* F16 */, 'F16', 127, 'VK_F16', empty, empty], [75, 1, 114 /* F17 */, 'F17', 75 /* F17 */, 'F17', 128, 'VK_F17', empty, empty], [76, 1, 115 /* F18 */, 'F18', 76 /* F18 */, 'F18', 129, 'VK_F18', empty, empty], [77, 1, 116 /* F19 */, 'F19', 77 /* F19 */, 'F19', 130, 'VK_F19', empty, empty], [0, 1, 117 /* F20 */, 'F20', 0 /* Unknown */, empty, 0, 'VK_F20', empty, empty], [0, 1, 118 /* F21 */, 'F21', 0 /* Unknown */, empty, 0, 'VK_F21', empty, empty], [0, 1, 119 /* F22 */, 'F22', 0 /* Unknown */, empty, 0, 'VK_F22', empty, empty], [0, 1, 120 /* F23 */, 'F23', 0 /* Unknown */, empty, 0, 'VK_F23', empty, empty], [0, 1, 121 /* F24 */, 'F24', 0 /* Unknown */, empty, 0, 'VK_F24', empty, empty], [0, 1, 122 /* Open */, 'Open', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 123 /* Help */, 'Help', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 124 /* Select */, 'Select', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 125 /* Again */, 'Again', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 126 /* Undo */, 'Undo', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 127 /* Cut */, 'Cut', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 128 /* Copy */, 'Copy', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 129 /* Paste */, 'Paste', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 130 /* Find */, 'Find', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 131 /* AudioVolumeMute */, 'AudioVolumeMute', 112 /* AudioVolumeMute */, 'AudioVolumeMute', 173, 'VK_VOLUME_MUTE', empty, empty], [0, 1, 132 /* AudioVolumeUp */, 'AudioVolumeUp', 113 /* AudioVolumeUp */, 'AudioVolumeUp', 175, 'VK_VOLUME_UP', empty, empty], [0, 1, 133 /* AudioVolumeDown */, 'AudioVolumeDown', 114 /* AudioVolumeDown */, 'AudioVolumeDown', 174, 'VK_VOLUME_DOWN', empty, empty], [105, 1, 134 /* NumpadComma */, 'NumpadComma', 105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator', 108, 'VK_SEPARATOR', empty, empty], [110, 0, 135 /* IntlRo */, 'IntlRo', 110 /* ABNT_C1 */, 'ABNT_C1', 193, 'VK_ABNT_C1', empty, empty], [0, 1, 136 /* KanaMode */, 'KanaMode', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 0, 137 /* IntlYen */, 'IntlYen', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 138 /* Convert */, 'Convert', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 139 /* NonConvert */, 'NonConvert', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 140 /* Lang1 */, 'Lang1', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 141 /* Lang2 */, 'Lang2', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 142 /* Lang3 */, 'Lang3', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 143 /* Lang4 */, 'Lang4', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 144 /* Lang5 */, 'Lang5', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 145 /* Abort */, 'Abort', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 146 /* Props */, 'Props', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 147 /* NumpadParenLeft */, 'NumpadParenLeft', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 148 /* NumpadParenRight */, 'NumpadParenRight', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 149 /* NumpadBackspace */, 'NumpadBackspace', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 150 /* NumpadMemoryStore */, 'NumpadMemoryStore', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 151 /* NumpadMemoryRecall */, 'NumpadMemoryRecall', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 152 /* NumpadMemoryClear */, 'NumpadMemoryClear', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 153 /* NumpadMemoryAdd */, 'NumpadMemoryAdd', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 154 /* NumpadMemorySubtract */, 'NumpadMemorySubtract', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 155 /* NumpadClear */, 'NumpadClear', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 156 /* NumpadClearEntry */, 'NumpadClearEntry', 0 /* Unknown */, empty, 0, empty, empty, empty], [5, 1, 0 /* None */, empty, 5 /* Ctrl */, 'Ctrl', 17, 'VK_CONTROL', empty, empty], [4, 1, 0 /* None */, empty, 4 /* Shift */, 'Shift', 16, 'VK_SHIFT', empty, empty], [6, 1, 0 /* None */, empty, 6 /* Alt */, 'Alt', 18, 'VK_MENU', empty, empty], [57, 1, 0 /* None */, empty, 57 /* Meta */, 'Meta', 0, 'VK_COMMAND', empty, empty], [5, 1, 157 /* ControlLeft */, 'ControlLeft', 5 /* Ctrl */, empty, 0, 'VK_LCONTROL', empty, empty], [4, 1, 158 /* ShiftLeft */, 'ShiftLeft', 4 /* Shift */, empty, 0, 'VK_LSHIFT', empty, empty], [6, 1, 159 /* AltLeft */, 'AltLeft', 6 /* Alt */, empty, 0, 'VK_LMENU', empty, empty], [57, 1, 160 /* MetaLeft */, 'MetaLeft', 57 /* Meta */, empty, 0, 'VK_LWIN', empty, empty], [5, 1, 161 /* ControlRight */, 'ControlRight', 5 /* Ctrl */, empty, 0, 'VK_RCONTROL', empty, empty], [4, 1, 162 /* ShiftRight */, 'ShiftRight', 4 /* Shift */, empty, 0, 'VK_RSHIFT', empty, empty], [6, 1, 163 /* AltRight */, 'AltRight', 6 /* Alt */, empty, 0, 'VK_RMENU', empty, empty], [57, 1, 164 /* MetaRight */, 'MetaRight', 57 /* Meta */, empty, 0, 'VK_RWIN', empty, empty], [0, 1, 165 /* BrightnessUp */, 'BrightnessUp', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 166 /* BrightnessDown */, 'BrightnessDown', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 167 /* MediaPlay */, 'MediaPlay', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 168 /* MediaRecord */, 'MediaRecord', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 169 /* MediaFastForward */, 'MediaFastForward', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 170 /* MediaRewind */, 'MediaRewind', 0 /* Unknown */, empty, 0, empty, empty, empty], [114, 1, 171 /* MediaTrackNext */, 'MediaTrackNext', 119 /* MediaTrackNext */, 'MediaTrackNext', 176, 'VK_MEDIA_NEXT_TRACK', empty, empty], [115, 1, 172 /* MediaTrackPrevious */, 'MediaTrackPrevious', 120 /* MediaTrackPrevious */, 'MediaTrackPrevious', 177, 'VK_MEDIA_PREV_TRACK', empty, empty], [116, 1, 173 /* MediaStop */, 'MediaStop', 121 /* MediaStop */, 'MediaStop', 178, 'VK_MEDIA_STOP', empty, empty], [0, 1, 174 /* Eject */, 'Eject', 0 /* Unknown */, empty, 0, empty, empty, empty], [117, 1, 175 /* MediaPlayPause */, 'MediaPlayPause', 122 /* MediaPlayPause */, 'MediaPlayPause', 179, 'VK_MEDIA_PLAY_PAUSE', empty, empty], [0, 1, 176 /* MediaSelect */, 'MediaSelect', 123 /* LaunchMediaPlayer */, 'LaunchMediaPlayer', 181, 'VK_MEDIA_LAUNCH_MEDIA_SELECT', empty, empty], [0, 1, 177 /* LaunchMail */, 'LaunchMail', 124 /* LaunchMail */, 'LaunchMail', 180, 'VK_MEDIA_LAUNCH_MAIL', empty, empty], [0, 1, 178 /* LaunchApp2 */, 'LaunchApp2', 125 /* LaunchApp2 */, 'LaunchApp2', 183, 'VK_MEDIA_LAUNCH_APP2', empty, empty], [0, 1, 179 /* LaunchApp1 */, 'LaunchApp1', 0 /* Unknown */, empty, 0, 'VK_MEDIA_LAUNCH_APP1', empty, empty], [0, 1, 180 /* SelectTask */, 'SelectTask', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 181 /* LaunchScreenSaver */, 'LaunchScreenSaver', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 182 /* BrowserSearch */, 'BrowserSearch', 115 /* BrowserSearch */, 'BrowserSearch', 170, 'VK_BROWSER_SEARCH', empty, empty], [0, 1, 183 /* BrowserHome */, 'BrowserHome', 116 /* BrowserHome */, 'BrowserHome', 172, 'VK_BROWSER_HOME', empty, empty], [112, 1, 184 /* BrowserBack */, 'BrowserBack', 117 /* BrowserBack */, 'BrowserBack', 166, 'VK_BROWSER_BACK', empty, empty], [113, 1, 185 /* BrowserForward */, 'BrowserForward', 118 /* BrowserForward */, 'BrowserForward', 167, 'VK_BROWSER_FORWARD', empty, empty], [0, 1, 186 /* BrowserStop */, 'BrowserStop', 0 /* Unknown */, empty, 0, 'VK_BROWSER_STOP', empty, empty], [0, 1, 187 /* BrowserRefresh */, 'BrowserRefresh', 0 /* Unknown */, empty, 0, 'VK_BROWSER_REFRESH', empty, empty], [0, 1, 188 /* BrowserFavorites */, 'BrowserFavorites', 0 /* Unknown */, empty, 0, 'VK_BROWSER_FAVORITES', empty, empty], [0, 1, 189 /* ZoomToggle */, 'ZoomToggle', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 190 /* MailReply */, 'MailReply', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 191 /* MailForward */, 'MailForward', 0 /* Unknown */, empty, 0, empty, empty, empty], [0, 1, 192 /* MailSend */, 'MailSend', 0 /* Unknown */, empty, 0, empty, empty, empty],
  // See https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html
  // If an Input Method Editor is processing key input and the event is keydown, return 229.
  [109, 1, 0 /* None */, empty, 109 /* KEY_IN_COMPOSITION */, 'KeyInComposition', 229, empty, empty, empty], [111, 1, 0 /* None */, empty, 111 /* ABNT_C2 */, 'ABNT_C2', 194, 'VK_ABNT_C2', empty, empty], [91, 1, 0 /* None */, empty, 91 /* OEM_8 */, 'OEM_8', 223, 'VK_OEM_8', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CLEAR', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANA', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANGUL', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_JUNJA', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_FINAL', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANJA', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANJI', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CONVERT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONCONVERT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ACCEPT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_MODECHANGE', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SELECT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PRINT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXECUTE', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SNAPSHOT', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HELP', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_APPS', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PROCESSKEY', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PACKET', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_SBCSCHAR', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_DBCSCHAR', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ATTN', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CRSEL', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXSEL', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EREOF', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PLAY', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ZOOM', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONAME', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PA1', empty, empty], [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_OEM_CLEAR', empty, empty]];
  var seenKeyCode = [];
  var seenScanCode = [];
  for (var _i2 = 0, _mappings = mappings; _i2 < _mappings.length; _i2++) {
    var mapping = _mappings[_i2];
    var _mapping = slicedToArray_default()(mapping, 10),
      _keyCodeOrd = _mapping[0],
      immutable = _mapping[1],
      scanCode = _mapping[2],
      scanCodeStr = _mapping[3],
      keyCode = _mapping[4],
      keyCodeStr = _mapping[5],
      eventKeyCode = _mapping[6],
      vkey = _mapping[7],
      usUserSettingsLabel = _mapping[8],
      generalUserSettingsLabel = _mapping[9];
    if (!seenScanCode[scanCode]) {
      seenScanCode[scanCode] = true;
      scanCodeIntToStr[scanCode] = scanCodeStr;
      scanCodeStrToInt[scanCodeStr] = scanCode;
      scanCodeLowerCaseStrToInt[scanCodeStr.toLowerCase()] = scanCode;
      if (immutable) {
        IMMUTABLE_CODE_TO_KEY_CODE[scanCode] = keyCode;
        if (keyCode !== 0 /* Unknown */ && keyCode !== 3 /* Enter */ && keyCode !== 5 /* Ctrl */ && keyCode !== 4 /* Shift */ && keyCode !== 6 /* Alt */ && keyCode !== 57 /* Meta */) {
          IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = scanCode;
        }
      }
    }
    if (!seenKeyCode[keyCode]) {
      seenKeyCode[keyCode] = true;
      if (!keyCodeStr) {
        throw new Error("String representation missing for key code ".concat(keyCode, " around scan code ").concat(scanCodeStr));
      }
      uiMap.define(keyCode, keyCodeStr);
      userSettingsUSMap.define(keyCode, usUserSettingsLabel || keyCodeStr);
      userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel || usUserSettingsLabel || keyCodeStr);
    }
    if (eventKeyCode) {
      EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;
    }
    if (vkey) {
      NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;
    }
  }
  // Manually added due to the exclusion above (due to duplication with NumpadEnter)
  IMMUTABLE_KEY_CODE_TO_CODE[3 /* Enter */] = 46 /* Enter */;
})();

var KeyCodeUtils;
(function (KeyCodeUtils) {
  function toString(keyCode) {
    return uiMap.keyCodeToStr(keyCode);
  }
  KeyCodeUtils.toString = toString;
  function fromString(key) {
    return uiMap.strToKeyCode(key);
  }
  KeyCodeUtils.fromString = fromString;
  function toUserSettingsUS(keyCode) {
    return userSettingsUSMap.keyCodeToStr(keyCode);
  }
  KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;
  function toUserSettingsGeneral(keyCode) {
    return userSettingsGeneralMap.keyCodeToStr(keyCode);
  }
  KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;
  function fromUserSettings(key) {
    return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);
  }
  KeyCodeUtils.fromUserSettings = fromUserSettings;
  function toElectronAccelerator(keyCode) {
    if (keyCode >= 93 /* Numpad0 */ && keyCode <= 108 /* NumpadDivide */) {
      // [Electron Accelerators] Electron is able to parse numpad keys, but unfortunately it
      // renders them just as regular keys in menus. For example, num0 is rendered as "0",
      // numdiv is rendered as "/", numsub is rendered as "-".
      //
      // This can lead to incredible confusion, as it makes numpad based keybindings indistinguishable
      // from keybindings based on regular keys.
      //
      // We therefore need to fall back to custom rendering for numpad keys.
      return null;
    }
    switch (keyCode) {
      case 16 /* UpArrow */:
        return 'Up';
      case 18 /* DownArrow */:
        return 'Down';
      case 15 /* LeftArrow */:
        return 'Left';
      case 17 /* RightArrow */:
        return 'Right';
    }
    return uiMap.keyCodeToStr(keyCode);
  }
  KeyCodeUtils.toElectronAccelerator = toElectronAccelerator;
})(KeyCodeUtils || (KeyCodeUtils = {}));
function KeyChord(firstPart, secondPart) {
  var chordPart = (secondPart & 0x0000FFFF) << 16 >>> 0;
  return (firstPart | chordPart) >>> 0;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js




/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


/**
 * A selection in the editor.
 * The selection is a range that has an orientation.
 */
var Selection = /*#__PURE__*/function (_Range) {
  inherits_default()(Selection, _Range);
  var _super = createSuper_default()(Selection);
  function Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {
    var _this;
    classCallCheck_default()(this, Selection);
    _this = _super.call(this, selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);
    _this.selectionStartLineNumber = selectionStartLineNumber;
    _this.selectionStartColumn = selectionStartColumn;
    _this.positionLineNumber = positionLineNumber;
    _this.positionColumn = positionColumn;
    return _this;
  }
  /**
   * Transform to a human-readable representation.
   */
  createClass_default()(Selection, [{
    key: "toString",
    value: function toString() {
      return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';
    }
    /**
     * Test if equals other selection.
     */
  }, {
    key: "equalsSelection",
    value: function equalsSelection(other) {
      return Selection.selectionsEqual(this, other);
    }
    /**
     * Test if the two selections are equal.
     */
  }, {
    key: "getDirection",
    value:
    /**
     * Get directions (LTR or RTL).
     */
    function getDirection() {
      if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {
        return 0 /* LTR */;
      }

      return 1 /* RTL */;
    }
    /**
     * Create a new selection with a different `positionLineNumber` and `positionColumn`.
     */
  }, {
    key: "setEndPosition",
    value: function setEndPosition(endLineNumber, endColumn) {
      if (this.getDirection() === 0 /* LTR */) {
        return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
      }
      return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);
    }
    /**
     * Get the position at `positionLineNumber` and `positionColumn`.
     */
  }, {
    key: "getPosition",
    value: function getPosition() {
      return new Position(this.positionLineNumber, this.positionColumn);
    }
    /**
     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.
     */
  }, {
    key: "setStartPosition",
    value: function setStartPosition(startLineNumber, startColumn) {
      if (this.getDirection() === 0 /* LTR */) {
        return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
      }
      return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);
    }
    // ----
    /**
     * Create a `Selection` from one or two positions
     */
  }], [{
    key: "selectionsEqual",
    value: function selectionsEqual(a, b) {
      return a.selectionStartLineNumber === b.selectionStartLineNumber && a.selectionStartColumn === b.selectionStartColumn && a.positionLineNumber === b.positionLineNumber && a.positionColumn === b.positionColumn;
    }
  }, {
    key: "fromPositions",
    value: function fromPositions(start) {
      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : start;
      return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);
    }
    /**
     * Create a `Selection` from an `ISelection`.
     */
  }, {
    key: "liftSelection",
    value: function liftSelection(sel) {
      return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);
    }
    /**
     * `a` equals `b`.
     */
  }, {
    key: "selectionsArrEqual",
    value: function selectionsArrEqual(a, b) {
      if (a && !b || !a && b) {
        return false;
      }
      if (!a && !b) {
        return true;
      }
      if (a.length !== b.length) {
        return false;
      }
      for (var i = 0, len = a.length; i < len; i++) {
        if (!this.selectionsEqual(a[i], b[i])) {
          return false;
        }
      }
      return true;
    }
    /**
     * Test if `obj` is an `ISelection`.
     */
  }, {
    key: "isISelection",
    value: function isISelection(obj) {
      return obj && typeof obj.selectionStartLineNumber === 'number' && typeof obj.selectionStartColumn === 'number' && typeof obj.positionLineNumber === 'number' && typeof obj.positionColumn === 'number';
    }
    /**
     * Create with a direction.
     */
  }, {
    key: "createWithDirection",
    value: function createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {
      if (direction === 0 /* LTR */) {
        return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);
      }
      return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);
    }
  }]);
  return Selection;
}(Range);
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/core/token.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var Token = /*#__PURE__*/function () {
  function Token(offset, type, language) {
    classCallCheck_default()(this, Token);
    this._tokenBrand = undefined;
    this.offset = offset | 0; // @perf
    this.type = type;
    this.language = language;
  }
  createClass_default()(Token, [{
    key: "toString",
    value: function toString() {
      return '(' + this.offset + ', ' + this.type + ')';
    }
  }]);
  return Token;
}();
var TokenizationResult = /*#__PURE__*/(/* unused pure expression or super */ null && (_createClass(function TokenizationResult(tokens, endState) {
  _classCallCheck(this, TokenizationResult);
  this._tokenizationResultBrand = undefined;
  this.tokens = tokens;
  this.endState = endState;
})));
var TokenizationResult2 = /*#__PURE__*/(/* unused pure expression or super */ null && (_createClass(function TokenizationResult2(tokens, endState) {
  _classCallCheck(this, TokenizationResult2);
  this._tokenizationResult2Brand = undefined;
  this.tokens = tokens;
  this.endState = endState;
})));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.
var AccessibilitySupport;
(function (AccessibilitySupport) {
  /**
   * This should be the browser case where it is not known if a screen reader is attached or no.
   */
  AccessibilitySupport[AccessibilitySupport["Unknown"] = 0] = "Unknown";
  AccessibilitySupport[AccessibilitySupport["Disabled"] = 1] = "Disabled";
  AccessibilitySupport[AccessibilitySupport["Enabled"] = 2] = "Enabled";
})(AccessibilitySupport || (AccessibilitySupport = {}));
var CompletionItemInsertTextRule;
(function (CompletionItemInsertTextRule) {
  /**
   * Adjust whitespace/indentation of multiline insert texts to
   * match the current line indentation.
   */
  CompletionItemInsertTextRule[CompletionItemInsertTextRule["KeepWhitespace"] = 1] = "KeepWhitespace";
  /**
   * `insertText` is a snippet.
   */
  CompletionItemInsertTextRule[CompletionItemInsertTextRule["InsertAsSnippet"] = 4] = "InsertAsSnippet";
})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));
var CompletionItemKind;
(function (CompletionItemKind) {
  CompletionItemKind[CompletionItemKind["Method"] = 0] = "Method";
  CompletionItemKind[CompletionItemKind["Function"] = 1] = "Function";
  CompletionItemKind[CompletionItemKind["Constructor"] = 2] = "Constructor";
  CompletionItemKind[CompletionItemKind["Field"] = 3] = "Field";
  CompletionItemKind[CompletionItemKind["Variable"] = 4] = "Variable";
  CompletionItemKind[CompletionItemKind["Class"] = 5] = "Class";
  CompletionItemKind[CompletionItemKind["Struct"] = 6] = "Struct";
  CompletionItemKind[CompletionItemKind["Interface"] = 7] = "Interface";
  CompletionItemKind[CompletionItemKind["Module"] = 8] = "Module";
  CompletionItemKind[CompletionItemKind["Property"] = 9] = "Property";
  CompletionItemKind[CompletionItemKind["Event"] = 10] = "Event";
  CompletionItemKind[CompletionItemKind["Operator"] = 11] = "Operator";
  CompletionItemKind[CompletionItemKind["Unit"] = 12] = "Unit";
  CompletionItemKind[CompletionItemKind["Value"] = 13] = "Value";
  CompletionItemKind[CompletionItemKind["Constant"] = 14] = "Constant";
  CompletionItemKind[CompletionItemKind["Enum"] = 15] = "Enum";
  CompletionItemKind[CompletionItemKind["EnumMember"] = 16] = "EnumMember";
  CompletionItemKind[CompletionItemKind["Keyword"] = 17] = "Keyword";
  CompletionItemKind[CompletionItemKind["Text"] = 18] = "Text";
  CompletionItemKind[CompletionItemKind["Color"] = 19] = "Color";
  CompletionItemKind[CompletionItemKind["File"] = 20] = "File";
  CompletionItemKind[CompletionItemKind["Reference"] = 21] = "Reference";
  CompletionItemKind[CompletionItemKind["Customcolor"] = 22] = "Customcolor";
  CompletionItemKind[CompletionItemKind["Folder"] = 23] = "Folder";
  CompletionItemKind[CompletionItemKind["TypeParameter"] = 24] = "TypeParameter";
  CompletionItemKind[CompletionItemKind["User"] = 25] = "User";
  CompletionItemKind[CompletionItemKind["Issue"] = 26] = "Issue";
  CompletionItemKind[CompletionItemKind["Snippet"] = 27] = "Snippet";
})(CompletionItemKind || (CompletionItemKind = {}));
var CompletionItemTag;
(function (CompletionItemTag) {
  CompletionItemTag[CompletionItemTag["Deprecated"] = 1] = "Deprecated";
})(CompletionItemTag || (CompletionItemTag = {}));
/**
 * How a suggest provider was triggered.
 */
var CompletionTriggerKind;
(function (CompletionTriggerKind) {
  CompletionTriggerKind[CompletionTriggerKind["Invoke"] = 0] = "Invoke";
  CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 1] = "TriggerCharacter";
  CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 2] = "TriggerForIncompleteCompletions";
})(CompletionTriggerKind || (CompletionTriggerKind = {}));
/**
 * A positioning preference for rendering content widgets.
 */
var ContentWidgetPositionPreference;
(function (ContentWidgetPositionPreference) {
  /**
   * Place the content widget exactly at a position
   */
  ContentWidgetPositionPreference[ContentWidgetPositionPreference["EXACT"] = 0] = "EXACT";
  /**
   * Place the content widget above a position
   */
  ContentWidgetPositionPreference[ContentWidgetPositionPreference["ABOVE"] = 1] = "ABOVE";
  /**
   * Place the content widget below a position
   */
  ContentWidgetPositionPreference[ContentWidgetPositionPreference["BELOW"] = 2] = "BELOW";
})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));
/**
 * Describes the reason the cursor has changed its position.
 */
var CursorChangeReason;
(function (CursorChangeReason) {
  /**
   * Unknown or not set.
   */
  CursorChangeReason[CursorChangeReason["NotSet"] = 0] = "NotSet";
  /**
   * A `model.setValue()` was called.
   */
  CursorChangeReason[CursorChangeReason["ContentFlush"] = 1] = "ContentFlush";
  /**
   * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.
   */
  CursorChangeReason[CursorChangeReason["RecoverFromMarkers"] = 2] = "RecoverFromMarkers";
  /**
   * There was an explicit user gesture.
   */
  CursorChangeReason[CursorChangeReason["Explicit"] = 3] = "Explicit";
  /**
   * There was a Paste.
   */
  CursorChangeReason[CursorChangeReason["Paste"] = 4] = "Paste";
  /**
   * There was an Undo.
   */
  CursorChangeReason[CursorChangeReason["Undo"] = 5] = "Undo";
  /**
   * There was a Redo.
   */
  CursorChangeReason[CursorChangeReason["Redo"] = 6] = "Redo";
})(CursorChangeReason || (CursorChangeReason = {}));
/**
 * The default end of line to use when instantiating models.
 */
var DefaultEndOfLine;
(function (DefaultEndOfLine) {
  /**
   * Use line feed (\n) as the end of line character.
   */
  DefaultEndOfLine[DefaultEndOfLine["LF"] = 1] = "LF";
  /**
   * Use carriage return and line feed (\r\n) as the end of line character.
   */
  DefaultEndOfLine[DefaultEndOfLine["CRLF"] = 2] = "CRLF";
})(DefaultEndOfLine || (DefaultEndOfLine = {}));
/**
 * A document highlight kind.
 */
var DocumentHighlightKind;
(function (DocumentHighlightKind) {
  /**
   * A textual occurrence.
   */
  DocumentHighlightKind[DocumentHighlightKind["Text"] = 0] = "Text";
  /**
   * Read-access of a symbol, like reading a variable.
   */
  DocumentHighlightKind[DocumentHighlightKind["Read"] = 1] = "Read";
  /**
   * Write-access of a symbol, like writing to a variable.
   */
  DocumentHighlightKind[DocumentHighlightKind["Write"] = 2] = "Write";
})(DocumentHighlightKind || (DocumentHighlightKind = {}));
/**
 * Configuration options for auto indentation in the editor
 */
var EditorAutoIndentStrategy;
(function (EditorAutoIndentStrategy) {
  EditorAutoIndentStrategy[EditorAutoIndentStrategy["None"] = 0] = "None";
  EditorAutoIndentStrategy[EditorAutoIndentStrategy["Keep"] = 1] = "Keep";
  EditorAutoIndentStrategy[EditorAutoIndentStrategy["Brackets"] = 2] = "Brackets";
  EditorAutoIndentStrategy[EditorAutoIndentStrategy["Advanced"] = 3] = "Advanced";
  EditorAutoIndentStrategy[EditorAutoIndentStrategy["Full"] = 4] = "Full";
})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {}));
var EditorOption;
(function (EditorOption) {
  EditorOption[EditorOption["acceptSuggestionOnCommitCharacter"] = 0] = "acceptSuggestionOnCommitCharacter";
  EditorOption[EditorOption["acceptSuggestionOnEnter"] = 1] = "acceptSuggestionOnEnter";
  EditorOption[EditorOption["accessibilitySupport"] = 2] = "accessibilitySupport";
  EditorOption[EditorOption["accessibilityPageSize"] = 3] = "accessibilityPageSize";
  EditorOption[EditorOption["ariaLabel"] = 4] = "ariaLabel";
  EditorOption[EditorOption["autoClosingBrackets"] = 5] = "autoClosingBrackets";
  EditorOption[EditorOption["autoClosingDelete"] = 6] = "autoClosingDelete";
  EditorOption[EditorOption["autoClosingOvertype"] = 7] = "autoClosingOvertype";
  EditorOption[EditorOption["autoClosingQuotes"] = 8] = "autoClosingQuotes";
  EditorOption[EditorOption["autoIndent"] = 9] = "autoIndent";
  EditorOption[EditorOption["automaticLayout"] = 10] = "automaticLayout";
  EditorOption[EditorOption["autoSurround"] = 11] = "autoSurround";
  EditorOption[EditorOption["bracketPairColorization"] = 12] = "bracketPairColorization";
  EditorOption[EditorOption["guides"] = 13] = "guides";
  EditorOption[EditorOption["codeLens"] = 14] = "codeLens";
  EditorOption[EditorOption["codeLensFontFamily"] = 15] = "codeLensFontFamily";
  EditorOption[EditorOption["codeLensFontSize"] = 16] = "codeLensFontSize";
  EditorOption[EditorOption["colorDecorators"] = 17] = "colorDecorators";
  EditorOption[EditorOption["columnSelection"] = 18] = "columnSelection";
  EditorOption[EditorOption["comments"] = 19] = "comments";
  EditorOption[EditorOption["contextmenu"] = 20] = "contextmenu";
  EditorOption[EditorOption["copyWithSyntaxHighlighting"] = 21] = "copyWithSyntaxHighlighting";
  EditorOption[EditorOption["cursorBlinking"] = 22] = "cursorBlinking";
  EditorOption[EditorOption["cursorSmoothCaretAnimation"] = 23] = "cursorSmoothCaretAnimation";
  EditorOption[EditorOption["cursorStyle"] = 24] = "cursorStyle";
  EditorOption[EditorOption["cursorSurroundingLines"] = 25] = "cursorSurroundingLines";
  EditorOption[EditorOption["cursorSurroundingLinesStyle"] = 26] = "cursorSurroundingLinesStyle";
  EditorOption[EditorOption["cursorWidth"] = 27] = "cursorWidth";
  EditorOption[EditorOption["disableLayerHinting"] = 28] = "disableLayerHinting";
  EditorOption[EditorOption["disableMonospaceOptimizations"] = 29] = "disableMonospaceOptimizations";
  EditorOption[EditorOption["domReadOnly"] = 30] = "domReadOnly";
  EditorOption[EditorOption["dragAndDrop"] = 31] = "dragAndDrop";
  EditorOption[EditorOption["emptySelectionClipboard"] = 32] = "emptySelectionClipboard";
  EditorOption[EditorOption["extraEditorClassName"] = 33] = "extraEditorClassName";
  EditorOption[EditorOption["fastScrollSensitivity"] = 34] = "fastScrollSensitivity";
  EditorOption[EditorOption["find"] = 35] = "find";
  EditorOption[EditorOption["fixedOverflowWidgets"] = 36] = "fixedOverflowWidgets";
  EditorOption[EditorOption["folding"] = 37] = "folding";
  EditorOption[EditorOption["foldingStrategy"] = 38] = "foldingStrategy";
  EditorOption[EditorOption["foldingHighlight"] = 39] = "foldingHighlight";
  EditorOption[EditorOption["foldingImportsByDefault"] = 40] = "foldingImportsByDefault";
  EditorOption[EditorOption["unfoldOnClickAfterEndOfLine"] = 41] = "unfoldOnClickAfterEndOfLine";
  EditorOption[EditorOption["fontFamily"] = 42] = "fontFamily";
  EditorOption[EditorOption["fontInfo"] = 43] = "fontInfo";
  EditorOption[EditorOption["fontLigatures"] = 44] = "fontLigatures";
  EditorOption[EditorOption["fontSize"] = 45] = "fontSize";
  EditorOption[EditorOption["fontWeight"] = 46] = "fontWeight";
  EditorOption[EditorOption["formatOnPaste"] = 47] = "formatOnPaste";
  EditorOption[EditorOption["formatOnType"] = 48] = "formatOnType";
  EditorOption[EditorOption["glyphMargin"] = 49] = "glyphMargin";
  EditorOption[EditorOption["gotoLocation"] = 50] = "gotoLocation";
  EditorOption[EditorOption["hideCursorInOverviewRuler"] = 51] = "hideCursorInOverviewRuler";
  EditorOption[EditorOption["hover"] = 52] = "hover";
  EditorOption[EditorOption["inDiffEditor"] = 53] = "inDiffEditor";
  EditorOption[EditorOption["inlineSuggest"] = 54] = "inlineSuggest";
  EditorOption[EditorOption["letterSpacing"] = 55] = "letterSpacing";
  EditorOption[EditorOption["lightbulb"] = 56] = "lightbulb";
  EditorOption[EditorOption["lineDecorationsWidth"] = 57] = "lineDecorationsWidth";
  EditorOption[EditorOption["lineHeight"] = 58] = "lineHeight";
  EditorOption[EditorOption["lineNumbers"] = 59] = "lineNumbers";
  EditorOption[EditorOption["lineNumbersMinChars"] = 60] = "lineNumbersMinChars";
  EditorOption[EditorOption["linkedEditing"] = 61] = "linkedEditing";
  EditorOption[EditorOption["links"] = 62] = "links";
  EditorOption[EditorOption["matchBrackets"] = 63] = "matchBrackets";
  EditorOption[EditorOption["minimap"] = 64] = "minimap";
  EditorOption[EditorOption["mouseStyle"] = 65] = "mouseStyle";
  EditorOption[EditorOption["mouseWheelScrollSensitivity"] = 66] = "mouseWheelScrollSensitivity";
  EditorOption[EditorOption["mouseWheelZoom"] = 67] = "mouseWheelZoom";
  EditorOption[EditorOption["multiCursorMergeOverlapping"] = 68] = "multiCursorMergeOverlapping";
  EditorOption[EditorOption["multiCursorModifier"] = 69] = "multiCursorModifier";
  EditorOption[EditorOption["multiCursorPaste"] = 70] = "multiCursorPaste";
  EditorOption[EditorOption["occurrencesHighlight"] = 71] = "occurrencesHighlight";
  EditorOption[EditorOption["overviewRulerBorder"] = 72] = "overviewRulerBorder";
  EditorOption[EditorOption["overviewRulerLanes"] = 73] = "overviewRulerLanes";
  EditorOption[EditorOption["padding"] = 74] = "padding";
  EditorOption[EditorOption["parameterHints"] = 75] = "parameterHints";
  EditorOption[EditorOption["peekWidgetDefaultFocus"] = 76] = "peekWidgetDefaultFocus";
  EditorOption[EditorOption["definitionLinkOpensInPeek"] = 77] = "definitionLinkOpensInPeek";
  EditorOption[EditorOption["quickSuggestions"] = 78] = "quickSuggestions";
  EditorOption[EditorOption["quickSuggestionsDelay"] = 79] = "quickSuggestionsDelay";
  EditorOption[EditorOption["readOnly"] = 80] = "readOnly";
  EditorOption[EditorOption["renameOnType"] = 81] = "renameOnType";
  EditorOption[EditorOption["renderControlCharacters"] = 82] = "renderControlCharacters";
  EditorOption[EditorOption["renderFinalNewline"] = 83] = "renderFinalNewline";
  EditorOption[EditorOption["renderLineHighlight"] = 84] = "renderLineHighlight";
  EditorOption[EditorOption["renderLineHighlightOnlyWhenFocus"] = 85] = "renderLineHighlightOnlyWhenFocus";
  EditorOption[EditorOption["renderValidationDecorations"] = 86] = "renderValidationDecorations";
  EditorOption[EditorOption["renderWhitespace"] = 87] = "renderWhitespace";
  EditorOption[EditorOption["revealHorizontalRightPadding"] = 88] = "revealHorizontalRightPadding";
  EditorOption[EditorOption["roundedSelection"] = 89] = "roundedSelection";
  EditorOption[EditorOption["rulers"] = 90] = "rulers";
  EditorOption[EditorOption["scrollbar"] = 91] = "scrollbar";
  EditorOption[EditorOption["scrollBeyondLastColumn"] = 92] = "scrollBeyondLastColumn";
  EditorOption[EditorOption["scrollBeyondLastLine"] = 93] = "scrollBeyondLastLine";
  EditorOption[EditorOption["scrollPredominantAxis"] = 94] = "scrollPredominantAxis";
  EditorOption[EditorOption["selectionClipboard"] = 95] = "selectionClipboard";
  EditorOption[EditorOption["selectionHighlight"] = 96] = "selectionHighlight";
  EditorOption[EditorOption["selectOnLineNumbers"] = 97] = "selectOnLineNumbers";
  EditorOption[EditorOption["showFoldingControls"] = 98] = "showFoldingControls";
  EditorOption[EditorOption["showUnused"] = 99] = "showUnused";
  EditorOption[EditorOption["snippetSuggestions"] = 100] = "snippetSuggestions";
  EditorOption[EditorOption["smartSelect"] = 101] = "smartSelect";
  EditorOption[EditorOption["smoothScrolling"] = 102] = "smoothScrolling";
  EditorOption[EditorOption["stickyTabStops"] = 103] = "stickyTabStops";
  EditorOption[EditorOption["stopRenderingLineAfter"] = 104] = "stopRenderingLineAfter";
  EditorOption[EditorOption["suggest"] = 105] = "suggest";
  EditorOption[EditorOption["suggestFontSize"] = 106] = "suggestFontSize";
  EditorOption[EditorOption["suggestLineHeight"] = 107] = "suggestLineHeight";
  EditorOption[EditorOption["suggestOnTriggerCharacters"] = 108] = "suggestOnTriggerCharacters";
  EditorOption[EditorOption["suggestSelection"] = 109] = "suggestSelection";
  EditorOption[EditorOption["tabCompletion"] = 110] = "tabCompletion";
  EditorOption[EditorOption["tabIndex"] = 111] = "tabIndex";
  EditorOption[EditorOption["unusualLineTerminators"] = 112] = "unusualLineTerminators";
  EditorOption[EditorOption["useShadowDOM"] = 113] = "useShadowDOM";
  EditorOption[EditorOption["useTabStops"] = 114] = "useTabStops";
  EditorOption[EditorOption["wordSeparators"] = 115] = "wordSeparators";
  EditorOption[EditorOption["wordWrap"] = 116] = "wordWrap";
  EditorOption[EditorOption["wordWrapBreakAfterCharacters"] = 117] = "wordWrapBreakAfterCharacters";
  EditorOption[EditorOption["wordWrapBreakBeforeCharacters"] = 118] = "wordWrapBreakBeforeCharacters";
  EditorOption[EditorOption["wordWrapColumn"] = 119] = "wordWrapColumn";
  EditorOption[EditorOption["wordWrapOverride1"] = 120] = "wordWrapOverride1";
  EditorOption[EditorOption["wordWrapOverride2"] = 121] = "wordWrapOverride2";
  EditorOption[EditorOption["wrappingIndent"] = 122] = "wrappingIndent";
  EditorOption[EditorOption["wrappingStrategy"] = 123] = "wrappingStrategy";
  EditorOption[EditorOption["showDeprecated"] = 124] = "showDeprecated";
  EditorOption[EditorOption["inlayHints"] = 125] = "inlayHints";
  EditorOption[EditorOption["editorClassName"] = 126] = "editorClassName";
  EditorOption[EditorOption["pixelRatio"] = 127] = "pixelRatio";
  EditorOption[EditorOption["tabFocusMode"] = 128] = "tabFocusMode";
  EditorOption[EditorOption["layoutInfo"] = 129] = "layoutInfo";
  EditorOption[EditorOption["wrappingInfo"] = 130] = "wrappingInfo";
})(EditorOption || (EditorOption = {}));
/**
 * End of line character preference.
 */
var EndOfLinePreference;
(function (EndOfLinePreference) {
  /**
   * Use the end of line character identified in the text buffer.
   */
  EndOfLinePreference[EndOfLinePreference["TextDefined"] = 0] = "TextDefined";
  /**
   * Use line feed (\n) as the end of line character.
   */
  EndOfLinePreference[EndOfLinePreference["LF"] = 1] = "LF";
  /**
   * Use carriage return and line feed (\r\n) as the end of line character.
   */
  EndOfLinePreference[EndOfLinePreference["CRLF"] = 2] = "CRLF";
})(EndOfLinePreference || (EndOfLinePreference = {}));
/**
 * End of line character preference.
 */
var EndOfLineSequence;
(function (EndOfLineSequence) {
  /**
   * Use line feed (\n) as the end of line character.
   */
  EndOfLineSequence[EndOfLineSequence["LF"] = 0] = "LF";
  /**
   * Use carriage return and line feed (\r\n) as the end of line character.
   */
  EndOfLineSequence[EndOfLineSequence["CRLF"] = 1] = "CRLF";
})(EndOfLineSequence || (EndOfLineSequence = {}));
/**
 * Describes what to do with the indentation when pressing Enter.
 */
var IndentAction;
(function (IndentAction) {
  /**
   * Insert new line and copy the previous line's indentation.
   */
  IndentAction[IndentAction["None"] = 0] = "None";
  /**
   * Insert new line and indent once (relative to the previous line's indentation).
   */
  IndentAction[IndentAction["Indent"] = 1] = "Indent";
  /**
   * Insert two new lines:
   *  - the first one indented which will hold the cursor
   *  - the second one at the same indentation level
   */
  IndentAction[IndentAction["IndentOutdent"] = 2] = "IndentOutdent";
  /**
   * Insert new line and outdent once (relative to the previous line's indentation).
   */
  IndentAction[IndentAction["Outdent"] = 3] = "Outdent";
})(IndentAction || (IndentAction = {}));
var InlayHintKind;
(function (InlayHintKind) {
  InlayHintKind[InlayHintKind["Other"] = 0] = "Other";
  InlayHintKind[InlayHintKind["Type"] = 1] = "Type";
  InlayHintKind[InlayHintKind["Parameter"] = 2] = "Parameter";
})(InlayHintKind || (InlayHintKind = {}));
/**
 * How an {@link InlineCompletionsProvider inline completion provider} was triggered.
 */
var InlineCompletionTriggerKind;
(function (InlineCompletionTriggerKind) {
  /**
   * Completion was triggered automatically while editing.
   * It is sufficient to return a single completion item in this case.
   */
  InlineCompletionTriggerKind[InlineCompletionTriggerKind["Automatic"] = 0] = "Automatic";
  /**
   * Completion was triggered explicitly by a user gesture.
   * Return multiple completion items to enable cycling through them.
   */
  InlineCompletionTriggerKind[InlineCompletionTriggerKind["Explicit"] = 1] = "Explicit";
})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
/**
 * Virtual Key Codes, the value does not hold any inherent meaning.
 * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
 * But these are "more general", as they should work across browsers & OS`s.
 */
var KeyCode;
(function (KeyCode) {
  KeyCode[KeyCode["DependsOnKbLayout"] = -1] = "DependsOnKbLayout";
  /**
   * Placed first to cover the 0 value of the enum.
   */
  KeyCode[KeyCode["Unknown"] = 0] = "Unknown";
  KeyCode[KeyCode["Backspace"] = 1] = "Backspace";
  KeyCode[KeyCode["Tab"] = 2] = "Tab";
  KeyCode[KeyCode["Enter"] = 3] = "Enter";
  KeyCode[KeyCode["Shift"] = 4] = "Shift";
  KeyCode[KeyCode["Ctrl"] = 5] = "Ctrl";
  KeyCode[KeyCode["Alt"] = 6] = "Alt";
  KeyCode[KeyCode["PauseBreak"] = 7] = "PauseBreak";
  KeyCode[KeyCode["CapsLock"] = 8] = "CapsLock";
  KeyCode[KeyCode["Escape"] = 9] = "Escape";
  KeyCode[KeyCode["Space"] = 10] = "Space";
  KeyCode[KeyCode["PageUp"] = 11] = "PageUp";
  KeyCode[KeyCode["PageDown"] = 12] = "PageDown";
  KeyCode[KeyCode["End"] = 13] = "End";
  KeyCode[KeyCode["Home"] = 14] = "Home";
  KeyCode[KeyCode["LeftArrow"] = 15] = "LeftArrow";
  KeyCode[KeyCode["UpArrow"] = 16] = "UpArrow";
  KeyCode[KeyCode["RightArrow"] = 17] = "RightArrow";
  KeyCode[KeyCode["DownArrow"] = 18] = "DownArrow";
  KeyCode[KeyCode["Insert"] = 19] = "Insert";
  KeyCode[KeyCode["Delete"] = 20] = "Delete";
  KeyCode[KeyCode["Digit0"] = 21] = "Digit0";
  KeyCode[KeyCode["Digit1"] = 22] = "Digit1";
  KeyCode[KeyCode["Digit2"] = 23] = "Digit2";
  KeyCode[KeyCode["Digit3"] = 24] = "Digit3";
  KeyCode[KeyCode["Digit4"] = 25] = "Digit4";
  KeyCode[KeyCode["Digit5"] = 26] = "Digit5";
  KeyCode[KeyCode["Digit6"] = 27] = "Digit6";
  KeyCode[KeyCode["Digit7"] = 28] = "Digit7";
  KeyCode[KeyCode["Digit8"] = 29] = "Digit8";
  KeyCode[KeyCode["Digit9"] = 30] = "Digit9";
  KeyCode[KeyCode["KeyA"] = 31] = "KeyA";
  KeyCode[KeyCode["KeyB"] = 32] = "KeyB";
  KeyCode[KeyCode["KeyC"] = 33] = "KeyC";
  KeyCode[KeyCode["KeyD"] = 34] = "KeyD";
  KeyCode[KeyCode["KeyE"] = 35] = "KeyE";
  KeyCode[KeyCode["KeyF"] = 36] = "KeyF";
  KeyCode[KeyCode["KeyG"] = 37] = "KeyG";
  KeyCode[KeyCode["KeyH"] = 38] = "KeyH";
  KeyCode[KeyCode["KeyI"] = 39] = "KeyI";
  KeyCode[KeyCode["KeyJ"] = 40] = "KeyJ";
  KeyCode[KeyCode["KeyK"] = 41] = "KeyK";
  KeyCode[KeyCode["KeyL"] = 42] = "KeyL";
  KeyCode[KeyCode["KeyM"] = 43] = "KeyM";
  KeyCode[KeyCode["KeyN"] = 44] = "KeyN";
  KeyCode[KeyCode["KeyO"] = 45] = "KeyO";
  KeyCode[KeyCode["KeyP"] = 46] = "KeyP";
  KeyCode[KeyCode["KeyQ"] = 47] = "KeyQ";
  KeyCode[KeyCode["KeyR"] = 48] = "KeyR";
  KeyCode[KeyCode["KeyS"] = 49] = "KeyS";
  KeyCode[KeyCode["KeyT"] = 50] = "KeyT";
  KeyCode[KeyCode["KeyU"] = 51] = "KeyU";
  KeyCode[KeyCode["KeyV"] = 52] = "KeyV";
  KeyCode[KeyCode["KeyW"] = 53] = "KeyW";
  KeyCode[KeyCode["KeyX"] = 54] = "KeyX";
  KeyCode[KeyCode["KeyY"] = 55] = "KeyY";
  KeyCode[KeyCode["KeyZ"] = 56] = "KeyZ";
  KeyCode[KeyCode["Meta"] = 57] = "Meta";
  KeyCode[KeyCode["ContextMenu"] = 58] = "ContextMenu";
  KeyCode[KeyCode["F1"] = 59] = "F1";
  KeyCode[KeyCode["F2"] = 60] = "F2";
  KeyCode[KeyCode["F3"] = 61] = "F3";
  KeyCode[KeyCode["F4"] = 62] = "F4";
  KeyCode[KeyCode["F5"] = 63] = "F5";
  KeyCode[KeyCode["F6"] = 64] = "F6";
  KeyCode[KeyCode["F7"] = 65] = "F7";
  KeyCode[KeyCode["F8"] = 66] = "F8";
  KeyCode[KeyCode["F9"] = 67] = "F9";
  KeyCode[KeyCode["F10"] = 68] = "F10";
  KeyCode[KeyCode["F11"] = 69] = "F11";
  KeyCode[KeyCode["F12"] = 70] = "F12";
  KeyCode[KeyCode["F13"] = 71] = "F13";
  KeyCode[KeyCode["F14"] = 72] = "F14";
  KeyCode[KeyCode["F15"] = 73] = "F15";
  KeyCode[KeyCode["F16"] = 74] = "F16";
  KeyCode[KeyCode["F17"] = 75] = "F17";
  KeyCode[KeyCode["F18"] = 76] = "F18";
  KeyCode[KeyCode["F19"] = 77] = "F19";
  KeyCode[KeyCode["NumLock"] = 78] = "NumLock";
  KeyCode[KeyCode["ScrollLock"] = 79] = "ScrollLock";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the ';:' key
   */
  KeyCode[KeyCode["Semicolon"] = 80] = "Semicolon";
  /**
   * For any country/region, the '+' key
   * For the US standard keyboard, the '=+' key
   */
  KeyCode[KeyCode["Equal"] = 81] = "Equal";
  /**
   * For any country/region, the ',' key
   * For the US standard keyboard, the ',<' key
   */
  KeyCode[KeyCode["Comma"] = 82] = "Comma";
  /**
   * For any country/region, the '-' key
   * For the US standard keyboard, the '-_' key
   */
  KeyCode[KeyCode["Minus"] = 83] = "Minus";
  /**
   * For any country/region, the '.' key
   * For the US standard keyboard, the '.>' key
   */
  KeyCode[KeyCode["Period"] = 84] = "Period";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the '/?' key
   */
  KeyCode[KeyCode["Slash"] = 85] = "Slash";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the '`~' key
   */
  KeyCode[KeyCode["Backquote"] = 86] = "Backquote";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the '[{' key
   */
  KeyCode[KeyCode["BracketLeft"] = 87] = "BracketLeft";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the '\|' key
   */
  KeyCode[KeyCode["Backslash"] = 88] = "Backslash";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the ']}' key
   */
  KeyCode[KeyCode["BracketRight"] = 89] = "BracketRight";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   * For the US standard keyboard, the ''"' key
   */
  KeyCode[KeyCode["Quote"] = 90] = "Quote";
  /**
   * Used for miscellaneous characters; it can vary by keyboard.
   */
  KeyCode[KeyCode["OEM_8"] = 91] = "OEM_8";
  /**
   * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
   */
  KeyCode[KeyCode["IntlBackslash"] = 92] = "IntlBackslash";
  KeyCode[KeyCode["Numpad0"] = 93] = "Numpad0";
  KeyCode[KeyCode["Numpad1"] = 94] = "Numpad1";
  KeyCode[KeyCode["Numpad2"] = 95] = "Numpad2";
  KeyCode[KeyCode["Numpad3"] = 96] = "Numpad3";
  KeyCode[KeyCode["Numpad4"] = 97] = "Numpad4";
  KeyCode[KeyCode["Numpad5"] = 98] = "Numpad5";
  KeyCode[KeyCode["Numpad6"] = 99] = "Numpad6";
  KeyCode[KeyCode["Numpad7"] = 100] = "Numpad7";
  KeyCode[KeyCode["Numpad8"] = 101] = "Numpad8";
  KeyCode[KeyCode["Numpad9"] = 102] = "Numpad9";
  KeyCode[KeyCode["NumpadMultiply"] = 103] = "NumpadMultiply";
  KeyCode[KeyCode["NumpadAdd"] = 104] = "NumpadAdd";
  KeyCode[KeyCode["NUMPAD_SEPARATOR"] = 105] = "NUMPAD_SEPARATOR";
  KeyCode[KeyCode["NumpadSubtract"] = 106] = "NumpadSubtract";
  KeyCode[KeyCode["NumpadDecimal"] = 107] = "NumpadDecimal";
  KeyCode[KeyCode["NumpadDivide"] = 108] = "NumpadDivide";
  /**
   * Cover all key codes when IME is processing input.
   */
  KeyCode[KeyCode["KEY_IN_COMPOSITION"] = 109] = "KEY_IN_COMPOSITION";
  KeyCode[KeyCode["ABNT_C1"] = 110] = "ABNT_C1";
  KeyCode[KeyCode["ABNT_C2"] = 111] = "ABNT_C2";
  KeyCode[KeyCode["AudioVolumeMute"] = 112] = "AudioVolumeMute";
  KeyCode[KeyCode["AudioVolumeUp"] = 113] = "AudioVolumeUp";
  KeyCode[KeyCode["AudioVolumeDown"] = 114] = "AudioVolumeDown";
  KeyCode[KeyCode["BrowserSearch"] = 115] = "BrowserSearch";
  KeyCode[KeyCode["BrowserHome"] = 116] = "BrowserHome";
  KeyCode[KeyCode["BrowserBack"] = 117] = "BrowserBack";
  KeyCode[KeyCode["BrowserForward"] = 118] = "BrowserForward";
  KeyCode[KeyCode["MediaTrackNext"] = 119] = "MediaTrackNext";
  KeyCode[KeyCode["MediaTrackPrevious"] = 120] = "MediaTrackPrevious";
  KeyCode[KeyCode["MediaStop"] = 121] = "MediaStop";
  KeyCode[KeyCode["MediaPlayPause"] = 122] = "MediaPlayPause";
  KeyCode[KeyCode["LaunchMediaPlayer"] = 123] = "LaunchMediaPlayer";
  KeyCode[KeyCode["LaunchMail"] = 124] = "LaunchMail";
  KeyCode[KeyCode["LaunchApp2"] = 125] = "LaunchApp2";
  /**
   * Placed last to cover the length of the enum.
   * Please do not depend on this value!
   */
  KeyCode[KeyCode["MAX_VALUE"] = 126] = "MAX_VALUE";
})(KeyCode || (KeyCode = {}));
var MarkerSeverity;
(function (MarkerSeverity) {
  MarkerSeverity[MarkerSeverity["Hint"] = 1] = "Hint";
  MarkerSeverity[MarkerSeverity["Info"] = 2] = "Info";
  MarkerSeverity[MarkerSeverity["Warning"] = 4] = "Warning";
  MarkerSeverity[MarkerSeverity["Error"] = 8] = "Error";
})(MarkerSeverity || (MarkerSeverity = {}));
var MarkerTag;
(function (MarkerTag) {
  MarkerTag[MarkerTag["Unnecessary"] = 1] = "Unnecessary";
  MarkerTag[MarkerTag["Deprecated"] = 2] = "Deprecated";
})(MarkerTag || (MarkerTag = {}));
/**
 * Position in the minimap to render the decoration.
 */
var MinimapPosition;
(function (MinimapPosition) {
  MinimapPosition[MinimapPosition["Inline"] = 1] = "Inline";
  MinimapPosition[MinimapPosition["Gutter"] = 2] = "Gutter";
})(MinimapPosition || (MinimapPosition = {}));
/**
 * Type of hit element with the mouse in the editor.
 */
var MouseTargetType;
(function (MouseTargetType) {
  /**
   * Mouse is on top of an unknown element.
   */
  MouseTargetType[MouseTargetType["UNKNOWN"] = 0] = "UNKNOWN";
  /**
   * Mouse is on top of the textarea used for input.
   */
  MouseTargetType[MouseTargetType["TEXTAREA"] = 1] = "TEXTAREA";
  /**
   * Mouse is on top of the glyph margin
   */
  MouseTargetType[MouseTargetType["GUTTER_GLYPH_MARGIN"] = 2] = "GUTTER_GLYPH_MARGIN";
  /**
   * Mouse is on top of the line numbers
   */
  MouseTargetType[MouseTargetType["GUTTER_LINE_NUMBERS"] = 3] = "GUTTER_LINE_NUMBERS";
  /**
   * Mouse is on top of the line decorations
   */
  MouseTargetType[MouseTargetType["GUTTER_LINE_DECORATIONS"] = 4] = "GUTTER_LINE_DECORATIONS";
  /**
   * Mouse is on top of the whitespace left in the gutter by a view zone.
   */
  MouseTargetType[MouseTargetType["GUTTER_VIEW_ZONE"] = 5] = "GUTTER_VIEW_ZONE";
  /**
   * Mouse is on top of text in the content.
   */
  MouseTargetType[MouseTargetType["CONTENT_TEXT"] = 6] = "CONTENT_TEXT";
  /**
   * Mouse is on top of empty space in the content (e.g. after line text or below last line)
   */
  MouseTargetType[MouseTargetType["CONTENT_EMPTY"] = 7] = "CONTENT_EMPTY";
  /**
   * Mouse is on top of a view zone in the content.
   */
  MouseTargetType[MouseTargetType["CONTENT_VIEW_ZONE"] = 8] = "CONTENT_VIEW_ZONE";
  /**
   * Mouse is on top of a content widget.
   */
  MouseTargetType[MouseTargetType["CONTENT_WIDGET"] = 9] = "CONTENT_WIDGET";
  /**
   * Mouse is on top of the decorations overview ruler.
   */
  MouseTargetType[MouseTargetType["OVERVIEW_RULER"] = 10] = "OVERVIEW_RULER";
  /**
   * Mouse is on top of a scrollbar.
   */
  MouseTargetType[MouseTargetType["SCROLLBAR"] = 11] = "SCROLLBAR";
  /**
   * Mouse is on top of an overlay widget.
   */
  MouseTargetType[MouseTargetType["OVERLAY_WIDGET"] = 12] = "OVERLAY_WIDGET";
  /**
   * Mouse is outside of the editor.
   */
  MouseTargetType[MouseTargetType["OUTSIDE_EDITOR"] = 13] = "OUTSIDE_EDITOR";
})(MouseTargetType || (MouseTargetType = {}));
/**
 * A positioning preference for rendering overlay widgets.
 */
var OverlayWidgetPositionPreference;
(function (OverlayWidgetPositionPreference) {
  /**
   * Position the overlay widget in the top right corner
   */
  OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_RIGHT_CORNER"] = 0] = "TOP_RIGHT_CORNER";
  /**
   * Position the overlay widget in the bottom right corner
   */
  OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["BOTTOM_RIGHT_CORNER"] = 1] = "BOTTOM_RIGHT_CORNER";
  /**
   * Position the overlay widget in the top center
   */
  OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_CENTER"] = 2] = "TOP_CENTER";
})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));
/**
 * Vertical Lane in the overview ruler of the editor.
 */
var OverviewRulerLane;
(function (OverviewRulerLane) {
  OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
  OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
  OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
  OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
})(OverviewRulerLane || (OverviewRulerLane = {}));
var RenderLineNumbersType;
(function (RenderLineNumbersType) {
  RenderLineNumbersType[RenderLineNumbersType["Off"] = 0] = "Off";
  RenderLineNumbersType[RenderLineNumbersType["On"] = 1] = "On";
  RenderLineNumbersType[RenderLineNumbersType["Relative"] = 2] = "Relative";
  RenderLineNumbersType[RenderLineNumbersType["Interval"] = 3] = "Interval";
  RenderLineNumbersType[RenderLineNumbersType["Custom"] = 4] = "Custom";
})(RenderLineNumbersType || (RenderLineNumbersType = {}));
var RenderMinimap;
(function (RenderMinimap) {
  RenderMinimap[RenderMinimap["None"] = 0] = "None";
  RenderMinimap[RenderMinimap["Text"] = 1] = "Text";
  RenderMinimap[RenderMinimap["Blocks"] = 2] = "Blocks";
})(RenderMinimap || (RenderMinimap = {}));
var ScrollType;
(function (ScrollType) {
  ScrollType[ScrollType["Smooth"] = 0] = "Smooth";
  ScrollType[ScrollType["Immediate"] = 1] = "Immediate";
})(ScrollType || (ScrollType = {}));
var ScrollbarVisibility;
(function (ScrollbarVisibility) {
  ScrollbarVisibility[ScrollbarVisibility["Auto"] = 1] = "Auto";
  ScrollbarVisibility[ScrollbarVisibility["Hidden"] = 2] = "Hidden";
  ScrollbarVisibility[ScrollbarVisibility["Visible"] = 3] = "Visible";
})(ScrollbarVisibility || (ScrollbarVisibility = {}));
/**
 * The direction of a selection.
 */
var SelectionDirection;
(function (SelectionDirection) {
  /**
   * The selection starts above where it ends.
   */
  SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR";
  /**
   * The selection starts below where it ends.
   */
  SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL";
})(SelectionDirection || (SelectionDirection = {}));
var SignatureHelpTriggerKind;
(function (SignatureHelpTriggerKind) {
  SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke";
  SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter";
  SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange";
})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));
/**
 * A symbol kind.
 */
var SymbolKind;
(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";
})(SymbolKind || (SymbolKind = {}));
var SymbolTag;
(function (SymbolTag) {
  SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated";
})(SymbolTag || (SymbolTag = {}));
/**
 * The kind of animation in which the editor's cursor should be rendered.
 */
var TextEditorCursorBlinkingStyle;
(function (TextEditorCursorBlinkingStyle) {
  /**
   * Hidden
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Hidden"] = 0] = "Hidden";
  /**
   * Blinking
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Blink"] = 1] = "Blink";
  /**
   * Blinking with smooth fading
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Smooth"] = 2] = "Smooth";
  /**
   * Blinking with prolonged filled state and smooth fading
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Phase"] = 3] = "Phase";
  /**
   * Expand collapse animation on the y axis
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Expand"] = 4] = "Expand";
  /**
   * No-Blinking
   */
  TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Solid"] = 5] = "Solid";
})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));
/**
 * The style in which the editor's cursor should be rendered.
 */
var TextEditorCursorStyle;
(function (TextEditorCursorStyle) {
  /**
   * As a vertical line (sitting between two characters).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["Line"] = 1] = "Line";
  /**
   * As a block (sitting on top of a character).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["Block"] = 2] = "Block";
  /**
   * As a horizontal line (sitting under a character).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["Underline"] = 3] = "Underline";
  /**
   * As a thin vertical line (sitting between two characters).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["LineThin"] = 4] = "LineThin";
  /**
   * As an outlined block (sitting on top of a character).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["BlockOutline"] = 5] = "BlockOutline";
  /**
   * As a thin horizontal line (sitting under a character).
   */
  TextEditorCursorStyle[TextEditorCursorStyle["UnderlineThin"] = 6] = "UnderlineThin";
})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));
/**
 * Describes the behavior of decorations when typing/editing near their edges.
 * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`
 */
var TrackedRangeStickiness;
(function (TrackedRangeStickiness) {
  TrackedRangeStickiness[TrackedRangeStickiness["AlwaysGrowsWhenTypingAtEdges"] = 0] = "AlwaysGrowsWhenTypingAtEdges";
  TrackedRangeStickiness[TrackedRangeStickiness["NeverGrowsWhenTypingAtEdges"] = 1] = "NeverGrowsWhenTypingAtEdges";
  TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingBefore"] = 2] = "GrowsOnlyWhenTypingBefore";
  TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingAfter"] = 3] = "GrowsOnlyWhenTypingAfter";
})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));
/**
 * Describes how to indent wrapped lines.
 */
var WrappingIndent;
(function (WrappingIndent) {
  /**
   * No indentation => wrapped lines begin at column 1.
   */
  WrappingIndent[WrappingIndent["None"] = 0] = "None";
  /**
   * Same => wrapped lines get the same indentation as the parent.
   */
  WrappingIndent[WrappingIndent["Same"] = 1] = "Same";
  /**
   * Indent => wrapped lines get +1 indentation toward the parent.
   */
  WrappingIndent[WrappingIndent["Indent"] = 2] = "Indent";
  /**
   * DeepIndent => wrapped lines get +2 indentation toward the parent.
   */
  WrappingIndent[WrappingIndent["DeepIndent"] = 3] = "DeepIndent";
})(WrappingIndent || (WrappingIndent = {}));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js


/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/









var KeyMod = /*#__PURE__*/function () {
  function KeyMod() {
    classCallCheck_default()(this, KeyMod);
  }
  createClass_default()(KeyMod, null, [{
    key: "chord",
    value: function chord(firstPart, secondPart) {
      return KeyChord(firstPart, secondPart);
    }
  }]);
  return KeyMod;
}();
KeyMod.CtrlCmd = 2048 /* CtrlCmd */;
KeyMod.Shift = 1024 /* Shift */;
KeyMod.Alt = 512 /* Alt */;
KeyMod.WinCtrl = 256 /* WinCtrl */;
function createMonacoBaseAPI() {
  return {
    editor: undefined,
    languages: undefined,
    CancellationTokenSource: CancellationTokenSource,
    Emitter: Emitter,
    KeyCode: KeyCode,
    KeyMod: KeyMod,
    Position: Position,
    Range: Range,
    Selection: Selection,
    SelectionDirection: SelectionDirection,
    MarkerSeverity: MarkerSeverity,
    MarkerTag: MarkerTag,
    Uri: URI,
    Token: Token
  };
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js







/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};













/**
 * @internal
 */
var MirrorModel = /*#__PURE__*/function (_BaseMirrorModel) {
  inherits_default()(MirrorModel, _BaseMirrorModel);
  var _super = createSuper_default()(MirrorModel);
  function MirrorModel() {
    classCallCheck_default()(this, MirrorModel);
    return _super.apply(this, arguments);
  }
  createClass_default()(MirrorModel, [{
    key: "uri",
    get: function get() {
      return this._uri;
    }
  }, {
    key: "eol",
    get: function get() {
      return this._eol;
    }
  }, {
    key: "getValue",
    value: function getValue() {
      return this.getText();
    }
  }, {
    key: "getLinesContent",
    value: function getLinesContent() {
      return this._lines.slice(0);
    }
  }, {
    key: "getLineCount",
    value: function getLineCount() {
      return this._lines.length;
    }
  }, {
    key: "getLineContent",
    value: function getLineContent(lineNumber) {
      return this._lines[lineNumber - 1];
    }
  }, {
    key: "getWordAtPosition",
    value: function getWordAtPosition(position, wordDefinition) {
      var wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
      if (wordAtText) {
        return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);
      }
      return null;
    }
  }, {
    key: "words",
    value: function words(wordDefinition) {
      var lines = this._lines;
      var wordenize = this._wordenize.bind(this);
      var lineNumber = 0;
      var lineText = '';
      var wordRangesIdx = 0;
      var wordRanges = [];
      return defineProperty_default()({}, Symbol.iterator, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee() {
        var value;
        return regeneratorRuntime_default()().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (false) {}
              if (!(wordRangesIdx < wordRanges.length)) {
                _context.next = 8;
                break;
              }
              value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);
              wordRangesIdx += 1;
              _context.next = 6;
              return value;
            case 6:
              _context.next = 16;
              break;
            case 8:
              if (!(lineNumber < lines.length)) {
                _context.next = 15;
                break;
              }
              lineText = lines[lineNumber];
              wordRanges = wordenize(lineText, wordDefinition);
              wordRangesIdx = 0;
              lineNumber += 1;
              _context.next = 16;
              break;
            case 15:
              return _context.abrupt("break", 18);
            case 16:
              _context.next = 0;
              break;
            case 18:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }));
    }
  }, {
    key: "getLineWords",
    value: function getLineWords(lineNumber, wordDefinition) {
      var content = this._lines[lineNumber - 1];
      var ranges = this._wordenize(content, wordDefinition);
      var words = [];
      var _iterator = createForOfIteratorHelper_default()(ranges),
        _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var range = _step.value;
          words.push({
            word: content.substring(range.start, range.end),
            startColumn: range.start + 1,
            endColumn: range.end + 1
          });
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      return words;
    }
  }, {
    key: "_wordenize",
    value: function _wordenize(content, wordDefinition) {
      var result = [];
      var match;
      wordDefinition.lastIndex = 0; // reset lastIndex just to be sure
      while (match = wordDefinition.exec(content)) {
        if (match[0].length === 0) {
          // it did match the empty string
          break;
        }
        result.push({
          start: match.index,
          end: match.index + match[0].length
        });
      }
      return result;
    }
  }, {
    key: "getValueInRange",
    value: function getValueInRange(range) {
      range = this._validateRange(range);
      if (range.startLineNumber === range.endLineNumber) {
        return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
      }
      var lineEnding = this._eol;
      var startLineIndex = range.startLineNumber - 1;
      var endLineIndex = range.endLineNumber - 1;
      var resultLines = [];
      resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
      for (var i = startLineIndex + 1; i < endLineIndex; i++) {
        resultLines.push(this._lines[i]);
      }
      resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
      return resultLines.join(lineEnding);
    }
  }, {
    key: "offsetAt",
    value: function offsetAt(position) {
      position = this._validatePosition(position);
      this._ensureLineStarts();
      return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);
    }
  }, {
    key: "positionAt",
    value: function positionAt(offset) {
      offset = Math.floor(offset);
      offset = Math.max(0, offset);
      this._ensureLineStarts();
      var out = this._lineStarts.getIndexOf(offset);
      var lineLength = this._lines[out.index].length;
      // Ensure we return a valid position
      return {
        lineNumber: 1 + out.index,
        column: 1 + Math.min(out.remainder, lineLength)
      };
    }
  }, {
    key: "_validateRange",
    value: function _validateRange(range) {
      var start = this._validatePosition({
        lineNumber: range.startLineNumber,
        column: range.startColumn
      });
      var end = this._validatePosition({
        lineNumber: range.endLineNumber,
        column: range.endColumn
      });
      if (start.lineNumber !== range.startLineNumber || start.column !== range.startColumn || end.lineNumber !== range.endLineNumber || end.column !== range.endColumn) {
        return {
          startLineNumber: start.lineNumber,
          startColumn: start.column,
          endLineNumber: end.lineNumber,
          endColumn: end.column
        };
      }
      return range;
    }
  }, {
    key: "_validatePosition",
    value: function _validatePosition(position) {
      if (!Position.isIPosition(position)) {
        throw new Error('bad position');
      }
      var lineNumber = position.lineNumber,
        column = position.column;
      var hasChanged = false;
      if (lineNumber < 1) {
        lineNumber = 1;
        column = 1;
        hasChanged = true;
      } else if (lineNumber > this._lines.length) {
        lineNumber = this._lines.length;
        column = this._lines[lineNumber - 1].length + 1;
        hasChanged = true;
      } else {
        var maxCharacter = this._lines[lineNumber - 1].length + 1;
        if (column < 1) {
          column = 1;
          hasChanged = true;
        } else if (column > maxCharacter) {
          column = maxCharacter;
          hasChanged = true;
        }
      }
      if (!hasChanged) {
        return position;
      } else {
        return {
          lineNumber: lineNumber,
          column: column
        };
      }
    }
  }]);
  return MirrorModel;
}(MirrorTextModel);
/**
 * @internal
 */
var EditorSimpleWorker = /*#__PURE__*/function () {
  function EditorSimpleWorker(host, foreignModuleFactory) {
    classCallCheck_default()(this, EditorSimpleWorker);
    this._host = host;
    this._models = Object.create(null);
    this._foreignModuleFactory = foreignModuleFactory;
    this._foreignModule = null;
  }
  createClass_default()(EditorSimpleWorker, [{
    key: "dispose",
    value: function dispose() {
      this._models = Object.create(null);
    }
  }, {
    key: "_getModel",
    value: function _getModel(uri) {
      return this._models[uri];
    }
  }, {
    key: "_getModels",
    value: function _getModels() {
      var _this = this;
      var all = [];
      Object.keys(this._models).forEach(function (key) {
        return all.push(_this._models[key]);
      });
      return all;
    }
  }, {
    key: "acceptNewModel",
    value: function acceptNewModel(data) {
      this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);
    }
  }, {
    key: "acceptModelChanged",
    value: function acceptModelChanged(strURL, e) {
      if (!this._models[strURL]) {
        return;
      }
      var model = this._models[strURL];
      model.onEvents(e);
    }
  }, {
    key: "acceptRemovedModel",
    value: function acceptRemovedModel(strURL) {
      if (!this._models[strURL]) {
        return;
      }
      delete this._models[strURL];
    }
    // ---- BEGIN diff --------------------------------------------------------------------------
  }, {
    key: "computeDiff",
    value: function computeDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace, maxComputationTime) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee2() {
        var original, modified, originalLines, modifiedLines, diffComputer, diffResult, identical;
        return regeneratorRuntime_default()().wrap(function _callee2$(_context2) {
          while (1) switch (_context2.prev = _context2.next) {
            case 0:
              original = this._getModel(originalUrl);
              modified = this._getModel(modifiedUrl);
              if (!(!original || !modified)) {
                _context2.next = 4;
                break;
              }
              return _context2.abrupt("return", null);
            case 4:
              originalLines = original.getLinesContent();
              modifiedLines = modified.getLinesContent();
              diffComputer = new DiffComputer(originalLines, modifiedLines, {
                shouldComputeCharChanges: true,
                shouldPostProcessCharChanges: true,
                shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
                shouldMakePrettyDiff: true,
                maxComputationTime: maxComputationTime
              });
              diffResult = diffComputer.computeDiff();
              identical = diffResult.changes.length > 0 ? false : this._modelsAreIdentical(original, modified);
              return _context2.abrupt("return", {
                quitEarly: diffResult.quitEarly,
                identical: identical,
                changes: diffResult.changes
              });
            case 10:
            case "end":
              return _context2.stop();
          }
        }, _callee2, this);
      }));
    }
  }, {
    key: "_modelsAreIdentical",
    value: function _modelsAreIdentical(original, modified) {
      var originalLineCount = original.getLineCount();
      var modifiedLineCount = modified.getLineCount();
      if (originalLineCount !== modifiedLineCount) {
        return false;
      }
      for (var line = 1; line <= originalLineCount; line++) {
        var originalLine = original.getLineContent(line);
        var modifiedLine = modified.getLineContent(line);
        if (originalLine !== modifiedLine) {
          return false;
        }
      }
      return true;
    }
  }, {
    key: "computeMoreMinimalEdits",
    value: function computeMoreMinimalEdits(modelUrl, edits) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee3() {
        var model, result, lastEol, _iterator2, _step2, _step2$value, range, text, eol, original, changes, editOffset, _iterator3, _step3, change, start, end, newEdit;
        return regeneratorRuntime_default()().wrap(function _callee3$(_context3) {
          while (1) switch (_context3.prev = _context3.next) {
            case 0:
              model = this._getModel(modelUrl);
              if (model) {
                _context3.next = 3;
                break;
              }
              return _context3.abrupt("return", edits);
            case 3:
              result = [];
              lastEol = undefined;
              edits = edits.slice(0).sort(function (a, b) {
                if (a.range && b.range) {
                  return Range.compareRangesUsingStarts(a.range, b.range);
                }
                // eol only changes should go to the end
                var aRng = a.range ? 0 : 1;
                var bRng = b.range ? 0 : 1;
                return aRng - bRng;
              });
              _iterator2 = createForOfIteratorHelper_default()(edits);
              _context3.prev = 7;
              _iterator2.s();
            case 9:
              if ((_step2 = _iterator2.n()).done) {
                _context3.next = 27;
                break;
              }
              _step2$value = _step2.value, range = _step2$value.range, text = _step2$value.text, eol = _step2$value.eol;
              if (typeof eol === 'number') {
                lastEol = eol;
              }
              if (!(Range.isEmpty(range) && !text)) {
                _context3.next = 14;
                break;
              }
              return _context3.abrupt("continue", 25);
            case 14:
              original = model.getValueInRange(range);
              text = text.replace(/\r\n|\n|\r/g, model.eol);
              if (!(original === text)) {
                _context3.next = 18;
                break;
              }
              return _context3.abrupt("continue", 25);
            case 18:
              if (!(Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit)) {
                _context3.next = 21;
                break;
              }
              result.push({
                range: range,
                text: text
              });
              return _context3.abrupt("continue", 25);
            case 21:
              // compute diff between original and edit.text
              changes = stringDiff(original, text, false);
              editOffset = model.offsetAt(Range.lift(range).getStartPosition());
              _iterator3 = createForOfIteratorHelper_default()(changes);
              try {
                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
                  change = _step3.value;
                  start = model.positionAt(editOffset + change.originalStart);
                  end = model.positionAt(editOffset + change.originalStart + change.originalLength);
                  newEdit = {
                    text: text.substr(change.modifiedStart, change.modifiedLength),
                    range: {
                      startLineNumber: start.lineNumber,
                      startColumn: start.column,
                      endLineNumber: end.lineNumber,
                      endColumn: end.column
                    }
                  };
                  if (model.getValueInRange(newEdit.range) !== newEdit.text) {
                    result.push(newEdit);
                  }
                }
              } catch (err) {
                _iterator3.e(err);
              } finally {
                _iterator3.f();
              }
            case 25:
              _context3.next = 9;
              break;
            case 27:
              _context3.next = 32;
              break;
            case 29:
              _context3.prev = 29;
              _context3.t0 = _context3["catch"](7);
              _iterator2.e(_context3.t0);
            case 32:
              _context3.prev = 32;
              _iterator2.f();
              return _context3.finish(32);
            case 35:
              if (typeof lastEol === 'number') {
                result.push({
                  eol: lastEol,
                  text: '',
                  range: {
                    startLineNumber: 0,
                    startColumn: 0,
                    endLineNumber: 0,
                    endColumn: 0
                  }
                });
              }
              return _context3.abrupt("return", result);
            case 37:
            case "end":
              return _context3.stop();
          }
        }, _callee3, this, [[7, 29, 32, 35]]);
      }));
    }
    // ---- END minimal edits ---------------------------------------------------------------
  }, {
    key: "computeLinks",
    value: function computeLinks(modelUrl) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee4() {
        var model;
        return regeneratorRuntime_default()().wrap(function _callee4$(_context4) {
          while (1) switch (_context4.prev = _context4.next) {
            case 0:
              model = this._getModel(modelUrl);
              if (model) {
                _context4.next = 3;
                break;
              }
              return _context4.abrupt("return", null);
            case 3:
              return _context4.abrupt("return", linkComputer_computeLinks(model));
            case 4:
            case "end":
              return _context4.stop();
          }
        }, _callee4, this);
      }));
    }
  }, {
    key: "textualSuggest",
    value: function textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee5() {
        var sw, wordDefRegExp, seen, _iterator4, _step4, url, model, _iterator5, _step5, word;
        return regeneratorRuntime_default()().wrap(function _callee5$(_context5) {
          while (1) switch (_context5.prev = _context5.next) {
            case 0:
              sw = new StopWatch(true);
              wordDefRegExp = new RegExp(wordDef, wordDefFlags);
              seen = new Set();
              _iterator4 = createForOfIteratorHelper_default()(modelUrls);
              _context5.prev = 4;
              _iterator4.s();
            case 6:
              if ((_step4 = _iterator4.n()).done) {
                _context5.next = 33;
                break;
              }
              url = _step4.value;
              model = this._getModel(url);
              if (model) {
                _context5.next = 11;
                break;
              }
              return _context5.abrupt("continue", 31);
            case 11:
              _iterator5 = createForOfIteratorHelper_default()(model.words(wordDefRegExp));
              _context5.prev = 12;
              _iterator5.s();
            case 14:
              if ((_step5 = _iterator5.n()).done) {
                _context5.next = 23;
                break;
              }
              word = _step5.value;
              if (!(word === leadingWord || !isNaN(Number(word)))) {
                _context5.next = 18;
                break;
              }
              return _context5.abrupt("continue", 21);
            case 18:
              seen.add(word);
              if (!(seen.size > EditorSimpleWorker._suggestionsLimit)) {
                _context5.next = 21;
                break;
              }
              return _context5.abrupt("break", 33);
            case 21:
              _context5.next = 14;
              break;
            case 23:
              _context5.next = 28;
              break;
            case 25:
              _context5.prev = 25;
              _context5.t0 = _context5["catch"](12);
              _iterator5.e(_context5.t0);
            case 28:
              _context5.prev = 28;
              _iterator5.f();
              return _context5.finish(28);
            case 31:
              _context5.next = 6;
              break;
            case 33:
              _context5.next = 38;
              break;
            case 35:
              _context5.prev = 35;
              _context5.t1 = _context5["catch"](4);
              _iterator4.e(_context5.t1);
            case 38:
              _context5.prev = 38;
              _iterator4.f();
              return _context5.finish(38);
            case 41:
              return _context5.abrupt("return", {
                words: Array.from(seen),
                duration: sw.elapsed()
              });
            case 42:
            case "end":
              return _context5.stop();
          }
        }, _callee5, this, [[4, 35, 38, 41], [12, 25, 28, 31]]);
      }));
    }
    // ---- END suggest --------------------------------------------------------------------------
    //#region -- word ranges --
  }, {
    key: "computeWordRanges",
    value: function computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee6() {
        var model, wordDefRegExp, result, line, words, _iterator6, _step6, word, array;
        return regeneratorRuntime_default()().wrap(function _callee6$(_context6) {
          while (1) switch (_context6.prev = _context6.next) {
            case 0:
              model = this._getModel(modelUrl);
              if (model) {
                _context6.next = 3;
                break;
              }
              return _context6.abrupt("return", Object.create(null));
            case 3:
              wordDefRegExp = new RegExp(wordDef, wordDefFlags);
              result = Object.create(null);
              line = range.startLineNumber;
            case 6:
              if (!(line < range.endLineNumber)) {
                _context6.next = 31;
                break;
              }
              words = model.getLineWords(line, wordDefRegExp);
              _iterator6 = createForOfIteratorHelper_default()(words);
              _context6.prev = 9;
              _iterator6.s();
            case 11:
              if ((_step6 = _iterator6.n()).done) {
                _context6.next = 20;
                break;
              }
              word = _step6.value;
              if (isNaN(Number(word.word))) {
                _context6.next = 15;
                break;
              }
              return _context6.abrupt("continue", 18);
            case 15:
              array = result[word.word];
              if (!array) {
                array = [];
                result[word.word] = array;
              }
              array.push({
                startLineNumber: line,
                startColumn: word.startColumn,
                endLineNumber: line,
                endColumn: word.endColumn
              });
            case 18:
              _context6.next = 11;
              break;
            case 20:
              _context6.next = 25;
              break;
            case 22:
              _context6.prev = 22;
              _context6.t0 = _context6["catch"](9);
              _iterator6.e(_context6.t0);
            case 25:
              _context6.prev = 25;
              _iterator6.f();
              return _context6.finish(25);
            case 28:
              line++;
              _context6.next = 6;
              break;
            case 31:
              return _context6.abrupt("return", result);
            case 32:
            case "end":
              return _context6.stop();
          }
        }, _callee6, this, [[9, 22, 25, 28]]);
      }));
    }
    //#endregion
  }, {
    key: "navigateValueSet",
    value: function navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
      return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee7() {
        var model, wordDefRegExp, selectionText, wordRange, word, result;
        return regeneratorRuntime_default()().wrap(function _callee7$(_context7) {
          while (1) switch (_context7.prev = _context7.next) {
            case 0:
              model = this._getModel(modelUrl);
              if (model) {
                _context7.next = 3;
                break;
              }
              return _context7.abrupt("return", null);
            case 3:
              wordDefRegExp = new RegExp(wordDef, wordDefFlags);
              if (range.startColumn === range.endColumn) {
                range = {
                  startLineNumber: range.startLineNumber,
                  startColumn: range.startColumn,
                  endLineNumber: range.endLineNumber,
                  endColumn: range.endColumn + 1
                };
              }
              selectionText = model.getValueInRange(range);
              wordRange = model.getWordAtPosition({
                lineNumber: range.startLineNumber,
                column: range.startColumn
              }, wordDefRegExp);
              if (wordRange) {
                _context7.next = 9;
                break;
              }
              return _context7.abrupt("return", null);
            case 9:
              word = model.getValueInRange(wordRange);
              result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
              return _context7.abrupt("return", result);
            case 12:
            case "end":
              return _context7.stop();
          }
        }, _callee7, this);
      }));
    }
    // ---- BEGIN foreign module support --------------------------------------------------------------------------
  }, {
    key: "loadForeignModule",
    value: function loadForeignModule(moduleId, createData, foreignHostMethods) {
      var _this2 = this;
      var proxyMethodRequest = function proxyMethodRequest(method, args) {
        return _this2._host.fhr(method, args);
      };
      var foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);
      var ctx = {
        host: foreignHost,
        getMirrorModels: function getMirrorModels() {
          return _this2._getModels();
        }
      };
      if (this._foreignModuleFactory) {
        this._foreignModule = this._foreignModuleFactory(ctx, createData);
        // static foreing module
        return Promise.resolve(getAllMethodNames(this._foreignModule));
      }
      // ESM-comment-begin
      // 		return new Promise<any>((resolve, reject) => {
      // 			require([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {
      // 				this._foreignModule = foreignModule.create(ctx, createData);
      // 
      // 				resolve(types.getAllMethodNames(this._foreignModule));
      // 
      // 			}, reject);
      // 		});
      // ESM-comment-end
      // ESM-uncomment-begin
      return Promise.reject(new Error("Unexpected usage"));
      // ESM-uncomment-end
    }
    // foreign method request
  }, {
    key: "fmr",
    value: function fmr(method, args) {
      if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
        return Promise.reject(new Error('Missing requestHandler or method: ' + method));
      }
      try {
        return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
      } catch (e) {
        return Promise.reject(e);
      }
    }
  }]);
  return EditorSimpleWorker;
}();
// ---- END diff --------------------------------------------------------------------------
// ---- BEGIN minimal edits ---------------------------------------------------------------
EditorSimpleWorker._diffLimit = 100000;
// ---- BEGIN suggest --------------------------------------------------------------------------
EditorSimpleWorker._suggestionsLimit = 10000;
/**
 * Called on the worker side
 * @internal
 */
function editorSimpleWorker_create(host) {
  return new EditorSimpleWorker(host, null);
}
if (typeof importScripts === 'function') {
  // Running in a web worker
  platform_globals.monaco = createMonacoBaseAPI();
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/editor/editor.worker.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


var initialized = false;
function initialize(foreignModule) {
  if (initialized) {
    return;
  }
  initialized = true;
  var simpleWorker = new SimpleWorkerServer(function (msg) {
    self.postMessage(msg);
  }, function (host) {
    return new EditorSimpleWorker(host, foreignModule);
  });
  self.onmessage = function (e) {
    simpleWorker.onmessage(e.data);
  };
}
self.onmessage = function (e) {
  // Ignore first message in this case and initialize if not yet initialized
  if (!initialized) {
    initialize(null);
  }
};
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/scanner.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


/**
 * Creates a JSON scanner on the given text.
 * If ignoreTrivia is set, whitespaces or comments are ignored.
 */
function createScanner(text, ignoreTrivia) {
  if (ignoreTrivia === void 0) {
    ignoreTrivia = false;
  }
  var len = text.length;
  var pos = 0,
    value = '',
    tokenOffset = 0,
    token = 16 /* Unknown */,
    lineNumber = 0,
    lineStartOffset = 0,
    tokenLineStartOffset = 0,
    prevTokenLineStartOffset = 0,
    scanError = 0 /* None */;
  function scanHexDigits(count, exact) {
    var digits = 0;
    var value = 0;
    while (digits < count || !exact) {
      var ch = text.charCodeAt(pos);
      if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
        value = value * 16 + ch - 48 /* _0 */;
      } else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
        value = value * 16 + ch - 65 /* A */ + 10;
      } else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
        value = value * 16 + ch - 97 /* a */ + 10;
      } else {
        break;
      }
      pos++;
      digits++;
    }
    if (digits < count) {
      value = -1;
    }
    return value;
  }
  function setPosition(newPosition) {
    pos = newPosition;
    value = '';
    tokenOffset = 0;
    token = 16 /* Unknown */;
    scanError = 0 /* None */;
  }

  function scanNumber() {
    var start = pos;
    if (text.charCodeAt(pos) === 48 /* _0 */) {
      pos++;
    } else {
      pos++;
      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
        pos++;
      }
    }
    if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
      pos++;
      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
        pos++;
        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
          pos++;
        }
      } else {
        scanError = 3 /* UnexpectedEndOfNumber */;
        return text.substring(start, pos);
      }
    }
    var end = pos;
    if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
      pos++;
      if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
        pos++;
      }
      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
        pos++;
        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
          pos++;
        }
        end = pos;
      } else {
        scanError = 3 /* UnexpectedEndOfNumber */;
      }
    }

    return text.substring(start, end);
  }
  function scanString() {
    var result = '',
      start = pos;
    while (true) {
      if (pos >= len) {
        result += text.substring(start, pos);
        scanError = 2 /* UnexpectedEndOfString */;
        break;
      }
      var ch = text.charCodeAt(pos);
      if (ch === 34 /* doubleQuote */) {
        result += text.substring(start, pos);
        pos++;
        break;
      }
      if (ch === 92 /* backslash */) {
        result += text.substring(start, pos);
        pos++;
        if (pos >= len) {
          scanError = 2 /* UnexpectedEndOfString */;
          break;
        }
        var ch2 = text.charCodeAt(pos++);
        switch (ch2) {
          case 34 /* doubleQuote */:
            result += '\"';
            break;
          case 92 /* backslash */:
            result += '\\';
            break;
          case 47 /* slash */:
            result += '/';
            break;
          case 98 /* b */:
            result += '\b';
            break;
          case 102 /* f */:
            result += '\f';
            break;
          case 110 /* n */:
            result += '\n';
            break;
          case 114 /* r */:
            result += '\r';
            break;
          case 116 /* t */:
            result += '\t';
            break;
          case 117 /* u */:
            var ch3 = scanHexDigits(4, true);
            if (ch3 >= 0) {
              result += String.fromCharCode(ch3);
            } else {
              scanError = 4 /* InvalidUnicode */;
            }

            break;
          default:
            scanError = 5 /* InvalidEscapeCharacter */;
        }

        start = pos;
        continue;
      }
      if (ch >= 0 && ch <= 0x1f) {
        if (isLineBreak(ch)) {
          result += text.substring(start, pos);
          scanError = 2 /* UnexpectedEndOfString */;
          break;
        } else {
          scanError = 6 /* InvalidCharacter */;
          // mark as error but continue with string
        }
      }

      pos++;
    }
    return result;
  }
  function scanNext() {
    value = '';
    scanError = 0 /* None */;
    tokenOffset = pos;
    lineStartOffset = lineNumber;
    prevTokenLineStartOffset = tokenLineStartOffset;
    if (pos >= len) {
      // at the end
      tokenOffset = len;
      return token = 17 /* EOF */;
    }

    var code = text.charCodeAt(pos);
    // trivia: whitespace
    if (isWhiteSpace(code)) {
      do {
        pos++;
        value += String.fromCharCode(code);
        code = text.charCodeAt(pos);
      } while (isWhiteSpace(code));
      return token = 15 /* Trivia */;
    }
    // trivia: newlines
    if (isLineBreak(code)) {
      pos++;
      value += String.fromCharCode(code);
      if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
        pos++;
        value += '\n';
      }
      lineNumber++;
      tokenLineStartOffset = pos;
      return token = 14 /* LineBreakTrivia */;
    }

    switch (code) {
      // tokens: []{}:,
      case 123 /* openBrace */:
        pos++;
        return token = 1 /* OpenBraceToken */;
      case 125 /* closeBrace */:
        pos++;
        return token = 2 /* CloseBraceToken */;
      case 91 /* openBracket */:
        pos++;
        return token = 3 /* OpenBracketToken */;
      case 93 /* closeBracket */:
        pos++;
        return token = 4 /* CloseBracketToken */;
      case 58 /* colon */:
        pos++;
        return token = 6 /* ColonToken */;
      case 44 /* comma */:
        pos++;
        return token = 5 /* CommaToken */;
      // strings
      case 34 /* doubleQuote */:
        pos++;
        value = scanString();
        return token = 10 /* StringLiteral */;
      // comments
      case 47 /* slash */:
        var start = pos - 1;
        // Single-line comment
        if (text.charCodeAt(pos + 1) === 47 /* slash */) {
          pos += 2;
          while (pos < len) {
            if (isLineBreak(text.charCodeAt(pos))) {
              break;
            }
            pos++;
          }
          value = text.substring(start, pos);
          return token = 12 /* LineCommentTrivia */;
        }
        // Multi-line comment
        if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
          pos += 2;
          var safeLength = len - 1; // For lookahead.
          var commentClosed = false;
          while (pos < safeLength) {
            var ch = text.charCodeAt(pos);
            if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
              pos += 2;
              commentClosed = true;
              break;
            }
            pos++;
            if (isLineBreak(ch)) {
              if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
                pos++;
              }
              lineNumber++;
              tokenLineStartOffset = pos;
            }
          }
          if (!commentClosed) {
            pos++;
            scanError = 1 /* UnexpectedEndOfComment */;
          }

          value = text.substring(start, pos);
          return token = 13 /* BlockCommentTrivia */;
        }
        // just a single slash
        value += String.fromCharCode(code);
        pos++;
        return token = 16 /* Unknown */;
      // numbers
      case 45 /* minus */:
        value += String.fromCharCode(code);
        pos++;
        if (pos === len || !isDigit(text.charCodeAt(pos))) {
          return token = 16 /* Unknown */;
        }
      // found a minus, followed by a number so
      // we fall through to proceed with scanning
      // numbers
      case 48 /* _0 */:
      case 49 /* _1 */:
      case 50 /* _2 */:
      case 51 /* _3 */:
      case 52 /* _4 */:
      case 53 /* _5 */:
      case 54 /* _6 */:
      case 55 /* _7 */:
      case 56 /* _8 */:
      case 57 /* _9 */:
        value += scanNumber();
        return token = 11 /* NumericLiteral */;
      // literals and unknown symbols
      default:
        // is a literal? Read the full word.
        while (pos < len && isUnknownContentCharacter(code)) {
          pos++;
          code = text.charCodeAt(pos);
        }
        if (tokenOffset !== pos) {
          value = text.substring(tokenOffset, pos);
          // keywords: true, false, null
          switch (value) {
            case 'true':
              return token = 8 /* TrueKeyword */;
            case 'false':
              return token = 9 /* FalseKeyword */;
            case 'null':
              return token = 7 /* NullKeyword */;
          }

          return token = 16 /* Unknown */;
        }
        // some
        value += String.fromCharCode(code);
        pos++;
        return token = 16 /* Unknown */;
    }
  }

  function isUnknownContentCharacter(code) {
    if (isWhiteSpace(code) || isLineBreak(code)) {
      return false;
    }
    switch (code) {
      case 125 /* closeBrace */:
      case 93 /* closeBracket */:
      case 123 /* openBrace */:
      case 91 /* openBracket */:
      case 34 /* doubleQuote */:
      case 58 /* colon */:
      case 44 /* comma */:
      case 47 /* slash */:
        return false;
    }
    return true;
  }
  function scanNextNonTrivia() {
    var result;
    do {
      result = scanNext();
    } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
    return result;
  }
  return {
    setPosition: setPosition,
    getPosition: function getPosition() {
      return pos;
    },
    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
    getToken: function getToken() {
      return token;
    },
    getTokenValue: function getTokenValue() {
      return value;
    },
    getTokenOffset: function getTokenOffset() {
      return tokenOffset;
    },
    getTokenLength: function getTokenLength() {
      return pos - tokenOffset;
    },
    getTokenStartLine: function getTokenStartLine() {
      return lineStartOffset;
    },
    getTokenStartCharacter: function getTokenStartCharacter() {
      return tokenOffset - prevTokenLineStartOffset;
    },
    getTokenError: function getTokenError() {
      return scanError;
    }
  };
}
function isWhiteSpace(ch) {
  return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ || ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ || ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
}

function isLineBreak(ch) {
  return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
}

function isDigit(ch) {
  return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/format.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/



function format_format(documentText, range, options) {
  var initialIndentLevel;
  var formatText;
  var formatTextStart;
  var rangeStart;
  var rangeEnd;
  if (range) {
    rangeStart = range.offset;
    rangeEnd = rangeStart + range.length;
    formatTextStart = rangeStart;
    while (formatTextStart > 0 && !format_isEOL(documentText, formatTextStart - 1)) {
      formatTextStart--;
    }
    var endOffset = rangeEnd;
    while (endOffset < documentText.length && !format_isEOL(documentText, endOffset)) {
      endOffset++;
    }
    formatText = documentText.substring(formatTextStart, endOffset);
    initialIndentLevel = computeIndentLevel(formatText, options);
  } else {
    formatText = documentText;
    initialIndentLevel = 0;
    formatTextStart = 0;
    rangeStart = 0;
    rangeEnd = documentText.length;
  }
  var eol = getEOL(options, documentText);
  var lineBreak = false;
  var indentLevel = 0;
  var indentValue;
  if (options.insertSpaces) {
    indentValue = repeat(' ', options.tabSize || 4);
  } else {
    indentValue = '\t';
  }
  var scanner = createScanner(formatText, false);
  var hasError = false;
  function newLineAndIndent() {
    return eol + repeat(indentValue, initialIndentLevel + indentLevel);
  }
  function scanNext() {
    var token = scanner.scan();
    lineBreak = false;
    while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {
      lineBreak = lineBreak || token === 14 /* LineBreakTrivia */;
      token = scanner.scan();
    }
    hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;
    return token;
  }
  var editOperations = [];
  function addEdit(text, startOffset, endOffset) {
    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
      editOperations.push({
        offset: startOffset,
        length: endOffset - startOffset,
        content: text
      });
    }
  }
  var firstToken = scanNext();
  if (firstToken !== 17 /* EOF */) {
    var firstTokenStart = scanner.getTokenOffset() + formatTextStart;
    var initialIndent = repeat(indentValue, initialIndentLevel);
    addEdit(initialIndent, formatTextStart, firstTokenStart);
  }
  while (firstToken !== 17 /* EOF */) {
    var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
    var secondToken = scanNext();
    var replaceContent = '';
    var needsLineBreak = false;
    while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
      // comments on the same line: keep them on the same line, but ignore them otherwise
      var commentTokenStart = scanner.getTokenOffset() + formatTextStart;
      addEdit(' ', firstTokenEnd, commentTokenStart);
      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
      needsLineBreak = secondToken === 12 /* LineCommentTrivia */;
      replaceContent = needsLineBreak ? newLineAndIndent() : '';
      secondToken = scanNext();
    }
    if (secondToken === 2 /* CloseBraceToken */) {
      if (firstToken !== 1 /* OpenBraceToken */) {
        indentLevel--;
        replaceContent = newLineAndIndent();
      }
    } else if (secondToken === 4 /* CloseBracketToken */) {
      if (firstToken !== 3 /* OpenBracketToken */) {
        indentLevel--;
        replaceContent = newLineAndIndent();
      }
    } else {
      switch (firstToken) {
        case 3 /* OpenBracketToken */:
        case 1 /* OpenBraceToken */:
          indentLevel++;
          replaceContent = newLineAndIndent();
          break;
        case 5 /* CommaToken */:
        case 12 /* LineCommentTrivia */:
          replaceContent = newLineAndIndent();
          break;
        case 13 /* BlockCommentTrivia */:
          if (lineBreak) {
            replaceContent = newLineAndIndent();
          } else if (!needsLineBreak) {
            // symbol following comment on the same line: keep on same line, separate with ' '
            replaceContent = ' ';
          }
          break;
        case 6 /* ColonToken */:
          if (!needsLineBreak) {
            replaceContent = ' ';
          }
          break;
        case 10 /* StringLiteral */:
          if (secondToken === 6 /* ColonToken */) {
            if (!needsLineBreak) {
              replaceContent = '';
            }
            break;
          }
        // fall through
        case 7 /* NullKeyword */:
        case 8 /* TrueKeyword */:
        case 9 /* FalseKeyword */:
        case 11 /* NumericLiteral */:
        case 2 /* CloseBraceToken */:
        case 4 /* CloseBracketToken */:
          if (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */) {
            if (!needsLineBreak) {
              replaceContent = ' ';
            }
          } else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {
            hasError = true;
          }
          break;
        case 16 /* Unknown */:
          hasError = true;
          break;
      }
      if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
        replaceContent = newLineAndIndent();
      }
    }
    if (secondToken === 17 /* EOF */) {
      replaceContent = options.insertFinalNewline ? eol : '';
    }
    var secondTokenStart = scanner.getTokenOffset() + formatTextStart;
    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
    firstToken = secondToken;
  }
  return editOperations;
}
function repeat(s, count) {
  var result = '';
  for (var i = 0; i < count; i++) {
    result += s;
  }
  return result;
}
function computeIndentLevel(content, options) {
  var i = 0;
  var nChars = 0;
  var tabSize = options.tabSize || 4;
  while (i < content.length) {
    var ch = content.charAt(i);
    if (ch === ' ') {
      nChars++;
    } else if (ch === '\t') {
      nChars += tabSize;
    } else {
      break;
    }
    i++;
  }
  return Math.floor(nChars / tabSize);
}
function getEOL(options, text) {
  for (var i = 0; i < text.length; i++) {
    var ch = text.charAt(i);
    if (ch === '\r') {
      if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
        return '\r\n';
      }
      return '\r';
    } else if (ch === '\n') {
      return '\n';
    }
  }
  return options && options.eol || '\n';
}
function format_isEOL(text, offset) {
  return '\r\n'.indexOf(text.charAt(offset)) !== -1;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/parser.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/




var ParseOptions;
(function (ParseOptions) {
  ParseOptions.DEFAULT = {
    allowTrailingComma: false
  };
})(ParseOptions || (ParseOptions = {}));
/**
 * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
 */
function getLocation(text, position) {
  var segments = []; // strings or numbers
  var earlyReturnException = new Object();
  var previousNode = undefined;
  var previousNodeInst = {
    value: {},
    offset: 0,
    length: 0,
    type: 'object',
    parent: undefined
  };
  var isAtPropertyKey = false;
  function setPreviousNode(value, offset, length, type) {
    previousNodeInst.value = value;
    previousNodeInst.offset = offset;
    previousNodeInst.length = length;
    previousNodeInst.type = type;
    previousNodeInst.colonOffset = undefined;
    previousNode = previousNodeInst;
  }
  try {
    visit(text, {
      onObjectBegin: function onObjectBegin(offset, length) {
        if (position <= offset) {
          throw earlyReturnException;
        }
        previousNode = undefined;
        isAtPropertyKey = position > offset;
        segments.push(''); // push a placeholder (will be replaced)
      },

      onObjectProperty: function onObjectProperty(name, offset, length) {
        if (position < offset) {
          throw earlyReturnException;
        }
        setPreviousNode(name, offset, length, 'property');
        segments[segments.length - 1] = name;
        if (position <= offset + length) {
          throw earlyReturnException;
        }
      },
      onObjectEnd: function onObjectEnd(offset, length) {
        if (position <= offset) {
          throw earlyReturnException;
        }
        previousNode = undefined;
        segments.pop();
      },
      onArrayBegin: function onArrayBegin(offset, length) {
        if (position <= offset) {
          throw earlyReturnException;
        }
        previousNode = undefined;
        segments.push(0);
      },
      onArrayEnd: function onArrayEnd(offset, length) {
        if (position <= offset) {
          throw earlyReturnException;
        }
        previousNode = undefined;
        segments.pop();
      },
      onLiteralValue: function onLiteralValue(value, offset, length) {
        if (position < offset) {
          throw earlyReturnException;
        }
        setPreviousNode(value, offset, length, getNodeType(value));
        if (position <= offset + length) {
          throw earlyReturnException;
        }
      },
      onSeparator: function onSeparator(sep, offset, length) {
        if (position <= offset) {
          throw earlyReturnException;
        }
        if (sep === ':' && previousNode && previousNode.type === 'property') {
          previousNode.colonOffset = offset;
          isAtPropertyKey = false;
          previousNode = undefined;
        } else if (sep === ',') {
          var last = segments[segments.length - 1];
          if (typeof last === 'number') {
            segments[segments.length - 1] = last + 1;
          } else {
            isAtPropertyKey = true;
            segments[segments.length - 1] = '';
          }
          previousNode = undefined;
        }
      }
    });
  } catch (e) {
    if (e !== earlyReturnException) {
      throw e;
    }
  }
  return {
    path: segments,
    previousNode: previousNode,
    isAtPropertyKey: isAtPropertyKey,
    matches: function matches(pattern) {
      var k = 0;
      for (var i = 0; k < pattern.length && i < segments.length; i++) {
        if (pattern[k] === segments[i] || pattern[k] === '*') {
          k++;
        } else if (pattern[k] !== '**') {
          return false;
        }
      }
      return k === pattern.length;
    }
  };
}
/**
 * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
 * Therefore always check the errors list to find out if the input was valid.
 */
function parse(text, errors, options) {
  if (errors === void 0) {
    errors = [];
  }
  if (options === void 0) {
    options = ParseOptions.DEFAULT;
  }
  var currentProperty = null;
  var currentParent = [];
  var previousParents = [];
  function onValue(value) {
    if (Array.isArray(currentParent)) {
      currentParent.push(value);
    } else if (currentProperty !== null) {
      currentParent[currentProperty] = value;
    }
  }
  var visitor = {
    onObjectBegin: function onObjectBegin() {
      var object = {};
      onValue(object);
      previousParents.push(currentParent);
      currentParent = object;
      currentProperty = null;
    },
    onObjectProperty: function onObjectProperty(name) {
      currentProperty = name;
    },
    onObjectEnd: function onObjectEnd() {
      currentParent = previousParents.pop();
    },
    onArrayBegin: function onArrayBegin() {
      var array = [];
      onValue(array);
      previousParents.push(currentParent);
      currentParent = array;
      currentProperty = null;
    },
    onArrayEnd: function onArrayEnd() {
      currentParent = previousParents.pop();
    },
    onLiteralValue: onValue,
    onError: function onError(error, offset, length) {
      errors.push({
        error: error,
        offset: offset,
        length: length
      });
    }
  };
  visit(text, visitor, options);
  return currentParent[0];
}
/**
 * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
 */
function parser_parseTree(text, errors, options) {
  if (errors === void 0) {
    errors = [];
  }
  if (options === void 0) {
    options = ParseOptions.DEFAULT;
  }
  var currentParent = {
    type: 'array',
    offset: -1,
    length: -1,
    children: [],
    parent: undefined
  }; // artificial root
  function ensurePropertyComplete(endOffset) {
    if (currentParent.type === 'property') {
      currentParent.length = endOffset - currentParent.offset;
      currentParent = currentParent.parent;
    }
  }
  function onValue(valueNode) {
    currentParent.children.push(valueNode);
    return valueNode;
  }
  var visitor = {
    onObjectBegin: function onObjectBegin(offset) {
      currentParent = onValue({
        type: 'object',
        offset: offset,
        length: -1,
        parent: currentParent,
        children: []
      });
    },
    onObjectProperty: function onObjectProperty(name, offset, length) {
      currentParent = onValue({
        type: 'property',
        offset: offset,
        length: -1,
        parent: currentParent,
        children: []
      });
      currentParent.children.push({
        type: 'string',
        value: name,
        offset: offset,
        length: length,
        parent: currentParent
      });
    },
    onObjectEnd: function onObjectEnd(offset, length) {
      ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
      currentParent.length = offset + length - currentParent.offset;
      currentParent = currentParent.parent;
      ensurePropertyComplete(offset + length);
    },
    onArrayBegin: function onArrayBegin(offset, length) {
      currentParent = onValue({
        type: 'array',
        offset: offset,
        length: -1,
        parent: currentParent,
        children: []
      });
    },
    onArrayEnd: function onArrayEnd(offset, length) {
      currentParent.length = offset + length - currentParent.offset;
      currentParent = currentParent.parent;
      ensurePropertyComplete(offset + length);
    },
    onLiteralValue: function onLiteralValue(value, offset, length) {
      onValue({
        type: getNodeType(value),
        offset: offset,
        length: length,
        parent: currentParent,
        value: value
      });
      ensurePropertyComplete(offset + length);
    },
    onSeparator: function onSeparator(sep, offset, length) {
      if (currentParent.type === 'property') {
        if (sep === ':') {
          currentParent.colonOffset = offset;
        } else if (sep === ',') {
          ensurePropertyComplete(offset);
        }
      }
    },
    onError: function onError(error, offset, length) {
      errors.push({
        error: error,
        offset: offset,
        length: length
      });
    }
  };
  visit(text, visitor, options);
  var result = currentParent.children[0];
  if (result) {
    delete result.parent;
  }
  return result;
}
/**
 * Finds the node at the given path in a JSON DOM.
 */
function parser_findNodeAtLocation(root, path) {
  if (!root) {
    return undefined;
  }
  var node = root;
  for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
    var segment = path_1[_i];
    if (typeof segment === 'string') {
      if (node.type !== 'object' || !Array.isArray(node.children)) {
        return undefined;
      }
      var found = false;
      for (var _a = 0, _b = node.children; _a < _b.length; _a++) {
        var propertyNode = _b[_a];
        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
          node = propertyNode.children[1];
          found = true;
          break;
        }
      }
      if (!found) {
        return undefined;
      }
    } else {
      var index = segment;
      if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
        return undefined;
      }
      node = node.children[index];
    }
  }
  return node;
}
/**
 * Gets the JSON path of the given JSON DOM node
 */
function getNodePath(node) {
  if (!node.parent || !node.parent.children) {
    return [];
  }
  var path = getNodePath(node.parent);
  if (node.parent.type === 'property') {
    var key = node.parent.children[0].value;
    path.push(key);
  } else if (node.parent.type === 'array') {
    var index = node.parent.children.indexOf(node);
    if (index !== -1) {
      path.push(index);
    }
  }
  return path;
}
/**
 * Evaluates the JavaScript object of the given JSON DOM node
 */
function getNodeValue(node) {
  switch (node.type) {
    case 'array':
      return node.children.map(getNodeValue);
    case 'object':
      var obj = Object.create(null);
      for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
        var prop = _a[_i];
        var valueNode = prop.children[1];
        if (valueNode) {
          obj[prop.children[0].value] = getNodeValue(valueNode);
        }
      }
      return obj;
    case 'null':
    case 'string':
    case 'number':
    case 'boolean':
      return node.value;
    default:
      return undefined;
  }
}
function contains(node, offset, includeRightBound) {
  if (includeRightBound === void 0) {
    includeRightBound = false;
  }
  return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
}
/**
 * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
 */
function findNodeAtOffset(node, offset, includeRightBound) {
  if (includeRightBound === void 0) {
    includeRightBound = false;
  }
  if (contains(node, offset, includeRightBound)) {
    var children = node.children;
    if (Array.isArray(children)) {
      for (var i = 0; i < children.length && children[i].offset <= offset; i++) {
        var item = findNodeAtOffset(children[i], offset, includeRightBound);
        if (item) {
          return item;
        }
      }
    }
    return node;
  }
  return undefined;
}
/**
 * Parses the given text and invokes the visitor functions for each object, array and literal reached.
 */
function visit(text, visitor, options) {
  if (options === void 0) {
    options = ParseOptions.DEFAULT;
  }
  var _scanner = createScanner(text, false);
  function toNoArgVisit(visitFunction) {
    return visitFunction ? function () {
      return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
    } : function () {
      return true;
    };
  }
  function toOneArgVisit(visitFunction) {
    return visitFunction ? function (arg) {
      return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
    } : function () {
      return true;
    };
  }
  var onObjectBegin = toNoArgVisit(visitor.onObjectBegin),
    onObjectProperty = toOneArgVisit(visitor.onObjectProperty),
    onObjectEnd = toNoArgVisit(visitor.onObjectEnd),
    onArrayBegin = toNoArgVisit(visitor.onArrayBegin),
    onArrayEnd = toNoArgVisit(visitor.onArrayEnd),
    onLiteralValue = toOneArgVisit(visitor.onLiteralValue),
    onSeparator = toOneArgVisit(visitor.onSeparator),
    onComment = toNoArgVisit(visitor.onComment),
    onError = toOneArgVisit(visitor.onError);
  var disallowComments = options && options.disallowComments;
  var allowTrailingComma = options && options.allowTrailingComma;
  function scanNext() {
    while (true) {
      var token = _scanner.scan();
      switch (_scanner.getTokenError()) {
        case 4 /* InvalidUnicode */:
          handleError(14 /* InvalidUnicode */);
          break;
        case 5 /* InvalidEscapeCharacter */:
          handleError(15 /* InvalidEscapeCharacter */);
          break;
        case 3 /* UnexpectedEndOfNumber */:
          handleError(13 /* UnexpectedEndOfNumber */);
          break;
        case 1 /* UnexpectedEndOfComment */:
          if (!disallowComments) {
            handleError(11 /* UnexpectedEndOfComment */);
          }

          break;
        case 2 /* UnexpectedEndOfString */:
          handleError(12 /* UnexpectedEndOfString */);
          break;
        case 6 /* InvalidCharacter */:
          handleError(16 /* InvalidCharacter */);
          break;
      }
      switch (token) {
        case 12 /* LineCommentTrivia */:
        case 13 /* BlockCommentTrivia */:
          if (disallowComments) {
            handleError(10 /* InvalidCommentToken */);
          } else {
            onComment();
          }
          break;
        case 16 /* Unknown */:
          handleError(1 /* InvalidSymbol */);
          break;
        case 15 /* Trivia */:
        case 14 /* LineBreakTrivia */:
          break;
        default:
          return token;
      }
    }
  }
  function handleError(error, skipUntilAfter, skipUntil) {
    if (skipUntilAfter === void 0) {
      skipUntilAfter = [];
    }
    if (skipUntil === void 0) {
      skipUntil = [];
    }
    onError(error);
    if (skipUntilAfter.length + skipUntil.length > 0) {
      var token = _scanner.getToken();
      while (token !== 17 /* EOF */) {
        if (skipUntilAfter.indexOf(token) !== -1) {
          scanNext();
          break;
        } else if (skipUntil.indexOf(token) !== -1) {
          break;
        }
        token = scanNext();
      }
    }
  }
  function parseString(isValue) {
    var value = _scanner.getTokenValue();
    if (isValue) {
      onLiteralValue(value);
    } else {
      onObjectProperty(value);
    }
    scanNext();
    return true;
  }
  function parseLiteral() {
    switch (_scanner.getToken()) {
      case 11 /* NumericLiteral */:
        var tokenValue = _scanner.getTokenValue();
        var value = Number(tokenValue);
        if (isNaN(value)) {
          handleError(2 /* InvalidNumberFormat */);
          value = 0;
        }
        onLiteralValue(value);
        break;
      case 7 /* NullKeyword */:
        onLiteralValue(null);
        break;
      case 8 /* TrueKeyword */:
        onLiteralValue(true);
        break;
      case 9 /* FalseKeyword */:
        onLiteralValue(false);
        break;
      default:
        return false;
    }
    scanNext();
    return true;
  }
  function parseProperty() {
    if (_scanner.getToken() !== 10 /* StringLiteral */) {
      handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
      return false;
    }
    parseString(false);
    if (_scanner.getToken() === 6 /* ColonToken */) {
      onSeparator(':');
      scanNext(); // consume colon
      if (!parseValue()) {
        handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
      }
    } else {
      handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
    }

    return true;
  }
  function parseObject() {
    onObjectBegin();
    scanNext(); // consume open brace
    var needsComma = false;
    while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
      if (_scanner.getToken() === 5 /* CommaToken */) {
        if (!needsComma) {
          handleError(4 /* ValueExpected */, [], []);
        }
        onSeparator(',');
        scanNext(); // consume comma
        if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
          break;
        }
      } else if (needsComma) {
        handleError(6 /* CommaExpected */, [], []);
      }
      if (!parseProperty()) {
        handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
      }

      needsComma = true;
    }
    onObjectEnd();
    if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
      handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
    } else {
      scanNext(); // consume close brace
    }

    return true;
  }
  function parseArray() {
    onArrayBegin();
    scanNext(); // consume open bracket
    var needsComma = false;
    while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
      if (_scanner.getToken() === 5 /* CommaToken */) {
        if (!needsComma) {
          handleError(4 /* ValueExpected */, [], []);
        }
        onSeparator(',');
        scanNext(); // consume comma
        if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
          break;
        }
      } else if (needsComma) {
        handleError(6 /* CommaExpected */, [], []);
      }
      if (!parseValue()) {
        handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
      }

      needsComma = true;
    }
    onArrayEnd();
    if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
      handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
    } else {
      scanNext(); // consume close bracket
    }

    return true;
  }
  function parseValue() {
    switch (_scanner.getToken()) {
      case 3 /* OpenBracketToken */:
        return parseArray();
      case 1 /* OpenBraceToken */:
        return parseObject();
      case 10 /* StringLiteral */:
        return parseString(true);
      default:
        return parseLiteral();
    }
  }
  scanNext();
  if (_scanner.getToken() === 17 /* EOF */) {
    if (options.allowEmptyContent) {
      return true;
    }
    handleError(4 /* ValueExpected */, [], []);
    return false;
  }
  if (!parseValue()) {
    handleError(4 /* ValueExpected */, [], []);
    return false;
  }
  if (_scanner.getToken() !== 17 /* EOF */) {
    handleError(9 /* EndOfFileExpected */, [], []);
  }
  return true;
}
/**
 * Takes JSON with JavaScript-style comments and remove
 * them. Optionally replaces every none-newline character
 * of comments with a replaceCharacter
 */
function stripComments(text, replaceCh) {
  var _scanner = createScanner(text),
    parts = [],
    kind,
    offset = 0,
    pos;
  do {
    pos = _scanner.getPosition();
    kind = _scanner.scan();
    switch (kind) {
      case 12 /* LineCommentTrivia */:
      case 13 /* BlockCommentTrivia */:
      case 17 /* EOF */:
        if (offset !== pos) {
          parts.push(text.substring(offset, pos));
        }
        if (replaceCh !== undefined) {
          parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
        }
        offset = _scanner.getPosition();
        break;
    }
  } while (kind !== 17 /* EOF */);
  return parts.join('');
}
function getNodeType(value) {
  switch (typeof_default()(value)) {
    case 'boolean':
      return 'boolean';
    case 'number':
      return 'number';
    case 'string':
      return 'string';
    case 'object':
      {
        if (!value) {
          return 'null';
        } else if (Array.isArray(value)) {
          return 'array';
        }
        return 'object';
      }
    default:
      return 'null';
  }
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/edit.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/




function removeProperty(text, path, options) {
  return setProperty(text, path, void 0, options);
}
function setProperty(text, originalPath, value, options) {
  var _a;
  var path = originalPath.slice();
  var errors = [];
  var root = parseTree(text, errors);
  var parent = void 0;
  var lastSegment = void 0;
  while (path.length > 0) {
    lastSegment = path.pop();
    parent = findNodeAtLocation(root, path);
    if (parent === void 0 && value !== void 0) {
      if (typeof lastSegment === 'string') {
        value = (_a = {}, _a[lastSegment] = value, _a);
      } else {
        value = [value];
      }
    } else {
      break;
    }
  }
  if (!parent) {
    // empty document
    if (value === void 0) {
      // delete
      throw new Error('Can not delete in empty document');
    }
    return withFormatting(text, {
      offset: root ? root.offset : 0,
      length: root ? root.length : 0,
      content: JSON.stringify(value)
    }, options);
  } else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
    var existing = findNodeAtLocation(parent, [lastSegment]);
    if (existing !== void 0) {
      if (value === void 0) {
        // delete
        if (!existing.parent) {
          throw new Error('Malformed AST');
        }
        var propertyIndex = parent.children.indexOf(existing.parent);
        var removeBegin = void 0;
        var removeEnd = existing.parent.offset + existing.parent.length;
        if (propertyIndex > 0) {
          // remove the comma of the previous node
          var previous = parent.children[propertyIndex - 1];
          removeBegin = previous.offset + previous.length;
        } else {
          removeBegin = parent.offset + 1;
          if (parent.children.length > 1) {
            // remove the comma of the next node
            var next = parent.children[1];
            removeEnd = next.offset;
          }
        }
        return withFormatting(text, {
          offset: removeBegin,
          length: removeEnd - removeBegin,
          content: ''
        }, options);
      } else {
        // set value of existing property
        return withFormatting(text, {
          offset: existing.offset,
          length: existing.length,
          content: JSON.stringify(value)
        }, options);
      }
    } else {
      if (value === void 0) {
        // delete
        return []; // property does not exist, nothing to do
      }

      var newProperty = JSON.stringify(lastSegment) + ": " + JSON.stringify(value);
      var index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(function (p) {
        return p.children[0].value;
      })) : parent.children.length;
      var edit = void 0;
      if (index > 0) {
        var previous = parent.children[index - 1];
        edit = {
          offset: previous.offset + previous.length,
          length: 0,
          content: ',' + newProperty
        };
      } else if (parent.children.length === 0) {
        edit = {
          offset: parent.offset + 1,
          length: 0,
          content: newProperty
        };
      } else {
        edit = {
          offset: parent.offset + 1,
          length: 0,
          content: newProperty + ','
        };
      }
      return withFormatting(text, edit, options);
    }
  } else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
    var insertIndex = lastSegment;
    if (insertIndex === -1) {
      // Insert
      var newProperty = "" + JSON.stringify(value);
      var edit = void 0;
      if (parent.children.length === 0) {
        edit = {
          offset: parent.offset + 1,
          length: 0,
          content: newProperty
        };
      } else {
        var previous = parent.children[parent.children.length - 1];
        edit = {
          offset: previous.offset + previous.length,
          length: 0,
          content: ',' + newProperty
        };
      }
      return withFormatting(text, edit, options);
    } else if (value === void 0 && parent.children.length >= 0) {
      // Removal
      var removalIndex = lastSegment;
      var toRemove = parent.children[removalIndex];
      var edit = void 0;
      if (parent.children.length === 1) {
        // only item
        edit = {
          offset: parent.offset + 1,
          length: parent.length - 2,
          content: ''
        };
      } else if (parent.children.length - 1 === removalIndex) {
        // last item
        var previous = parent.children[removalIndex - 1];
        var offset = previous.offset + previous.length;
        var parentEndOffset = parent.offset + parent.length;
        edit = {
          offset: offset,
          length: parentEndOffset - 2 - offset,
          content: ''
        };
      } else {
        edit = {
          offset: toRemove.offset,
          length: parent.children[removalIndex + 1].offset - toRemove.offset,
          content: ''
        };
      }
      return withFormatting(text, edit, options);
    } else if (value !== void 0) {
      var edit = void 0;
      var newProperty = "" + JSON.stringify(value);
      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
        var toModify = parent.children[lastSegment];
        edit = {
          offset: toModify.offset,
          length: toModify.length,
          content: newProperty
        };
      } else if (parent.children.length === 0 || lastSegment === 0) {
        edit = {
          offset: parent.offset + 1,
          length: 0,
          content: parent.children.length === 0 ? newProperty : newProperty + ','
        };
      } else {
        var index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
        var previous = parent.children[index - 1];
        edit = {
          offset: previous.offset + previous.length,
          length: 0,
          content: ',' + newProperty
        };
      }
      return withFormatting(text, edit, options);
    } else {
      throw new Error("Can not " + (value === void 0 ? 'remove' : options.isArrayInsertion ? 'insert' : 'modify') + " Array index " + insertIndex + " as length is not sufficient");
    }
  } else {
    throw new Error("Can not add " + (typeof lastSegment !== 'number' ? 'index' : 'property') + " to parent of type " + parent.type);
  }
}
function withFormatting(text, edit, options) {
  if (!options.formattingOptions) {
    return [edit];
  }
  // apply the edit
  var newText = applyEdit(text, edit);
  // format the new text
  var begin = edit.offset;
  var end = edit.offset + edit.content.length;
  if (edit.length === 0 || edit.content.length === 0) {
    // insert or remove
    while (begin > 0 && !isEOL(newText, begin - 1)) {
      begin--;
    }
    while (end < newText.length && !isEOL(newText, end)) {
      end++;
    }
  }
  var edits = format(newText, {
    offset: begin,
    length: end - begin
  }, options.formattingOptions);
  // apply the formatting edits and track the begin and end offsets of the changes
  for (var i = edits.length - 1; i >= 0; i--) {
    var edit_1 = edits[i];
    newText = applyEdit(newText, edit_1);
    begin = Math.min(begin, edit_1.offset);
    end = Math.max(end, edit_1.offset + edit_1.length);
    end += edit_1.content.length - edit_1.length;
  }
  // create a single edit with all changes
  var editLength = text.length - (newText.length - end) - begin;
  return [{
    offset: begin,
    length: editLength,
    content: newText.substring(begin, end)
  }];
}
function applyEdit(text, edit) {
  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
}
function isWS(text, offset) {
  return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/main.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/






/**
 * Creates a JSON scanner on the given text.
 * If ignoreTrivia is set, whitespaces or comments are ignored.
 */
var main_createScanner = createScanner;
/**
 * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
 */
var main_getLocation = getLocation;
/**
 * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
 * Therefore, always check the errors list to find out if the input was valid.
 */
var main_parse = parse;
/**
 * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
 */
var main_parseTree = parser_parseTree;
/**
 * Finds the node at the given path in a JSON DOM.
 */
var main_findNodeAtLocation = parser_findNodeAtLocation;
/**
 * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
 */
var main_findNodeAtOffset = findNodeAtOffset;
/**
 * Gets the JSON path of the given JSON DOM node
 */
var main_getNodePath = getNodePath;
/**
 * Evaluates the JavaScript object of the given JSON DOM node
 */
var main_getNodeValue = getNodeValue;
/**
 * Parses the given text and invokes the visitor functions for each object, array and literal reached.
 */
var main_visit = visit;
/**
 * Takes JSON with JavaScript-style comments and remove
 * them. Optionally replaces every none-newline character
 * of comments with a replaceCharacter
 */
var main_stripComments = stripComments;
function printParseErrorCode(code) {
  switch (code) {
    case 1 /* InvalidSymbol */:
      return 'InvalidSymbol';
    case 2 /* InvalidNumberFormat */:
      return 'InvalidNumberFormat';
    case 3 /* PropertyNameExpected */:
      return 'PropertyNameExpected';
    case 4 /* ValueExpected */:
      return 'ValueExpected';
    case 5 /* ColonExpected */:
      return 'ColonExpected';
    case 6 /* CommaExpected */:
      return 'CommaExpected';
    case 7 /* CloseBraceExpected */:
      return 'CloseBraceExpected';
    case 8 /* CloseBracketExpected */:
      return 'CloseBracketExpected';
    case 9 /* EndOfFileExpected */:
      return 'EndOfFileExpected';
    case 10 /* InvalidCommentToken */:
      return 'InvalidCommentToken';
    case 11 /* UnexpectedEndOfComment */:
      return 'UnexpectedEndOfComment';
    case 12 /* UnexpectedEndOfString */:
      return 'UnexpectedEndOfString';
    case 13 /* UnexpectedEndOfNumber */:
      return 'UnexpectedEndOfNumber';
    case 14 /* InvalidUnicode */:
      return 'InvalidUnicode';
    case 15 /* InvalidEscapeCharacter */:
      return 'InvalidEscapeCharacter';
    case 16 /* InvalidCharacter */:
      return 'InvalidCharacter';
  }
  return '<unknown ParseErrorCode>';
}
/**
 * Computes the edits needed to format a JSON document.
 *
 * @param documentText The input text
 * @param range The range to format or `undefined` to format the full content
 * @param options The formatting options
 * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
 * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
 * text in the original document. However, multiple edits can have
 * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
 * To apply edits to an input, you can use `applyEdits`.
 */
function main_format(documentText, range, options) {
  return format_format(documentText, range, options);
}
/**
 * Computes the edits needed to modify a value in the JSON document.
 *
 * @param documentText The input text
 * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
 * If the path points to an non-existing property or item, it will be created.
 * @param value The new value for the specified property or item. If the value is undefined,
 * the property or item will be removed.
 * @param options Options
 * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
 * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
 * text in the original document. However, multiple edits can have
 * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
 * To apply edits to an input, you can use `applyEdits`.
 */
function modify(text, path, value, options) {
  return edit.setProperty(text, path, value, options);
}
/**
 * Applies edits to a input string.
 */
function applyEdits(text, edits) {
  for (var i = edits.length - 1; i >= 0; i--) {
    text = edit.applyEdit(text, edits[i]);
  }
  return text;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/objects.js

/*---------------------------------------------------------------------------------------------
*  Copyright (c) Microsoft Corporation. All rights reserved.
*  Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
function equals(one, other) {
  if (one === other) {
    return true;
  }
  if (one === null || one === undefined || other === null || other === undefined) {
    return false;
  }
  if (typeof_default()(one) !== typeof_default()(other)) {
    return false;
  }
  if (typeof_default()(one) !== 'object') {
    return false;
  }
  if (Array.isArray(one) !== Array.isArray(other)) {
    return false;
  }
  var i, key;
  if (Array.isArray(one)) {
    if (one.length !== other.length) {
      return false;
    }
    for (i = 0; i < one.length; i++) {
      if (!equals(one[i], other[i])) {
        return false;
      }
    }
  } else {
    var oneKeys = [];
    for (key in one) {
      oneKeys.push(key);
    }
    oneKeys.sort();
    var otherKeys = [];
    for (key in other) {
      otherKeys.push(key);
    }
    otherKeys.sort();
    if (!equals(oneKeys, otherKeys)) {
      return false;
    }
    for (i = 0; i < oneKeys.length; i++) {
      if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
        return false;
      }
    }
  }
  return true;
}
function objects_isNumber(val) {
  return typeof val === 'number';
}
function objects_isDefined(val) {
  return typeof val !== 'undefined';
}
function objects_isBoolean(val) {
  return typeof val === 'boolean';
}
function objects_isString(val) {
  return typeof val === 'string';
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/strings.js
/*---------------------------------------------------------------------------------------------
*  Copyright (c) Microsoft Corporation. All rights reserved.
*  Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
function startsWith(haystack, needle) {
  if (haystack.length < needle.length) {
    return false;
  }
  for (var i = 0; i < needle.length; i++) {
    if (haystack[i] !== needle[i]) {
      return false;
    }
  }
  return true;
}
/**
 * Determines if haystack ends with needle.
 */
function endsWith(haystack, needle) {
  var diff = haystack.length - needle.length;
  if (diff > 0) {
    return haystack.lastIndexOf(needle) === diff;
  } else if (diff === 0) {
    return haystack === needle;
  } else {
    return false;
  }
}
function strings_convertSimple2RegExpPattern(pattern) {
  return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
}
function strings_repeat(value, count) {
  var s = '';
  while (count > 0) {
    if ((count & 1) === 1) {
      s += value;
    }
    value += value;
    count = count >>> 1;
  }
  return s;
}
function extendedRegExp(pattern) {
  if (startsWith(pattern, '(?i)')) {
    return new RegExp(pattern.substring(4), 'iu');
  } else {
    return new RegExp(pattern, 'u');
  }
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-languageserver-types/main.js
/* --------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 * ------------------------------------------------------------------------------------------ */



var integer;
(function (integer) {
  integer.MIN_VALUE = -2147483648;
  integer.MAX_VALUE = 2147483647;
})(integer || (integer = {}));
var uinteger;
(function (uinteger) {
  uinteger.MIN_VALUE = 0;
  uinteger.MAX_VALUE = 2147483647;
})(uinteger || (uinteger = {}));
/**
 * The Position namespace provides helper functions to work with
 * [Position](#Position) literals.
 */
var main_Position;
(function (Position) {
  /**
   * Creates a new Position literal from the given line and character.
   * @param line The position's line.
   * @param character The position's character.
   */
  function create(line, character) {
    if (line === Number.MAX_VALUE) {
      line = uinteger.MAX_VALUE;
    }
    if (character === Number.MAX_VALUE) {
      character = uinteger.MAX_VALUE;
    }
    return {
      line: line,
      character: character
    };
  }
  Position.create = create;
  /**
   * Checks whether the given literal conforms to the [Position](#Position) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
  }
  Position.is = is;
})(main_Position || (main_Position = {}));
/**
 * The Range namespace provides helper functions to work with
 * [Range](#Range) literals.
 */
var main_Range;
(function (Range) {
  function create(one, two, three, four) {
    if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
      return {
        start: main_Position.create(one, two),
        end: main_Position.create(three, four)
      };
    } else if (main_Position.is(one) && main_Position.is(two)) {
      return {
        start: one,
        end: two
      };
    } else {
      throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
    }
  }
  Range.create = create;
  /**
   * Checks whether the given literal conforms to the [Range](#Range) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.objectLiteral(candidate) && main_Position.is(candidate.start) && main_Position.is(candidate.end);
  }
  Range.is = is;
})(main_Range || (main_Range = {}));
/**
 * The Location namespace provides helper functions to work with
 * [Location](#Location) literals.
 */
var Location;
(function (Location) {
  /**
   * Creates a Location literal.
   * @param uri The location's uri.
   * @param range The location's range.
   */
  function create(uri, range) {
    return {
      uri: uri,
      range: range
    };
  }
  Location.create = create;
  /**
   * Checks whether the given literal conforms to the [Location](#Location) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && main_Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
  }
  Location.is = is;
})(Location || (Location = {}));
/**
 * The LocationLink namespace provides helper functions to work with
 * [LocationLink](#LocationLink) literals.
 */
var LocationLink;
(function (LocationLink) {
  /**
   * Creates a LocationLink literal.
   * @param targetUri The definition's uri.
   * @param targetRange The full range of the definition.
   * @param targetSelectionRange The span of the symbol definition at the target.
   * @param originSelectionRange The span of the symbol being defined in the originating source file.
   */
  function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
    return {
      targetUri: targetUri,
      targetRange: targetRange,
      targetSelectionRange: targetSelectionRange,
      originSelectionRange: originSelectionRange
    };
  }
  LocationLink.create = create;
  /**
   * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && main_Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && (main_Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (main_Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
  }
  LocationLink.is = is;
})(LocationLink || (LocationLink = {}));
/**
 * The Color namespace provides helper functions to work with
 * [Color](#Color) literals.
 */
var Color;
(function (Color) {
  /**
   * Creates a new Color literal.
   */
  function create(red, green, blue, alpha) {
    return {
      red: red,
      green: green,
      blue: blue,
      alpha: alpha
    };
  }
  Color.create = create;
  /**
   * Checks whether the given literal conforms to the [Color](#Color) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
  }
  Color.is = is;
})(Color || (Color = {}));
/**
 * The ColorInformation namespace provides helper functions to work with
 * [ColorInformation](#ColorInformation) literals.
 */
var ColorInformation;
(function (ColorInformation) {
  /**
   * Creates a new ColorInformation literal.
   */
  function create(range, color) {
    return {
      range: range,
      color: color
    };
  }
  ColorInformation.create = create;
  /**
   * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.
   */
  function is(value) {
    var candidate = value;
    return main_Range.is(candidate.range) && Color.is(candidate.color);
  }
  ColorInformation.is = is;
})(ColorInformation || (ColorInformation = {}));
/**
 * The Color namespace provides helper functions to work with
 * [ColorPresentation](#ColorPresentation) literals.
 */
var ColorPresentation;
(function (ColorPresentation) {
  /**
   * Creates a new ColorInformation literal.
   */
  function create(label, textEdit, additionalTextEdits) {
    return {
      label: label,
      textEdit: textEdit,
      additionalTextEdits: additionalTextEdits
    };
  }
  ColorPresentation.create = create;
  /**
   * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
  }
  ColorPresentation.is = is;
})(ColorPresentation || (ColorPresentation = {}));
/**
 * Enum of known range kinds
 */
var FoldingRangeKind;
(function (FoldingRangeKind) {
  /**
   * Folding range for a comment
   */
  FoldingRangeKind["Comment"] = "comment";
  /**
   * Folding range for a imports or includes
   */
  FoldingRangeKind["Imports"] = "imports";
  /**
   * Folding range for a region (e.g. `#region`)
   */
  FoldingRangeKind["Region"] = "region";
})(FoldingRangeKind || (FoldingRangeKind = {}));
/**
 * The folding range namespace provides helper functions to work with
 * [FoldingRange](#FoldingRange) literals.
 */
var FoldingRange;
(function (FoldingRange) {
  /**
   * Creates a new FoldingRange literal.
   */
  function create(startLine, endLine, startCharacter, endCharacter, kind) {
    var result = {
      startLine: startLine,
      endLine: endLine
    };
    if (Is.defined(startCharacter)) {
      result.startCharacter = startCharacter;
    }
    if (Is.defined(endCharacter)) {
      result.endCharacter = endCharacter;
    }
    if (Is.defined(kind)) {
      result.kind = kind;
    }
    return result;
  }
  FoldingRange.create = create;
  /**
   * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
  }
  FoldingRange.is = is;
})(FoldingRange || (FoldingRange = {}));
/**
 * The DiagnosticRelatedInformation namespace provides helper functions to work with
 * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.
 */
var DiagnosticRelatedInformation;
(function (DiagnosticRelatedInformation) {
  /**
   * Creates a new DiagnosticRelatedInformation literal.
   */
  function create(location, message) {
    return {
      location: location,
      message: message
    };
  }
  DiagnosticRelatedInformation.create = create;
  /**
   * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
  }
  DiagnosticRelatedInformation.is = is;
})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
/**
 * The diagnostic's severity.
 */
var DiagnosticSeverity;
(function (DiagnosticSeverity) {
  /**
   * Reports an error.
   */
  DiagnosticSeverity.Error = 1;
  /**
   * Reports a warning.
   */
  DiagnosticSeverity.Warning = 2;
  /**
   * Reports an information.
   */
  DiagnosticSeverity.Information = 3;
  /**
   * Reports a hint.
   */
  DiagnosticSeverity.Hint = 4;
})(DiagnosticSeverity || (DiagnosticSeverity = {}));
/**
 * The diagnostic tags.
 *
 * @since 3.15.0
 */
var DiagnosticTag;
(function (DiagnosticTag) {
  /**
   * Unused or unnecessary code.
   *
   * Clients are allowed to render diagnostics with this tag faded out instead of having
   * an error squiggle.
   */
  DiagnosticTag.Unnecessary = 1;
  /**
   * Deprecated or obsolete code.
   *
   * Clients are allowed to rendered diagnostics with this tag strike through.
   */
  DiagnosticTag.Deprecated = 2;
})(DiagnosticTag || (DiagnosticTag = {}));
/**
 * The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.
 *
 * @since 3.16.0
 */
var CodeDescription;
(function (CodeDescription) {
  function is(value) {
    var candidate = value;
    return candidate !== undefined && candidate !== null && Is.string(candidate.href);
  }
  CodeDescription.is = is;
})(CodeDescription || (CodeDescription = {}));
/**
 * The Diagnostic namespace provides helper functions to work with
 * [Diagnostic](#Diagnostic) literals.
 */
var Diagnostic;
(function (Diagnostic) {
  /**
   * Creates a new Diagnostic literal.
   */
  function create(range, message, severity, code, source, relatedInformation) {
    var result = {
      range: range,
      message: message
    };
    if (Is.defined(severity)) {
      result.severity = severity;
    }
    if (Is.defined(code)) {
      result.code = code;
    }
    if (Is.defined(source)) {
      result.source = source;
    }
    if (Is.defined(relatedInformation)) {
      result.relatedInformation = relatedInformation;
    }
    return result;
  }
  Diagnostic.create = create;
  /**
   * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.
   */
  function is(value) {
    var _a;
    var candidate = value;
    return Is.defined(candidate) && main_Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
  }
  Diagnostic.is = is;
})(Diagnostic || (Diagnostic = {}));
/**
 * The Command namespace provides helper functions to work with
 * [Command](#Command) literals.
 */
var Command;
(function (Command) {
  /**
   * Creates a new Command literal.
   */
  function create(title, command) {
    var args = [];
    for (var _i = 2; _i < arguments.length; _i++) {
      args[_i - 2] = arguments[_i];
    }
    var result = {
      title: title,
      command: command
    };
    if (Is.defined(args) && args.length > 0) {
      result.arguments = args;
    }
    return result;
  }
  Command.create = create;
  /**
   * Checks whether the given literal conforms to the [Command](#Command) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
  }
  Command.is = is;
})(Command || (Command = {}));
/**
 * The TextEdit namespace provides helper function to create replace,
 * insert and delete edits more easily.
 */
var TextEdit;
(function (TextEdit) {
  /**
   * Creates a replace text edit.
   * @param range The range of text to be replaced.
   * @param newText The new text.
   */
  function replace(range, newText) {
    return {
      range: range,
      newText: newText
    };
  }
  TextEdit.replace = replace;
  /**
   * Creates a insert text edit.
   * @param position The position to insert the text at.
   * @param newText The text to be inserted.
   */
  function insert(position, newText) {
    return {
      range: {
        start: position,
        end: position
      },
      newText: newText
    };
  }
  TextEdit.insert = insert;
  /**
   * Creates a delete text edit.
   * @param range The range of text to be deleted.
   */
  function del(range) {
    return {
      range: range,
      newText: ''
    };
  }
  TextEdit.del = del;
  function is(value) {
    var candidate = value;
    return Is.objectLiteral(candidate) && Is.string(candidate.newText) && main_Range.is(candidate.range);
  }
  TextEdit.is = is;
})(TextEdit || (TextEdit = {}));
var ChangeAnnotation;
(function (ChangeAnnotation) {
  function create(label, needsConfirmation, description) {
    var result = {
      label: label
    };
    if (needsConfirmation !== undefined) {
      result.needsConfirmation = needsConfirmation;
    }
    if (description !== undefined) {
      result.description = description;
    }
    return result;
  }
  ChangeAnnotation.create = create;
  function is(value) {
    var candidate = value;
    return candidate !== undefined && Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is["boolean"](candidate.needsConfirmation) || candidate.needsConfirmation === undefined) && (Is.string(candidate.description) || candidate.description === undefined);
  }
  ChangeAnnotation.is = is;
})(ChangeAnnotation || (ChangeAnnotation = {}));
var ChangeAnnotationIdentifier;
(function (ChangeAnnotationIdentifier) {
  function is(value) {
    var candidate = value;
    return typeof candidate === 'string';
  }
  ChangeAnnotationIdentifier.is = is;
})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
var AnnotatedTextEdit;
(function (AnnotatedTextEdit) {
  /**
   * Creates an annotated replace text edit.
   *
   * @param range The range of text to be replaced.
   * @param newText The new text.
   * @param annotation The annotation.
   */
  function replace(range, newText, annotation) {
    return {
      range: range,
      newText: newText,
      annotationId: annotation
    };
  }
  AnnotatedTextEdit.replace = replace;
  /**
   * Creates an annotated insert text edit.
   *
   * @param position The position to insert the text at.
   * @param newText The text to be inserted.
   * @param annotation The annotation.
   */
  function insert(position, newText, annotation) {
    return {
      range: {
        start: position,
        end: position
      },
      newText: newText,
      annotationId: annotation
    };
  }
  AnnotatedTextEdit.insert = insert;
  /**
   * Creates an annotated delete text edit.
   *
   * @param range The range of text to be deleted.
   * @param annotation The annotation.
   */
  function del(range, annotation) {
    return {
      range: range,
      newText: '',
      annotationId: annotation
    };
  }
  AnnotatedTextEdit.del = del;
  function is(value) {
    var candidate = value;
    return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
  }
  AnnotatedTextEdit.is = is;
})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
/**
 * The TextDocumentEdit namespace provides helper function to create
 * an edit that manipulates a text document.
 */
var TextDocumentEdit;
(function (TextDocumentEdit) {
  /**
   * Creates a new `TextDocumentEdit`
   */
  function create(textDocument, edits) {
    return {
      textDocument: textDocument,
      edits: edits
    };
  }
  TextDocumentEdit.create = create;
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
  }
  TextDocumentEdit.is = is;
})(TextDocumentEdit || (TextDocumentEdit = {}));
var CreateFile;
(function (CreateFile) {
  function create(uri, options, annotation) {
    var result = {
      kind: 'create',
      uri: uri
    };
    if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
      result.options = options;
    }
    if (annotation !== undefined) {
      result.annotationId = annotation;
    }
    return result;
  }
  CreateFile.create = create;
  function is(value) {
    var candidate = value;
    return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is["boolean"](candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is["boolean"](candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
  }
  CreateFile.is = is;
})(CreateFile || (CreateFile = {}));
var RenameFile;
(function (RenameFile) {
  function create(oldUri, newUri, options, annotation) {
    var result = {
      kind: 'rename',
      oldUri: oldUri,
      newUri: newUri
    };
    if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
      result.options = options;
    }
    if (annotation !== undefined) {
      result.annotationId = annotation;
    }
    return result;
  }
  RenameFile.create = create;
  function is(value) {
    var candidate = value;
    return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is["boolean"](candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is["boolean"](candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
  }
  RenameFile.is = is;
})(RenameFile || (RenameFile = {}));
var DeleteFile;
(function (DeleteFile) {
  function create(uri, options, annotation) {
    var result = {
      kind: 'delete',
      uri: uri
    };
    if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {
      result.options = options;
    }
    if (annotation !== undefined) {
      result.annotationId = annotation;
    }
    return result;
  }
  DeleteFile.create = create;
  function is(value) {
    var candidate = value;
    return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.recursive === undefined || Is["boolean"](candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is["boolean"](candidate.options.ignoreIfNotExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
  }
  DeleteFile.is = is;
})(DeleteFile || (DeleteFile = {}));
var WorkspaceEdit;
(function (WorkspaceEdit) {
  function is(value) {
    var candidate = value;
    return candidate && (candidate.changes !== undefined || candidate.documentChanges !== undefined) && (candidate.documentChanges === undefined || candidate.documentChanges.every(function (change) {
      if (Is.string(change.kind)) {
        return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
      } else {
        return TextDocumentEdit.is(change);
      }
    }));
  }
  WorkspaceEdit.is = is;
})(WorkspaceEdit || (WorkspaceEdit = {}));
var TextEditChangeImpl = /** @class */function () {
  function TextEditChangeImpl(edits, changeAnnotations) {
    this.edits = edits;
    this.changeAnnotations = changeAnnotations;
  }
  TextEditChangeImpl.prototype.insert = function (position, newText, annotation) {
    var edit;
    var id;
    if (annotation === undefined) {
      edit = TextEdit.insert(position, newText);
    } else if (ChangeAnnotationIdentifier.is(annotation)) {
      id = annotation;
      edit = AnnotatedTextEdit.insert(position, newText, annotation);
    } else {
      this.assertChangeAnnotations(this.changeAnnotations);
      id = this.changeAnnotations.manage(annotation);
      edit = AnnotatedTextEdit.insert(position, newText, id);
    }
    this.edits.push(edit);
    if (id !== undefined) {
      return id;
    }
  };
  TextEditChangeImpl.prototype.replace = function (range, newText, annotation) {
    var edit;
    var id;
    if (annotation === undefined) {
      edit = TextEdit.replace(range, newText);
    } else if (ChangeAnnotationIdentifier.is(annotation)) {
      id = annotation;
      edit = AnnotatedTextEdit.replace(range, newText, annotation);
    } else {
      this.assertChangeAnnotations(this.changeAnnotations);
      id = this.changeAnnotations.manage(annotation);
      edit = AnnotatedTextEdit.replace(range, newText, id);
    }
    this.edits.push(edit);
    if (id !== undefined) {
      return id;
    }
  };
  TextEditChangeImpl.prototype["delete"] = function (range, annotation) {
    var edit;
    var id;
    if (annotation === undefined) {
      edit = TextEdit.del(range);
    } else if (ChangeAnnotationIdentifier.is(annotation)) {
      id = annotation;
      edit = AnnotatedTextEdit.del(range, annotation);
    } else {
      this.assertChangeAnnotations(this.changeAnnotations);
      id = this.changeAnnotations.manage(annotation);
      edit = AnnotatedTextEdit.del(range, id);
    }
    this.edits.push(edit);
    if (id !== undefined) {
      return id;
    }
  };
  TextEditChangeImpl.prototype.add = function (edit) {
    this.edits.push(edit);
  };
  TextEditChangeImpl.prototype.all = function () {
    return this.edits;
  };
  TextEditChangeImpl.prototype.clear = function () {
    this.edits.splice(0, this.edits.length);
  };
  TextEditChangeImpl.prototype.assertChangeAnnotations = function (value) {
    if (value === undefined) {
      throw new Error("Text edit change is not configured to manage change annotations.");
    }
  };
  return TextEditChangeImpl;
}();
/**
 * A helper class
 */
var ChangeAnnotations = /** @class */function () {
  function ChangeAnnotations(annotations) {
    this._annotations = annotations === undefined ? Object.create(null) : annotations;
    this._counter = 0;
    this._size = 0;
  }
  ChangeAnnotations.prototype.all = function () {
    return this._annotations;
  };
  Object.defineProperty(ChangeAnnotations.prototype, "size", {
    get: function get() {
      return this._size;
    },
    enumerable: false,
    configurable: true
  });
  ChangeAnnotations.prototype.manage = function (idOrAnnotation, annotation) {
    var id;
    if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
      id = idOrAnnotation;
    } else {
      id = this.nextId();
      annotation = idOrAnnotation;
    }
    if (this._annotations[id] !== undefined) {
      throw new Error("Id " + id + " is already in use.");
    }
    if (annotation === undefined) {
      throw new Error("No annotation provided for id " + id);
    }
    this._annotations[id] = annotation;
    this._size++;
    return id;
  };
  ChangeAnnotations.prototype.nextId = function () {
    this._counter++;
    return this._counter.toString();
  };
  return ChangeAnnotations;
}();
/**
 * A workspace change helps constructing changes to a workspace.
 */
var WorkspaceChange = /** @class */function () {
  function WorkspaceChange(workspaceEdit) {
    var _this = this;
    this._textEditChanges = Object.create(null);
    if (workspaceEdit !== undefined) {
      this._workspaceEdit = workspaceEdit;
      if (workspaceEdit.documentChanges) {
        this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
        workspaceEdit.changeAnnotations = this._changeAnnotations.all();
        workspaceEdit.documentChanges.forEach(function (change) {
          if (TextDocumentEdit.is(change)) {
            var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
            _this._textEditChanges[change.textDocument.uri] = textEditChange;
          }
        });
      } else if (workspaceEdit.changes) {
        Object.keys(workspaceEdit.changes).forEach(function (key) {
          var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
          _this._textEditChanges[key] = textEditChange;
        });
      }
    } else {
      this._workspaceEdit = {};
    }
  }
  Object.defineProperty(WorkspaceChange.prototype, "edit", {
    /**
     * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal
     * use to be returned from a workspace edit operation like rename.
     */
    get: function get() {
      this.initDocumentChanges();
      if (this._changeAnnotations !== undefined) {
        if (this._changeAnnotations.size === 0) {
          this._workspaceEdit.changeAnnotations = undefined;
        } else {
          this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
        }
      }
      return this._workspaceEdit;
    },
    enumerable: false,
    configurable: true
  });
  WorkspaceChange.prototype.getTextEditChange = function (key) {
    if (OptionalVersionedTextDocumentIdentifier.is(key)) {
      this.initDocumentChanges();
      if (this._workspaceEdit.documentChanges === undefined) {
        throw new Error('Workspace edit is not configured for document changes.');
      }
      var textDocument = {
        uri: key.uri,
        version: key.version
      };
      var result = this._textEditChanges[textDocument.uri];
      if (!result) {
        var edits = [];
        var textDocumentEdit = {
          textDocument: textDocument,
          edits: edits
        };
        this._workspaceEdit.documentChanges.push(textDocumentEdit);
        result = new TextEditChangeImpl(edits, this._changeAnnotations);
        this._textEditChanges[textDocument.uri] = result;
      }
      return result;
    } else {
      this.initChanges();
      if (this._workspaceEdit.changes === undefined) {
        throw new Error('Workspace edit is not configured for normal text edit changes.');
      }
      var result = this._textEditChanges[key];
      if (!result) {
        var edits = [];
        this._workspaceEdit.changes[key] = edits;
        result = new TextEditChangeImpl(edits);
        this._textEditChanges[key] = result;
      }
      return result;
    }
  };
  WorkspaceChange.prototype.initDocumentChanges = function () {
    if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
      this._changeAnnotations = new ChangeAnnotations();
      this._workspaceEdit.documentChanges = [];
      this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
    }
  };
  WorkspaceChange.prototype.initChanges = function () {
    if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
      this._workspaceEdit.changes = Object.create(null);
    }
  };
  WorkspaceChange.prototype.createFile = function (uri, optionsOrAnnotation, options) {
    this.initDocumentChanges();
    if (this._workspaceEdit.documentChanges === undefined) {
      throw new Error('Workspace edit is not configured for document changes.');
    }
    var annotation;
    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
      annotation = optionsOrAnnotation;
    } else {
      options = optionsOrAnnotation;
    }
    var operation;
    var id;
    if (annotation === undefined) {
      operation = CreateFile.create(uri, options);
    } else {
      id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
      operation = CreateFile.create(uri, options, id);
    }
    this._workspaceEdit.documentChanges.push(operation);
    if (id !== undefined) {
      return id;
    }
  };
  WorkspaceChange.prototype.renameFile = function (oldUri, newUri, optionsOrAnnotation, options) {
    this.initDocumentChanges();
    if (this._workspaceEdit.documentChanges === undefined) {
      throw new Error('Workspace edit is not configured for document changes.');
    }
    var annotation;
    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
      annotation = optionsOrAnnotation;
    } else {
      options = optionsOrAnnotation;
    }
    var operation;
    var id;
    if (annotation === undefined) {
      operation = RenameFile.create(oldUri, newUri, options);
    } else {
      id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
      operation = RenameFile.create(oldUri, newUri, options, id);
    }
    this._workspaceEdit.documentChanges.push(operation);
    if (id !== undefined) {
      return id;
    }
  };
  WorkspaceChange.prototype.deleteFile = function (uri, optionsOrAnnotation, options) {
    this.initDocumentChanges();
    if (this._workspaceEdit.documentChanges === undefined) {
      throw new Error('Workspace edit is not configured for document changes.');
    }
    var annotation;
    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
      annotation = optionsOrAnnotation;
    } else {
      options = optionsOrAnnotation;
    }
    var operation;
    var id;
    if (annotation === undefined) {
      operation = DeleteFile.create(uri, options);
    } else {
      id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
      operation = DeleteFile.create(uri, options, id);
    }
    this._workspaceEdit.documentChanges.push(operation);
    if (id !== undefined) {
      return id;
    }
  };
  return WorkspaceChange;
}();

/**
 * The TextDocumentIdentifier namespace provides helper functions to work with
 * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.
 */
var TextDocumentIdentifier;
(function (TextDocumentIdentifier) {
  /**
   * Creates a new TextDocumentIdentifier literal.
   * @param uri The document's uri.
   */
  function create(uri) {
    return {
      uri: uri
    };
  }
  TextDocumentIdentifier.create = create;
  /**
   * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.uri);
  }
  TextDocumentIdentifier.is = is;
})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
/**
 * The VersionedTextDocumentIdentifier namespace provides helper functions to work with
 * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.
 */
var VersionedTextDocumentIdentifier;
(function (VersionedTextDocumentIdentifier) {
  /**
   * Creates a new VersionedTextDocumentIdentifier literal.
   * @param uri The document's uri.
   * @param uri The document's text.
   */
  function create(uri, version) {
    return {
      uri: uri,
      version: version
    };
  }
  VersionedTextDocumentIdentifier.create = create;
  /**
   * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
  }
  VersionedTextDocumentIdentifier.is = is;
})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
/**
 * The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with
 * [OptionalVersionedTextDocumentIdentifier](#OptionalVersionedTextDocumentIdentifier) literals.
 */
var OptionalVersionedTextDocumentIdentifier;
(function (OptionalVersionedTextDocumentIdentifier) {
  /**
   * Creates a new OptionalVersionedTextDocumentIdentifier literal.
   * @param uri The document's uri.
   * @param uri The document's text.
   */
  function create(uri, version) {
    return {
      uri: uri,
      version: version
    };
  }
  OptionalVersionedTextDocumentIdentifier.create = create;
  /**
   * Checks whether the given literal conforms to the [OptionalVersionedTextDocumentIdentifier](#OptionalVersionedTextDocumentIdentifier) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
  }
  OptionalVersionedTextDocumentIdentifier.is = is;
})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
/**
 * The TextDocumentItem namespace provides helper functions to work with
 * [TextDocumentItem](#TextDocumentItem) literals.
 */
var TextDocumentItem;
(function (TextDocumentItem) {
  /**
   * Creates a new TextDocumentItem literal.
   * @param uri The document's uri.
   * @param languageId The document's language identifier.
   * @param version The document's version number.
   * @param text The document's text.
   */
  function create(uri, languageId, version, text) {
    return {
      uri: uri,
      languageId: languageId,
      version: version,
      text: text
    };
  }
  TextDocumentItem.create = create;
  /**
   * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
  }
  TextDocumentItem.is = is;
})(TextDocumentItem || (TextDocumentItem = {}));
/**
 * Describes the content type that a client supports in various
 * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
 *
 * Please note that `MarkupKinds` must not start with a `$`. This kinds
 * are reserved for internal usage.
 */
var MarkupKind;
(function (MarkupKind) {
  /**
   * Plain text is supported as a content format
   */
  MarkupKind.PlainText = 'plaintext';
  /**
   * Markdown is supported as a content format
   */
  MarkupKind.Markdown = 'markdown';
})(MarkupKind || (MarkupKind = {}));
(function (MarkupKind) {
  /**
   * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type.
   */
  function is(value) {
    var candidate = value;
    return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;
  }
  MarkupKind.is = is;
})(MarkupKind || (MarkupKind = {}));
var MarkupContent;
(function (MarkupContent) {
  /**
   * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
  }
  MarkupContent.is = is;
})(MarkupContent || (MarkupContent = {}));
/**
 * The kind of a completion entry.
 */
var main_CompletionItemKind;
(function (CompletionItemKind) {
  CompletionItemKind.Text = 1;
  CompletionItemKind.Method = 2;
  CompletionItemKind.Function = 3;
  CompletionItemKind.Constructor = 4;
  CompletionItemKind.Field = 5;
  CompletionItemKind.Variable = 6;
  CompletionItemKind.Class = 7;
  CompletionItemKind.Interface = 8;
  CompletionItemKind.Module = 9;
  CompletionItemKind.Property = 10;
  CompletionItemKind.Unit = 11;
  CompletionItemKind.Value = 12;
  CompletionItemKind.Enum = 13;
  CompletionItemKind.Keyword = 14;
  CompletionItemKind.Snippet = 15;
  CompletionItemKind.Color = 16;
  CompletionItemKind.File = 17;
  CompletionItemKind.Reference = 18;
  CompletionItemKind.Folder = 19;
  CompletionItemKind.EnumMember = 20;
  CompletionItemKind.Constant = 21;
  CompletionItemKind.Struct = 22;
  CompletionItemKind.Event = 23;
  CompletionItemKind.Operator = 24;
  CompletionItemKind.TypeParameter = 25;
})(main_CompletionItemKind || (main_CompletionItemKind = {}));
/**
 * Defines whether the insert text in a completion item should be interpreted as
 * plain text or a snippet.
 */
var InsertTextFormat;
(function (InsertTextFormat) {
  /**
   * The primary text to be inserted is treated as a plain string.
   */
  InsertTextFormat.PlainText = 1;
  /**
   * The primary text to be inserted is treated as a snippet.
   *
   * A snippet can define tab stops and placeholders with `$1`, `$2`
   * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
   * the end of the snippet. Placeholders with equal identifiers are linked,
   * that is typing in one will update others too.
   *
   * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
   */
  InsertTextFormat.Snippet = 2;
})(InsertTextFormat || (InsertTextFormat = {}));
/**
 * Completion item tags are extra annotations that tweak the rendering of a completion
 * item.
 *
 * @since 3.15.0
 */
var main_CompletionItemTag;
(function (CompletionItemTag) {
  /**
   * Render a completion as obsolete, usually using a strike-out.
   */
  CompletionItemTag.Deprecated = 1;
})(main_CompletionItemTag || (main_CompletionItemTag = {}));
/**
 * The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.
 *
 * @since 3.16.0
 */
var InsertReplaceEdit;
(function (InsertReplaceEdit) {
  /**
   * Creates a new insert / replace edit
   */
  function create(newText, insert, replace) {
    return {
      newText: newText,
      insert: insert,
      replace: replace
    };
  }
  InsertReplaceEdit.create = create;
  /**
   * Checks whether the given literal conforms to the [InsertReplaceEdit](#InsertReplaceEdit) interface.
   */
  function is(value) {
    var candidate = value;
    return candidate && Is.string(candidate.newText) && main_Range.is(candidate.insert) && main_Range.is(candidate.replace);
  }
  InsertReplaceEdit.is = is;
})(InsertReplaceEdit || (InsertReplaceEdit = {}));
/**
 * How whitespace and indentation is handled during completion
 * item insertion.
 *
 * @since 3.16.0
 */
var InsertTextMode;
(function (InsertTextMode) {
  /**
   * The insertion or replace strings is taken as it is. If the
   * value is multi line the lines below the cursor will be
   * inserted using the indentation defined in the string value.
   * The client will not apply any kind of adjustments to the
   * string.
   */
  InsertTextMode.asIs = 1;
  /**
   * The editor adjusts leading whitespace of new lines so that
   * they match the indentation up to the cursor of the line for
   * which the item is accepted.
   *
   * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
   * multi line completion item is indented using 2 tabs and all
   * following lines inserted will be indented using 2 tabs as well.
   */
  InsertTextMode.adjustIndentation = 2;
})(InsertTextMode || (InsertTextMode = {}));
/**
 * The CompletionItem namespace provides functions to deal with
 * completion items.
 */
var CompletionItem;
(function (CompletionItem) {
  /**
   * Create a completion item and seed it with a label.
   * @param label The completion item's label
   */
  function create(label) {
    return {
      label: label
    };
  }
  CompletionItem.create = create;
})(CompletionItem || (CompletionItem = {}));
/**
 * The CompletionList namespace provides functions to deal with
 * completion lists.
 */
var CompletionList;
(function (CompletionList) {
  /**
   * Creates a new completion list.
   *
   * @param items The completion items.
   * @param isIncomplete The list is not complete.
   */
  function create(items, isIncomplete) {
    return {
      items: items ? items : [],
      isIncomplete: !!isIncomplete
    };
  }
  CompletionList.create = create;
})(CompletionList || (CompletionList = {}));
var MarkedString;
(function (MarkedString) {
  /**
   * Creates a marked string from plain text.
   *
   * @param plainText The plain text.
   */
  function fromPlainText(plainText) {
    return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
  }

  MarkedString.fromPlainText = fromPlainText;
  /**
   * Checks whether the given value conforms to the [MarkedString](#MarkedString) type.
   */
  function is(value) {
    var candidate = value;
    return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
  }
  MarkedString.is = is;
})(MarkedString || (MarkedString = {}));
var Hover;
(function (Hover) {
  /**
   * Checks whether the given value conforms to the [Hover](#Hover) interface.
   */
  function is(value) {
    var candidate = value;
    return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || main_Range.is(value.range));
  }
  Hover.is = is;
})(Hover || (Hover = {}));
/**
 * The ParameterInformation namespace provides helper functions to work with
 * [ParameterInformation](#ParameterInformation) literals.
 */
var ParameterInformation;
(function (ParameterInformation) {
  /**
   * Creates a new parameter information literal.
   *
   * @param label A label string.
   * @param documentation A doc string.
   */
  function create(label, documentation) {
    return documentation ? {
      label: label,
      documentation: documentation
    } : {
      label: label
    };
  }
  ParameterInformation.create = create;
})(ParameterInformation || (ParameterInformation = {}));
/**
 * The SignatureInformation namespace provides helper functions to work with
 * [SignatureInformation](#SignatureInformation) literals.
 */
var SignatureInformation;
(function (SignatureInformation) {
  function create(label, documentation) {
    var parameters = [];
    for (var _i = 2; _i < arguments.length; _i++) {
      parameters[_i - 2] = arguments[_i];
    }
    var result = {
      label: label
    };
    if (Is.defined(documentation)) {
      result.documentation = documentation;
    }
    if (Is.defined(parameters)) {
      result.parameters = parameters;
    } else {
      result.parameters = [];
    }
    return result;
  }
  SignatureInformation.create = create;
})(SignatureInformation || (SignatureInformation = {}));
/**
 * A document highlight kind.
 */
var main_DocumentHighlightKind;
(function (DocumentHighlightKind) {
  /**
   * A textual occurrence.
   */
  DocumentHighlightKind.Text = 1;
  /**
   * Read-access of a symbol, like reading a variable.
   */
  DocumentHighlightKind.Read = 2;
  /**
   * Write-access of a symbol, like writing to a variable.
   */
  DocumentHighlightKind.Write = 3;
})(main_DocumentHighlightKind || (main_DocumentHighlightKind = {}));
/**
 * DocumentHighlight namespace to provide helper functions to work with
 * [DocumentHighlight](#DocumentHighlight) literals.
 */
var DocumentHighlight;
(function (DocumentHighlight) {
  /**
   * Create a DocumentHighlight object.
   * @param range The range the highlight applies to.
   */
  function create(range, kind) {
    var result = {
      range: range
    };
    if (Is.number(kind)) {
      result.kind = kind;
    }
    return result;
  }
  DocumentHighlight.create = create;
})(DocumentHighlight || (DocumentHighlight = {}));
/**
 * A symbol kind.
 */
var main_SymbolKind;
(function (SymbolKind) {
  SymbolKind.File = 1;
  SymbolKind.Module = 2;
  SymbolKind.Namespace = 3;
  SymbolKind.Package = 4;
  SymbolKind.Class = 5;
  SymbolKind.Method = 6;
  SymbolKind.Property = 7;
  SymbolKind.Field = 8;
  SymbolKind.Constructor = 9;
  SymbolKind.Enum = 10;
  SymbolKind.Interface = 11;
  SymbolKind.Function = 12;
  SymbolKind.Variable = 13;
  SymbolKind.Constant = 14;
  SymbolKind.String = 15;
  SymbolKind.Number = 16;
  SymbolKind.Boolean = 17;
  SymbolKind.Array = 18;
  SymbolKind.Object = 19;
  SymbolKind.Key = 20;
  SymbolKind.Null = 21;
  SymbolKind.EnumMember = 22;
  SymbolKind.Struct = 23;
  SymbolKind.Event = 24;
  SymbolKind.Operator = 25;
  SymbolKind.TypeParameter = 26;
})(main_SymbolKind || (main_SymbolKind = {}));
/**
 * Symbol tags are extra annotations that tweak the rendering of a symbol.
 * @since 3.16
 */
var main_SymbolTag;
(function (SymbolTag) {
  /**
   * Render a symbol as obsolete, usually using a strike-out.
   */
  SymbolTag.Deprecated = 1;
})(main_SymbolTag || (main_SymbolTag = {}));
var SymbolInformation;
(function (SymbolInformation) {
  /**
   * Creates a new symbol information literal.
   *
   * @param name The name of the symbol.
   * @param kind The kind of the symbol.
   * @param range The range of the location of the symbol.
   * @param uri The resource of the location of symbol, defaults to the current document.
   * @param containerName The name of the symbol containing the symbol.
   */
  function create(name, kind, range, uri, containerName) {
    var result = {
      name: name,
      kind: kind,
      location: {
        uri: uri,
        range: range
      }
    };
    if (containerName) {
      result.containerName = containerName;
    }
    return result;
  }
  SymbolInformation.create = create;
})(SymbolInformation || (SymbolInformation = {}));
var DocumentSymbol;
(function (DocumentSymbol) {
  /**
   * Creates a new symbol information literal.
   *
   * @param name The name of the symbol.
   * @param detail The detail of the symbol.
   * @param kind The kind of the symbol.
   * @param range The range of the symbol.
   * @param selectionRange The selectionRange of the symbol.
   * @param children Children of the symbol.
   */
  function create(name, detail, kind, range, selectionRange, children) {
    var result = {
      name: name,
      detail: detail,
      kind: kind,
      range: range,
      selectionRange: selectionRange
    };
    if (children !== undefined) {
      result.children = children;
    }
    return result;
  }
  DocumentSymbol.create = create;
  /**
   * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface.
   */
  function is(value) {
    var candidate = value;
    return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && main_Range.is(candidate.range) && main_Range.is(candidate.selectionRange) && (candidate.detail === undefined || Is.string(candidate.detail)) && (candidate.deprecated === undefined || Is["boolean"](candidate.deprecated)) && (candidate.children === undefined || Array.isArray(candidate.children)) && (candidate.tags === undefined || Array.isArray(candidate.tags));
  }
  DocumentSymbol.is = is;
})(DocumentSymbol || (DocumentSymbol = {}));
/**
 * A set of predefined code action kinds
 */
var CodeActionKind;
(function (CodeActionKind) {
  /**
   * Empty kind.
   */
  CodeActionKind.Empty = '';
  /**
   * Base kind for quickfix actions: 'quickfix'
   */
  CodeActionKind.QuickFix = 'quickfix';
  /**
   * Base kind for refactoring actions: 'refactor'
   */
  CodeActionKind.Refactor = 'refactor';
  /**
   * Base kind for refactoring extraction actions: 'refactor.extract'
   *
   * Example extract actions:
   *
   * - Extract method
   * - Extract function
   * - Extract variable
   * - Extract interface from class
   * - ...
   */
  CodeActionKind.RefactorExtract = 'refactor.extract';
  /**
   * Base kind for refactoring inline actions: 'refactor.inline'
   *
   * Example inline actions:
   *
   * - Inline function
   * - Inline variable
   * - Inline constant
   * - ...
   */
  CodeActionKind.RefactorInline = 'refactor.inline';
  /**
   * Base kind for refactoring rewrite actions: 'refactor.rewrite'
   *
   * Example rewrite actions:
   *
   * - Convert JavaScript function to class
   * - Add or remove parameter
   * - Encapsulate field
   * - Make method static
   * - Move method to base class
   * - ...
   */
  CodeActionKind.RefactorRewrite = 'refactor.rewrite';
  /**
   * Base kind for source actions: `source`
   *
   * Source code actions apply to the entire file.
   */
  CodeActionKind.Source = 'source';
  /**
   * Base kind for an organize imports source action: `source.organizeImports`
   */
  CodeActionKind.SourceOrganizeImports = 'source.organizeImports';
  /**
   * Base kind for auto-fix source actions: `source.fixAll`.
   *
   * Fix all actions automatically fix errors that have a clear fix that do not require user input.
   * They should not suppress errors or perform unsafe fixes such as generating new types or classes.
   *
   * @since 3.15.0
   */
  CodeActionKind.SourceFixAll = 'source.fixAll';
})(CodeActionKind || (CodeActionKind = {}));
/**
 * The CodeActionContext namespace provides helper functions to work with
 * [CodeActionContext](#CodeActionContext) literals.
 */
var CodeActionContext;
(function (CodeActionContext) {
  /**
   * Creates a new CodeActionContext literal.
   */
  function create(diagnostics, only) {
    var result = {
      diagnostics: diagnostics
    };
    if (only !== undefined && only !== null) {
      result.only = only;
    }
    return result;
  }
  CodeActionContext.create = create;
  /**
   * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string));
  }
  CodeActionContext.is = is;
})(CodeActionContext || (CodeActionContext = {}));
var CodeAction;
(function (CodeAction) {
  function create(title, kindOrCommandOrEdit, kind) {
    var result = {
      title: title
    };
    var checkKind = true;
    if (typeof kindOrCommandOrEdit === 'string') {
      checkKind = false;
      result.kind = kindOrCommandOrEdit;
    } else if (Command.is(kindOrCommandOrEdit)) {
      result.command = kindOrCommandOrEdit;
    } else {
      result.edit = kindOrCommandOrEdit;
    }
    if (checkKind && kind !== undefined) {
      result.kind = kind;
    }
    return result;
  }
  CodeAction.create = create;
  function is(value) {
    var candidate = value;
    return candidate && Is.string(candidate.title) && (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === undefined || Is.string(candidate.kind)) && (candidate.edit !== undefined || candidate.command !== undefined) && (candidate.command === undefined || Command.is(candidate.command)) && (candidate.isPreferred === undefined || Is["boolean"](candidate.isPreferred)) && (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));
  }
  CodeAction.is = is;
})(CodeAction || (CodeAction = {}));
/**
 * The CodeLens namespace provides helper functions to work with
 * [CodeLens](#CodeLens) literals.
 */
var CodeLens;
(function (CodeLens) {
  /**
   * Creates a new CodeLens literal.
   */
  function create(range, data) {
    var result = {
      range: range
    };
    if (Is.defined(data)) {
      result.data = data;
    }
    return result;
  }
  CodeLens.create = create;
  /**
   * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && main_Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
  }
  CodeLens.is = is;
})(CodeLens || (CodeLens = {}));
/**
 * The FormattingOptions namespace provides helper functions to work with
 * [FormattingOptions](#FormattingOptions) literals.
 */
var FormattingOptions;
(function (FormattingOptions) {
  /**
   * Creates a new FormattingOptions literal.
   */
  function create(tabSize, insertSpaces) {
    return {
      tabSize: tabSize,
      insertSpaces: insertSpaces
    };
  }
  FormattingOptions.create = create;
  /**
   * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is["boolean"](candidate.insertSpaces);
  }
  FormattingOptions.is = is;
})(FormattingOptions || (FormattingOptions = {}));
/**
 * The DocumentLink namespace provides helper functions to work with
 * [DocumentLink](#DocumentLink) literals.
 */
var DocumentLink;
(function (DocumentLink) {
  /**
   * Creates a new DocumentLink literal.
   */
  function create(range, target, data) {
    return {
      range: range,
      target: target,
      data: data
    };
  }
  DocumentLink.create = create;
  /**
   * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && main_Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
  }
  DocumentLink.is = is;
})(DocumentLink || (DocumentLink = {}));
/**
 * The SelectionRange namespace provides helper function to work with
 * SelectionRange literals.
 */
var SelectionRange;
(function (SelectionRange) {
  /**
   * Creates a new SelectionRange
   * @param range the range.
   * @param parent an optional parent.
   */
  function create(range, parent) {
    return {
      range: range,
      parent: parent
    };
  }
  SelectionRange.create = create;
  function is(value) {
    var candidate = value;
    return candidate !== undefined && main_Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));
  }
  SelectionRange.is = is;
})(SelectionRange || (SelectionRange = {}));
var EOL = (/* unused pure expression or super */ null && (['\n', '\r\n', '\r']));
/**
 * @deprecated Use the text document from the new vscode-languageserver-textdocument package.
 */
var TextDocument;
(function (TextDocument) {
  /**
   * Creates a new ITextDocument literal from the given uri and content.
   * @param uri The document's uri.
   * @param languageId  The document's language Id.
   * @param content The document's content.
   */
  function create(uri, languageId, version, content) {
    return new FullTextDocument(uri, languageId, version, content);
  }
  TextDocument.create = create;
  /**
   * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.
   */
  function is(value) {
    var candidate = value;
    return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
  }
  TextDocument.is = is;
  function applyEdits(document, edits) {
    var text = document.getText();
    var sortedEdits = mergeSort(edits, function (a, b) {
      var diff = a.range.start.line - b.range.start.line;
      if (diff === 0) {
        return a.range.start.character - b.range.start.character;
      }
      return diff;
    });
    var lastModifiedOffset = text.length;
    for (var i = sortedEdits.length - 1; i >= 0; i--) {
      var e = sortedEdits[i];
      var startOffset = document.offsetAt(e.range.start);
      var endOffset = document.offsetAt(e.range.end);
      if (endOffset <= lastModifiedOffset) {
        text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
      } else {
        throw new Error('Overlapping edit');
      }
      lastModifiedOffset = startOffset;
    }
    return text;
  }
  TextDocument.applyEdits = applyEdits;
  function mergeSort(data, compare) {
    if (data.length <= 1) {
      // sorted
      return data;
    }
    var p = data.length / 2 | 0;
    var left = data.slice(0, p);
    var right = data.slice(p);
    mergeSort(left, compare);
    mergeSort(right, compare);
    var leftIdx = 0;
    var rightIdx = 0;
    var i = 0;
    while (leftIdx < left.length && rightIdx < right.length) {
      var ret = compare(left[leftIdx], right[rightIdx]);
      if (ret <= 0) {
        // smaller_equal -> take left to preserve order
        data[i++] = left[leftIdx++];
      } else {
        // greater -> take right
        data[i++] = right[rightIdx++];
      }
    }
    while (leftIdx < left.length) {
      data[i++] = left[leftIdx++];
    }
    while (rightIdx < right.length) {
      data[i++] = right[rightIdx++];
    }
    return data;
  }
})(TextDocument || (TextDocument = {}));
/**
 * @deprecated Use the text document from the new vscode-languageserver-textdocument package.
 */
var FullTextDocument = /** @class */function () {
  function FullTextDocument(uri, languageId, version, content) {
    this._uri = uri;
    this._languageId = languageId;
    this._version = version;
    this._content = content;
    this._lineOffsets = undefined;
  }
  Object.defineProperty(FullTextDocument.prototype, "uri", {
    get: function get() {
      return this._uri;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(FullTextDocument.prototype, "languageId", {
    get: function get() {
      return this._languageId;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(FullTextDocument.prototype, "version", {
    get: function get() {
      return this._version;
    },
    enumerable: false,
    configurable: true
  });
  FullTextDocument.prototype.getText = function (range) {
    if (range) {
      var start = this.offsetAt(range.start);
      var end = this.offsetAt(range.end);
      return this._content.substring(start, end);
    }
    return this._content;
  };
  FullTextDocument.prototype.update = function (event, version) {
    this._content = event.text;
    this._version = version;
    this._lineOffsets = undefined;
  };
  FullTextDocument.prototype.getLineOffsets = function () {
    if (this._lineOffsets === undefined) {
      var lineOffsets = [];
      var text = this._content;
      var isLineStart = true;
      for (var i = 0; i < text.length; i++) {
        if (isLineStart) {
          lineOffsets.push(i);
          isLineStart = false;
        }
        var ch = text.charAt(i);
        isLineStart = ch === '\r' || ch === '\n';
        if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
          i++;
        }
      }
      if (isLineStart && text.length > 0) {
        lineOffsets.push(text.length);
      }
      this._lineOffsets = lineOffsets;
    }
    return this._lineOffsets;
  };
  FullTextDocument.prototype.positionAt = function (offset) {
    offset = Math.max(Math.min(offset, this._content.length), 0);
    var lineOffsets = this.getLineOffsets();
    var low = 0,
      high = lineOffsets.length;
    if (high === 0) {
      return main_Position.create(0, offset);
    }
    while (low < high) {
      var mid = Math.floor((low + high) / 2);
      if (lineOffsets[mid] > offset) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    // low is the least x for which the line offset is larger than the current offset
    // or array.length if no line offset is larger than the current offset
    var line = low - 1;
    return main_Position.create(line, offset - lineOffsets[line]);
  };
  FullTextDocument.prototype.offsetAt = function (position) {
    var lineOffsets = this.getLineOffsets();
    if (position.line >= lineOffsets.length) {
      return this._content.length;
    } else if (position.line < 0) {
      return 0;
    }
    var lineOffset = lineOffsets[position.line];
    var nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
    return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
  };
  Object.defineProperty(FullTextDocument.prototype, "lineCount", {
    get: function get() {
      return this.getLineOffsets().length;
    },
    enumerable: false,
    configurable: true
  });
  return FullTextDocument;
}();
var Is;
(function (Is) {
  var toString = Object.prototype.toString;
  function defined(value) {
    return typeof value !== 'undefined';
  }
  Is.defined = defined;
  function undefined(value) {
    return typeof value === 'undefined';
  }
  Is.undefined = undefined;
  function _boolean(value) {
    return value === true || value === false;
  }
  Is["boolean"] = _boolean;
  function string(value) {
    return toString.call(value) === '[object String]';
  }
  Is.string = string;
  function number(value) {
    return toString.call(value) === '[object Number]';
  }
  Is.number = number;
  function numberRange(value, min, max) {
    return toString.call(value) === '[object Number]' && min <= value && value <= max;
  }
  Is.numberRange = numberRange;
  function integer(value) {
    return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;
  }
  Is.integer = integer;
  function uinteger(value) {
    return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;
  }
  Is.uinteger = uinteger;
  function func(value) {
    return toString.call(value) === '[object Function]';
  }
  Is.func = func;
  function objectLiteral(value) {
    // Strictly speaking class instances pass this check as well. Since the LSP
    // doesn't use classes we ignore this for now. If we do we need to add something
    // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`
    return value !== null && typeof_default()(value) === 'object';
  }
  Is.objectLiteral = objectLiteral;
  function typedArray(value, check) {
    return Array.isArray(value) && value.every(check);
  }
  Is.typedArray = typedArray;
})(Is || (Is = {}));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-languageserver-textdocument/lib/esm/main.js
/* --------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 * ------------------------------------------------------------------------------------------ */


var __spreadArray = undefined && undefined.__spreadArray || function (to, from, pack) {
  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
    if (ar || !(i in from)) {
      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
      ar[i] = from[i];
    }
  }
  return to.concat(ar || Array.prototype.slice.call(from));
};
var main_FullTextDocument = /** @class */function () {
  function FullTextDocument(uri, languageId, version, content) {
    this._uri = uri;
    this._languageId = languageId;
    this._version = version;
    this._content = content;
    this._lineOffsets = undefined;
  }
  Object.defineProperty(FullTextDocument.prototype, "uri", {
    get: function get() {
      return this._uri;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(FullTextDocument.prototype, "languageId", {
    get: function get() {
      return this._languageId;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(FullTextDocument.prototype, "version", {
    get: function get() {
      return this._version;
    },
    enumerable: false,
    configurable: true
  });
  FullTextDocument.prototype.getText = function (range) {
    if (range) {
      var start = this.offsetAt(range.start);
      var end = this.offsetAt(range.end);
      return this._content.substring(start, end);
    }
    return this._content;
  };
  FullTextDocument.prototype.update = function (changes, version) {
    for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {
      var change = changes_1[_i];
      if (FullTextDocument.isIncremental(change)) {
        // makes sure start is before end
        var range = getWellformedRange(change.range);
        // update content
        var startOffset = this.offsetAt(range.start);
        var endOffset = this.offsetAt(range.end);
        this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
        // update the offsets
        var startLine = Math.max(range.start.line, 0);
        var endLine = Math.max(range.end.line, 0);
        var lineOffsets = this._lineOffsets;
        var addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
        if (endLine - startLine === addedLineOffsets.length) {
          for (var i = 0, len = addedLineOffsets.length; i < len; i++) {
            lineOffsets[i + startLine + 1] = addedLineOffsets[i];
          }
        } else {
          if (addedLineOffsets.length < 10000) {
            lineOffsets.splice.apply(lineOffsets, __spreadArray([startLine + 1, endLine - startLine], addedLineOffsets, false));
          } else {
            // avoid too many arguments for splice
            this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
          }
        }
        var diff = change.text.length - (endOffset - startOffset);
        if (diff !== 0) {
          for (var i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
            lineOffsets[i] = lineOffsets[i] + diff;
          }
        }
      } else if (FullTextDocument.isFull(change)) {
        this._content = change.text;
        this._lineOffsets = undefined;
      } else {
        throw new Error('Unknown change event received');
      }
    }
    this._version = version;
  };
  FullTextDocument.prototype.getLineOffsets = function () {
    if (this._lineOffsets === undefined) {
      this._lineOffsets = computeLineOffsets(this._content, true);
    }
    return this._lineOffsets;
  };
  FullTextDocument.prototype.positionAt = function (offset) {
    offset = Math.max(Math.min(offset, this._content.length), 0);
    var lineOffsets = this.getLineOffsets();
    var low = 0,
      high = lineOffsets.length;
    if (high === 0) {
      return {
        line: 0,
        character: offset
      };
    }
    while (low < high) {
      var mid = Math.floor((low + high) / 2);
      if (lineOffsets[mid] > offset) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    // low is the least x for which the line offset is larger than the current offset
    // or array.length if no line offset is larger than the current offset
    var line = low - 1;
    return {
      line: line,
      character: offset - lineOffsets[line]
    };
  };
  FullTextDocument.prototype.offsetAt = function (position) {
    var lineOffsets = this.getLineOffsets();
    if (position.line >= lineOffsets.length) {
      return this._content.length;
    } else if (position.line < 0) {
      return 0;
    }
    var lineOffset = lineOffsets[position.line];
    var nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
    return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
  };
  Object.defineProperty(FullTextDocument.prototype, "lineCount", {
    get: function get() {
      return this.getLineOffsets().length;
    },
    enumerable: false,
    configurable: true
  });
  FullTextDocument.isIncremental = function (event) {
    var candidate = event;
    return candidate !== undefined && candidate !== null && typeof candidate.text === 'string' && candidate.range !== undefined && (candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
  };
  FullTextDocument.isFull = function (event) {
    var candidate = event;
    return candidate !== undefined && candidate !== null && typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
  };
  return FullTextDocument;
}();
var main_TextDocument;
(function (TextDocument) {
  /**
   * Creates a new text document.
   *
   * @param uri The document's uri.
   * @param languageId  The document's language Id.
   * @param version The document's initial version number.
   * @param content The document's content.
   */
  function create(uri, languageId, version, content) {
    return new main_FullTextDocument(uri, languageId, version, content);
  }
  TextDocument.create = create;
  /**
   * Updates a TextDocument by modifying its content.
   *
   * @param document the document to update. Only documents created by TextDocument.create are valid inputs.
   * @param changes the changes to apply to the document.
   * @param version the changes version for the document.
   * @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.
   *
   */
  function update(document, changes, version) {
    if (document instanceof main_FullTextDocument) {
      document.update(changes, version);
      return document;
    } else {
      throw new Error('TextDocument.update: document must be created by TextDocument.create');
    }
  }
  TextDocument.update = update;
  function applyEdits(document, edits) {
    var text = document.getText();
    var sortedEdits = mergeSort(edits.map(getWellformedEdit), function (a, b) {
      var diff = a.range.start.line - b.range.start.line;
      if (diff === 0) {
        return a.range.start.character - b.range.start.character;
      }
      return diff;
    });
    var lastModifiedOffset = 0;
    var spans = [];
    for (var _i = 0, sortedEdits_1 = sortedEdits; _i < sortedEdits_1.length; _i++) {
      var e = sortedEdits_1[_i];
      var startOffset = document.offsetAt(e.range.start);
      if (startOffset < lastModifiedOffset) {
        throw new Error('Overlapping edit');
      } else if (startOffset > lastModifiedOffset) {
        spans.push(text.substring(lastModifiedOffset, startOffset));
      }
      if (e.newText.length) {
        spans.push(e.newText);
      }
      lastModifiedOffset = document.offsetAt(e.range.end);
    }
    spans.push(text.substr(lastModifiedOffset));
    return spans.join('');
  }
  TextDocument.applyEdits = applyEdits;
})(main_TextDocument || (main_TextDocument = {}));
function mergeSort(data, compare) {
  if (data.length <= 1) {
    // sorted
    return data;
  }
  var p = data.length / 2 | 0;
  var left = data.slice(0, p);
  var right = data.slice(p);
  mergeSort(left, compare);
  mergeSort(right, compare);
  var leftIdx = 0;
  var rightIdx = 0;
  var i = 0;
  while (leftIdx < left.length && rightIdx < right.length) {
    var ret = compare(left[leftIdx], right[rightIdx]);
    if (ret <= 0) {
      // smaller_equal -> take left to preserve order
      data[i++] = left[leftIdx++];
    } else {
      // greater -> take right
      data[i++] = right[rightIdx++];
    }
  }
  while (leftIdx < left.length) {
    data[i++] = left[leftIdx++];
  }
  while (rightIdx < right.length) {
    data[i++] = right[rightIdx++];
  }
  return data;
}
function computeLineOffsets(text, isAtLineStart, textOffset) {
  if (textOffset === void 0) {
    textOffset = 0;
  }
  var result = isAtLineStart ? [textOffset] : [];
  for (var i = 0; i < text.length; i++) {
    var ch = text.charCodeAt(i);
    if (ch === 13 /* CarriageReturn */ || ch === 10 /* LineFeed */) {
      if (ch === 13 /* CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* LineFeed */) {
        i++;
      }
      result.push(textOffset + i + 1);
    }
  }
  return result;
}
function getWellformedRange(range) {
  var start = range.start;
  var end = range.end;
  if (start.line > end.line || start.line === end.line && start.character > end.character) {
    return {
      start: end,
      end: start
    };
  }
  return range;
}
function getWellformedEdit(textEdit) {
  var range = getWellformedRange(textEdit.range);
  if (range !== textEdit.range) {
    return {
      newText: textEdit.newText,
      range: range
    };
  }
  return textEdit;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/jsonLanguageTypes.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/



/**
 * Error codes used by diagnostics
 */
var ErrorCode;
(function (ErrorCode) {
  ErrorCode[ErrorCode["Undefined"] = 0] = "Undefined";
  ErrorCode[ErrorCode["EnumValueMismatch"] = 1] = "EnumValueMismatch";
  ErrorCode[ErrorCode["Deprecated"] = 2] = "Deprecated";
  ErrorCode[ErrorCode["UnexpectedEndOfComment"] = 257] = "UnexpectedEndOfComment";
  ErrorCode[ErrorCode["UnexpectedEndOfString"] = 258] = "UnexpectedEndOfString";
  ErrorCode[ErrorCode["UnexpectedEndOfNumber"] = 259] = "UnexpectedEndOfNumber";
  ErrorCode[ErrorCode["InvalidUnicode"] = 260] = "InvalidUnicode";
  ErrorCode[ErrorCode["InvalidEscapeCharacter"] = 261] = "InvalidEscapeCharacter";
  ErrorCode[ErrorCode["InvalidCharacter"] = 262] = "InvalidCharacter";
  ErrorCode[ErrorCode["PropertyExpected"] = 513] = "PropertyExpected";
  ErrorCode[ErrorCode["CommaExpected"] = 514] = "CommaExpected";
  ErrorCode[ErrorCode["ColonExpected"] = 515] = "ColonExpected";
  ErrorCode[ErrorCode["ValueExpected"] = 516] = "ValueExpected";
  ErrorCode[ErrorCode["CommaOrCloseBacketExpected"] = 517] = "CommaOrCloseBacketExpected";
  ErrorCode[ErrorCode["CommaOrCloseBraceExpected"] = 518] = "CommaOrCloseBraceExpected";
  ErrorCode[ErrorCode["TrailingComma"] = 519] = "TrailingComma";
  ErrorCode[ErrorCode["DuplicateKey"] = 520] = "DuplicateKey";
  ErrorCode[ErrorCode["CommentNotPermitted"] = 521] = "CommentNotPermitted";
  ErrorCode[ErrorCode["SchemaResolveError"] = 768] = "SchemaResolveError";
})(ErrorCode || (ErrorCode = {}));
var ClientCapabilities;
(function (ClientCapabilities) {
  ClientCapabilities.LATEST = {
    textDocument: {
      completion: {
        completionItem: {
          documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText],
          commitCharactersSupport: true
        }
      }
    }
  };
})(ClientCapabilities || (ClientCapabilities = {}));
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/fillers/vscode-nls.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function vscode_nls_format(message, args) {
  var result;
  if (args.length === 0) {
    result = message;
  } else {
    result = message.replace(/\{(\d+)\}/g, function (match, rest) {
      var index = rest[0];
      return typeof args[index] !== 'undefined' ? args[index] : match;
    });
  }
  return result;
}
function localize(key, message) {
  var args = [];
  for (var _i = 2; _i < arguments.length; _i++) {
    args[_i - 2] = arguments[_i];
  }
  return vscode_nls_format(message, args);
}
function loadMessageBundle(file) {
  return localize;
}
function config(opt) {
  return loadMessageBundle;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/parser/jsonParser.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __extends = undefined && undefined.__extends || function () {
  var _extendStatics = function extendStatics(d, b) {
    _extendStatics = Object.setPrototypeOf || {
      __proto__: []
    } instanceof Array && function (d, b) {
      d.__proto__ = b;
    } || function (d, b) {
      for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
    };
    return _extendStatics(d, b);
  };
  return function (d, b) {
    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
    _extendStatics(d, b);
    function __() {
      this.constructor = d;
    }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();





var jsonParser_localize = loadMessageBundle();
var formats = {
  'color-hex': {
    errorMessage: jsonParser_localize('colorHexFormatWarning', 'Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA.'),
    pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/
  },
  'date-time': {
    errorMessage: jsonParser_localize('dateTimeFormatWarning', 'String is not a RFC3339 date-time.'),
    pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
  },
  'date': {
    errorMessage: jsonParser_localize('dateFormatWarning', 'String is not a RFC3339 date.'),
    pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/i
  },
  'time': {
    errorMessage: jsonParser_localize('timeFormatWarning', 'String is not a RFC3339 time.'),
    pattern: /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
  },
  'email': {
    errorMessage: jsonParser_localize('emailFormatWarning', 'String is not an e-mail address.'),
    pattern: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
  }
};
var ASTNodeImpl = /** @class */function () {
  function ASTNodeImpl(parent, offset, length) {
    if (length === void 0) {
      length = 0;
    }
    this.offset = offset;
    this.length = length;
    this.parent = parent;
  }
  Object.defineProperty(ASTNodeImpl.prototype, "children", {
    get: function get() {
      return [];
    },
    enumerable: false,
    configurable: true
  });
  ASTNodeImpl.prototype.toString = function () {
    return 'type: ' + this.type + ' (' + this.offset + '/' + this.length + ')' + (this.parent ? ' parent: {' + this.parent.toString() + '}' : '');
  };
  return ASTNodeImpl;
}();

var NullASTNodeImpl = /** @class */function (_super) {
  __extends(NullASTNodeImpl, _super);
  function NullASTNodeImpl(parent, offset) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'null';
    _this.value = null;
    return _this;
  }
  return NullASTNodeImpl;
}(ASTNodeImpl);

var BooleanASTNodeImpl = /** @class */function (_super) {
  __extends(BooleanASTNodeImpl, _super);
  function BooleanASTNodeImpl(parent, boolValue, offset) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'boolean';
    _this.value = boolValue;
    return _this;
  }
  return BooleanASTNodeImpl;
}(ASTNodeImpl);

var ArrayASTNodeImpl = /** @class */function (_super) {
  __extends(ArrayASTNodeImpl, _super);
  function ArrayASTNodeImpl(parent, offset) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'array';
    _this.items = [];
    return _this;
  }
  Object.defineProperty(ArrayASTNodeImpl.prototype, "children", {
    get: function get() {
      return this.items;
    },
    enumerable: false,
    configurable: true
  });
  return ArrayASTNodeImpl;
}(ASTNodeImpl);

var NumberASTNodeImpl = /** @class */function (_super) {
  __extends(NumberASTNodeImpl, _super);
  function NumberASTNodeImpl(parent, offset) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'number';
    _this.isInteger = true;
    _this.value = Number.NaN;
    return _this;
  }
  return NumberASTNodeImpl;
}(ASTNodeImpl);

var StringASTNodeImpl = /** @class */function (_super) {
  __extends(StringASTNodeImpl, _super);
  function StringASTNodeImpl(parent, offset, length) {
    var _this = _super.call(this, parent, offset, length) || this;
    _this.type = 'string';
    _this.value = '';
    return _this;
  }
  return StringASTNodeImpl;
}(ASTNodeImpl);

var PropertyASTNodeImpl = /** @class */function (_super) {
  __extends(PropertyASTNodeImpl, _super);
  function PropertyASTNodeImpl(parent, offset, keyNode) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'property';
    _this.colonOffset = -1;
    _this.keyNode = keyNode;
    return _this;
  }
  Object.defineProperty(PropertyASTNodeImpl.prototype, "children", {
    get: function get() {
      return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
    },
    enumerable: false,
    configurable: true
  });
  return PropertyASTNodeImpl;
}(ASTNodeImpl);

var ObjectASTNodeImpl = /** @class */function (_super) {
  __extends(ObjectASTNodeImpl, _super);
  function ObjectASTNodeImpl(parent, offset) {
    var _this = _super.call(this, parent, offset) || this;
    _this.type = 'object';
    _this.properties = [];
    return _this;
  }
  Object.defineProperty(ObjectASTNodeImpl.prototype, "children", {
    get: function get() {
      return this.properties;
    },
    enumerable: false,
    configurable: true
  });
  return ObjectASTNodeImpl;
}(ASTNodeImpl);

function asSchema(schema) {
  if (objects_isBoolean(schema)) {
    return schema ? {} : {
      "not": {}
    };
  }
  return schema;
}
var EnumMatch;
(function (EnumMatch) {
  EnumMatch[EnumMatch["Key"] = 0] = "Key";
  EnumMatch[EnumMatch["Enum"] = 1] = "Enum";
})(EnumMatch || (EnumMatch = {}));
var SchemaCollector = /** @class */function () {
  function SchemaCollector(focusOffset, exclude) {
    if (focusOffset === void 0) {
      focusOffset = -1;
    }
    this.focusOffset = focusOffset;
    this.exclude = exclude;
    this.schemas = [];
  }
  SchemaCollector.prototype.add = function (schema) {
    this.schemas.push(schema);
  };
  SchemaCollector.prototype.merge = function (other) {
    Array.prototype.push.apply(this.schemas, other.schemas);
  };
  SchemaCollector.prototype.include = function (node) {
    return (this.focusOffset === -1 || jsonParser_contains(node, this.focusOffset)) && node !== this.exclude;
  };
  SchemaCollector.prototype.newSub = function () {
    return new SchemaCollector(-1, this.exclude);
  };
  return SchemaCollector;
}();
var NoOpSchemaCollector = /** @class */function () {
  function NoOpSchemaCollector() {}
  Object.defineProperty(NoOpSchemaCollector.prototype, "schemas", {
    get: function get() {
      return [];
    },
    enumerable: false,
    configurable: true
  });
  NoOpSchemaCollector.prototype.add = function (schema) {};
  NoOpSchemaCollector.prototype.merge = function (other) {};
  NoOpSchemaCollector.prototype.include = function (node) {
    return true;
  };
  NoOpSchemaCollector.prototype.newSub = function () {
    return this;
  };
  NoOpSchemaCollector.instance = new NoOpSchemaCollector();
  return NoOpSchemaCollector;
}();
var ValidationResult = /** @class */function () {
  function ValidationResult() {
    this.problems = [];
    this.propertiesMatches = 0;
    this.propertiesValueMatches = 0;
    this.primaryValueMatches = 0;
    this.enumValueMatch = false;
    this.enumValues = undefined;
  }
  ValidationResult.prototype.hasProblems = function () {
    return !!this.problems.length;
  };
  ValidationResult.prototype.mergeAll = function (validationResults) {
    for (var _i = 0, validationResults_1 = validationResults; _i < validationResults_1.length; _i++) {
      var validationResult = validationResults_1[_i];
      this.merge(validationResult);
    }
  };
  ValidationResult.prototype.merge = function (validationResult) {
    this.problems = this.problems.concat(validationResult.problems);
  };
  ValidationResult.prototype.mergeEnumValues = function (validationResult) {
    if (!this.enumValueMatch && !validationResult.enumValueMatch && this.enumValues && validationResult.enumValues) {
      this.enumValues = this.enumValues.concat(validationResult.enumValues);
      for (var _i = 0, _a = this.problems; _i < _a.length; _i++) {
        var error = _a[_i];
        if (error.code === ErrorCode.EnumValueMismatch) {
          error.message = jsonParser_localize('enumWarning', 'Value is not accepted. Valid values: {0}.', this.enumValues.map(function (v) {
            return JSON.stringify(v);
          }).join(', '));
        }
      }
    }
  };
  ValidationResult.prototype.mergePropertyMatch = function (propertyValidationResult) {
    this.merge(propertyValidationResult);
    this.propertiesMatches++;
    if (propertyValidationResult.enumValueMatch || !propertyValidationResult.hasProblems() && propertyValidationResult.propertiesMatches) {
      this.propertiesValueMatches++;
    }
    if (propertyValidationResult.enumValueMatch && propertyValidationResult.enumValues && propertyValidationResult.enumValues.length === 1) {
      this.primaryValueMatches++;
    }
  };
  ValidationResult.prototype.compare = function (other) {
    var hasProblems = this.hasProblems();
    if (hasProblems !== other.hasProblems()) {
      return hasProblems ? -1 : 1;
    }
    if (this.enumValueMatch !== other.enumValueMatch) {
      return other.enumValueMatch ? -1 : 1;
    }
    if (this.primaryValueMatches !== other.primaryValueMatches) {
      return this.primaryValueMatches - other.primaryValueMatches;
    }
    if (this.propertiesValueMatches !== other.propertiesValueMatches) {
      return this.propertiesValueMatches - other.propertiesValueMatches;
    }
    return this.propertiesMatches - other.propertiesMatches;
  };
  return ValidationResult;
}();

function jsonParser_newJSONDocument(root, diagnostics) {
  if (diagnostics === void 0) {
    diagnostics = [];
  }
  return new JSONDocument(root, diagnostics, []);
}
function jsonParser_getNodeValue(node) {
  return main_getNodeValue(node);
}
function jsonParser_getNodePath(node) {
  return main_getNodePath(node);
}
function jsonParser_contains(node, offset, includeRightBound) {
  if (includeRightBound === void 0) {
    includeRightBound = false;
  }
  return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
}
var JSONDocument = /** @class */function () {
  function JSONDocument(root, syntaxErrors, comments) {
    if (syntaxErrors === void 0) {
      syntaxErrors = [];
    }
    if (comments === void 0) {
      comments = [];
    }
    this.root = root;
    this.syntaxErrors = syntaxErrors;
    this.comments = comments;
  }
  JSONDocument.prototype.getNodeFromOffset = function (offset, includeRightBound) {
    if (includeRightBound === void 0) {
      includeRightBound = false;
    }
    if (this.root) {
      return main_findNodeAtOffset(this.root, offset, includeRightBound);
    }
    return undefined;
  };
  JSONDocument.prototype.visit = function (visitor) {
    if (this.root) {
      var doVisit_1 = function doVisit_1(node) {
        var ctn = visitor(node);
        var children = node.children;
        if (Array.isArray(children)) {
          for (var i = 0; i < children.length && ctn; i++) {
            ctn = doVisit_1(children[i]);
          }
        }
        return ctn;
      };
      doVisit_1(this.root);
    }
  };
  JSONDocument.prototype.validate = function (textDocument, schema, severity) {
    if (severity === void 0) {
      severity = DiagnosticSeverity.Warning;
    }
    if (this.root && schema) {
      var validationResult = new ValidationResult();
      validate(this.root, schema, validationResult, NoOpSchemaCollector.instance);
      return validationResult.problems.map(function (p) {
        var _a;
        var range = main_Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
        return Diagnostic.create(range, p.message, (_a = p.severity) !== null && _a !== void 0 ? _a : severity, p.code);
      });
    }
    return undefined;
  };
  JSONDocument.prototype.getMatchingSchemas = function (schema, focusOffset, exclude) {
    if (focusOffset === void 0) {
      focusOffset = -1;
    }
    var matchingSchemas = new SchemaCollector(focusOffset, exclude);
    if (this.root && schema) {
      validate(this.root, schema, new ValidationResult(), matchingSchemas);
    }
    return matchingSchemas.schemas;
  };
  return JSONDocument;
}();

function validate(n, schema, validationResult, matchingSchemas) {
  if (!n || !matchingSchemas.include(n)) {
    return;
  }
  var node = n;
  switch (node.type) {
    case 'object':
      _validateObjectNode(node, schema, validationResult, matchingSchemas);
      break;
    case 'array':
      _validateArrayNode(node, schema, validationResult, matchingSchemas);
      break;
    case 'string':
      _validateStringNode(node, schema, validationResult, matchingSchemas);
      break;
    case 'number':
      _validateNumberNode(node, schema, validationResult, matchingSchemas);
      break;
    case 'property':
      return validate(node.valueNode, schema, validationResult, matchingSchemas);
  }
  _validateNode();
  matchingSchemas.add({
    node: node,
    schema: schema
  });
  function _validateNode() {
    function matchesType(type) {
      return node.type === type || type === 'integer' && node.type === 'number' && node.isInteger;
    }
    if (Array.isArray(schema.type)) {
      if (!schema.type.some(matchesType)) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: schema.errorMessage || jsonParser_localize('typeArrayMismatchWarning', 'Incorrect type. Expected one of {0}.', schema.type.join(', '))
        });
      }
    } else if (schema.type) {
      if (!matchesType(schema.type)) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: schema.errorMessage || jsonParser_localize('typeMismatchWarning', 'Incorrect type. Expected "{0}".', schema.type)
        });
      }
    }
    if (Array.isArray(schema.allOf)) {
      for (var _i = 0, _a = schema.allOf; _i < _a.length; _i++) {
        var subSchemaRef = _a[_i];
        validate(node, asSchema(subSchemaRef), validationResult, matchingSchemas);
      }
    }
    var notSchema = asSchema(schema.not);
    if (notSchema) {
      var subValidationResult = new ValidationResult();
      var subMatchingSchemas = matchingSchemas.newSub();
      validate(node, notSchema, subValidationResult, subMatchingSchemas);
      if (!subValidationResult.hasProblems()) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: jsonParser_localize('notSchemaWarning', "Matches a schema that is not allowed.")
        });
      }
      for (var _b = 0, _c = subMatchingSchemas.schemas; _b < _c.length; _b++) {
        var ms = _c[_b];
        ms.inverted = !ms.inverted;
        matchingSchemas.add(ms);
      }
    }
    var testAlternatives = function testAlternatives(alternatives, maxOneMatch) {
      var matches = [];
      // remember the best match that is used for error messages
      var bestMatch = undefined;
      for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) {
        var subSchemaRef = alternatives_1[_i];
        var subSchema = asSchema(subSchemaRef);
        var subValidationResult = new ValidationResult();
        var subMatchingSchemas = matchingSchemas.newSub();
        validate(node, subSchema, subValidationResult, subMatchingSchemas);
        if (!subValidationResult.hasProblems()) {
          matches.push(subSchema);
        }
        if (!bestMatch) {
          bestMatch = {
            schema: subSchema,
            validationResult: subValidationResult,
            matchingSchemas: subMatchingSchemas
          };
        } else {
          if (!maxOneMatch && !subValidationResult.hasProblems() && !bestMatch.validationResult.hasProblems()) {
            // no errors, both are equally good matches
            bestMatch.matchingSchemas.merge(subMatchingSchemas);
            bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;
            bestMatch.validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
          } else {
            var compareResult = subValidationResult.compare(bestMatch.validationResult);
            if (compareResult > 0) {
              // our node is the best matching so far
              bestMatch = {
                schema: subSchema,
                validationResult: subValidationResult,
                matchingSchemas: subMatchingSchemas
              };
            } else if (compareResult === 0) {
              // there's already a best matching but we are as good
              bestMatch.matchingSchemas.merge(subMatchingSchemas);
              bestMatch.validationResult.mergeEnumValues(subValidationResult);
            }
          }
        }
      }
      if (matches.length > 1 && maxOneMatch) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: 1
          },
          message: jsonParser_localize('oneOfWarning', "Matches multiple schemas when only one must validate.")
        });
      }
      if (bestMatch) {
        validationResult.merge(bestMatch.validationResult);
        validationResult.propertiesMatches += bestMatch.validationResult.propertiesMatches;
        validationResult.propertiesValueMatches += bestMatch.validationResult.propertiesValueMatches;
        matchingSchemas.merge(bestMatch.matchingSchemas);
      }
      return matches.length;
    };
    if (Array.isArray(schema.anyOf)) {
      testAlternatives(schema.anyOf, false);
    }
    if (Array.isArray(schema.oneOf)) {
      testAlternatives(schema.oneOf, true);
    }
    var testBranch = function testBranch(schema) {
      var subValidationResult = new ValidationResult();
      var subMatchingSchemas = matchingSchemas.newSub();
      validate(node, asSchema(schema), subValidationResult, subMatchingSchemas);
      validationResult.merge(subValidationResult);
      validationResult.propertiesMatches += subValidationResult.propertiesMatches;
      validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
      matchingSchemas.merge(subMatchingSchemas);
    };
    var testCondition = function testCondition(ifSchema, thenSchema, elseSchema) {
      var subSchema = asSchema(ifSchema);
      var subValidationResult = new ValidationResult();
      var subMatchingSchemas = matchingSchemas.newSub();
      validate(node, subSchema, subValidationResult, subMatchingSchemas);
      matchingSchemas.merge(subMatchingSchemas);
      if (!subValidationResult.hasProblems()) {
        if (thenSchema) {
          testBranch(thenSchema);
        }
      } else if (elseSchema) {
        testBranch(elseSchema);
      }
    };
    var ifSchema = asSchema(schema["if"]);
    if (ifSchema) {
      testCondition(ifSchema, asSchema(schema.then), asSchema(schema["else"]));
    }
    if (Array.isArray(schema["enum"])) {
      var val = jsonParser_getNodeValue(node);
      var enumValueMatch = false;
      for (var _d = 0, _e = schema["enum"]; _d < _e.length; _d++) {
        var e = _e[_d];
        if (equals(val, e)) {
          enumValueMatch = true;
          break;
        }
      }
      validationResult.enumValues = schema["enum"];
      validationResult.enumValueMatch = enumValueMatch;
      if (!enumValueMatch) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          code: ErrorCode.EnumValueMismatch,
          message: schema.errorMessage || jsonParser_localize('enumWarning', 'Value is not accepted. Valid values: {0}.', schema["enum"].map(function (v) {
            return JSON.stringify(v);
          }).join(', '))
        });
      }
    }
    if (objects_isDefined(schema["const"])) {
      var val = jsonParser_getNodeValue(node);
      if (!equals(val, schema["const"])) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          code: ErrorCode.EnumValueMismatch,
          message: schema.errorMessage || jsonParser_localize('constWarning', 'Value must be {0}.', JSON.stringify(schema["const"]))
        });
        validationResult.enumValueMatch = false;
      } else {
        validationResult.enumValueMatch = true;
      }
      validationResult.enumValues = [schema["const"]];
    }
    if (schema.deprecationMessage && node.parent) {
      validationResult.problems.push({
        location: {
          offset: node.parent.offset,
          length: node.parent.length
        },
        severity: DiagnosticSeverity.Warning,
        message: schema.deprecationMessage,
        code: ErrorCode.Deprecated
      });
    }
  }
  function _validateNumberNode(node, schema, validationResult, matchingSchemas) {
    var val = node.value;
    function normalizeFloats(_float) {
      var _a;
      var parts = /^(-?\d+)(?:\.(\d+))?(?:e([-+]\d+))?$/.exec(_float.toString());
      return parts && {
        value: Number(parts[1] + (parts[2] || '')),
        multiplier: (((_a = parts[2]) === null || _a === void 0 ? void 0 : _a.length) || 0) - (parseInt(parts[3]) || 0)
      };
    }
    ;
    if (objects_isNumber(schema.multipleOf)) {
      var remainder = -1;
      if (Number.isInteger(schema.multipleOf)) {
        remainder = val % schema.multipleOf;
      } else {
        var normMultipleOf = normalizeFloats(schema.multipleOf);
        var normValue = normalizeFloats(val);
        if (normMultipleOf && normValue) {
          var multiplier = Math.pow(10, Math.abs(normValue.multiplier - normMultipleOf.multiplier));
          if (normValue.multiplier < normMultipleOf.multiplier) {
            normValue.value *= multiplier;
          } else {
            normMultipleOf.value *= multiplier;
          }
          remainder = normValue.value % normMultipleOf.value;
        }
      }
      if (remainder !== 0) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: jsonParser_localize('multipleOfWarning', 'Value is not divisible by {0}.', schema.multipleOf)
        });
      }
    }
    function getExclusiveLimit(limit, exclusive) {
      if (objects_isNumber(exclusive)) {
        return exclusive;
      }
      if (objects_isBoolean(exclusive) && exclusive) {
        return limit;
      }
      return undefined;
    }
    function getLimit(limit, exclusive) {
      if (!objects_isBoolean(exclusive) || !exclusive) {
        return limit;
      }
      return undefined;
    }
    var exclusiveMinimum = getExclusiveLimit(schema.minimum, schema.exclusiveMinimum);
    if (objects_isNumber(exclusiveMinimum) && val <= exclusiveMinimum) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('exclusiveMinimumWarning', 'Value is below the exclusive minimum of {0}.', exclusiveMinimum)
      });
    }
    var exclusiveMaximum = getExclusiveLimit(schema.maximum, schema.exclusiveMaximum);
    if (objects_isNumber(exclusiveMaximum) && val >= exclusiveMaximum) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('exclusiveMaximumWarning', 'Value is above the exclusive maximum of {0}.', exclusiveMaximum)
      });
    }
    var minimum = getLimit(schema.minimum, schema.exclusiveMinimum);
    if (objects_isNumber(minimum) && val < minimum) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('minimumWarning', 'Value is below the minimum of {0}.', minimum)
      });
    }
    var maximum = getLimit(schema.maximum, schema.exclusiveMaximum);
    if (objects_isNumber(maximum) && val > maximum) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('maximumWarning', 'Value is above the maximum of {0}.', maximum)
      });
    }
  }
  function _validateStringNode(node, schema, validationResult, matchingSchemas) {
    if (objects_isNumber(schema.minLength) && node.value.length < schema.minLength) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('minLengthWarning', 'String is shorter than the minimum length of {0}.', schema.minLength)
      });
    }
    if (objects_isNumber(schema.maxLength) && node.value.length > schema.maxLength) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('maxLengthWarning', 'String is longer than the maximum length of {0}.', schema.maxLength)
      });
    }
    if (objects_isString(schema.pattern)) {
      var regex = extendedRegExp(schema.pattern);
      if (!regex.test(node.value)) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: schema.patternErrorMessage || schema.errorMessage || jsonParser_localize('patternWarning', 'String does not match the pattern of "{0}".', schema.pattern)
        });
      }
    }
    if (schema.format) {
      switch (schema.format) {
        case 'uri':
        case 'uri-reference':
          {
            var errorMessage = void 0;
            if (!node.value) {
              errorMessage = jsonParser_localize('uriEmpty', 'URI expected.');
            } else {
              var match = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/.exec(node.value);
              if (!match) {
                errorMessage = jsonParser_localize('uriMissing', 'URI is expected.');
              } else if (!match[2] && schema.format === 'uri') {
                errorMessage = jsonParser_localize('uriSchemeMissing', 'URI with a scheme is expected.');
              }
            }
            if (errorMessage) {
              validationResult.problems.push({
                location: {
                  offset: node.offset,
                  length: node.length
                },
                message: schema.patternErrorMessage || schema.errorMessage || jsonParser_localize('uriFormatWarning', 'String is not a URI: {0}', errorMessage)
              });
            }
          }
          break;
        case 'color-hex':
        case 'date-time':
        case 'date':
        case 'time':
        case 'email':
          var format = formats[schema.format];
          if (!node.value || !format.pattern.exec(node.value)) {
            validationResult.problems.push({
              location: {
                offset: node.offset,
                length: node.length
              },
              message: schema.patternErrorMessage || schema.errorMessage || format.errorMessage
            });
          }
        default:
      }
    }
  }
  function _validateArrayNode(node, schema, validationResult, matchingSchemas) {
    if (Array.isArray(schema.items)) {
      var subSchemas = schema.items;
      for (var index = 0; index < subSchemas.length; index++) {
        var subSchemaRef = subSchemas[index];
        var subSchema = asSchema(subSchemaRef);
        var itemValidationResult = new ValidationResult();
        var item = node.items[index];
        if (item) {
          validate(item, subSchema, itemValidationResult, matchingSchemas);
          validationResult.mergePropertyMatch(itemValidationResult);
        } else if (node.items.length >= subSchemas.length) {
          validationResult.propertiesValueMatches++;
        }
      }
      if (node.items.length > subSchemas.length) {
        if (typeof_default()(schema.additionalItems) === 'object') {
          for (var i = subSchemas.length; i < node.items.length; i++) {
            var itemValidationResult = new ValidationResult();
            validate(node.items[i], schema.additionalItems, itemValidationResult, matchingSchemas);
            validationResult.mergePropertyMatch(itemValidationResult);
          }
        } else if (schema.additionalItems === false) {
          validationResult.problems.push({
            location: {
              offset: node.offset,
              length: node.length
            },
            message: jsonParser_localize('additionalItemsWarning', 'Array has too many items according to schema. Expected {0} or fewer.', subSchemas.length)
          });
        }
      }
    } else {
      var itemSchema = asSchema(schema.items);
      if (itemSchema) {
        for (var _i = 0, _a = node.items; _i < _a.length; _i++) {
          var item = _a[_i];
          var itemValidationResult = new ValidationResult();
          validate(item, itemSchema, itemValidationResult, matchingSchemas);
          validationResult.mergePropertyMatch(itemValidationResult);
        }
      }
    }
    var containsSchema = asSchema(schema.contains);
    if (containsSchema) {
      var doesContain = node.items.some(function (item) {
        var itemValidationResult = new ValidationResult();
        validate(item, containsSchema, itemValidationResult, NoOpSchemaCollector.instance);
        return !itemValidationResult.hasProblems();
      });
      if (!doesContain) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: schema.errorMessage || jsonParser_localize('requiredItemMissingWarning', 'Array does not contain required item.')
        });
      }
    }
    if (objects_isNumber(schema.minItems) && node.items.length < schema.minItems) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('minItemsWarning', 'Array has too few items. Expected {0} or more.', schema.minItems)
      });
    }
    if (objects_isNumber(schema.maxItems) && node.items.length > schema.maxItems) {
      validationResult.problems.push({
        location: {
          offset: node.offset,
          length: node.length
        },
        message: jsonParser_localize('maxItemsWarning', 'Array has too many items. Expected {0} or fewer.', schema.maxItems)
      });
    }
    if (schema.uniqueItems === true) {
      var values_1 = jsonParser_getNodeValue(node);
      var duplicates = values_1.some(function (value, index) {
        return index !== values_1.lastIndexOf(value);
      });
      if (duplicates) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: jsonParser_localize('uniqueItemsWarning', 'Array has duplicate items.')
        });
      }
    }
  }
  function _validateObjectNode(node, schema, validationResult, matchingSchemas) {
    var seenKeys = Object.create(null);
    var unprocessedProperties = [];
    for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
      var propertyNode = _a[_i];
      var key = propertyNode.keyNode.value;
      seenKeys[key] = propertyNode.valueNode;
      unprocessedProperties.push(key);
    }
    if (Array.isArray(schema.required)) {
      for (var _b = 0, _c = schema.required; _b < _c.length; _b++) {
        var propertyName = _c[_b];
        if (!seenKeys[propertyName]) {
          var keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;
          var location = keyNode ? {
            offset: keyNode.offset,
            length: keyNode.length
          } : {
            offset: node.offset,
            length: 1
          };
          validationResult.problems.push({
            location: location,
            message: jsonParser_localize('MissingRequiredPropWarning', 'Missing property "{0}".', propertyName)
          });
        }
      }
    }
    var propertyProcessed = function propertyProcessed(prop) {
      var index = unprocessedProperties.indexOf(prop);
      while (index >= 0) {
        unprocessedProperties.splice(index, 1);
        index = unprocessedProperties.indexOf(prop);
      }
    };
    if (schema.properties) {
      for (var _d = 0, _e = Object.keys(schema.properties); _d < _e.length; _d++) {
        var propertyName = _e[_d];
        propertyProcessed(propertyName);
        var propertySchema = schema.properties[propertyName];
        var child = seenKeys[propertyName];
        if (child) {
          if (objects_isBoolean(propertySchema)) {
            if (!propertySchema) {
              var propertyNode = child.parent;
              validationResult.problems.push({
                location: {
                  offset: propertyNode.keyNode.offset,
                  length: propertyNode.keyNode.length
                },
                message: schema.errorMessage || jsonParser_localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
              });
            } else {
              validationResult.propertiesMatches++;
              validationResult.propertiesValueMatches++;
            }
          } else {
            var propertyValidationResult = new ValidationResult();
            validate(child, propertySchema, propertyValidationResult, matchingSchemas);
            validationResult.mergePropertyMatch(propertyValidationResult);
          }
        }
      }
    }
    if (schema.patternProperties) {
      for (var _f = 0, _g = Object.keys(schema.patternProperties); _f < _g.length; _f++) {
        var propertyPattern = _g[_f];
        var regex = extendedRegExp(propertyPattern);
        for (var _h = 0, _j = unprocessedProperties.slice(0); _h < _j.length; _h++) {
          var propertyName = _j[_h];
          if (regex.test(propertyName)) {
            propertyProcessed(propertyName);
            var child = seenKeys[propertyName];
            if (child) {
              var propertySchema = schema.patternProperties[propertyPattern];
              if (objects_isBoolean(propertySchema)) {
                if (!propertySchema) {
                  var propertyNode = child.parent;
                  validationResult.problems.push({
                    location: {
                      offset: propertyNode.keyNode.offset,
                      length: propertyNode.keyNode.length
                    },
                    message: schema.errorMessage || jsonParser_localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
                  });
                } else {
                  validationResult.propertiesMatches++;
                  validationResult.propertiesValueMatches++;
                }
              } else {
                var propertyValidationResult = new ValidationResult();
                validate(child, propertySchema, propertyValidationResult, matchingSchemas);
                validationResult.mergePropertyMatch(propertyValidationResult);
              }
            }
          }
        }
      }
    }
    if (typeof_default()(schema.additionalProperties) === 'object') {
      for (var _k = 0, unprocessedProperties_1 = unprocessedProperties; _k < unprocessedProperties_1.length; _k++) {
        var propertyName = unprocessedProperties_1[_k];
        var child = seenKeys[propertyName];
        if (child) {
          var propertyValidationResult = new ValidationResult();
          validate(child, schema.additionalProperties, propertyValidationResult, matchingSchemas);
          validationResult.mergePropertyMatch(propertyValidationResult);
        }
      }
    } else if (schema.additionalProperties === false) {
      if (unprocessedProperties.length > 0) {
        for (var _l = 0, unprocessedProperties_2 = unprocessedProperties; _l < unprocessedProperties_2.length; _l++) {
          var propertyName = unprocessedProperties_2[_l];
          var child = seenKeys[propertyName];
          if (child) {
            var propertyNode = child.parent;
            validationResult.problems.push({
              location: {
                offset: propertyNode.keyNode.offset,
                length: propertyNode.keyNode.length
              },
              message: schema.errorMessage || jsonParser_localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
            });
          }
        }
      }
    }
    if (objects_isNumber(schema.maxProperties)) {
      if (node.properties.length > schema.maxProperties) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: jsonParser_localize('MaxPropWarning', 'Object has more properties than limit of {0}.', schema.maxProperties)
        });
      }
    }
    if (objects_isNumber(schema.minProperties)) {
      if (node.properties.length < schema.minProperties) {
        validationResult.problems.push({
          location: {
            offset: node.offset,
            length: node.length
          },
          message: jsonParser_localize('MinPropWarning', 'Object has fewer properties than the required number of {0}', schema.minProperties)
        });
      }
    }
    if (schema.dependencies) {
      for (var _m = 0, _o = Object.keys(schema.dependencies); _m < _o.length; _m++) {
        var key = _o[_m];
        var prop = seenKeys[key];
        if (prop) {
          var propertyDep = schema.dependencies[key];
          if (Array.isArray(propertyDep)) {
            for (var _p = 0, propertyDep_1 = propertyDep; _p < propertyDep_1.length; _p++) {
              var requiredProp = propertyDep_1[_p];
              if (!seenKeys[requiredProp]) {
                validationResult.problems.push({
                  location: {
                    offset: node.offset,
                    length: node.length
                  },
                  message: jsonParser_localize('RequiredDependentPropWarning', 'Object is missing property {0} required by property {1}.', requiredProp, key)
                });
              } else {
                validationResult.propertiesValueMatches++;
              }
            }
          } else {
            var propertySchema = asSchema(propertyDep);
            if (propertySchema) {
              var propertyValidationResult = new ValidationResult();
              validate(node, propertySchema, propertyValidationResult, matchingSchemas);
              validationResult.mergePropertyMatch(propertyValidationResult);
            }
          }
        }
      }
    }
    var propertyNames = asSchema(schema.propertyNames);
    if (propertyNames) {
      for (var _q = 0, _r = node.properties; _q < _r.length; _q++) {
        var f = _r[_q];
        var key = f.keyNode;
        if (key) {
          validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance);
        }
      }
    }
  }
}
function jsonParser_parse(textDocument, config) {
  var problems = [];
  var lastProblemOffset = -1;
  var text = textDocument.getText();
  var scanner = main_createScanner(text, false);
  var commentRanges = config && config.collectComments ? [] : undefined;
  function _scanNext() {
    while (true) {
      var token_1 = scanner.scan();
      _checkScanError();
      switch (token_1) {
        case 12 /* LineCommentTrivia */:
        case 13 /* BlockCommentTrivia */:
          if (Array.isArray(commentRanges)) {
            commentRanges.push(main_Range.create(textDocument.positionAt(scanner.getTokenOffset()), textDocument.positionAt(scanner.getTokenOffset() + scanner.getTokenLength())));
          }
          break;
        case 15 /* Trivia */:
        case 14 /* LineBreakTrivia */:
          break;
        default:
          return token_1;
      }
    }
  }
  function _accept(token) {
    if (scanner.getToken() === token) {
      _scanNext();
      return true;
    }
    return false;
  }
  function _errorAtRange(message, code, startOffset, endOffset, severity) {
    if (severity === void 0) {
      severity = DiagnosticSeverity.Error;
    }
    if (problems.length === 0 || startOffset !== lastProblemOffset) {
      var range = main_Range.create(textDocument.positionAt(startOffset), textDocument.positionAt(endOffset));
      problems.push(Diagnostic.create(range, message, severity, code, textDocument.languageId));
      lastProblemOffset = startOffset;
    }
  }
  function _error(message, code, node, skipUntilAfter, skipUntil) {
    if (node === void 0) {
      node = undefined;
    }
    if (skipUntilAfter === void 0) {
      skipUntilAfter = [];
    }
    if (skipUntil === void 0) {
      skipUntil = [];
    }
    var start = scanner.getTokenOffset();
    var end = scanner.getTokenOffset() + scanner.getTokenLength();
    if (start === end && start > 0) {
      start--;
      while (start > 0 && /\s/.test(text.charAt(start))) {
        start--;
      }
      end = start + 1;
    }
    _errorAtRange(message, code, start, end);
    if (node) {
      _finalize(node, false);
    }
    if (skipUntilAfter.length + skipUntil.length > 0) {
      var token_2 = scanner.getToken();
      while (token_2 !== 17 /* EOF */) {
        if (skipUntilAfter.indexOf(token_2) !== -1) {
          _scanNext();
          break;
        } else if (skipUntil.indexOf(token_2) !== -1) {
          break;
        }
        token_2 = _scanNext();
      }
    }
    return node;
  }
  function _checkScanError() {
    switch (scanner.getTokenError()) {
      case 4 /* InvalidUnicode */:
        _error(jsonParser_localize('InvalidUnicode', 'Invalid unicode sequence in string.'), ErrorCode.InvalidUnicode);
        return true;
      case 5 /* InvalidEscapeCharacter */:
        _error(jsonParser_localize('InvalidEscapeCharacter', 'Invalid escape character in string.'), ErrorCode.InvalidEscapeCharacter);
        return true;
      case 3 /* UnexpectedEndOfNumber */:
        _error(jsonParser_localize('UnexpectedEndOfNumber', 'Unexpected end of number.'), ErrorCode.UnexpectedEndOfNumber);
        return true;
      case 1 /* UnexpectedEndOfComment */:
        _error(jsonParser_localize('UnexpectedEndOfComment', 'Unexpected end of comment.'), ErrorCode.UnexpectedEndOfComment);
        return true;
      case 2 /* UnexpectedEndOfString */:
        _error(jsonParser_localize('UnexpectedEndOfString', 'Unexpected end of string.'), ErrorCode.UnexpectedEndOfString);
        return true;
      case 6 /* InvalidCharacter */:
        _error(jsonParser_localize('InvalidCharacter', 'Invalid characters in string. Control characters must be escaped.'), ErrorCode.InvalidCharacter);
        return true;
    }
    return false;
  }
  function _finalize(node, scanNext) {
    node.length = scanner.getTokenOffset() + scanner.getTokenLength() - node.offset;
    if (scanNext) {
      _scanNext();
    }
    return node;
  }
  function _parseArray(parent) {
    if (scanner.getToken() !== 3 /* OpenBracketToken */) {
      return undefined;
    }
    var node = new ArrayASTNodeImpl(parent, scanner.getTokenOffset());
    _scanNext(); // consume OpenBracketToken
    var count = 0;
    var needsComma = false;
    while (scanner.getToken() !== 4 /* CloseBracketToken */ && scanner.getToken() !== 17 /* EOF */) {
      if (scanner.getToken() === 5 /* CommaToken */) {
        if (!needsComma) {
          _error(jsonParser_localize('ValueExpected', 'Value expected'), ErrorCode.ValueExpected);
        }
        var commaOffset = scanner.getTokenOffset();
        _scanNext(); // consume comma
        if (scanner.getToken() === 4 /* CloseBracketToken */) {
          if (needsComma) {
            _errorAtRange(jsonParser_localize('TrailingComma', 'Trailing comma'), ErrorCode.TrailingComma, commaOffset, commaOffset + 1);
          }
          continue;
        }
      } else if (needsComma) {
        _error(jsonParser_localize('ExpectedComma', 'Expected comma'), ErrorCode.CommaExpected);
      }
      var item = _parseValue(node);
      if (!item) {
        _error(jsonParser_localize('PropertyExpected', 'Value expected'), ErrorCode.ValueExpected, undefined, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
      } else {
        node.items.push(item);
      }
      needsComma = true;
    }
    if (scanner.getToken() !== 4 /* CloseBracketToken */) {
      return _error(jsonParser_localize('ExpectedCloseBracket', 'Expected comma or closing bracket'), ErrorCode.CommaOrCloseBacketExpected, node);
    }
    return _finalize(node, true);
  }
  var keyPlaceholder = new StringASTNodeImpl(undefined, 0, 0);
  function _parseProperty(parent, keysSeen) {
    var node = new PropertyASTNodeImpl(parent, scanner.getTokenOffset(), keyPlaceholder);
    var key = _parseString(node);
    if (!key) {
      if (scanner.getToken() === 16 /* Unknown */) {
        // give a more helpful error message
        _error(jsonParser_localize('DoubleQuotesExpected', 'Property keys must be doublequoted'), ErrorCode.Undefined);
        var keyNode = new StringASTNodeImpl(node, scanner.getTokenOffset(), scanner.getTokenLength());
        keyNode.value = scanner.getTokenValue();
        key = keyNode;
        _scanNext(); // consume Unknown
      } else {
        return undefined;
      }
    }
    node.keyNode = key;
    var seen = keysSeen[key.value];
    if (seen) {
      _errorAtRange(jsonParser_localize('DuplicateKeyWarning', "Duplicate object key"), ErrorCode.DuplicateKey, node.keyNode.offset, node.keyNode.offset + node.keyNode.length, DiagnosticSeverity.Warning);
      if (typeof_default()(seen) === 'object') {
        _errorAtRange(jsonParser_localize('DuplicateKeyWarning', "Duplicate object key"), ErrorCode.DuplicateKey, seen.keyNode.offset, seen.keyNode.offset + seen.keyNode.length, DiagnosticSeverity.Warning);
      }
      keysSeen[key.value] = true; // if the same key is duplicate again, avoid duplicate error reporting
    } else {
      keysSeen[key.value] = node;
    }
    if (scanner.getToken() === 6 /* ColonToken */) {
      node.colonOffset = scanner.getTokenOffset();
      _scanNext(); // consume ColonToken
    } else {
      _error(jsonParser_localize('ColonExpected', 'Colon expected'), ErrorCode.ColonExpected);
      if (scanner.getToken() === 10 /* StringLiteral */ && textDocument.positionAt(key.offset + key.length).line < textDocument.positionAt(scanner.getTokenOffset()).line) {
        node.length = key.length;
        return node;
      }
    }
    var value = _parseValue(node);
    if (!value) {
      return _error(jsonParser_localize('ValueExpected', 'Value expected'), ErrorCode.ValueExpected, node, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
    }

    node.valueNode = value;
    node.length = value.offset + value.length - node.offset;
    return node;
  }
  function _parseObject(parent) {
    if (scanner.getToken() !== 1 /* OpenBraceToken */) {
      return undefined;
    }
    var node = new ObjectASTNodeImpl(parent, scanner.getTokenOffset());
    var keysSeen = Object.create(null);
    _scanNext(); // consume OpenBraceToken
    var needsComma = false;
    while (scanner.getToken() !== 2 /* CloseBraceToken */ && scanner.getToken() !== 17 /* EOF */) {
      if (scanner.getToken() === 5 /* CommaToken */) {
        if (!needsComma) {
          _error(jsonParser_localize('PropertyExpected', 'Property expected'), ErrorCode.PropertyExpected);
        }
        var commaOffset = scanner.getTokenOffset();
        _scanNext(); // consume comma
        if (scanner.getToken() === 2 /* CloseBraceToken */) {
          if (needsComma) {
            _errorAtRange(jsonParser_localize('TrailingComma', 'Trailing comma'), ErrorCode.TrailingComma, commaOffset, commaOffset + 1);
          }
          continue;
        }
      } else if (needsComma) {
        _error(jsonParser_localize('ExpectedComma', 'Expected comma'), ErrorCode.CommaExpected);
      }
      var property = _parseProperty(node, keysSeen);
      if (!property) {
        _error(jsonParser_localize('PropertyExpected', 'Property expected'), ErrorCode.PropertyExpected, undefined, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
      } else {
        node.properties.push(property);
      }
      needsComma = true;
    }
    if (scanner.getToken() !== 2 /* CloseBraceToken */) {
      return _error(jsonParser_localize('ExpectedCloseBrace', 'Expected comma or closing brace'), ErrorCode.CommaOrCloseBraceExpected, node);
    }
    return _finalize(node, true);
  }
  function _parseString(parent) {
    if (scanner.getToken() !== 10 /* StringLiteral */) {
      return undefined;
    }
    var node = new StringASTNodeImpl(parent, scanner.getTokenOffset());
    node.value = scanner.getTokenValue();
    return _finalize(node, true);
  }
  function _parseNumber(parent) {
    if (scanner.getToken() !== 11 /* NumericLiteral */) {
      return undefined;
    }
    var node = new NumberASTNodeImpl(parent, scanner.getTokenOffset());
    if (scanner.getTokenError() === 0 /* None */) {
      var tokenValue = scanner.getTokenValue();
      try {
        var numberValue = JSON.parse(tokenValue);
        if (!objects_isNumber(numberValue)) {
          return _error(jsonParser_localize('InvalidNumberFormat', 'Invalid number format.'), ErrorCode.Undefined, node);
        }
        node.value = numberValue;
      } catch (e) {
        return _error(jsonParser_localize('InvalidNumberFormat', 'Invalid number format.'), ErrorCode.Undefined, node);
      }
      node.isInteger = tokenValue.indexOf('.') === -1;
    }
    return _finalize(node, true);
  }
  function _parseLiteral(parent) {
    var node;
    switch (scanner.getToken()) {
      case 7 /* NullKeyword */:
        return _finalize(new NullASTNodeImpl(parent, scanner.getTokenOffset()), true);
      case 8 /* TrueKeyword */:
        return _finalize(new BooleanASTNodeImpl(parent, true, scanner.getTokenOffset()), true);
      case 9 /* FalseKeyword */:
        return _finalize(new BooleanASTNodeImpl(parent, false, scanner.getTokenOffset()), true);
      default:
        return undefined;
    }
  }
  function _parseValue(parent) {
    return _parseArray(parent) || _parseObject(parent) || _parseString(parent) || _parseNumber(parent) || _parseLiteral(parent);
  }
  var _root = undefined;
  var token = _scanNext();
  if (token !== 17 /* EOF */) {
    _root = _parseValue(_root);
    if (!_root) {
      _error(jsonParser_localize('Invalid symbol', 'Expected a JSON object, array or literal.'), ErrorCode.Undefined);
    } else if (scanner.getToken() !== 17 /* EOF */) {
      _error(jsonParser_localize('End of file expected', 'End of file expected.'), ErrorCode.Undefined);
    }
  }
  return new JSONDocument(_root, problems, commentRanges);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/json.js

/*---------------------------------------------------------------------------------------------
*  Copyright (c) Microsoft Corporation. All rights reserved.
*  Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
function stringifyObject(obj, indent, stringifyLiteral) {
  if (obj !== null && typeof_default()(obj) === 'object') {
    var newIndent = indent + '\t';
    if (Array.isArray(obj)) {
      if (obj.length === 0) {
        return '[]';
      }
      var result = '[\n';
      for (var i = 0; i < obj.length; i++) {
        result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
        if (i < obj.length - 1) {
          result += ',';
        }
        result += '\n';
      }
      result += indent + ']';
      return result;
    } else {
      var keys = Object.keys(obj);
      if (keys.length === 0) {
        return '{}';
      }
      var result = '{\n';
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);
        if (i < keys.length - 1) {
          result += ',';
        }
        result += '\n';
      }
      result += indent + '}';
      return result;
    }
  }
  return stringifyLiteral(obj);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonCompletion.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/







var jsonCompletion_localize = loadMessageBundle();
var valueCommitCharacters = [',', '}', ']'];
var propertyCommitCharacters = [':'];
var JSONCompletion = /** @class */function () {
  function JSONCompletion(schemaService, contributions, promiseConstructor, clientCapabilities) {
    if (contributions === void 0) {
      contributions = [];
    }
    if (promiseConstructor === void 0) {
      promiseConstructor = Promise;
    }
    if (clientCapabilities === void 0) {
      clientCapabilities = {};
    }
    this.schemaService = schemaService;
    this.contributions = contributions;
    this.promiseConstructor = promiseConstructor;
    this.clientCapabilities = clientCapabilities;
  }
  JSONCompletion.prototype.doResolve = function (item) {
    for (var i = this.contributions.length - 1; i >= 0; i--) {
      var resolveCompletion = this.contributions[i].resolveCompletion;
      if (resolveCompletion) {
        var resolver = resolveCompletion(item);
        if (resolver) {
          return resolver;
        }
      }
    }
    return this.promiseConstructor.resolve(item);
  };
  JSONCompletion.prototype.doComplete = function (document, position, doc) {
    var _this = this;
    var result = {
      items: [],
      isIncomplete: false
    };
    var text = document.getText();
    var offset = document.offsetAt(position);
    var node = doc.getNodeFromOffset(offset, true);
    if (this.isInComment(document, node ? node.offset : 0, offset)) {
      return Promise.resolve(result);
    }
    if (node && offset === node.offset + node.length && offset > 0) {
      var ch = text[offset - 1];
      if (node.type === 'object' && ch === '}' || node.type === 'array' && ch === ']') {
        // after ] or }
        node = node.parent;
      }
    }
    var currentWord = this.getCurrentWord(document, offset);
    var overwriteRange;
    if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
      overwriteRange = main_Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
    } else {
      var overwriteStart = offset - currentWord.length;
      if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
        overwriteStart--;
      }
      overwriteRange = main_Range.create(document.positionAt(overwriteStart), position);
    }
    var supportsCommitCharacters = false; //this.doesSupportsCommitCharacters(); disabled for now, waiting for new API: https://github.com/microsoft/vscode/issues/42544
    var proposed = {};
    var collector = {
      add: function add(suggestion) {
        var label = suggestion.label;
        var existing = proposed[label];
        if (!existing) {
          label = label.replace(/[\n]/g, '↵');
          if (label.length > 60) {
            var shortendedLabel = label.substr(0, 57).trim() + '...';
            if (!proposed[shortendedLabel]) {
              label = shortendedLabel;
            }
          }
          if (overwriteRange && suggestion.insertText !== undefined) {
            suggestion.textEdit = TextEdit.replace(overwriteRange, suggestion.insertText);
          }
          if (supportsCommitCharacters) {
            suggestion.commitCharacters = suggestion.kind === main_CompletionItemKind.Property ? propertyCommitCharacters : valueCommitCharacters;
          }
          suggestion.label = label;
          proposed[label] = suggestion;
          result.items.push(suggestion);
        } else {
          if (!existing.documentation) {
            existing.documentation = suggestion.documentation;
          }
          if (!existing.detail) {
            existing.detail = suggestion.detail;
          }
        }
      },
      setAsIncomplete: function setAsIncomplete() {
        result.isIncomplete = true;
      },
      error: function error(message) {
        console.error(message);
      },
      log: function log(message) {
        console.log(message);
      },
      getNumberOfProposals: function getNumberOfProposals() {
        return result.items.length;
      }
    };
    return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
      var collectionPromises = [];
      var addValue = true;
      var currentKey = '';
      var currentProperty = undefined;
      if (node) {
        if (node.type === 'string') {
          var parent = node.parent;
          if (parent && parent.type === 'property' && parent.keyNode === node) {
            addValue = !parent.valueNode;
            currentProperty = parent;
            currentKey = text.substr(node.offset + 1, node.length - 2);
            if (parent) {
              node = parent.parent;
            }
          }
        }
      }
      // proposals for properties
      if (node && node.type === 'object') {
        // don't suggest keys when the cursor is just before the opening curly brace
        if (node.offset === offset) {
          return result;
        }
        // don't suggest properties that are already present
        var properties = node.properties;
        properties.forEach(function (p) {
          if (!currentProperty || currentProperty !== p) {
            proposed[p.keyNode.value] = CompletionItem.create('__');
          }
        });
        var separatorAfter_1 = '';
        if (addValue) {
          separatorAfter_1 = _this.evaluateSeparatorAfter(document, document.offsetAt(overwriteRange.end));
        }
        if (schema) {
          // property proposals with schema
          _this.getPropertyCompletions(schema, doc, node, addValue, separatorAfter_1, collector);
        } else {
          // property proposals without schema
          _this.getSchemaLessPropertyCompletions(doc, node, currentKey, collector);
        }
        var location_1 = jsonParser_getNodePath(node);
        _this.contributions.forEach(function (contribution) {
          var collectPromise = contribution.collectPropertyCompletions(document.uri, location_1, currentWord, addValue, separatorAfter_1 === '', collector);
          if (collectPromise) {
            collectionPromises.push(collectPromise);
          }
        });
        if (!schema && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
          collector.add({
            kind: main_CompletionItemKind.Property,
            label: _this.getLabelForValue(currentWord),
            insertText: _this.getInsertTextForProperty(currentWord, undefined, false, separatorAfter_1),
            insertTextFormat: InsertTextFormat.Snippet,
            documentation: ''
          });
          collector.setAsIncomplete();
        }
      }
      // proposals for values
      var types = {};
      if (schema) {
        // value proposals with schema
        _this.getValueCompletions(schema, doc, node, offset, document, collector, types);
      } else {
        // value proposals without schema
        _this.getSchemaLessValueCompletions(doc, node, offset, document, collector);
      }
      if (_this.contributions.length > 0) {
        _this.getContributedValueCompletions(doc, node, offset, document, collector, collectionPromises);
      }
      return _this.promiseConstructor.all(collectionPromises).then(function () {
        if (collector.getNumberOfProposals() === 0) {
          var offsetForSeparator = offset;
          if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
            offsetForSeparator = node.offset + node.length;
          }
          var separatorAfter = _this.evaluateSeparatorAfter(document, offsetForSeparator);
          _this.addFillerValueCompletions(types, separatorAfter, collector);
        }
        return result;
      });
    });
  };
  JSONCompletion.prototype.getPropertyCompletions = function (schema, doc, node, addValue, separatorAfter, collector) {
    var _this = this;
    var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
    matchingSchemas.forEach(function (s) {
      if (s.node === node && !s.inverted) {
        var schemaProperties_1 = s.schema.properties;
        if (schemaProperties_1) {
          Object.keys(schemaProperties_1).forEach(function (key) {
            var propertySchema = schemaProperties_1[key];
            if (typeof_default()(propertySchema) === 'object' && !propertySchema.deprecationMessage && !propertySchema.doNotSuggest) {
              var proposal = {
                kind: main_CompletionItemKind.Property,
                label: key,
                insertText: _this.getInsertTextForProperty(key, propertySchema, addValue, separatorAfter),
                insertTextFormat: InsertTextFormat.Snippet,
                filterText: _this.getFilterTextForValue(key),
                documentation: _this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || ''
              };
              if (propertySchema.suggestSortText !== undefined) {
                proposal.sortText = propertySchema.suggestSortText;
              }
              if (proposal.insertText && endsWith(proposal.insertText, "$1" + separatorAfter)) {
                proposal.command = {
                  title: 'Suggest',
                  command: 'editor.action.triggerSuggest'
                };
              }
              collector.add(proposal);
            }
          });
        }
        var schemaPropertyNames_1 = s.schema.propertyNames;
        if (typeof_default()(schemaPropertyNames_1) === 'object' && !schemaPropertyNames_1.deprecationMessage && !schemaPropertyNames_1.doNotSuggest) {
          var propertyNameCompletionItem = function propertyNameCompletionItem(name, enumDescription) {
            if (enumDescription === void 0) {
              enumDescription = undefined;
            }
            var proposal = {
              kind: main_CompletionItemKind.Property,
              label: name,
              insertText: _this.getInsertTextForProperty(name, undefined, addValue, separatorAfter),
              insertTextFormat: InsertTextFormat.Snippet,
              filterText: _this.getFilterTextForValue(name),
              documentation: enumDescription || _this.fromMarkup(schemaPropertyNames_1.markdownDescription) || schemaPropertyNames_1.description || ''
            };
            if (schemaPropertyNames_1.suggestSortText !== undefined) {
              proposal.sortText = schemaPropertyNames_1.suggestSortText;
            }
            if (proposal.insertText && endsWith(proposal.insertText, "$1" + separatorAfter)) {
              proposal.command = {
                title: 'Suggest',
                command: 'editor.action.triggerSuggest'
              };
            }
            collector.add(proposal);
          };
          if (schemaPropertyNames_1["enum"]) {
            for (var i = 0; i < schemaPropertyNames_1["enum"].length; i++) {
              var enumDescription = undefined;
              if (schemaPropertyNames_1.markdownEnumDescriptions && i < schemaPropertyNames_1.markdownEnumDescriptions.length) {
                enumDescription = _this.fromMarkup(schemaPropertyNames_1.markdownEnumDescriptions[i]);
              } else if (schemaPropertyNames_1.enumDescriptions && i < schemaPropertyNames_1.enumDescriptions.length) {
                enumDescription = schemaPropertyNames_1.enumDescriptions[i];
              }
              propertyNameCompletionItem(schemaPropertyNames_1["enum"][i], enumDescription);
            }
          }
          if (schemaPropertyNames_1["const"]) {
            propertyNameCompletionItem(schemaPropertyNames_1["const"]);
          }
        }
      }
    });
  };
  JSONCompletion.prototype.getSchemaLessPropertyCompletions = function (doc, node, currentKey, collector) {
    var _this = this;
    var collectCompletionsForSimilarObject = function collectCompletionsForSimilarObject(obj) {
      obj.properties.forEach(function (p) {
        var key = p.keyNode.value;
        collector.add({
          kind: main_CompletionItemKind.Property,
          label: key,
          insertText: _this.getInsertTextForValue(key, ''),
          insertTextFormat: InsertTextFormat.Snippet,
          filterText: _this.getFilterTextForValue(key),
          documentation: ''
        });
      });
    };
    if (node.parent) {
      if (node.parent.type === 'property') {
        // if the object is a property value, check the tree for other objects that hang under a property of the same name
        var parentKey_1 = node.parent.keyNode.value;
        doc.visit(function (n) {
          if (n.type === 'property' && n !== node.parent && n.keyNode.value === parentKey_1 && n.valueNode && n.valueNode.type === 'object') {
            collectCompletionsForSimilarObject(n.valueNode);
          }
          return true;
        });
      } else if (node.parent.type === 'array') {
        // if the object is in an array, use all other array elements as similar objects
        node.parent.items.forEach(function (n) {
          if (n.type === 'object' && n !== node) {
            collectCompletionsForSimilarObject(n);
          }
        });
      }
    } else if (node.type === 'object') {
      collector.add({
        kind: main_CompletionItemKind.Property,
        label: '$schema',
        insertText: this.getInsertTextForProperty('$schema', undefined, true, ''),
        insertTextFormat: InsertTextFormat.Snippet,
        documentation: '',
        filterText: this.getFilterTextForValue("$schema")
      });
    }
  };
  JSONCompletion.prototype.getSchemaLessValueCompletions = function (doc, node, offset, document, collector) {
    var _this = this;
    var offsetForSeparator = offset;
    if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
      offsetForSeparator = node.offset + node.length;
      node = node.parent;
    }
    if (!node) {
      collector.add({
        kind: this.getSuggestionKind('object'),
        label: 'Empty object',
        insertText: this.getInsertTextForValue({}, ''),
        insertTextFormat: InsertTextFormat.Snippet,
        documentation: ''
      });
      collector.add({
        kind: this.getSuggestionKind('array'),
        label: 'Empty array',
        insertText: this.getInsertTextForValue([], ''),
        insertTextFormat: InsertTextFormat.Snippet,
        documentation: ''
      });
      return;
    }
    var separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
    var collectSuggestionsForValues = function collectSuggestionsForValues(value) {
      if (value.parent && !jsonParser_contains(value.parent, offset, true)) {
        collector.add({
          kind: _this.getSuggestionKind(value.type),
          label: _this.getLabelTextForMatchingNode(value, document),
          insertText: _this.getInsertTextForMatchingNode(value, document, separatorAfter),
          insertTextFormat: InsertTextFormat.Snippet,
          documentation: ''
        });
      }
      if (value.type === 'boolean') {
        _this.addBooleanValueCompletion(!value.value, separatorAfter, collector);
      }
    };
    if (node.type === 'property') {
      if (offset > (node.colonOffset || 0)) {
        var valueNode = node.valueNode;
        if (valueNode && (offset > valueNode.offset + valueNode.length || valueNode.type === 'object' || valueNode.type === 'array')) {
          return;
        }
        // suggest values at the same key
        var parentKey_2 = node.keyNode.value;
        doc.visit(function (n) {
          if (n.type === 'property' && n.keyNode.value === parentKey_2 && n.valueNode) {
            collectSuggestionsForValues(n.valueNode);
          }
          return true;
        });
        if (parentKey_2 === '$schema' && node.parent && !node.parent.parent) {
          this.addDollarSchemaCompletions(separatorAfter, collector);
        }
      }
    }
    if (node.type === 'array') {
      if (node.parent && node.parent.type === 'property') {
        // suggest items of an array at the same key
        var parentKey_3 = node.parent.keyNode.value;
        doc.visit(function (n) {
          if (n.type === 'property' && n.keyNode.value === parentKey_3 && n.valueNode && n.valueNode.type === 'array') {
            n.valueNode.items.forEach(collectSuggestionsForValues);
          }
          return true;
        });
      } else {
        // suggest items in the same array
        node.items.forEach(collectSuggestionsForValues);
      }
    }
  };
  JSONCompletion.prototype.getValueCompletions = function (schema, doc, node, offset, document, collector, types) {
    var offsetForSeparator = offset;
    var parentKey = undefined;
    var valueNode = undefined;
    if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
      offsetForSeparator = node.offset + node.length;
      valueNode = node;
      node = node.parent;
    }
    if (!node) {
      this.addSchemaValueCompletions(schema.schema, '', collector, types);
      return;
    }
    if (node.type === 'property' && offset > (node.colonOffset || 0)) {
      var valueNode_1 = node.valueNode;
      if (valueNode_1 && offset > valueNode_1.offset + valueNode_1.length) {
        return; // we are past the value node
      }

      parentKey = node.keyNode.value;
      node = node.parent;
    }
    if (node && (parentKey !== undefined || node.type === 'array')) {
      var separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
      var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset, valueNode);
      for (var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++) {
        var s = matchingSchemas_1[_i];
        if (s.node === node && !s.inverted && s.schema) {
          if (node.type === 'array' && s.schema.items) {
            if (Array.isArray(s.schema.items)) {
              var index = this.findItemAtOffset(node, document, offset);
              if (index < s.schema.items.length) {
                this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types);
              }
            } else {
              this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
            }
          }
          if (parentKey !== undefined) {
            var propertyMatched = false;
            if (s.schema.properties) {
              var propertySchema = s.schema.properties[parentKey];
              if (propertySchema) {
                propertyMatched = true;
                this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
              }
            }
            if (s.schema.patternProperties && !propertyMatched) {
              for (var _a = 0, _b = Object.keys(s.schema.patternProperties); _a < _b.length; _a++) {
                var pattern = _b[_a];
                var regex = extendedRegExp(pattern);
                if (regex.test(parentKey)) {
                  propertyMatched = true;
                  var propertySchema = s.schema.patternProperties[pattern];
                  this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                }
              }
            }
            if (s.schema.additionalProperties && !propertyMatched) {
              var propertySchema = s.schema.additionalProperties;
              this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
            }
          }
        }
      }
      if (parentKey === '$schema' && !node.parent) {
        this.addDollarSchemaCompletions(separatorAfter, collector);
      }
      if (types['boolean']) {
        this.addBooleanValueCompletion(true, separatorAfter, collector);
        this.addBooleanValueCompletion(false, separatorAfter, collector);
      }
      if (types['null']) {
        this.addNullValueCompletion(separatorAfter, collector);
      }
    }
  };
  JSONCompletion.prototype.getContributedValueCompletions = function (doc, node, offset, document, collector, collectionPromises) {
    if (!node) {
      this.contributions.forEach(function (contribution) {
        var collectPromise = contribution.collectDefaultCompletions(document.uri, collector);
        if (collectPromise) {
          collectionPromises.push(collectPromise);
        }
      });
    } else {
      if (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null') {
        node = node.parent;
      }
      if (node && node.type === 'property' && offset > (node.colonOffset || 0)) {
        var parentKey_4 = node.keyNode.value;
        var valueNode = node.valueNode;
        if ((!valueNode || offset <= valueNode.offset + valueNode.length) && node.parent) {
          var location_2 = jsonParser_getNodePath(node.parent);
          this.contributions.forEach(function (contribution) {
            var collectPromise = contribution.collectValueCompletions(document.uri, location_2, parentKey_4, collector);
            if (collectPromise) {
              collectionPromises.push(collectPromise);
            }
          });
        }
      }
    }
  };
  JSONCompletion.prototype.addSchemaValueCompletions = function (schema, separatorAfter, collector, types) {
    var _this = this;
    if (typeof_default()(schema) === 'object') {
      this.addEnumValueCompletions(schema, separatorAfter, collector);
      this.addDefaultValueCompletions(schema, separatorAfter, collector);
      this.collectTypes(schema, types);
      if (Array.isArray(schema.allOf)) {
        schema.allOf.forEach(function (s) {
          return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
        });
      }
      if (Array.isArray(schema.anyOf)) {
        schema.anyOf.forEach(function (s) {
          return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
        });
      }
      if (Array.isArray(schema.oneOf)) {
        schema.oneOf.forEach(function (s) {
          return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
        });
      }
    }
  };
  JSONCompletion.prototype.addDefaultValueCompletions = function (schema, separatorAfter, collector, arrayDepth) {
    var _this = this;
    if (arrayDepth === void 0) {
      arrayDepth = 0;
    }
    var hasProposals = false;
    if (objects_isDefined(schema["default"])) {
      var type = schema.type;
      var value = schema["default"];
      for (var i = arrayDepth; i > 0; i--) {
        value = [value];
        type = 'array';
      }
      collector.add({
        kind: this.getSuggestionKind(type),
        label: this.getLabelForValue(value),
        insertText: this.getInsertTextForValue(value, separatorAfter),
        insertTextFormat: InsertTextFormat.Snippet,
        detail: jsonCompletion_localize('json.suggest.default', 'Default value')
      });
      hasProposals = true;
    }
    if (Array.isArray(schema.examples)) {
      schema.examples.forEach(function (example) {
        var type = schema.type;
        var value = example;
        for (var i = arrayDepth; i > 0; i--) {
          value = [value];
          type = 'array';
        }
        collector.add({
          kind: _this.getSuggestionKind(type),
          label: _this.getLabelForValue(value),
          insertText: _this.getInsertTextForValue(value, separatorAfter),
          insertTextFormat: InsertTextFormat.Snippet
        });
        hasProposals = true;
      });
    }
    if (Array.isArray(schema.defaultSnippets)) {
      schema.defaultSnippets.forEach(function (s) {
        var type = schema.type;
        var value = s.body;
        var label = s.label;
        var insertText;
        var filterText;
        if (objects_isDefined(value)) {
          var type_1 = schema.type;
          for (var i = arrayDepth; i > 0; i--) {
            value = [value];
            type_1 = 'array';
          }
          insertText = _this.getInsertTextForSnippetValue(value, separatorAfter);
          filterText = _this.getFilterTextForSnippetValue(value);
          label = label || _this.getLabelForSnippetValue(value);
        } else if (typeof s.bodyText === 'string') {
          var prefix = '',
            suffix = '',
            indent = '';
          for (var i = arrayDepth; i > 0; i--) {
            prefix = prefix + indent + '[\n';
            suffix = suffix + '\n' + indent + ']';
            indent += '\t';
            type = 'array';
          }
          insertText = prefix + indent + s.bodyText.split('\n').join('\n' + indent) + suffix + separatorAfter;
          label = label || insertText, filterText = insertText.replace(/[\n]/g, ''); // remove new lines
        } else {
          return;
        }
        collector.add({
          kind: _this.getSuggestionKind(type),
          label: label,
          documentation: _this.fromMarkup(s.markdownDescription) || s.description,
          insertText: insertText,
          insertTextFormat: InsertTextFormat.Snippet,
          filterText: filterText
        });
        hasProposals = true;
      });
    }
    if (!hasProposals && typeof_default()(schema.items) === 'object' && !Array.isArray(schema.items) && arrayDepth < 5 /* beware of recursion */) {
      this.addDefaultValueCompletions(schema.items, separatorAfter, collector, arrayDepth + 1);
    }
  };
  JSONCompletion.prototype.addEnumValueCompletions = function (schema, separatorAfter, collector) {
    if (objects_isDefined(schema["const"])) {
      collector.add({
        kind: this.getSuggestionKind(schema.type),
        label: this.getLabelForValue(schema["const"]),
        insertText: this.getInsertTextForValue(schema["const"], separatorAfter),
        insertTextFormat: InsertTextFormat.Snippet,
        documentation: this.fromMarkup(schema.markdownDescription) || schema.description
      });
    }
    if (Array.isArray(schema["enum"])) {
      for (var i = 0, length = schema["enum"].length; i < length; i++) {
        var enm = schema["enum"][i];
        var documentation = this.fromMarkup(schema.markdownDescription) || schema.description;
        if (schema.markdownEnumDescriptions && i < schema.markdownEnumDescriptions.length && this.doesSupportMarkdown()) {
          documentation = this.fromMarkup(schema.markdownEnumDescriptions[i]);
        } else if (schema.enumDescriptions && i < schema.enumDescriptions.length) {
          documentation = schema.enumDescriptions[i];
        }
        collector.add({
          kind: this.getSuggestionKind(schema.type),
          label: this.getLabelForValue(enm),
          insertText: this.getInsertTextForValue(enm, separatorAfter),
          insertTextFormat: InsertTextFormat.Snippet,
          documentation: documentation
        });
      }
    }
  };
  JSONCompletion.prototype.collectTypes = function (schema, types) {
    if (Array.isArray(schema["enum"]) || objects_isDefined(schema["const"])) {
      return;
    }
    var type = schema.type;
    if (Array.isArray(type)) {
      type.forEach(function (t) {
        return types[t] = true;
      });
    } else if (type) {
      types[type] = true;
    }
  };
  JSONCompletion.prototype.addFillerValueCompletions = function (types, separatorAfter, collector) {
    if (types['object']) {
      collector.add({
        kind: this.getSuggestionKind('object'),
        label: '{}',
        insertText: this.getInsertTextForGuessedValue({}, separatorAfter),
        insertTextFormat: InsertTextFormat.Snippet,
        detail: jsonCompletion_localize('defaults.object', 'New object'),
        documentation: ''
      });
    }
    if (types['array']) {
      collector.add({
        kind: this.getSuggestionKind('array'),
        label: '[]',
        insertText: this.getInsertTextForGuessedValue([], separatorAfter),
        insertTextFormat: InsertTextFormat.Snippet,
        detail: jsonCompletion_localize('defaults.array', 'New array'),
        documentation: ''
      });
    }
  };
  JSONCompletion.prototype.addBooleanValueCompletion = function (value, separatorAfter, collector) {
    collector.add({
      kind: this.getSuggestionKind('boolean'),
      label: value ? 'true' : 'false',
      insertText: this.getInsertTextForValue(value, separatorAfter),
      insertTextFormat: InsertTextFormat.Snippet,
      documentation: ''
    });
  };
  JSONCompletion.prototype.addNullValueCompletion = function (separatorAfter, collector) {
    collector.add({
      kind: this.getSuggestionKind('null'),
      label: 'null',
      insertText: 'null' + separatorAfter,
      insertTextFormat: InsertTextFormat.Snippet,
      documentation: ''
    });
  };
  JSONCompletion.prototype.addDollarSchemaCompletions = function (separatorAfter, collector) {
    var _this = this;
    var schemaIds = this.schemaService.getRegisteredSchemaIds(function (schema) {
      return schema === 'http' || schema === 'https';
    });
    schemaIds.forEach(function (schemaId) {
      return collector.add({
        kind: main_CompletionItemKind.Module,
        label: _this.getLabelForValue(schemaId),
        filterText: _this.getFilterTextForValue(schemaId),
        insertText: _this.getInsertTextForValue(schemaId, separatorAfter),
        insertTextFormat: InsertTextFormat.Snippet,
        documentation: ''
      });
    });
  };
  JSONCompletion.prototype.getLabelForValue = function (value) {
    return JSON.stringify(value);
  };
  JSONCompletion.prototype.getFilterTextForValue = function (value) {
    return JSON.stringify(value);
  };
  JSONCompletion.prototype.getFilterTextForSnippetValue = function (value) {
    return JSON.stringify(value).replace(/\$\{\d+:([^}]+)\}|\$\d+/g, '$1');
  };
  JSONCompletion.prototype.getLabelForSnippetValue = function (value) {
    var label = JSON.stringify(value);
    return label.replace(/\$\{\d+:([^}]+)\}|\$\d+/g, '$1');
  };
  JSONCompletion.prototype.getInsertTextForPlainText = function (text) {
    return text.replace(/[\\\$\}]/g, '\\$&'); // escape $, \ and } 
  };

  JSONCompletion.prototype.getInsertTextForValue = function (value, separatorAfter) {
    var text = JSON.stringify(value, null, '\t');
    if (text === '{}') {
      return '{$1}' + separatorAfter;
    } else if (text === '[]') {
      return '[$1]' + separatorAfter;
    }
    return this.getInsertTextForPlainText(text + separatorAfter);
  };
  JSONCompletion.prototype.getInsertTextForSnippetValue = function (value, separatorAfter) {
    var replacer = function replacer(value) {
      if (typeof value === 'string') {
        if (value[0] === '^') {
          return value.substr(1);
        }
      }
      return JSON.stringify(value);
    };
    return stringifyObject(value, '', replacer) + separatorAfter;
  };
  JSONCompletion.prototype.getInsertTextForGuessedValue = function (value, separatorAfter) {
    switch (typeof_default()(value)) {
      case 'object':
        if (value === null) {
          return '${1:null}' + separatorAfter;
        }
        return this.getInsertTextForValue(value, separatorAfter);
      case 'string':
        var snippetValue = JSON.stringify(value);
        snippetValue = snippetValue.substr(1, snippetValue.length - 2); // remove quotes
        snippetValue = this.getInsertTextForPlainText(snippetValue); // escape \ and }
        return '"${1:' + snippetValue + '}"' + separatorAfter;
      case 'number':
      case 'boolean':
        return '${1:' + JSON.stringify(value) + '}' + separatorAfter;
    }
    return this.getInsertTextForValue(value, separatorAfter);
  };
  JSONCompletion.prototype.getSuggestionKind = function (type) {
    if (Array.isArray(type)) {
      var array = type;
      type = array.length > 0 ? array[0] : undefined;
    }
    if (!type) {
      return main_CompletionItemKind.Value;
    }
    switch (type) {
      case 'string':
        return main_CompletionItemKind.Value;
      case 'object':
        return main_CompletionItemKind.Module;
      case 'property':
        return main_CompletionItemKind.Property;
      default:
        return main_CompletionItemKind.Value;
    }
  };
  JSONCompletion.prototype.getLabelTextForMatchingNode = function (node, document) {
    switch (node.type) {
      case 'array':
        return '[]';
      case 'object':
        return '{}';
      default:
        var content = document.getText().substr(node.offset, node.length);
        return content;
    }
  };
  JSONCompletion.prototype.getInsertTextForMatchingNode = function (node, document, separatorAfter) {
    switch (node.type) {
      case 'array':
        return this.getInsertTextForValue([], separatorAfter);
      case 'object':
        return this.getInsertTextForValue({}, separatorAfter);
      default:
        var content = document.getText().substr(node.offset, node.length) + separatorAfter;
        return this.getInsertTextForPlainText(content);
    }
  };
  JSONCompletion.prototype.getInsertTextForProperty = function (key, propertySchema, addValue, separatorAfter) {
    var propertyText = this.getInsertTextForValue(key, '');
    if (!addValue) {
      return propertyText;
    }
    var resultText = propertyText + ': ';
    var value;
    var nValueProposals = 0;
    if (propertySchema) {
      if (Array.isArray(propertySchema.defaultSnippets)) {
        if (propertySchema.defaultSnippets.length === 1) {
          var body = propertySchema.defaultSnippets[0].body;
          if (objects_isDefined(body)) {
            value = this.getInsertTextForSnippetValue(body, '');
          }
        }
        nValueProposals += propertySchema.defaultSnippets.length;
      }
      if (propertySchema["enum"]) {
        if (!value && propertySchema["enum"].length === 1) {
          value = this.getInsertTextForGuessedValue(propertySchema["enum"][0], '');
        }
        nValueProposals += propertySchema["enum"].length;
      }
      if (objects_isDefined(propertySchema["default"])) {
        if (!value) {
          value = this.getInsertTextForGuessedValue(propertySchema["default"], '');
        }
        nValueProposals++;
      }
      if (Array.isArray(propertySchema.examples) && propertySchema.examples.length) {
        if (!value) {
          value = this.getInsertTextForGuessedValue(propertySchema.examples[0], '');
        }
        nValueProposals += propertySchema.examples.length;
      }
      if (nValueProposals === 0) {
        var type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
        if (!type) {
          if (propertySchema.properties) {
            type = 'object';
          } else if (propertySchema.items) {
            type = 'array';
          }
        }
        switch (type) {
          case 'boolean':
            value = '$1';
            break;
          case 'string':
            value = '"$1"';
            break;
          case 'object':
            value = '{$1}';
            break;
          case 'array':
            value = '[$1]';
            break;
          case 'number':
          case 'integer':
            value = '${1:0}';
            break;
          case 'null':
            value = '${1:null}';
            break;
          default:
            return propertyText;
        }
      }
    }
    if (!value || nValueProposals > 1) {
      value = '$1';
    }
    return resultText + value + separatorAfter;
  };
  JSONCompletion.prototype.getCurrentWord = function (document, offset) {
    var i = offset - 1;
    var text = document.getText();
    while (i >= 0 && ' \t\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1) {
      i--;
    }
    return text.substring(i + 1, offset);
  };
  JSONCompletion.prototype.evaluateSeparatorAfter = function (document, offset) {
    var scanner = main_createScanner(document.getText(), true);
    scanner.setPosition(offset);
    var token = scanner.scan();
    switch (token) {
      case 5 /* CommaToken */:
      case 2 /* CloseBraceToken */:
      case 4 /* CloseBracketToken */:
      case 17 /* EOF */:
        return '';
      default:
        return ',';
    }
  };
  JSONCompletion.prototype.findItemAtOffset = function (node, document, offset) {
    var scanner = main_createScanner(document.getText(), true);
    var children = node.items;
    for (var i = children.length - 1; i >= 0; i--) {
      var child = children[i];
      if (offset > child.offset + child.length) {
        scanner.setPosition(child.offset + child.length);
        var token = scanner.scan();
        if (token === 5 /* CommaToken */ && offset >= scanner.getTokenOffset() + scanner.getTokenLength()) {
          return i + 1;
        }
        return i;
      } else if (offset >= child.offset) {
        return i;
      }
    }
    return 0;
  };
  JSONCompletion.prototype.isInComment = function (document, start, offset) {
    var scanner = main_createScanner(document.getText(), false);
    scanner.setPosition(start);
    var token = scanner.scan();
    while (token !== 17 /* EOF */ && scanner.getTokenOffset() + scanner.getTokenLength() < offset) {
      token = scanner.scan();
    }
    return (token === 12 /* LineCommentTrivia */ || token === 13 /* BlockCommentTrivia */) && scanner.getTokenOffset() <= offset;
  };
  JSONCompletion.prototype.fromMarkup = function (markupString) {
    if (markupString && this.doesSupportMarkdown()) {
      return {
        kind: MarkupKind.Markdown,
        value: markupString
      };
    }
    return undefined;
  };
  JSONCompletion.prototype.doesSupportMarkdown = function () {
    if (!objects_isDefined(this.supportsMarkdown)) {
      var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
      this.supportsMarkdown = completion && completion.completionItem && Array.isArray(completion.completionItem.documentationFormat) && completion.completionItem.documentationFormat.indexOf(MarkupKind.Markdown) !== -1;
    }
    return this.supportsMarkdown;
  };
  JSONCompletion.prototype.doesSupportsCommitCharacters = function () {
    if (!objects_isDefined(this.supportsCommitCharacters)) {
      var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
      this.supportsCommitCharacters = completion && completion.completionItem && !!completion.completionItem.commitCharactersSupport;
    }
    return this.supportsCommitCharacters;
  };
  return JSONCompletion;
}();

;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonHover.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


var JSONHover = /** @class */function () {
  function JSONHover(schemaService, contributions, promiseConstructor) {
    if (contributions === void 0) {
      contributions = [];
    }
    this.schemaService = schemaService;
    this.contributions = contributions;
    this.promise = promiseConstructor || Promise;
  }
  JSONHover.prototype.doHover = function (document, position, doc) {
    var offset = document.offsetAt(position);
    var node = doc.getNodeFromOffset(offset);
    if (!node || (node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
      return this.promise.resolve(null);
    }
    var hoverRangeNode = node;
    // use the property description when hovering over an object key
    if (node.type === 'string') {
      var parent = node.parent;
      if (parent && parent.type === 'property' && parent.keyNode === node) {
        node = parent.valueNode;
        if (!node) {
          return this.promise.resolve(null);
        }
      }
    }
    var hoverRange = main_Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
    var createHover = function createHover(contents) {
      var result = {
        contents: contents,
        range: hoverRange
      };
      return result;
    };
    var location = jsonParser_getNodePath(node);
    for (var i = this.contributions.length - 1; i >= 0; i--) {
      var contribution = this.contributions[i];
      var promise = contribution.getInfoContribution(document.uri, location);
      if (promise) {
        return promise.then(function (htmlContent) {
          return createHover(htmlContent);
        });
      }
    }
    return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
      if (schema && node) {
        var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
        var title_1 = undefined;
        var markdownDescription_1 = undefined;
        var markdownEnumValueDescription_1 = undefined,
          enumValue_1 = undefined;
        matchingSchemas.every(function (s) {
          if (s.node === node && !s.inverted && s.schema) {
            title_1 = title_1 || s.schema.title;
            markdownDescription_1 = markdownDescription_1 || s.schema.markdownDescription || toMarkdown(s.schema.description);
            if (s.schema["enum"]) {
              var idx = s.schema["enum"].indexOf(jsonParser_getNodeValue(node));
              if (s.schema.markdownEnumDescriptions) {
                markdownEnumValueDescription_1 = s.schema.markdownEnumDescriptions[idx];
              } else if (s.schema.enumDescriptions) {
                markdownEnumValueDescription_1 = toMarkdown(s.schema.enumDescriptions[idx]);
              }
              if (markdownEnumValueDescription_1) {
                enumValue_1 = s.schema["enum"][idx];
                if (typeof enumValue_1 !== 'string') {
                  enumValue_1 = JSON.stringify(enumValue_1);
                }
              }
            }
          }
          return true;
        });
        var result = '';
        if (title_1) {
          result = toMarkdown(title_1);
        }
        if (markdownDescription_1) {
          if (result.length > 0) {
            result += "\n\n";
          }
          result += markdownDescription_1;
        }
        if (markdownEnumValueDescription_1) {
          if (result.length > 0) {
            result += "\n\n";
          }
          result += "`" + toMarkdownCodeBlock(enumValue_1) + "`: " + markdownEnumValueDescription_1;
        }
        return createHover([result]);
      }
      return null;
    });
  };
  return JSONHover;
}();

function toMarkdown(plain) {
  if (plain) {
    var res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
    return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
  }

  return undefined;
}
function toMarkdownCodeBlock(content) {
  // see https://daringfireball.net/projects/markdown/syntax#precode
  if (content.indexOf('`') !== -1) {
    return '`` ' + content + ' ``';
  }
  return content;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-uri/index.js
/* provided dependency */ var vscode_uri_process = __webpack_require__(/*! ./node_modules/process/browser.js */ 89);

var LIB;
LIB = function () {
  "use strict";

  var t = {
      470: function _(t) {
        function e(t) {
          if ("string" != typeof t) throw new TypeError("Path must be a string. Received " + JSON.stringify(t));
        }
        function r(t, e) {
          for (var r, n = "", o = 0, i = -1, a = 0, h = 0; h <= t.length; ++h) {
            if (h < t.length) r = t.charCodeAt(h);else {
              if (47 === r) break;
              r = 47;
            }
            if (47 === r) {
              if (i === h - 1 || 1 === a) ;else if (i !== h - 1 && 2 === a) {
                if (n.length < 2 || 2 !== o || 46 !== n.charCodeAt(n.length - 1) || 46 !== n.charCodeAt(n.length - 2)) if (n.length > 2) {
                  var s = n.lastIndexOf("/");
                  if (s !== n.length - 1) {
                    -1 === s ? (n = "", o = 0) : o = (n = n.slice(0, s)).length - 1 - n.lastIndexOf("/"), i = h, a = 0;
                    continue;
                  }
                } else if (2 === n.length || 1 === n.length) {
                  n = "", o = 0, i = h, a = 0;
                  continue;
                }
                e && (n.length > 0 ? n += "/.." : n = "..", o = 2);
              } else n.length > 0 ? n += "/" + t.slice(i + 1, h) : n = t.slice(i + 1, h), o = h - i - 1;
              i = h, a = 0;
            } else 46 === r && -1 !== a ? ++a : a = -1;
          }
          return n;
        }
        var n = {
          resolve: function resolve() {
            for (var t, n = "", o = !1, i = arguments.length - 1; i >= -1 && !o; i--) {
              var a;
              i >= 0 ? a = arguments[i] : (void 0 === t && (t = vscode_uri_process.cwd()), a = t), e(a), 0 !== a.length && (n = a + "/" + n, o = 47 === a.charCodeAt(0));
            }
            return n = r(n, !o), o ? n.length > 0 ? "/" + n : "/" : n.length > 0 ? n : ".";
          },
          normalize: function normalize(t) {
            if (e(t), 0 === t.length) return ".";
            var n = 47 === t.charCodeAt(0),
              o = 47 === t.charCodeAt(t.length - 1);
            return 0 !== (t = r(t, !n)).length || n || (t = "."), t.length > 0 && o && (t += "/"), n ? "/" + t : t;
          },
          isAbsolute: function isAbsolute(t) {
            return e(t), t.length > 0 && 47 === t.charCodeAt(0);
          },
          join: function join() {
            if (0 === arguments.length) return ".";
            for (var t, r = 0; r < arguments.length; ++r) {
              var o = arguments[r];
              e(o), o.length > 0 && (void 0 === t ? t = o : t += "/" + o);
            }
            return void 0 === t ? "." : n.normalize(t);
          },
          relative: function relative(t, r) {
            if (e(t), e(r), t === r) return "";
            if ((t = n.resolve(t)) === (r = n.resolve(r))) return "";
            for (var o = 1; o < t.length && 47 === t.charCodeAt(o); ++o);
            for (var i = t.length, a = i - o, h = 1; h < r.length && 47 === r.charCodeAt(h); ++h);
            for (var s = r.length - h, f = a < s ? a : s, u = -1, c = 0; c <= f; ++c) {
              if (c === f) {
                if (s > f) {
                  if (47 === r.charCodeAt(h + c)) return r.slice(h + c + 1);
                  if (0 === c) return r.slice(h + c);
                } else a > f && (47 === t.charCodeAt(o + c) ? u = c : 0 === c && (u = 0));
                break;
              }
              var l = t.charCodeAt(o + c);
              if (l !== r.charCodeAt(h + c)) break;
              47 === l && (u = c);
            }
            var p = "";
            for (c = o + u + 1; c <= i; ++c) c !== i && 47 !== t.charCodeAt(c) || (0 === p.length ? p += ".." : p += "/..");
            return p.length > 0 ? p + r.slice(h + u) : (h += u, 47 === r.charCodeAt(h) && ++h, r.slice(h));
          },
          _makeLong: function _makeLong(t) {
            return t;
          },
          dirname: function dirname(t) {
            if (e(t), 0 === t.length) return ".";
            for (var r = t.charCodeAt(0), n = 47 === r, o = -1, i = !0, a = t.length - 1; a >= 1; --a) if (47 === (r = t.charCodeAt(a))) {
              if (!i) {
                o = a;
                break;
              }
            } else i = !1;
            return -1 === o ? n ? "/" : "." : n && 1 === o ? "//" : t.slice(0, o);
          },
          basename: function basename(t, r) {
            if (void 0 !== r && "string" != typeof r) throw new TypeError('"ext" argument must be a string');
            e(t);
            var n,
              o = 0,
              i = -1,
              a = !0;
            if (void 0 !== r && r.length > 0 && r.length <= t.length) {
              if (r.length === t.length && r === t) return "";
              var h = r.length - 1,
                s = -1;
              for (n = t.length - 1; n >= 0; --n) {
                var f = t.charCodeAt(n);
                if (47 === f) {
                  if (!a) {
                    o = n + 1;
                    break;
                  }
                } else -1 === s && (a = !1, s = n + 1), h >= 0 && (f === r.charCodeAt(h) ? -1 == --h && (i = n) : (h = -1, i = s));
              }
              return o === i ? i = s : -1 === i && (i = t.length), t.slice(o, i);
            }
            for (n = t.length - 1; n >= 0; --n) if (47 === t.charCodeAt(n)) {
              if (!a) {
                o = n + 1;
                break;
              }
            } else -1 === i && (a = !1, i = n + 1);
            return -1 === i ? "" : t.slice(o, i);
          },
          extname: function extname(t) {
            e(t);
            for (var r = -1, n = 0, o = -1, i = !0, a = 0, h = t.length - 1; h >= 0; --h) {
              var s = t.charCodeAt(h);
              if (47 !== s) -1 === o && (i = !1, o = h + 1), 46 === s ? -1 === r ? r = h : 1 !== a && (a = 1) : -1 !== r && (a = -1);else if (!i) {
                n = h + 1;
                break;
              }
            }
            return -1 === r || -1 === o || 0 === a || 1 === a && r === o - 1 && r === n + 1 ? "" : t.slice(r, o);
          },
          format: function format(t) {
            if (null === t || "object" != typeof_default()(t)) throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof_default()(t));
            return function (t, e) {
              var r = e.dir || e.root,
                n = e.base || (e.name || "") + (e.ext || "");
              return r ? r === e.root ? r + n : r + "/" + n : n;
            }(0, t);
          },
          parse: function parse(t) {
            e(t);
            var r = {
              root: "",
              dir: "",
              base: "",
              ext: "",
              name: ""
            };
            if (0 === t.length) return r;
            var n,
              o = t.charCodeAt(0),
              i = 47 === o;
            i ? (r.root = "/", n = 1) : n = 0;
            for (var a = -1, h = 0, s = -1, f = !0, u = t.length - 1, c = 0; u >= n; --u) if (47 !== (o = t.charCodeAt(u))) -1 === s && (f = !1, s = u + 1), 46 === o ? -1 === a ? a = u : 1 !== c && (c = 1) : -1 !== a && (c = -1);else if (!f) {
              h = u + 1;
              break;
            }
            return -1 === a || -1 === s || 0 === c || 1 === c && a === s - 1 && a === h + 1 ? -1 !== s && (r.base = r.name = 0 === h && i ? t.slice(1, s) : t.slice(h, s)) : (0 === h && i ? (r.name = t.slice(1, a), r.base = t.slice(1, s)) : (r.name = t.slice(h, a), r.base = t.slice(h, s)), r.ext = t.slice(a, s)), h > 0 ? r.dir = t.slice(0, h - 1) : i && (r.dir = "/"), r;
          },
          sep: "/",
          delimiter: ":",
          win32: null,
          posix: null
        };
        n.posix = n, t.exports = n;
      },
      447: function _(t, e, r) {
        var n;
        if (r.r(e), r.d(e, {
          URI: function URI() {
            return g;
          },
          Utils: function Utils() {
            return O;
          }
        }), "object" == (typeof vscode_uri_process === "undefined" ? "undefined" : typeof_default()(vscode_uri_process))) n = "win32" === vscode_uri_process.platform;else if ("object" == (typeof navigator === "undefined" ? "undefined" : typeof_default()(navigator))) {
          var o = navigator.userAgent;
          n = o.indexOf("Windows") >= 0;
        }
        var _i,
          a,
          h = (_i = function i(t, e) {
            return (_i = Object.setPrototypeOf || {
              __proto__: []
            } instanceof Array && function (t, e) {
              t.__proto__ = e;
            } || function (t, e) {
              for (var r in e) Object.prototype.hasOwnProperty.call(e, r) && (t[r] = e[r]);
            })(t, e);
          }, function (t, e) {
            function r() {
              this.constructor = t;
            }
            _i(t, e), t.prototype = null === e ? Object.create(e) : (r.prototype = e.prototype, new r());
          }),
          s = /^\w[\w\d+.-]*$/,
          f = /^\//,
          u = /^\/\//,
          c = "",
          l = "/",
          p = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/,
          g = function () {
            function t(t, e, r, n, o, i) {
              void 0 === i && (i = !1), "object" == typeof_default()(t) ? (this.scheme = t.scheme || c, this.authority = t.authority || c, this.path = t.path || c, this.query = t.query || c, this.fragment = t.fragment || c) : (this.scheme = function (t, e) {
                return t || e ? t : "file";
              }(t, i), this.authority = e || c, this.path = function (t, e) {
                switch (t) {
                  case "https":
                  case "http":
                  case "file":
                    e ? e[0] !== l && (e = l + e) : e = l;
                }
                return e;
              }(this.scheme, r || c), this.query = n || c, this.fragment = o || c, function (t, e) {
                if (!t.scheme && e) throw new Error('[UriError]: Scheme is missing: {scheme: "", authority: "' + t.authority + '", path: "' + t.path + '", query: "' + t.query + '", fragment: "' + t.fragment + '"}');
                if (t.scheme && !s.test(t.scheme)) throw new Error("[UriError]: Scheme contains illegal characters.");
                if (t.path) if (t.authority) {
                  if (!f.test(t.path)) throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character');
                } else if (u.test(t.path)) throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
              }(this, i));
            }
            return t.isUri = function (e) {
              return e instanceof t || !!e && "string" == typeof e.authority && "string" == typeof e.fragment && "string" == typeof e.path && "string" == typeof e.query && "string" == typeof e.scheme && "function" == typeof e.fsPath && "function" == typeof e["with"] && "function" == typeof e.toString;
            }, Object.defineProperty(t.prototype, "fsPath", {
              get: function get() {
                return C(this, !1);
              },
              enumerable: !1,
              configurable: !0
            }), t.prototype["with"] = function (t) {
              if (!t) return this;
              var e = t.scheme,
                r = t.authority,
                n = t.path,
                o = t.query,
                i = t.fragment;
              return void 0 === e ? e = this.scheme : null === e && (e = c), void 0 === r ? r = this.authority : null === r && (r = c), void 0 === n ? n = this.path : null === n && (n = c), void 0 === o ? o = this.query : null === o && (o = c), void 0 === i ? i = this.fragment : null === i && (i = c), e === this.scheme && r === this.authority && n === this.path && o === this.query && i === this.fragment ? this : new v(e, r, n, o, i);
            }, t.parse = function (t, e) {
              void 0 === e && (e = !1);
              var r = p.exec(t);
              return r ? new v(r[2] || c, x(r[4] || c), x(r[5] || c), x(r[7] || c), x(r[9] || c), e) : new v(c, c, c, c, c);
            }, t.file = function (t) {
              var e = c;
              if (n && (t = t.replace(/\\/g, l)), t[0] === l && t[1] === l) {
                var r = t.indexOf(l, 2);
                -1 === r ? (e = t.substring(2), t = l) : (e = t.substring(2, r), t = t.substring(r) || l);
              }
              return new v("file", e, t, c, c);
            }, t.from = function (t) {
              return new v(t.scheme, t.authority, t.path, t.query, t.fragment);
            }, t.prototype.toString = function (t) {
              return void 0 === t && (t = !1), A(this, t);
            }, t.prototype.toJSON = function () {
              return this;
            }, t.revive = function (e) {
              if (e) {
                if (e instanceof t) return e;
                var r = new v(e);
                return r._formatted = e.external, r._fsPath = e._sep === d ? e.fsPath : null, r;
              }
              return e;
            }, t;
          }(),
          d = n ? 1 : void 0,
          v = function (t) {
            function e() {
              var e = null !== t && t.apply(this, arguments) || this;
              return e._formatted = null, e._fsPath = null, e;
            }
            return h(e, t), Object.defineProperty(e.prototype, "fsPath", {
              get: function get() {
                return this._fsPath || (this._fsPath = C(this, !1)), this._fsPath;
              },
              enumerable: !1,
              configurable: !0
            }), e.prototype.toString = function (t) {
              return void 0 === t && (t = !1), t ? A(this, !0) : (this._formatted || (this._formatted = A(this, !1)), this._formatted);
            }, e.prototype.toJSON = function () {
              var t = {
                $mid: 1
              };
              return this._fsPath && (t.fsPath = this._fsPath, t._sep = d), this._formatted && (t.external = this._formatted), this.path && (t.path = this.path), this.scheme && (t.scheme = this.scheme), this.authority && (t.authority = this.authority), this.query && (t.query = this.query), this.fragment && (t.fragment = this.fragment), t;
            }, e;
          }(g),
          m = ((a = {})[58] = "%3A", a[47] = "%2F", a[63] = "%3F", a[35] = "%23", a[91] = "%5B", a[93] = "%5D", a[64] = "%40", a[33] = "%21", a[36] = "%24", a[38] = "%26", a[39] = "%27", a[40] = "%28", a[41] = "%29", a[42] = "%2A", a[43] = "%2B", a[44] = "%2C", a[59] = "%3B", a[61] = "%3D", a[32] = "%20", a);
        function y(t, e) {
          for (var r = void 0, n = -1, o = 0; o < t.length; o++) {
            var i = t.charCodeAt(o);
            if (i >= 97 && i <= 122 || i >= 65 && i <= 90 || i >= 48 && i <= 57 || 45 === i || 46 === i || 95 === i || 126 === i || e && 47 === i) -1 !== n && (r += encodeURIComponent(t.substring(n, o)), n = -1), void 0 !== r && (r += t.charAt(o));else {
              void 0 === r && (r = t.substr(0, o));
              var a = m[i];
              void 0 !== a ? (-1 !== n && (r += encodeURIComponent(t.substring(n, o)), n = -1), r += a) : -1 === n && (n = o);
            }
          }
          return -1 !== n && (r += encodeURIComponent(t.substring(n))), void 0 !== r ? r : t;
        }
        function b(t) {
          for (var e = void 0, r = 0; r < t.length; r++) {
            var n = t.charCodeAt(r);
            35 === n || 63 === n ? (void 0 === e && (e = t.substr(0, r)), e += m[n]) : void 0 !== e && (e += t[r]);
          }
          return void 0 !== e ? e : t;
        }
        function C(t, e) {
          var r;
          return r = t.authority && t.path.length > 1 && "file" === t.scheme ? "//" + t.authority + t.path : 47 === t.path.charCodeAt(0) && (t.path.charCodeAt(1) >= 65 && t.path.charCodeAt(1) <= 90 || t.path.charCodeAt(1) >= 97 && t.path.charCodeAt(1) <= 122) && 58 === t.path.charCodeAt(2) ? e ? t.path.substr(1) : t.path[1].toLowerCase() + t.path.substr(2) : t.path, n && (r = r.replace(/\//g, "\\")), r;
        }
        function A(t, e) {
          var r = e ? b : y,
            n = "",
            o = t.scheme,
            i = t.authority,
            a = t.path,
            h = t.query,
            s = t.fragment;
          if (o && (n += o, n += ":"), (i || "file" === o) && (n += l, n += l), i) {
            var f = i.indexOf("@");
            if (-1 !== f) {
              var u = i.substr(0, f);
              i = i.substr(f + 1), -1 === (f = u.indexOf(":")) ? n += r(u, !1) : (n += r(u.substr(0, f), !1), n += ":", n += r(u.substr(f + 1), !1)), n += "@";
            }
            -1 === (f = (i = i.toLowerCase()).indexOf(":")) ? n += r(i, !1) : (n += r(i.substr(0, f), !1), n += i.substr(f));
          }
          if (a) {
            if (a.length >= 3 && 47 === a.charCodeAt(0) && 58 === a.charCodeAt(2)) (c = a.charCodeAt(1)) >= 65 && c <= 90 && (a = "/" + String.fromCharCode(c + 32) + ":" + a.substr(3));else if (a.length >= 2 && 58 === a.charCodeAt(1)) {
              var c;
              (c = a.charCodeAt(0)) >= 65 && c <= 90 && (a = String.fromCharCode(c + 32) + ":" + a.substr(2));
            }
            n += r(a, !0);
          }
          return h && (n += "?", n += r(h, !1)), s && (n += "#", n += e ? s : y(s, !1)), n;
        }
        function w(t) {
          try {
            return decodeURIComponent(t);
          } catch (e) {
            return t.length > 3 ? t.substr(0, 3) + w(t.substr(3)) : t;
          }
        }
        var _ = /(%[0-9A-Za-z][0-9A-Za-z])+/g;
        function x(t) {
          return t.match(_) ? t.replace(_, function (t) {
            return w(t);
          }) : t;
        }
        var O,
          P = r(470),
          j = function j() {
            for (var t = 0, e = 0, r = arguments.length; e < r; e++) t += arguments[e].length;
            var n = Array(t),
              o = 0;
            for (e = 0; e < r; e++) for (var i = arguments[e], a = 0, h = i.length; a < h; a++, o++) n[o] = i[a];
            return n;
          },
          U = P.posix || P;
        !function (t) {
          t.joinPath = function (t) {
            for (var e = [], r = 1; r < arguments.length; r++) e[r - 1] = arguments[r];
            return t["with"]({
              path: U.join.apply(U, j([t.path], e))
            });
          }, t.resolvePath = function (t) {
            for (var e = [], r = 1; r < arguments.length; r++) e[r - 1] = arguments[r];
            var n = t.path || "/";
            return t["with"]({
              path: U.resolve.apply(U, j([n], e))
            });
          }, t.dirname = function (t) {
            var e = U.dirname(t.path);
            return 1 === e.length && 46 === e.charCodeAt(0) ? t : t["with"]({
              path: e
            });
          }, t.basename = function (t) {
            return U.basename(t.path);
          }, t.extname = function (t) {
            return U.extname(t.path);
          };
        }(O || (O = {}));
      }
    },
    e = {};
  function r(n) {
    if (e[n]) return e[n].exports;
    var o = e[n] = {
      exports: {}
    };
    return t[n](o, o.exports, r), o.exports;
  }
  return r.d = function (t, e) {
    for (var n in e) r.o(e, n) && !r.o(t, n) && Object.defineProperty(t, n, {
      enumerable: !0,
      get: e[n]
    });
  }, r.o = function (t, e) {
    return Object.prototype.hasOwnProperty.call(t, e);
  }, r.r = function (t) {
    "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, {
      value: "Module"
    }), Object.defineProperty(t, "__esModule", {
      value: !0
    });
  }, r(447);
}();
var _LIB = LIB,
  vscode_uri_URI = _LIB.URI,
  Utils = _LIB.Utils;

;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/glob.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Copyright (c) 2013, Nick Fitzgerald
 *  Licensed under the MIT License. See LICENCE.md in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function createRegex(glob, opts) {
  if (typeof glob !== 'string') {
    throw new TypeError('Expected a string');
  }
  var str = String(glob);
  // The regexp we are building, as a string.
  var reStr = "";
  // Whether we are matching so called "extended" globs (like bash) and should
  // support single character matching, matching ranges of characters, group
  // matching, etc.
  var extended = opts ? !!opts.extended : false;
  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
  // When globstar is _true_, '/foo/*' is translated to regexp like
  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
  // which does not have a '/' to the right of it.
  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
  // globstar is _false_
  var globstar = opts ? !!opts.globstar : false;
  // If we are doing extended matching, this boolean is true when we are inside
  // a group (eg {*.html,*.js}), and false otherwise.
  var inGroup = false;
  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
  var flags = opts && typeof opts.flags === "string" ? opts.flags : "";
  var c;
  for (var i = 0, len = str.length; i < len; i++) {
    c = str[i];
    switch (c) {
      case "/":
      case "$":
      case "^":
      case "+":
      case ".":
      case "(":
      case ")":
      case "=":
      case "!":
      case "|":
        reStr += "\\" + c;
        break;
      case "?":
        if (extended) {
          reStr += ".";
          break;
        }
      case "[":
      case "]":
        if (extended) {
          reStr += c;
          break;
        }
      case "{":
        if (extended) {
          inGroup = true;
          reStr += "(";
          break;
        }
      case "}":
        if (extended) {
          inGroup = false;
          reStr += ")";
          break;
        }
      case ",":
        if (inGroup) {
          reStr += "|";
          break;
        }
        reStr += "\\" + c;
        break;
      case "*":
        // Move over all consecutive "*"'s.
        // Also store the previous and next characters
        var prevChar = str[i - 1];
        var starCount = 1;
        while (str[i + 1] === "*") {
          starCount++;
          i++;
        }
        var nextChar = str[i + 1];
        if (!globstar) {
          // globstar is disabled, so treat any number of "*" as one
          reStr += ".*";
        } else {
          // globstar is enabled, so determine if this is a globstar segment
          var isGlobstar = starCount > 1 // multiple "*"'s
          && (prevChar === "/" || prevChar === undefined || prevChar === '{' || prevChar === ',') // from the start of the segment
          && (nextChar === "/" || nextChar === undefined || nextChar === ',' || nextChar === '}'); // to the end of the segment
          if (isGlobstar) {
            if (nextChar === "/") {
              i++; // move over the "/"
            } else if (prevChar === '/' && reStr.endsWith('\\/')) {
              reStr = reStr.substr(0, reStr.length - 2);
            }
            // it's a globstar, so match zero or more path segments
            reStr += "((?:[^/]*(?:\/|$))*)";
          } else {
            // it's not a globstar, so only match one path segment
            reStr += "([^/]*)";
          }
        }
        break;
      default:
        reStr += c;
    }
  }
  // When regexp 'g' flag is specified don't
  // constrain the regular expression with ^ & $
  if (!flags || !~flags.indexOf('g')) {
    reStr = "^" + reStr + "$";
  }
  return new RegExp(reStr, flags);
}
;
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonSchemaService.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/






var jsonSchemaService_localize = loadMessageBundle();
var BANG = '!';
var PATH_SEP = '/';
var FilePatternAssociation = /** @class */function () {
  function FilePatternAssociation(pattern, uris) {
    this.globWrappers = [];
    try {
      for (var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++) {
        var patternString = pattern_1[_i];
        var include = patternString[0] !== BANG;
        if (!include) {
          patternString = patternString.substring(1);
        }
        if (patternString.length > 0) {
          if (patternString[0] === PATH_SEP) {
            patternString = patternString.substring(1);
          }
          this.globWrappers.push({
            regexp: createRegex('**/' + patternString, {
              extended: true,
              globstar: true
            }),
            include: include
          });
        }
      }
      ;
      this.uris = uris;
    } catch (e) {
      this.globWrappers.length = 0;
      this.uris = [];
    }
  }
  FilePatternAssociation.prototype.matchesPattern = function (fileName) {
    var match = false;
    for (var _i = 0, _a = this.globWrappers; _i < _a.length; _i++) {
      var _b = _a[_i],
        regexp = _b.regexp,
        include = _b.include;
      if (regexp.test(fileName)) {
        match = include;
      }
    }
    return match;
  };
  FilePatternAssociation.prototype.getURIs = function () {
    return this.uris;
  };
  return FilePatternAssociation;
}();
var SchemaHandle = /** @class */function () {
  function SchemaHandle(service, url, unresolvedSchemaContent) {
    this.service = service;
    this.url = url;
    this.dependencies = {};
    if (unresolvedSchemaContent) {
      this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));
    }
  }
  SchemaHandle.prototype.getUnresolvedSchema = function () {
    if (!this.unresolvedSchema) {
      this.unresolvedSchema = this.service.loadSchema(this.url);
    }
    return this.unresolvedSchema;
  };
  SchemaHandle.prototype.getResolvedSchema = function () {
    var _this = this;
    if (!this.resolvedSchema) {
      this.resolvedSchema = this.getUnresolvedSchema().then(function (unresolved) {
        return _this.service.resolveSchemaContent(unresolved, _this.url, _this.dependencies);
      });
    }
    return this.resolvedSchema;
  };
  SchemaHandle.prototype.clearSchema = function () {
    this.resolvedSchema = undefined;
    this.unresolvedSchema = undefined;
    this.dependencies = {};
  };
  return SchemaHandle;
}();
var UnresolvedSchema = /** @class */function () {
  function UnresolvedSchema(schema, errors) {
    if (errors === void 0) {
      errors = [];
    }
    this.schema = schema;
    this.errors = errors;
  }
  return UnresolvedSchema;
}();

var ResolvedSchema = /** @class */function () {
  function ResolvedSchema(schema, errors) {
    if (errors === void 0) {
      errors = [];
    }
    this.schema = schema;
    this.errors = errors;
  }
  ResolvedSchema.prototype.getSection = function (path) {
    var schemaRef = this.getSectionRecursive(path, this.schema);
    if (schemaRef) {
      return asSchema(schemaRef);
    }
    return undefined;
  };
  ResolvedSchema.prototype.getSectionRecursive = function (path, schema) {
    if (!schema || typeof schema === 'boolean' || path.length === 0) {
      return schema;
    }
    var next = path.shift();
    if (schema.properties && typeof_default()(schema.properties[next])) {
      return this.getSectionRecursive(path, schema.properties[next]);
    } else if (schema.patternProperties) {
      for (var _i = 0, _a = Object.keys(schema.patternProperties); _i < _a.length; _i++) {
        var pattern = _a[_i];
        var regex = extendedRegExp(pattern);
        if (regex.test(next)) {
          return this.getSectionRecursive(path, schema.patternProperties[pattern]);
        }
      }
    } else if (typeof_default()(schema.additionalProperties) === 'object') {
      return this.getSectionRecursive(path, schema.additionalProperties);
    } else if (next.match('[0-9]+')) {
      if (Array.isArray(schema.items)) {
        var index = parseInt(next, 10);
        if (!isNaN(index) && schema.items[index]) {
          return this.getSectionRecursive(path, schema.items[index]);
        }
      } else if (schema.items) {
        return this.getSectionRecursive(path, schema.items);
      }
    }
    return undefined;
  };
  return ResolvedSchema;
}();

var JSONSchemaService = /** @class */function () {
  function JSONSchemaService(requestService, contextService, promiseConstructor) {
    this.contextService = contextService;
    this.requestService = requestService;
    this.promiseConstructor = promiseConstructor || Promise;
    this.callOnDispose = [];
    this.contributionSchemas = {};
    this.contributionAssociations = [];
    this.schemasById = {};
    this.filePatternAssociations = [];
    this.registeredSchemasIds = {};
  }
  JSONSchemaService.prototype.getRegisteredSchemaIds = function (filter) {
    return Object.keys(this.registeredSchemasIds).filter(function (id) {
      var scheme = vscode_uri_URI.parse(id).scheme;
      return scheme !== 'schemaservice' && (!filter || filter(scheme));
    });
  };
  Object.defineProperty(JSONSchemaService.prototype, "promise", {
    get: function get() {
      return this.promiseConstructor;
    },
    enumerable: false,
    configurable: true
  });
  JSONSchemaService.prototype.dispose = function () {
    while (this.callOnDispose.length > 0) {
      this.callOnDispose.pop()();
    }
  };
  JSONSchemaService.prototype.onResourceChange = function (uri) {
    var _this = this;
    // always clear this local cache when a resource changes
    this.cachedSchemaForResource = undefined;
    var hasChanges = false;
    uri = normalizeId(uri);
    var toWalk = [uri];
    var all = Object.keys(this.schemasById).map(function (key) {
      return _this.schemasById[key];
    });
    while (toWalk.length) {
      var curr = toWalk.pop();
      for (var i = 0; i < all.length; i++) {
        var handle = all[i];
        if (handle && (handle.url === curr || handle.dependencies[curr])) {
          if (handle.url !== curr) {
            toWalk.push(handle.url);
          }
          handle.clearSchema();
          all[i] = undefined;
          hasChanges = true;
        }
      }
    }
    return hasChanges;
  };
  JSONSchemaService.prototype.setSchemaContributions = function (schemaContributions) {
    if (schemaContributions.schemas) {
      var schemas = schemaContributions.schemas;
      for (var id in schemas) {
        var normalizedId = normalizeId(id);
        this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas[id]);
      }
    }
    if (Array.isArray(schemaContributions.schemaAssociations)) {
      var schemaAssociations = schemaContributions.schemaAssociations;
      for (var _i = 0, schemaAssociations_1 = schemaAssociations; _i < schemaAssociations_1.length; _i++) {
        var schemaAssociation = schemaAssociations_1[_i];
        var uris = schemaAssociation.uris.map(normalizeId);
        var association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
        this.contributionAssociations.push(association);
      }
    }
  };
  JSONSchemaService.prototype.addSchemaHandle = function (id, unresolvedSchemaContent) {
    var schemaHandle = new SchemaHandle(this, id, unresolvedSchemaContent);
    this.schemasById[id] = schemaHandle;
    return schemaHandle;
  };
  JSONSchemaService.prototype.getOrAddSchemaHandle = function (id, unresolvedSchemaContent) {
    return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);
  };
  JSONSchemaService.prototype.addFilePatternAssociation = function (pattern, uris) {
    var fpa = new FilePatternAssociation(pattern, uris);
    this.filePatternAssociations.push(fpa);
    return fpa;
  };
  JSONSchemaService.prototype.registerExternalSchema = function (uri, filePatterns, unresolvedSchemaContent) {
    var id = normalizeId(uri);
    this.registeredSchemasIds[id] = true;
    this.cachedSchemaForResource = undefined;
    if (filePatterns) {
      this.addFilePatternAssociation(filePatterns, [id]);
    }
    return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);
  };
  JSONSchemaService.prototype.clearExternalSchemas = function () {
    this.schemasById = {};
    this.filePatternAssociations = [];
    this.registeredSchemasIds = {};
    this.cachedSchemaForResource = undefined;
    for (var id in this.contributionSchemas) {
      this.schemasById[id] = this.contributionSchemas[id];
      this.registeredSchemasIds[id] = true;
    }
    for (var _i = 0, _a = this.contributionAssociations; _i < _a.length; _i++) {
      var contributionAssociation = _a[_i];
      this.filePatternAssociations.push(contributionAssociation);
    }
  };
  JSONSchemaService.prototype.getResolvedSchema = function (schemaId) {
    var id = normalizeId(schemaId);
    var schemaHandle = this.schemasById[id];
    if (schemaHandle) {
      return schemaHandle.getResolvedSchema();
    }
    return this.promise.resolve(undefined);
  };
  JSONSchemaService.prototype.loadSchema = function (url) {
    if (!this.requestService) {
      var errorMessage = jsonSchemaService_localize('json.schema.norequestservice', 'Unable to load schema from \'{0}\'. No schema request service available', toDisplayString(url));
      return this.promise.resolve(new UnresolvedSchema({}, [errorMessage]));
    }
    return this.requestService(url).then(function (content) {
      if (!content) {
        var errorMessage = jsonSchemaService_localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': No content.', toDisplayString(url));
        return new UnresolvedSchema({}, [errorMessage]);
      }
      var schemaContent = {};
      var jsonErrors = [];
      schemaContent = main_parse(content, jsonErrors);
      var errors = jsonErrors.length ? [jsonSchemaService_localize('json.schema.invalidFormat', 'Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset)] : [];
      return new UnresolvedSchema(schemaContent, errors);
    }, function (error) {
      var errorMessage = error.toString();
      var errorSplit = error.toString().split('Error: ');
      if (errorSplit.length > 1) {
        // more concise error message, URL and context are attached by caller anyways
        errorMessage = errorSplit[1];
      }
      if (endsWith(errorMessage, '.')) {
        errorMessage = errorMessage.substr(0, errorMessage.length - 1);
      }
      return new UnresolvedSchema({}, [jsonSchemaService_localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': {1}.', toDisplayString(url), errorMessage)]);
    });
  };
  JSONSchemaService.prototype.resolveSchemaContent = function (schemaToResolve, schemaURL, dependencies) {
    var _this = this;
    var resolveErrors = schemaToResolve.errors.slice(0);
    var schema = schemaToResolve.schema;
    if (schema.$schema) {
      var id = normalizeId(schema.$schema);
      if (id === 'http://json-schema.org/draft-03/schema') {
        return this.promise.resolve(new ResolvedSchema({}, [jsonSchemaService_localize('json.schema.draft03.notsupported', "Draft-03 schemas are not supported.")]));
      } else if (id === 'https://json-schema.org/draft/2019-09/schema') {
        resolveErrors.push(jsonSchemaService_localize('json.schema.draft201909.notsupported', "Draft 2019-09 schemas are not yet fully supported."));
      }
    }
    var contextService = this.contextService;
    var findSection = function findSection(schema, path) {
      if (!path) {
        return schema;
      }
      var current = schema;
      if (path[0] === '/') {
        path = path.substr(1);
      }
      path.split('/').some(function (part) {
        part = part.replace(/~1/g, '/').replace(/~0/g, '~');
        current = current[part];
        return !current;
      });
      return current;
    };
    var merge = function merge(target, sourceRoot, sourceURI, refSegment) {
      var path = refSegment ? decodeURIComponent(refSegment) : undefined;
      var section = findSection(sourceRoot, path);
      if (section) {
        for (var key in section) {
          if (section.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
            target[key] = section[key];
          }
        }
      } else {
        resolveErrors.push(jsonSchemaService_localize('json.schema.invalidref', '$ref \'{0}\' in \'{1}\' can not be resolved.', path, sourceURI));
      }
    };
    var resolveExternalLink = function resolveExternalLink(node, uri, refSegment, parentSchemaURL, parentSchemaDependencies) {
      if (contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/\/.*/.test(uri)) {
        uri = contextService.resolveRelativePath(uri, parentSchemaURL);
      }
      uri = normalizeId(uri);
      var referencedHandle = _this.getOrAddSchemaHandle(uri);
      return referencedHandle.getUnresolvedSchema().then(function (unresolvedSchema) {
        parentSchemaDependencies[uri] = true;
        if (unresolvedSchema.errors.length) {
          var loc = refSegment ? uri + '#' + refSegment : uri;
          resolveErrors.push(jsonSchemaService_localize('json.schema.problemloadingref', 'Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0]));
        }
        merge(node, unresolvedSchema.schema, uri, refSegment);
        return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
      });
    };
    var resolveRefs = function resolveRefs(node, parentSchema, parentSchemaURL, parentSchemaDependencies) {
      if (!node || typeof_default()(node) !== 'object') {
        return Promise.resolve(null);
      }
      var toWalk = [node];
      var seen = [];
      var openPromises = [];
      var collectEntries = function collectEntries() {
        var entries = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          entries[_i] = arguments[_i];
        }
        for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {
          var entry = entries_1[_a];
          if (typeof_default()(entry) === 'object') {
            toWalk.push(entry);
          }
        }
      };
      var collectMapEntries = function collectMapEntries() {
        var maps = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          maps[_i] = arguments[_i];
        }
        for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {
          var map = maps_1[_a];
          if (typeof_default()(map) === 'object') {
            for (var k in map) {
              var key = k;
              var entry = map[key];
              if (typeof_default()(entry) === 'object') {
                toWalk.push(entry);
              }
            }
          }
        }
      };
      var collectArrayEntries = function collectArrayEntries() {
        var arrays = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          arrays[_i] = arguments[_i];
        }
        for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {
          var array = arrays_1[_a];
          if (Array.isArray(array)) {
            for (var _b = 0, array_1 = array; _b < array_1.length; _b++) {
              var entry = array_1[_b];
              if (typeof_default()(entry) === 'object') {
                toWalk.push(entry);
              }
            }
          }
        }
      };
      var handleRef = function handleRef(next) {
        var seenRefs = [];
        while (next.$ref) {
          var ref = next.$ref;
          var segments = ref.split('#', 2);
          delete next.$ref;
          if (segments[0].length > 0) {
            openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
            return;
          } else {
            if (seenRefs.indexOf(ref) === -1) {
              merge(next, parentSchema, parentSchemaURL, segments[1]); // can set next.$ref again, use seenRefs to avoid circle
              seenRefs.push(ref);
            }
          }
        }
        collectEntries(next.items, next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next["if"], next.then, next["else"]);
        collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);
        collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items);
      };
      while (toWalk.length) {
        var next = toWalk.pop();
        if (seen.indexOf(next) >= 0) {
          continue;
        }
        seen.push(next);
        handleRef(next);
      }
      return _this.promise.all(openPromises);
    };
    return resolveRefs(schema, schema, schemaURL, dependencies).then(function (_) {
      return new ResolvedSchema(schema, resolveErrors);
    });
  };
  JSONSchemaService.prototype.getSchemaForResource = function (resource, document) {
    // first use $schema if present
    if (document && document.root && document.root.type === 'object') {
      var schemaProperties = document.root.properties.filter(function (p) {
        return p.keyNode.value === '$schema' && p.valueNode && p.valueNode.type === 'string';
      });
      if (schemaProperties.length > 0) {
        var valueNode = schemaProperties[0].valueNode;
        if (valueNode && valueNode.type === 'string') {
          var schemeId = jsonParser_getNodeValue(valueNode);
          if (schemeId && startsWith(schemeId, '.') && this.contextService) {
            schemeId = this.contextService.resolveRelativePath(schemeId, resource);
          }
          if (schemeId) {
            var id = normalizeId(schemeId);
            return this.getOrAddSchemaHandle(id).getResolvedSchema();
          }
        }
      }
    }
    if (this.cachedSchemaForResource && this.cachedSchemaForResource.resource === resource) {
      return this.cachedSchemaForResource.resolvedSchema;
    }
    var seen = Object.create(null);
    var schemas = [];
    var normalizedResource = normalizeResourceForMatching(resource);
    for (var _i = 0, _a = this.filePatternAssociations; _i < _a.length; _i++) {
      var entry = _a[_i];
      if (entry.matchesPattern(normalizedResource)) {
        for (var _b = 0, _c = entry.getURIs(); _b < _c.length; _b++) {
          var schemaId = _c[_b];
          if (!seen[schemaId]) {
            schemas.push(schemaId);
            seen[schemaId] = true;
          }
        }
      }
    }
    var resolvedSchema = schemas.length > 0 ? this.createCombinedSchema(resource, schemas).getResolvedSchema() : this.promise.resolve(undefined);
    this.cachedSchemaForResource = {
      resource: resource,
      resolvedSchema: resolvedSchema
    };
    return resolvedSchema;
  };
  JSONSchemaService.prototype.createCombinedSchema = function (resource, schemaIds) {
    if (schemaIds.length === 1) {
      return this.getOrAddSchemaHandle(schemaIds[0]);
    } else {
      var combinedSchemaId = 'schemaservice://combinedSchema/' + encodeURIComponent(resource);
      var combinedSchema = {
        allOf: schemaIds.map(function (schemaId) {
          return {
            $ref: schemaId
          };
        })
      };
      return this.addSchemaHandle(combinedSchemaId, combinedSchema);
    }
  };
  JSONSchemaService.prototype.getMatchingSchemas = function (document, jsonDocument, schema) {
    if (schema) {
      var id = schema.id || 'schemaservice://untitled/matchingSchemas/' + idCounter++;
      return this.resolveSchemaContent(new UnresolvedSchema(schema), id, {}).then(function (resolvedSchema) {
        return jsonDocument.getMatchingSchemas(resolvedSchema.schema).filter(function (s) {
          return !s.inverted;
        });
      });
    }
    return this.getSchemaForResource(document.uri, jsonDocument).then(function (schema) {
      if (schema) {
        return jsonDocument.getMatchingSchemas(schema.schema).filter(function (s) {
          return !s.inverted;
        });
      }
      return [];
    });
  };
  return JSONSchemaService;
}();

var idCounter = 0;
function normalizeId(id) {
  // remove trailing '#', normalize drive capitalization
  try {
    return vscode_uri_URI.parse(id).toString();
  } catch (e) {
    return id;
  }
}
function normalizeResourceForMatching(resource) {
  // remove queries and fragments, normalize drive capitalization
  try {
    return vscode_uri_URI.parse(resource)["with"]({
      fragment: null,
      query: null
    }).toString();
  } catch (e) {
    return resource;
  }
}
function toDisplayString(url) {
  try {
    var uri = vscode_uri_URI.parse(url);
    if (uri.scheme === 'file') {
      return uri.fsPath;
    }
  } catch (e) {
    // ignore
  }
  return url;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonValidation.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/




var jsonValidation_localize = loadMessageBundle();
var JSONValidation = /** @class */function () {
  function JSONValidation(jsonSchemaService, promiseConstructor) {
    this.jsonSchemaService = jsonSchemaService;
    this.promise = promiseConstructor;
    this.validationEnabled = true;
  }
  JSONValidation.prototype.configure = function (raw) {
    if (raw) {
      this.validationEnabled = raw.validate !== false;
      this.commentSeverity = raw.allowComments ? undefined : DiagnosticSeverity.Error;
    }
  };
  JSONValidation.prototype.doValidation = function (textDocument, jsonDocument, documentSettings, schema) {
    var _this = this;
    if (!this.validationEnabled) {
      return this.promise.resolve([]);
    }
    var diagnostics = [];
    var added = {};
    var addProblem = function addProblem(problem) {
      // remove duplicated messages
      var signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
      if (!added[signature]) {
        added[signature] = true;
        diagnostics.push(problem);
      }
    };
    var getDiagnostics = function getDiagnostics(schema) {
      var trailingCommaSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.trailingCommas) ? toDiagnosticSeverity(documentSettings.trailingCommas) : DiagnosticSeverity.Error;
      var commentSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.comments) ? toDiagnosticSeverity(documentSettings.comments) : _this.commentSeverity;
      var schemaValidation = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaValidation) ? toDiagnosticSeverity(documentSettings.schemaValidation) : DiagnosticSeverity.Warning;
      var schemaRequest = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaRequest) ? toDiagnosticSeverity(documentSettings.schemaRequest) : DiagnosticSeverity.Warning;
      if (schema) {
        if (schema.errors.length && jsonDocument.root && schemaRequest) {
          var astRoot = jsonDocument.root;
          var property = astRoot.type === 'object' ? astRoot.properties[0] : undefined;
          if (property && property.keyNode.value === '$schema') {
            var node = property.valueNode || property;
            var range = main_Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
            addProblem(Diagnostic.create(range, schema.errors[0], schemaRequest, ErrorCode.SchemaResolveError));
          } else {
            var range = main_Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
            addProblem(Diagnostic.create(range, schema.errors[0], schemaRequest, ErrorCode.SchemaResolveError));
          }
        } else if (schemaValidation) {
          var semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation);
          if (semanticErrors) {
            semanticErrors.forEach(addProblem);
          }
        }
        if (schemaAllowsComments(schema.schema)) {
          commentSeverity = undefined;
        }
        if (schemaAllowsTrailingCommas(schema.schema)) {
          trailingCommaSeverity = undefined;
        }
      }
      for (var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++) {
        var p = _a[_i];
        if (p.code === ErrorCode.TrailingComma) {
          if (typeof trailingCommaSeverity !== 'number') {
            continue;
          }
          p.severity = trailingCommaSeverity;
        }
        addProblem(p);
      }
      if (typeof commentSeverity === 'number') {
        var message_1 = jsonValidation_localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
        jsonDocument.comments.forEach(function (c) {
          addProblem(Diagnostic.create(c, message_1, commentSeverity, ErrorCode.CommentNotPermitted));
        });
      }
      return diagnostics;
    };
    if (schema) {
      var id = schema.id || 'schemaservice://untitled/' + jsonValidation_idCounter++;
      return this.jsonSchemaService.resolveSchemaContent(new UnresolvedSchema(schema), id, {}).then(function (resolvedSchema) {
        return getDiagnostics(resolvedSchema);
      });
    }
    return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function (schema) {
      return getDiagnostics(schema);
    });
  };
  return JSONValidation;
}();

var jsonValidation_idCounter = 0;
function schemaAllowsComments(schemaRef) {
  if (schemaRef && typeof_default()(schemaRef) === 'object') {
    if (objects_isBoolean(schemaRef.allowComments)) {
      return schemaRef.allowComments;
    }
    if (schemaRef.allOf) {
      for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
        var schema = _a[_i];
        var allow = schemaAllowsComments(schema);
        if (objects_isBoolean(allow)) {
          return allow;
        }
      }
    }
  }
  return undefined;
}
function schemaAllowsTrailingCommas(schemaRef) {
  if (schemaRef && typeof_default()(schemaRef) === 'object') {
    if (objects_isBoolean(schemaRef.allowTrailingCommas)) {
      return schemaRef.allowTrailingCommas;
    }
    var deprSchemaRef = schemaRef;
    if (objects_isBoolean(deprSchemaRef['allowsTrailingCommas'])) {
      // deprecated
      return deprSchemaRef['allowsTrailingCommas'];
    }
    if (schemaRef.allOf) {
      for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
        var schema = _a[_i];
        var allow = schemaAllowsTrailingCommas(schema);
        if (objects_isBoolean(allow)) {
          return allow;
        }
      }
    }
  }
  return undefined;
}
function toDiagnosticSeverity(severityLevel) {
  switch (severityLevel) {
    case 'error':
      return DiagnosticSeverity.Error;
    case 'warning':
      return DiagnosticSeverity.Warning;
    case 'ignore':
      return undefined;
  }
  return undefined;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/colors.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var Digit0 = 48;
var Digit9 = 57;
var A = 65;
var a = 97;
var f = 102;
function hexDigit(charCode) {
  if (charCode < Digit0) {
    return 0;
  }
  if (charCode <= Digit9) {
    return charCode - Digit0;
  }
  if (charCode < a) {
    charCode += a - A;
  }
  if (charCode >= a && charCode <= f) {
    return charCode - a + 10;
  }
  return 0;
}
function colorFromHex(text) {
  if (text[0] !== '#') {
    return undefined;
  }
  switch (text.length) {
    case 4:
      return {
        red: hexDigit(text.charCodeAt(1)) * 0x11 / 255.0,
        green: hexDigit(text.charCodeAt(2)) * 0x11 / 255.0,
        blue: hexDigit(text.charCodeAt(3)) * 0x11 / 255.0,
        alpha: 1
      };
    case 5:
      return {
        red: hexDigit(text.charCodeAt(1)) * 0x11 / 255.0,
        green: hexDigit(text.charCodeAt(2)) * 0x11 / 255.0,
        blue: hexDigit(text.charCodeAt(3)) * 0x11 / 255.0,
        alpha: hexDigit(text.charCodeAt(4)) * 0x11 / 255.0
      };
    case 7:
      return {
        red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
        green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
        blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
        alpha: 1
      };
    case 9:
      return {
        red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
        green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
        blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
        alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
      };
  }
  return undefined;
}
function colorFrom256RGB(red, green, blue, alpha) {
  if (alpha === void 0) {
    alpha = 1.0;
  }
  return {
    red: red / 255.0,
    green: green / 255.0,
    blue: blue / 255.0,
    alpha: alpha
  };
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonDocumentSymbols.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/




var JSONDocumentSymbols = /** @class */function () {
  function JSONDocumentSymbols(schemaService) {
    this.schemaService = schemaService;
  }
  JSONDocumentSymbols.prototype.findDocumentSymbols = function (document, doc, context) {
    var _this = this;
    if (context === void 0) {
      context = {
        resultLimit: Number.MAX_VALUE
      };
    }
    var root = doc.root;
    if (!root) {
      return [];
    }
    var limit = context.resultLimit || Number.MAX_VALUE;
    // special handling for key bindings
    var resourceString = document.uri;
    if (resourceString === 'vscode://defaultsettings/keybindings.json' || endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
      if (root.type === 'array') {
        var result_1 = [];
        for (var _i = 0, _a = root.items; _i < _a.length; _i++) {
          var item = _a[_i];
          if (item.type === 'object') {
            for (var _b = 0, _c = item.properties; _b < _c.length; _b++) {
              var property = _c[_b];
              if (property.keyNode.value === 'key' && property.valueNode) {
                var location = Location.create(document.uri, getRange(document, item));
                result_1.push({
                  name: jsonParser_getNodeValue(property.valueNode),
                  kind: main_SymbolKind.Function,
                  location: location
                });
                limit--;
                if (limit <= 0) {
                  if (context && context.onResultLimitExceeded) {
                    context.onResultLimitExceeded(resourceString);
                  }
                  return result_1;
                }
              }
            }
          }
        }
        return result_1;
      }
    }
    var toVisit = [{
      node: root,
      containerName: ''
    }];
    var nextToVisit = 0;
    var limitExceeded = false;
    var result = [];
    var collectOutlineEntries = function collectOutlineEntries(node, containerName) {
      if (node.type === 'array') {
        node.items.forEach(function (node) {
          if (node) {
            toVisit.push({
              node: node,
              containerName: containerName
            });
          }
        });
      } else if (node.type === 'object') {
        node.properties.forEach(function (property) {
          var valueNode = property.valueNode;
          if (valueNode) {
            if (limit > 0) {
              limit--;
              var location = Location.create(document.uri, getRange(document, property));
              var childContainerName = containerName ? containerName + '.' + property.keyNode.value : property.keyNode.value;
              result.push({
                name: _this.getKeyLabel(property),
                kind: _this.getSymbolKind(valueNode.type),
                location: location,
                containerName: containerName
              });
              toVisit.push({
                node: valueNode,
                containerName: childContainerName
              });
            } else {
              limitExceeded = true;
            }
          }
        });
      }
    };
    // breath first traversal
    while (nextToVisit < toVisit.length) {
      var next = toVisit[nextToVisit++];
      collectOutlineEntries(next.node, next.containerName);
    }
    if (limitExceeded && context && context.onResultLimitExceeded) {
      context.onResultLimitExceeded(resourceString);
    }
    return result;
  };
  JSONDocumentSymbols.prototype.findDocumentSymbols2 = function (document, doc, context) {
    var _this = this;
    if (context === void 0) {
      context = {
        resultLimit: Number.MAX_VALUE
      };
    }
    var root = doc.root;
    if (!root) {
      return [];
    }
    var limit = context.resultLimit || Number.MAX_VALUE;
    // special handling for key bindings
    var resourceString = document.uri;
    if (resourceString === 'vscode://defaultsettings/keybindings.json' || endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
      if (root.type === 'array') {
        var result_2 = [];
        for (var _i = 0, _a = root.items; _i < _a.length; _i++) {
          var item = _a[_i];
          if (item.type === 'object') {
            for (var _b = 0, _c = item.properties; _b < _c.length; _b++) {
              var property = _c[_b];
              if (property.keyNode.value === 'key' && property.valueNode) {
                var range = getRange(document, item);
                var selectionRange = getRange(document, property.keyNode);
                result_2.push({
                  name: jsonParser_getNodeValue(property.valueNode),
                  kind: main_SymbolKind.Function,
                  range: range,
                  selectionRange: selectionRange
                });
                limit--;
                if (limit <= 0) {
                  if (context && context.onResultLimitExceeded) {
                    context.onResultLimitExceeded(resourceString);
                  }
                  return result_2;
                }
              }
            }
          }
        }
        return result_2;
      }
    }
    var result = [];
    var toVisit = [{
      node: root,
      result: result
    }];
    var nextToVisit = 0;
    var limitExceeded = false;
    var collectOutlineEntries = function collectOutlineEntries(node, result) {
      if (node.type === 'array') {
        node.items.forEach(function (node, index) {
          if (node) {
            if (limit > 0) {
              limit--;
              var range = getRange(document, node);
              var selectionRange = range;
              var name = String(index);
              var symbol = {
                name: name,
                kind: _this.getSymbolKind(node.type),
                range: range,
                selectionRange: selectionRange,
                children: []
              };
              result.push(symbol);
              toVisit.push({
                result: symbol.children,
                node: node
              });
            } else {
              limitExceeded = true;
            }
          }
        });
      } else if (node.type === 'object') {
        node.properties.forEach(function (property) {
          var valueNode = property.valueNode;
          if (valueNode) {
            if (limit > 0) {
              limit--;
              var range = getRange(document, property);
              var selectionRange = getRange(document, property.keyNode);
              var children = [];
              var symbol = {
                name: _this.getKeyLabel(property),
                kind: _this.getSymbolKind(valueNode.type),
                range: range,
                selectionRange: selectionRange,
                children: children,
                detail: _this.getDetail(valueNode)
              };
              result.push(symbol);
              toVisit.push({
                result: children,
                node: valueNode
              });
            } else {
              limitExceeded = true;
            }
          }
        });
      }
    };
    // breath first traversal
    while (nextToVisit < toVisit.length) {
      var next = toVisit[nextToVisit++];
      collectOutlineEntries(next.node, next.result);
    }
    if (limitExceeded && context && context.onResultLimitExceeded) {
      context.onResultLimitExceeded(resourceString);
    }
    return result;
  };
  JSONDocumentSymbols.prototype.getSymbolKind = function (nodeType) {
    switch (nodeType) {
      case 'object':
        return main_SymbolKind.Module;
      case 'string':
        return main_SymbolKind.String;
      case 'number':
        return main_SymbolKind.Number;
      case 'array':
        return main_SymbolKind.Array;
      case 'boolean':
        return main_SymbolKind.Boolean;
      default:
        // 'null'
        return main_SymbolKind.Variable;
    }
  };
  JSONDocumentSymbols.prototype.getKeyLabel = function (property) {
    var name = property.keyNode.value;
    if (name) {
      name = name.replace(/[\n]/g, '↵');
    }
    if (name && name.trim()) {
      return name;
    }
    return "\"" + name + "\"";
  };
  JSONDocumentSymbols.prototype.getDetail = function (node) {
    if (!node) {
      return undefined;
    }
    if (node.type === 'boolean' || node.type === 'number' || node.type === 'null' || node.type === 'string') {
      return String(node.value);
    } else {
      if (node.type === 'array') {
        return node.children.length ? undefined : '[]';
      } else if (node.type === 'object') {
        return node.children.length ? undefined : '{}';
      }
    }
    return undefined;
  };
  JSONDocumentSymbols.prototype.findDocumentColors = function (document, doc, context) {
    return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
      var result = [];
      if (schema) {
        var limit = context && typeof context.resultLimit === 'number' ? context.resultLimit : Number.MAX_VALUE;
        var matchingSchemas = doc.getMatchingSchemas(schema.schema);
        var visitedNode = {};
        for (var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++) {
          var s = matchingSchemas_1[_i];
          if (!s.inverted && s.schema && (s.schema.format === 'color' || s.schema.format === 'color-hex') && s.node && s.node.type === 'string') {
            var nodeId = String(s.node.offset);
            if (!visitedNode[nodeId]) {
              var color = colorFromHex(jsonParser_getNodeValue(s.node));
              if (color) {
                var range = getRange(document, s.node);
                result.push({
                  color: color,
                  range: range
                });
              }
              visitedNode[nodeId] = true;
              limit--;
              if (limit <= 0) {
                if (context && context.onResultLimitExceeded) {
                  context.onResultLimitExceeded(document.uri);
                }
                return result;
              }
            }
          }
        }
      }
      return result;
    });
  };
  JSONDocumentSymbols.prototype.getColorPresentations = function (document, doc, color, range) {
    var result = [];
    var red256 = Math.round(color.red * 255),
      green256 = Math.round(color.green * 255),
      blue256 = Math.round(color.blue * 255);
    function toTwoDigitHex(n) {
      var r = n.toString(16);
      return r.length !== 2 ? '0' + r : r;
    }
    var label;
    if (color.alpha === 1) {
      label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256);
    } else {
      label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256) + toTwoDigitHex(Math.round(color.alpha * 255));
    }
    result.push({
      label: label,
      textEdit: TextEdit.replace(range, JSON.stringify(label))
    });
    return result;
  };
  return JSONDocumentSymbols;
}();

function getRange(document, node) {
  return main_Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/configuration.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

var configuration_localize = loadMessageBundle();
var schemaContributions = {
  schemaAssociations: [],
  schemas: {
    // refer to the latest schema
    'http://json-schema.org/schema#': {
      $ref: 'http://json-schema.org/draft-07/schema#'
    },
    // bundle the schema-schema to include (localized) descriptions
    'http://json-schema.org/draft-04/schema#': {
      '$schema': 'http://json-schema.org/draft-04/schema#',
      'definitions': {
        'schemaArray': {
          'type': 'array',
          'minItems': 1,
          'items': {
            '$ref': '#'
          }
        },
        'positiveInteger': {
          'type': 'integer',
          'minimum': 0
        },
        'positiveIntegerDefault0': {
          'allOf': [{
            '$ref': '#/definitions/positiveInteger'
          }, {
            'default': 0
          }]
        },
        'simpleTypes': {
          'type': 'string',
          'enum': ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string']
        },
        'stringArray': {
          'type': 'array',
          'items': {
            'type': 'string'
          },
          'minItems': 1,
          'uniqueItems': true
        }
      },
      'type': 'object',
      'properties': {
        'id': {
          'type': 'string',
          'format': 'uri'
        },
        '$schema': {
          'type': 'string',
          'format': 'uri'
        },
        'title': {
          'type': 'string'
        },
        'description': {
          'type': 'string'
        },
        'default': {},
        'multipleOf': {
          'type': 'number',
          'minimum': 0,
          'exclusiveMinimum': true
        },
        'maximum': {
          'type': 'number'
        },
        'exclusiveMaximum': {
          'type': 'boolean',
          'default': false
        },
        'minimum': {
          'type': 'number'
        },
        'exclusiveMinimum': {
          'type': 'boolean',
          'default': false
        },
        'maxLength': {
          'allOf': [{
            '$ref': '#/definitions/positiveInteger'
          }]
        },
        'minLength': {
          'allOf': [{
            '$ref': '#/definitions/positiveIntegerDefault0'
          }]
        },
        'pattern': {
          'type': 'string',
          'format': 'regex'
        },
        'additionalItems': {
          'anyOf': [{
            'type': 'boolean'
          }, {
            '$ref': '#'
          }],
          'default': {}
        },
        'items': {
          'anyOf': [{
            '$ref': '#'
          }, {
            '$ref': '#/definitions/schemaArray'
          }],
          'default': {}
        },
        'maxItems': {
          'allOf': [{
            '$ref': '#/definitions/positiveInteger'
          }]
        },
        'minItems': {
          'allOf': [{
            '$ref': '#/definitions/positiveIntegerDefault0'
          }]
        },
        'uniqueItems': {
          'type': 'boolean',
          'default': false
        },
        'maxProperties': {
          'allOf': [{
            '$ref': '#/definitions/positiveInteger'
          }]
        },
        'minProperties': {
          'allOf': [{
            '$ref': '#/definitions/positiveIntegerDefault0'
          }]
        },
        'required': {
          'allOf': [{
            '$ref': '#/definitions/stringArray'
          }]
        },
        'additionalProperties': {
          'anyOf': [{
            'type': 'boolean'
          }, {
            '$ref': '#'
          }],
          'default': {}
        },
        'definitions': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'default': {}
        },
        'properties': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'default': {}
        },
        'patternProperties': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'default': {}
        },
        'dependencies': {
          'type': 'object',
          'additionalProperties': {
            'anyOf': [{
              '$ref': '#'
            }, {
              '$ref': '#/definitions/stringArray'
            }]
          }
        },
        'enum': {
          'type': 'array',
          'minItems': 1,
          'uniqueItems': true
        },
        'type': {
          'anyOf': [{
            '$ref': '#/definitions/simpleTypes'
          }, {
            'type': 'array',
            'items': {
              '$ref': '#/definitions/simpleTypes'
            },
            'minItems': 1,
            'uniqueItems': true
          }]
        },
        'format': {
          'anyOf': [{
            'type': 'string',
            'enum': ['date-time', 'uri', 'email', 'hostname', 'ipv4', 'ipv6', 'regex']
          }, {
            'type': 'string'
          }]
        },
        'allOf': {
          'allOf': [{
            '$ref': '#/definitions/schemaArray'
          }]
        },
        'anyOf': {
          'allOf': [{
            '$ref': '#/definitions/schemaArray'
          }]
        },
        'oneOf': {
          'allOf': [{
            '$ref': '#/definitions/schemaArray'
          }]
        },
        'not': {
          'allOf': [{
            '$ref': '#'
          }]
        }
      },
      'dependencies': {
        'exclusiveMaximum': ['maximum'],
        'exclusiveMinimum': ['minimum']
      },
      'default': {}
    },
    'http://json-schema.org/draft-07/schema#': {
      'definitions': {
        'schemaArray': {
          'type': 'array',
          'minItems': 1,
          'items': {
            '$ref': '#'
          }
        },
        'nonNegativeInteger': {
          'type': 'integer',
          'minimum': 0
        },
        'nonNegativeIntegerDefault0': {
          'allOf': [{
            '$ref': '#/definitions/nonNegativeInteger'
          }, {
            'default': 0
          }]
        },
        'simpleTypes': {
          'enum': ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string']
        },
        'stringArray': {
          'type': 'array',
          'items': {
            'type': 'string'
          },
          'uniqueItems': true,
          'default': []
        }
      },
      'type': ['object', 'boolean'],
      'properties': {
        '$id': {
          'type': 'string',
          'format': 'uri-reference'
        },
        '$schema': {
          'type': 'string',
          'format': 'uri'
        },
        '$ref': {
          'type': 'string',
          'format': 'uri-reference'
        },
        '$comment': {
          'type': 'string'
        },
        'title': {
          'type': 'string'
        },
        'description': {
          'type': 'string'
        },
        'default': true,
        'readOnly': {
          'type': 'boolean',
          'default': false
        },
        'examples': {
          'type': 'array',
          'items': true
        },
        'multipleOf': {
          'type': 'number',
          'exclusiveMinimum': 0
        },
        'maximum': {
          'type': 'number'
        },
        'exclusiveMaximum': {
          'type': 'number'
        },
        'minimum': {
          'type': 'number'
        },
        'exclusiveMinimum': {
          'type': 'number'
        },
        'maxLength': {
          '$ref': '#/definitions/nonNegativeInteger'
        },
        'minLength': {
          '$ref': '#/definitions/nonNegativeIntegerDefault0'
        },
        'pattern': {
          'type': 'string',
          'format': 'regex'
        },
        'additionalItems': {
          '$ref': '#'
        },
        'items': {
          'anyOf': [{
            '$ref': '#'
          }, {
            '$ref': '#/definitions/schemaArray'
          }],
          'default': true
        },
        'maxItems': {
          '$ref': '#/definitions/nonNegativeInteger'
        },
        'minItems': {
          '$ref': '#/definitions/nonNegativeIntegerDefault0'
        },
        'uniqueItems': {
          'type': 'boolean',
          'default': false
        },
        'contains': {
          '$ref': '#'
        },
        'maxProperties': {
          '$ref': '#/definitions/nonNegativeInteger'
        },
        'minProperties': {
          '$ref': '#/definitions/nonNegativeIntegerDefault0'
        },
        'required': {
          '$ref': '#/definitions/stringArray'
        },
        'additionalProperties': {
          '$ref': '#'
        },
        'definitions': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'default': {}
        },
        'properties': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'default': {}
        },
        'patternProperties': {
          'type': 'object',
          'additionalProperties': {
            '$ref': '#'
          },
          'propertyNames': {
            'format': 'regex'
          },
          'default': {}
        },
        'dependencies': {
          'type': 'object',
          'additionalProperties': {
            'anyOf': [{
              '$ref': '#'
            }, {
              '$ref': '#/definitions/stringArray'
            }]
          }
        },
        'propertyNames': {
          '$ref': '#'
        },
        'const': true,
        'enum': {
          'type': 'array',
          'items': true,
          'minItems': 1,
          'uniqueItems': true
        },
        'type': {
          'anyOf': [{
            '$ref': '#/definitions/simpleTypes'
          }, {
            'type': 'array',
            'items': {
              '$ref': '#/definitions/simpleTypes'
            },
            'minItems': 1,
            'uniqueItems': true
          }]
        },
        'format': {
          'type': 'string'
        },
        'contentMediaType': {
          'type': 'string'
        },
        'contentEncoding': {
          'type': 'string'
        },
        'if': {
          '$ref': '#'
        },
        'then': {
          '$ref': '#'
        },
        'else': {
          '$ref': '#'
        },
        'allOf': {
          '$ref': '#/definitions/schemaArray'
        },
        'anyOf': {
          '$ref': '#/definitions/schemaArray'
        },
        'oneOf': {
          '$ref': '#/definitions/schemaArray'
        },
        'not': {
          '$ref': '#'
        }
      },
      'default': true
    }
  }
};
var descriptions = {
  id: configuration_localize('schema.json.id', "A unique identifier for the schema."),
  $schema: configuration_localize('schema.json.$schema', "The schema to verify this document against."),
  title: configuration_localize('schema.json.title', "A descriptive title of the element."),
  description: configuration_localize('schema.json.description', "A long description of the element. Used in hover menus and suggestions."),
  "default": configuration_localize('schema.json.default', "A default value. Used by suggestions."),
  multipleOf: configuration_localize('schema.json.multipleOf', "A number that should cleanly divide the current value (i.e. have no remainder)."),
  maximum: configuration_localize('schema.json.maximum', "The maximum numerical value, inclusive by default."),
  exclusiveMaximum: configuration_localize('schema.json.exclusiveMaximum', "Makes the maximum property exclusive."),
  minimum: configuration_localize('schema.json.minimum', "The minimum numerical value, inclusive by default."),
  exclusiveMinimum: configuration_localize('schema.json.exclusiveMininum', "Makes the minimum property exclusive."),
  maxLength: configuration_localize('schema.json.maxLength', "The maximum length of a string."),
  minLength: configuration_localize('schema.json.minLength', "The minimum length of a string."),
  pattern: configuration_localize('schema.json.pattern', "A regular expression to match the string against. It is not implicitly anchored."),
  additionalItems: configuration_localize('schema.json.additionalItems', "For arrays, only when items is set as an array. If it is a schema, then this schema validates items after the ones specified by the items array. If it is false, then additional items will cause validation to fail."),
  items: configuration_localize('schema.json.items', "For arrays. Can either be a schema to validate every element against or an array of schemas to validate each item against in order (the first schema will validate the first element, the second schema will validate the second element, and so on."),
  maxItems: configuration_localize('schema.json.maxItems', "The maximum number of items that can be inside an array. Inclusive."),
  minItems: configuration_localize('schema.json.minItems', "The minimum number of items that can be inside an array. Inclusive."),
  uniqueItems: configuration_localize('schema.json.uniqueItems', "If all of the items in the array must be unique. Defaults to false."),
  maxProperties: configuration_localize('schema.json.maxProperties', "The maximum number of properties an object can have. Inclusive."),
  minProperties: configuration_localize('schema.json.minProperties', "The minimum number of properties an object can have. Inclusive."),
  required: configuration_localize('schema.json.required', "An array of strings that lists the names of all properties required on this object."),
  additionalProperties: configuration_localize('schema.json.additionalProperties', "Either a schema or a boolean. If a schema, then used to validate all properties not matched by 'properties' or 'patternProperties'. If false, then any properties not matched by either will cause this schema to fail."),
  definitions: configuration_localize('schema.json.definitions', "Not used for validation. Place subschemas here that you wish to reference inline with $ref."),
  properties: configuration_localize('schema.json.properties', "A map of property names to schemas for each property."),
  patternProperties: configuration_localize('schema.json.patternProperties', "A map of regular expressions on property names to schemas for matching properties."),
  dependencies: configuration_localize('schema.json.dependencies', "A map of property names to either an array of property names or a schema. An array of property names means the property named in the key depends on the properties in the array being present in the object in order to be valid. If the value is a schema, then the schema is only applied to the object if the property in the key exists on the object."),
  "enum": configuration_localize('schema.json.enum', "The set of literal values that are valid."),
  type: configuration_localize('schema.json.type', "Either a string of one of the basic schema types (number, integer, null, array, object, boolean, string) or an array of strings specifying a subset of those types."),
  format: configuration_localize('schema.json.format', "Describes the format expected for the value."),
  allOf: configuration_localize('schema.json.allOf', "An array of schemas, all of which must match."),
  anyOf: configuration_localize('schema.json.anyOf', "An array of schemas, where at least one must match."),
  oneOf: configuration_localize('schema.json.oneOf', "An array of schemas, exactly one of which must match."),
  not: configuration_localize('schema.json.not', "A schema which must not match."),
  $id: configuration_localize('schema.json.$id', "A unique identifier for the schema."),
  $ref: configuration_localize('schema.json.$ref', "Reference a definition hosted on any location."),
  $comment: configuration_localize('schema.json.$comment', "Comments from schema authors to readers or maintainers of the schema."),
  readOnly: configuration_localize('schema.json.readOnly', "Indicates that the value of the instance is managed exclusively by the owning authority."),
  examples: configuration_localize('schema.json.examples', "Sample JSON values associated with a particular schema, for the purpose of illustrating usage."),
  contains: configuration_localize('schema.json.contains', "An array instance is valid against \"contains\" if at least one of its elements is valid against the given schema."),
  propertyNames: configuration_localize('schema.json.propertyNames', "If the instance is an object, this keyword validates if every property name in the instance validates against the provided schema."),
  "const": configuration_localize('schema.json.const', "An instance validates successfully against this keyword if its value is equal to the value of the keyword."),
  contentMediaType: configuration_localize('schema.json.contentMediaType', "Describes the media type of a string property."),
  contentEncoding: configuration_localize('schema.json.contentEncoding', "Describes the content encoding of a string property."),
  "if": configuration_localize('schema.json.if', "The validation outcome of the \"if\" subschema controls which of the \"then\" or \"else\" keywords are evaluated."),
  then: configuration_localize('schema.json.then', "The \"if\" subschema is used for validation when the \"if\" subschema succeeds."),
  "else": configuration_localize('schema.json.else', "The \"else\" subschema is used for validation when the \"if\" subschema fails.")
};
for (var schemaName in schemaContributions.schemas) {
  var schema = schemaContributions.schemas[schemaName];
  for (var property in schema.properties) {
    var propertyObject = schema.properties[property];
    if (typeof propertyObject === 'boolean') {
      propertyObject = schema.properties[property] = {};
    }
    var description = descriptions[property];
    if (description) {
      propertyObject['description'] = description;
    } else {
      console.log(property + ": localize('schema.json." + property + "', \"\")");
    }
  }
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonFolding.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


function getFoldingRanges(document, context) {
  var ranges = [];
  var nestingLevels = [];
  var stack = [];
  var prevStart = -1;
  var scanner = main_createScanner(document.getText(), false);
  var token = scanner.scan();
  function addRange(range) {
    ranges.push(range);
    nestingLevels.push(stack.length);
  }
  while (token !== 17 /* EOF */) {
    switch (token) {
      case 1 /* OpenBraceToken */:
      case 3 /* OpenBracketToken */:
        {
          var startLine = document.positionAt(scanner.getTokenOffset()).line;
          var range = {
            startLine: startLine,
            endLine: startLine,
            kind: token === 1 /* OpenBraceToken */ ? 'object' : 'array'
          };
          stack.push(range);
          break;
        }
      case 2 /* CloseBraceToken */:
      case 4 /* CloseBracketToken */:
        {
          var kind = token === 2 /* CloseBraceToken */ ? 'object' : 'array';
          if (stack.length > 0 && stack[stack.length - 1].kind === kind) {
            var range = stack.pop();
            var line = document.positionAt(scanner.getTokenOffset()).line;
            if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
              range.endLine = line - 1;
              addRange(range);
              prevStart = range.startLine;
            }
          }
          break;
        }
      case 13 /* BlockCommentTrivia */:
        {
          var startLine = document.positionAt(scanner.getTokenOffset()).line;
          var endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
          if (scanner.getTokenError() === 1 /* UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {
            scanner.setPosition(document.offsetAt(main_Position.create(startLine + 1, 0)));
          } else {
            if (startLine < endLine) {
              addRange({
                startLine: startLine,
                endLine: endLine,
                kind: FoldingRangeKind.Comment
              });
              prevStart = startLine;
            }
          }
          break;
        }
      case 12 /* LineCommentTrivia */:
        {
          var text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
          var m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
          if (m) {
            var line = document.positionAt(scanner.getTokenOffset()).line;
            if (m[1]) {
              // start pattern match
              var range = {
                startLine: line,
                endLine: line,
                kind: FoldingRangeKind.Region
              };
              stack.push(range);
            } else {
              var i = stack.length - 1;
              while (i >= 0 && stack[i].kind !== FoldingRangeKind.Region) {
                i--;
              }
              if (i >= 0) {
                var range = stack[i];
                stack.length = i;
                if (line > range.startLine && prevStart !== range.startLine) {
                  range.endLine = line;
                  addRange(range);
                  prevStart = range.startLine;
                }
              }
            }
          }
          break;
        }
    }
    token = scanner.scan();
  }
  var rangeLimit = context && context.rangeLimit;
  if (typeof rangeLimit !== 'number' || ranges.length <= rangeLimit) {
    return ranges;
  }
  if (context && context.onRangeLimitExceeded) {
    context.onRangeLimitExceeded(document.uri);
  }
  var counts = [];
  for (var _i = 0, nestingLevels_1 = nestingLevels; _i < nestingLevels_1.length; _i++) {
    var level = nestingLevels_1[_i];
    if (level < 30) {
      counts[level] = (counts[level] || 0) + 1;
    }
  }
  var entries = 0;
  var maxLevel = 0;
  for (var i = 0; i < counts.length; i++) {
    var n = counts[i];
    if (n) {
      if (n + entries > rangeLimit) {
        maxLevel = i;
        break;
      }
      entries += n;
    }
  }
  var result = [];
  for (var i = 0; i < ranges.length; i++) {
    var level = nestingLevels[i];
    if (typeof level === 'number') {
      if (level < maxLevel || level === maxLevel && entries++ < rangeLimit) {
        result.push(ranges[i]);
      }
    }
  }
  return result;
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonSelectionRanges.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


function getSelectionRanges(document, positions, doc) {
  function getSelectionRange(position) {
    var offset = document.offsetAt(position);
    var node = doc.getNodeFromOffset(offset, true);
    var result = [];
    while (node) {
      switch (node.type) {
        case 'string':
        case 'object':
        case 'array':
          // range without ", [ or {
          var cStart = node.offset + 1,
            cEnd = node.offset + node.length - 1;
          if (cStart < cEnd && offset >= cStart && offset <= cEnd) {
            result.push(newRange(cStart, cEnd));
          }
          result.push(newRange(node.offset, node.offset + node.length));
          break;
        case 'number':
        case 'boolean':
        case 'null':
        case 'property':
          result.push(newRange(node.offset, node.offset + node.length));
          break;
      }
      if (node.type === 'property' || node.parent && node.parent.type === 'array') {
        var afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* CommaToken */);
        if (afterCommaOffset !== -1) {
          result.push(newRange(node.offset, afterCommaOffset));
        }
      }
      node = node.parent;
    }
    var current = undefined;
    for (var index = result.length - 1; index >= 0; index--) {
      current = SelectionRange.create(result[index], current);
    }
    if (!current) {
      current = SelectionRange.create(main_Range.create(position, position));
    }
    return current;
  }
  function newRange(start, end) {
    return main_Range.create(document.positionAt(start), document.positionAt(end));
  }
  var scanner = main_createScanner(document.getText(), true);
  function getOffsetAfterNextToken(offset, expectedToken) {
    scanner.setPosition(offset);
    var token = scanner.scan();
    if (token === expectedToken) {
      return scanner.getTokenOffset() + scanner.getTokenLength();
    }
    return -1;
  }
  return positions.map(getSelectionRange);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonLinks.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

function findLinks(document, doc) {
  var links = [];
  doc.visit(function (node) {
    var _a;
    if (node.type === "property" && node.keyNode.value === "$ref" && ((_a = node.valueNode) === null || _a === void 0 ? void 0 : _a.type) === 'string') {
      var path = node.valueNode.value;
      var targetNode = findTargetNode(doc, path);
      if (targetNode) {
        var targetPos = document.positionAt(targetNode.offset);
        links.push({
          target: document.uri + "#" + (targetPos.line + 1) + "," + (targetPos.character + 1),
          range: createRange(document, node.valueNode)
        });
      }
    }
    return true;
  });
  return Promise.resolve(links);
}
function createRange(document, node) {
  return main_Range.create(document.positionAt(node.offset + 1), document.positionAt(node.offset + node.length - 1));
}
function findTargetNode(doc, path) {
  var tokens = parseJSONPointer(path);
  if (!tokens) {
    return null;
  }
  return findNode(tokens, doc.root);
}
function findNode(pointer, node) {
  if (!node) {
    return null;
  }
  if (pointer.length === 0) {
    return node;
  }
  var token = pointer.shift();
  if (node && node.type === 'object') {
    var propertyNode = node.properties.find(function (propertyNode) {
      return propertyNode.keyNode.value === token;
    });
    if (!propertyNode) {
      return null;
    }
    return findNode(pointer, propertyNode.valueNode);
  } else if (node && node.type === 'array') {
    if (token.match(/^(0|[1-9][0-9]*)$/)) {
      var index = Number.parseInt(token);
      var arrayItem = node.items[index];
      if (!arrayItem) {
        return null;
      }
      return findNode(pointer, arrayItem);
    }
  }
  return null;
}
function parseJSONPointer(path) {
  if (path === "#") {
    return [];
  }
  if (path[0] !== '#' || path[1] !== '/') {
    return null;
  }
  return path.substring(2).split(/\//).map(jsonLinks_unescape);
}
function jsonLinks_unescape(str) {
  return str.replace(/~1/g, '/').replace(/~0/g, '~');
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/jsonLanguageService.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/













function getLanguageService(params) {
  var promise = params.promiseConstructor || Promise;
  var jsonSchemaService = new JSONSchemaService(params.schemaRequestService, params.workspaceContext, promise);
  jsonSchemaService.setSchemaContributions(schemaContributions);
  var jsonCompletion = new JSONCompletion(jsonSchemaService, params.contributions, promise, params.clientCapabilities);
  var jsonHover = new JSONHover(jsonSchemaService, params.contributions, promise);
  var jsonDocumentSymbols = new JSONDocumentSymbols(jsonSchemaService);
  var jsonValidation = new JSONValidation(jsonSchemaService, promise);
  return {
    configure: function configure(settings) {
      jsonSchemaService.clearExternalSchemas();
      if (settings.schemas) {
        settings.schemas.forEach(function (settings) {
          jsonSchemaService.registerExternalSchema(settings.uri, settings.fileMatch, settings.schema);
        });
      }
      jsonValidation.configure(settings);
    },
    resetSchema: function resetSchema(uri) {
      return jsonSchemaService.onResourceChange(uri);
    },
    doValidation: jsonValidation.doValidation.bind(jsonValidation),
    parseJSONDocument: function parseJSONDocument(document) {
      return jsonParser_parse(document, {
        collectComments: true
      });
    },
    newJSONDocument: function newJSONDocument(root, diagnostics) {
      return jsonParser_newJSONDocument(root, diagnostics);
    },
    getMatchingSchemas: jsonSchemaService.getMatchingSchemas.bind(jsonSchemaService),
    doResolve: jsonCompletion.doResolve.bind(jsonCompletion),
    doComplete: jsonCompletion.doComplete.bind(jsonCompletion),
    findDocumentSymbols: jsonDocumentSymbols.findDocumentSymbols.bind(jsonDocumentSymbols),
    findDocumentSymbols2: jsonDocumentSymbols.findDocumentSymbols2.bind(jsonDocumentSymbols),
    findDocumentColors: jsonDocumentSymbols.findDocumentColors.bind(jsonDocumentSymbols),
    getColorPresentations: jsonDocumentSymbols.getColorPresentations.bind(jsonDocumentSymbols),
    doHover: jsonHover.doHover.bind(jsonHover),
    getFoldingRanges: getFoldingRanges,
    getSelectionRanges: getSelectionRanges,
    findDefinition: function findDefinition() {
      return Promise.resolve([]);
    },
    findLinks: findLinks,
    format: function format(d, r, o) {
      var range = undefined;
      if (r) {
        var offset = d.offsetAt(r.start);
        var length = d.offsetAt(r.end) - offset;
        range = {
          offset: offset,
          length: length
        };
      }
      var options = {
        tabSize: o ? o.tabSize : 4,
        insertSpaces: (o === null || o === void 0 ? void 0 : o.insertSpaces) === true,
        insertFinalNewline: (o === null || o === void 0 ? void 0 : o.insertFinalNewline) === true,
        eol: '\n'
      };
      return main_format(d.getText(), range, options).map(function (e) {
        return TextEdit.replace(main_Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);
      });
    }
  };
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/jsonWorker.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var jsonWorker_awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var __generator = undefined && undefined.__generator || function (thisArg, body) {
  var _ = {
      label: 0,
      sent: function sent() {
        if (t[0] & 1) throw t[1];
        return t[1];
      },
      trys: [],
      ops: []
    },
    f,
    y,
    t,
    g;
  return g = {
    next: verb(0),
    "throw": verb(1),
    "return": verb(2)
  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
    return this;
  }), g;
  function verb(n) {
    return function (v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");
    while (_) try {
      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
      if (y = 0, t) op = [op[0] & 2, t.value];
      switch (op[0]) {
        case 0:
        case 1:
          t = op;
          break;
        case 4:
          _.label++;
          return {
            value: op[1],
            done: false
          };
        case 5:
          _.label++;
          y = op[1];
          op = [0];
          continue;
        case 7:
          op = _.ops.pop();
          _.trys.pop();
          continue;
        default:
          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
            _ = 0;
            continue;
          }
          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
            _.label = op[1];
            break;
          }
          if (op[0] === 6 && _.label < t[1]) {
            _.label = t[1];
            t = op;
            break;
          }
          if (t && _.label < t[2]) {
            _.label = t[2];
            _.ops.push(op);
            break;
          }
          if (t[2]) _.ops.pop();
          _.trys.pop();
          continue;
      }
      op = body.call(thisArg, _);
    } catch (e) {
      op = [6, e];
      y = 0;
    } finally {
      f = t = 0;
    }
    if (op[0] & 5) throw op[1];
    return {
      value: op[0] ? op[1] : void 0,
      done: true
    };
  }
};


var defaultSchemaRequestService;
if (typeof fetch !== 'undefined') {
  defaultSchemaRequestService = function defaultSchemaRequestService(url) {
    return fetch(url).then(function (response) {
      return response.text();
    });
  };
}
var JSONWorker = /** @class */function () {
  function JSONWorker(ctx, createData) {
    this._ctx = ctx;
    this._languageSettings = createData.languageSettings;
    this._languageId = createData.languageId;
    this._languageService = getLanguageService({
      workspaceContext: {
        resolveRelativePath: function resolveRelativePath(relativePath, resource) {
          var base = resource.substr(0, resource.lastIndexOf('/') + 1);
          return resolvePath(base, relativePath);
        }
      },
      schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService
    });
    this._languageService.configure(this._languageSettings);
  }
  JSONWorker.prototype.doValidation = function (uri) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        if (document) {
          jsonDocument = this._languageService.parseJSONDocument(document);
          return [2 /*return*/, this._languageService.doValidation(document, jsonDocument, this._languageSettings)];
        }
        return [2 /*return*/, Promise.resolve([])];
      });
    });
  };
  JSONWorker.prototype.doComplete = function (uri, position) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        return [2 /*return*/, this._languageService.doComplete(document, position, jsonDocument)];
      });
    });
  };
  JSONWorker.prototype.doResolve = function (item) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      return __generator(this, function (_a) {
        return [2 /*return*/, this._languageService.doResolve(item)];
      });
    });
  };
  JSONWorker.prototype.doHover = function (uri, position) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        return [2 /*return*/, this._languageService.doHover(document, position, jsonDocument)];
      });
    });
  };
  JSONWorker.prototype.format = function (uri, range, options) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, textEdits;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        textEdits = this._languageService.format(document, range, options);
        return [2 /*return*/, Promise.resolve(textEdits)];
      });
    });
  };
  JSONWorker.prototype.resetSchema = function (uri) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      return __generator(this, function (_a) {
        return [2 /*return*/, Promise.resolve(this._languageService.resetSchema(uri))];
      });
    });
  };
  JSONWorker.prototype.findDocumentSymbols = function (uri) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument, symbols;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
        return [2 /*return*/, Promise.resolve(symbols)];
      });
    });
  };
  JSONWorker.prototype.findDocumentColors = function (uri) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument, colorSymbols;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
        return [2 /*return*/, Promise.resolve(colorSymbols)];
      });
    });
  };
  JSONWorker.prototype.getColorPresentations = function (uri, color, range) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument, colorPresentations;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range);
        return [2 /*return*/, Promise.resolve(colorPresentations)];
      });
    });
  };
  JSONWorker.prototype.getFoldingRanges = function (uri, context) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, ranges;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        ranges = this._languageService.getFoldingRanges(document, context);
        return [2 /*return*/, Promise.resolve(ranges)];
      });
    });
  };
  JSONWorker.prototype.getSelectionRanges = function (uri, positions) {
    return jsonWorker_awaiter(this, void 0, void 0, function () {
      var document, jsonDocument, ranges;
      return __generator(this, function (_a) {
        document = this._getTextDocument(uri);
        jsonDocument = this._languageService.parseJSONDocument(document);
        ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
        return [2 /*return*/, Promise.resolve(ranges)];
      });
    });
  };
  JSONWorker.prototype._getTextDocument = function (uri) {
    var models = this._ctx.getMirrorModels();
    for (var _i = 0, models_1 = models; _i < models_1.length; _i++) {
      var model = models_1[_i];
      if (model.uri.toString() === uri) {
        return main_TextDocument.create(uri, this._languageId, model.version, model.getValue());
      }
    }
    return null;
  };
  return JSONWorker;
}();

// URI path utilities, will (hopefully) move to vscode-uri
var Slash = '/'.charCodeAt(0);
var Dot = '.'.charCodeAt(0);
function isAbsolutePath(path) {
  return path.charCodeAt(0) === Slash;
}
function resolvePath(uriString, path) {
  if (isAbsolutePath(path)) {
    var uri = vscode_uri_URI.parse(uriString);
    var parts = path.split('/');
    return uri["with"]({
      path: normalizePath(parts)
    }).toString();
  }
  return joinPath(uriString, path);
}
function normalizePath(parts) {
  var newParts = [];
  for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
    var part = parts_1[_i];
    if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
      // ignore
    } else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
      newParts.pop();
    } else {
      newParts.push(part);
    }
  }
  if (parts.length > 1 && parts[parts.length - 1].length === 0) {
    newParts.push('');
  }
  var res = newParts.join('/');
  if (parts[0].length === 0) {
    res = '/' + res;
  }
  return res;
}
function joinPath(uriString) {
  var paths = [];
  for (var _i = 1; _i < arguments.length; _i++) {
    paths[_i - 1] = arguments[_i];
  }
  var uri = vscode_uri_URI.parse(uriString);
  var parts = uri.path.split('/');
  for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
    var path = paths_1[_a];
    parts.push.apply(parts, path.split('/'));
  }
  return uri["with"]({
    path: normalizePath(parts)
  }).toString();
}
function jsonWorker_create(ctx, createData) {
  return new JSONWorker(ctx, createData);
}
;// CONCATENATED MODULE: ./node_modules/monaco-editor/esm/vs/language/json/json.worker.js
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/


self.onmessage = function () {
  // ignore the first message
  initialize(function (ctx, createData) {
    return new JSONWorker(ctx, createData);
  });
};
}();
/******/ })()
;