!function(t){var r={};function i(e){if(r[e])return r[e].exports;var n=r[e]={i:e,l:!1,exports:{}};return t[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}i.m=t,i.c=r,i.d=function(e,n,t){i.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:t})},i.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},i.t=function(n,e){if(1&e&&(n=i(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var t=Object.create(null);if(i.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var r in n)i.d(t,r,function(e){return n[e]}.bind(null,r));return t},i.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return i.d(n,"a",n),n},i.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},i.p="",i(i.s="../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/editor.worker.js")}({"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/arrays.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tail", function() { return tail; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tail2", function() { return tail2; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "binarySearch", function() { return binarySearch; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findFirstInSorted", function() { return findFirstInSorted; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mergeSort", function() { return mergeSort; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "groupBy", function() { return groupBy; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "coalesce", function() { return coalesce; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFalsyOrEmpty", function() { return isFalsyOrEmpty; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isNonEmptyArray", function() { return isNonEmptyArray; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distinct", function() { return distinct; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distinctES6", function() { return distinctES6; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "firstIndex", function() { return firstIndex; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "first", function() { return first; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "flatten", function() { return flatten; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "range", function() { return range; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "arrayInsert", function() { return arrayInsert; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pushToStart", function() { return pushToStart; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pushToEnd", function() { return pushToEnd; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "asArray", function() { return asArray; });\n/**\n * Returns the last element of an array.\n * @param array The array.\n * @param n Which element from the end (default is zero).\n */\nfunction tail(array, n) {\n    if (n === void 0) { n = 0; }\n    return array[array.length - (1 + n)];\n}\nfunction tail2(arr) {\n    if (arr.length === 0) {\n        throw new Error(\'Invalid tail call\');\n    }\n    return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];\n}\nfunction equals(one, other, itemEquals) {\n    if (itemEquals === void 0) { itemEquals = function (a, b) { return a === b; }; }\n    if (one === other) {\n        return true;\n    }\n    if (!one || !other) {\n        return false;\n    }\n    if (one.length !== other.length) {\n        return false;\n    }\n    for (var i = 0, len = one.length; i < len; i++) {\n        if (!itemEquals(one[i], other[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction binarySearch(array, key, comparator) {\n    var low = 0, high = array.length - 1;\n    while (low <= high) {\n        var mid = ((low + high) / 2) | 0;\n        var comp = comparator(array[mid], key);\n        if (comp < 0) {\n            low = mid + 1;\n        }\n        else if (comp > 0) {\n            high = mid - 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return -(low + 1);\n}\n/**\n * Takes a sorted array and a function p. The array is sorted in such a way that all elements where p(x) is false\n * are located before all elements where p(x) is true.\n * @returns the least x for which p(x) is true or array.length if no element fullfills the given function.\n */\nfunction findFirstInSorted(array, p) {\n    var low = 0, high = array.length;\n    if (high === 0) {\n        return 0; // no children\n    }\n    while (low < high) {\n        var mid = Math.floor((low + high) / 2);\n        if (p(array[mid])) {\n            high = mid;\n        }\n        else {\n            low = mid + 1;\n        }\n    }\n    return low;\n}\n/**\n * Like `Array#sort` but always stable. Usually runs a little slower `than Array#sort`\n * so only use this when actually needing stable sort.\n */\nfunction mergeSort(data, compare) {\n    _sort(data, compare, 0, data.length - 1, []);\n    return data;\n}\nfunction _merge(a, compare, lo, mid, hi, aux) {\n    var leftIdx = lo, rightIdx = mid + 1;\n    for (var i = lo; i <= hi; i++) {\n        aux[i] = a[i];\n    }\n    for (var i = lo; i <= hi; i++) {\n        if (leftIdx > mid) {\n            // left side consumed\n            a[i] = aux[rightIdx++];\n        }\n        else if (rightIdx > hi) {\n            // right side consumed\n            a[i] = aux[leftIdx++];\n        }\n        else if (compare(aux[rightIdx], aux[leftIdx]) < 0) {\n            // right element is less -> comes first\n            a[i] = aux[rightIdx++];\n        }\n        else {\n            // left element comes first (less or equal)\n            a[i] = aux[leftIdx++];\n        }\n    }\n}\nfunction _sort(a, compare, lo, hi, aux) {\n    if (hi <= lo) {\n        return;\n    }\n    var mid = lo + ((hi - lo) / 2) | 0;\n    _sort(a, compare, lo, mid, aux);\n    _sort(a, compare, mid + 1, hi, aux);\n    if (compare(a[mid], a[mid + 1]) <= 0) {\n        // left and right are sorted and if the last-left element is less\n        // or equals than the first-right element there is nothing else\n        // to do\n        return;\n    }\n    _merge(a, compare, lo, mid, hi, aux);\n}\nfunction groupBy(data, compare) {\n    var result = [];\n    var currentGroup = undefined;\n    for (var _i = 0, _a = mergeSort(data.slice(0), compare); _i < _a.length; _i++) {\n        var element = _a[_i];\n        if (!currentGroup || compare(currentGroup[0], element) !== 0) {\n            currentGroup = [element];\n            result.push(currentGroup);\n        }\n        else {\n            currentGroup.push(element);\n        }\n    }\n    return result;\n}\n/**\n * @returns a new array with all falsy values removed. The original array IS NOT modified.\n */\nfunction coalesce(array) {\n    if (!array) {\n        return array;\n    }\n    return array.filter(function (e) { return !!e; });\n}\n/**\n * @returns false if the provided object is an array and not empty.\n */\nfunction isFalsyOrEmpty(obj) {\n    return !Array.isArray(obj) || obj.length === 0;\n}\n/**\n * @returns True if the provided object is an array and has at least one element.\n */\nfunction isNonEmptyArray(obj) {\n    return Array.isArray(obj) && obj.length > 0;\n}\n/**\n * Removes duplicates from the given array. The optional keyFn allows to specify\n * how elements are checked for equalness by returning a unique string for each.\n */\nfunction distinct(array, keyFn) {\n    if (!keyFn) {\n        return array.filter(function (element, position) {\n            return array.indexOf(element) === position;\n        });\n    }\n    var seen = Object.create(null);\n    return array.filter(function (elem) {\n        var key = keyFn(elem);\n        if (seen[key]) {\n            return false;\n        }\n        seen[key] = true;\n        return true;\n    });\n}\nfunction distinctES6(array) {\n    var seen = new Set();\n    return array.filter(function (element) {\n        if (seen.has(element)) {\n            return false;\n        }\n        seen.add(element);\n        return true;\n    });\n}\nfunction firstIndex(array, fn) {\n    for (var i = 0; i < array.length; i++) {\n        var element = array[i];\n        if (fn(element)) {\n            return i;\n        }\n    }\n    return -1;\n}\nfunction first(array, fn, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = undefined; }\n    var index = firstIndex(array, fn);\n    return index < 0 ? notFoundValue : array[index];\n}\nfunction flatten(arr) {\n    var _a;\n    return (_a = []).concat.apply(_a, arr);\n}\nfunction range(arg, to) {\n    var from = typeof to === \'number\' ? arg : 0;\n    if (typeof to === \'number\') {\n        from = arg;\n    }\n    else {\n        from = 0;\n        to = arg;\n    }\n    var result = [];\n    if (from <= to) {\n        for (var i = from; i < to; i++) {\n            result.push(i);\n        }\n    }\n    else {\n        for (var i = from; i > to; i--) {\n            result.push(i);\n        }\n    }\n    return result;\n}\n/**\n * Insert `insertArr` inside `target` at `insertIndex`.\n * Please don\'t touch unless you understand https://jsperf.com/inserting-an-array-within-an-array\n */\nfunction arrayInsert(target, insertIndex, insertArr) {\n    var before = target.slice(0, insertIndex);\n    var after = target.slice(insertIndex);\n    return before.concat(insertArr, after);\n}\n/**\n * Pushes an element to the start of the array, if found.\n */\nfunction pushToStart(arr, value) {\n    var index = arr.indexOf(value);\n    if (index > -1) {\n        arr.splice(index, 1);\n        arr.unshift(value);\n    }\n}\n/**\n * Pushes an element to the end of the array, if found.\n */\nfunction pushToEnd(arr, value) {\n    var index = arr.indexOf(value);\n    if (index > -1) {\n        arr.splice(index, 1);\n        arr.push(value);\n    }\n}\nfunction asArray(x) {\n    return Array.isArray(x) ? x : [x];\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/arrays.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/cancellation.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CancellationToken", function() { return CancellationToken; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CancellationTokenSource", function() { return CancellationTokenSource; });\n/* harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./event.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/event.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nvar shortcutEvent = Object.freeze(function (callback, context) {\n    var handle = setTimeout(callback.bind(context), 0);\n    return { dispose: function () { clearTimeout(handle); } };\n});\nvar CancellationToken;\n(function (CancellationToken) {\n    function isCancellationToken(thing) {\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n            return true;\n        }\n        if (thing instanceof MutableToken) {\n            return true;\n        }\n        if (!thing || typeof thing !== \'object\') {\n            return false;\n        }\n        return typeof thing.isCancellationRequested === \'boolean\'\n            && typeof thing.onCancellationRequested === \'function\';\n    }\n    CancellationToken.isCancellationToken = isCancellationToken;\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: _event_js__WEBPACK_IMPORTED_MODULE_0__["Event"].None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: shortcutEvent\n    });\n})(CancellationToken || (CancellationToken = {}));\nvar MutableToken = /** @class */ (function () {\n    function MutableToken() {\n        this._isCancelled = false;\n        this._emitter = null;\n    }\n    MutableToken.prototype.cancel = function () {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    };\n    Object.defineProperty(MutableToken.prototype, "isCancellationRequested", {\n        get: function () {\n            return this._isCancelled;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MutableToken.prototype, "onCancellationRequested", {\n        get: function () {\n            if (this._isCancelled) {\n                return shortcutEvent;\n            }\n            if (!this._emitter) {\n                this._emitter = new _event_js__WEBPACK_IMPORTED_MODULE_0__["Emitter"]();\n            }\n            return this._emitter.event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MutableToken.prototype.dispose = function () {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = null;\n        }\n    };\n    return MutableToken;\n}());\nvar CancellationTokenSource = /** @class */ (function () {\n    function CancellationTokenSource(parent) {\n        this._token = undefined;\n        this._parentListener = undefined;\n        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\n    }\n    Object.defineProperty(CancellationTokenSource.prototype, "token", {\n        get: function () {\n            if (!this._token) {\n                // be lazy and create the token only when\n                // actually needed\n                this._token = new MutableToken();\n            }\n            return this._token;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CancellationTokenSource.prototype.cancel = function () {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually cancel\n            this._token.cancel();\n        }\n    };\n    CancellationTokenSource.prototype.dispose = function () {\n        if (this._parentListener) {\n            this._parentListener.dispose();\n        }\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    };\n    return CancellationTokenSource;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/cancellation.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diff.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"stringDiff\", function() { return stringDiff; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Debug\", function() { return Debug; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"MyArray\", function() { return MyArray; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"LcsDiff\", function() { return LcsDiff; });\n/* harmony import */ var _diffChange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./diffChange.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diffChange.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nfunction createStringSequence(a) {\n    return {\n        getLength: function () { return a.length; },\n        getElementAtIndex: function (pos) { return a.charCodeAt(pos); }\n    };\n}\nfunction stringDiff(original, modified, pretty) {\n    return new LcsDiff(createStringSequence(original), createStringSequence(modified)).ComputeDiff(pretty);\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nvar Debug = /** @class */ (function () {\n    function Debug() {\n    }\n    Debug.Assert = function (condition, message) {\n        if (!condition) {\n            throw new Error(message);\n        }\n    };\n    return Debug;\n}());\n\nvar MyArray = /** @class */ (function () {\n    function MyArray() {\n    }\n    /**\n     * Copies a range of elements from an Array starting at the specified source index and pastes\n     * them to another Array starting at the specified destination index. The length and the indexes\n     * are specified as 64-bit integers.\n     * sourceArray:\n     *\t\tThe Array that contains the data to copy.\n     * sourceIndex:\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n     * destinationArray:\n     *\t\tThe Array that receives the data.\n     * destinationIndex:\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n     * length:\n     *\t\tA 64-bit integer that represents the number of elements to copy.\n     */\n    MyArray.Copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (var i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    };\n    return MyArray;\n}());\n\n//*****************************************************************************\n// LcsDiff.cs\n//\n// An implementation of the difference algorithm described in\n// \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n//\n// Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve\n//*****************************************************************************\n// Our total memory usage for storing history is (worst-case):\n// 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)\n// 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB\nvar MaxDifferencesHistory = 1447;\n//let MaxDifferencesHistory = 100;\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarktNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nvar DiffChangeHelper = /** @class */ (function () {\n    /**\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\n     */\n    function DiffChangeHelper() {\n        this.m_changes = [];\n        this.m_originalStart = Number.MAX_VALUE;\n        this.m_modifiedStart = Number.MAX_VALUE;\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n    }\n    /**\n     * Marks the beginning of the next change in the set of differences.\n     */\n    DiffChangeHelper.prototype.MarkNextChange = function () {\n        // Only add to the list if there is something to add\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Add the new change to our list\n            this.m_changes.push(new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n        }\n        // Reset for the next change\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n        this.m_originalStart = Number.MAX_VALUE;\n        this.m_modifiedStart = Number.MAX_VALUE;\n    };\n    /**\n     * Adds the original element at the given position to the elements\n     * affected by the current change. The modified index gives context\n     * to the change position with respect to the original sequence.\n     * @param originalIndex The index of the original element to add.\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n     */\n    DiffChangeHelper.prototype.AddOriginalElement = function (originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_originalCount++;\n    };\n    /**\n     * Adds the modified element at the given position to the elements\n     * affected by the current change. The original index gives context\n     * to the change position with respect to the modified sequence.\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n     * @param modifiedIndex The index of the modified element to add.\n     */\n    DiffChangeHelper.prototype.AddModifiedElement = function (originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_modifiedCount++;\n    };\n    /**\n     * Retrieves all of the changes marked by the class.\n     */\n    DiffChangeHelper.prototype.getChanges = function () {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        return this.m_changes;\n    };\n    /**\n     * Retrieves all of the changes marked by the class in the reverse order\n     */\n    DiffChangeHelper.prototype.getReverseChanges = function () {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        this.m_changes.reverse();\n        return this.m_changes;\n    };\n    return DiffChangeHelper;\n}());\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nvar LcsDiff = /** @class */ (function () {\n    /**\n     * Constructs the DiffFinder\n     */\n    function LcsDiff(originalSequence, newSequence, continueProcessingPredicate) {\n        if (continueProcessingPredicate === void 0) { continueProcessingPredicate = null; }\n        this.OriginalSequence = originalSequence;\n        this.ModifiedSequence = newSequence;\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n    }\n    LcsDiff.prototype.ElementsAreEqual = function (originalIndex, newIndex) {\n        return (this.OriginalSequence.getElementAtIndex(originalIndex) === this.ModifiedSequence.getElementAtIndex(newIndex));\n    };\n    LcsDiff.prototype.OriginalElementsAreEqual = function (index1, index2) {\n        return (this.OriginalSequence.getElementAtIndex(index1) === this.OriginalSequence.getElementAtIndex(index2));\n    };\n    LcsDiff.prototype.ModifiedElementsAreEqual = function (index1, index2) {\n        return (this.ModifiedSequence.getElementAtIndex(index1) === this.ModifiedSequence.getElementAtIndex(index2));\n    };\n    LcsDiff.prototype.ComputeDiff = function (pretty) {\n        return this._ComputeDiff(0, this.OriginalSequence.getLength() - 1, 0, this.ModifiedSequence.getLength() - 1, pretty);\n    };\n    /**\n     * Computes the differences between the original and modified input\n     * sequences on the bounded range.\n     * @returns An array of the differences between the two input sequences.\n     */\n    LcsDiff.prototype._ComputeDiff = function (originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n        var quitEarlyArr = [false];\n        var changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n        if (pretty) {\n            // We have to clean up the computed diff to be more intuitive\n            // but it turns out this cannot be done correctly until the entire set\n            // of diffs have been computed\n            return this.PrettifyChanges(changes);\n        }\n        return changes;\n    };\n    /**\n     * Private helper method which computes the differences on the bounded range\n     * recursively.\n     * @returns An array of the differences between the two input sequences.\n     */\n    LcsDiff.prototype.ComputeDiffRecursive = function (originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n        quitEarlyArr[0] = false;\n        // Find the start of the differences\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n            originalStart++;\n            modifiedStart++;\n        }\n        // Find the end of the differences\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n            originalEnd--;\n            modifiedEnd--;\n        }\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n            var changes = void 0;\n            if (modifiedStart <= modifiedEnd) {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                // All insertions\n                changes = [\n                    new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n                ];\n            }\n            else if (originalStart <= originalEnd) {\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // All deletions\n                changes = [\n                    new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n                ];\n            }\n            else {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // Identical sequences - No differences\n                changes = [];\n            }\n            return changes;\n        }\n        // This problem can be solved using the Divide-And-Conquer technique.\n        var midOriginalArr = [0], midModifiedArr = [0];\n        var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n        var midOriginal = midOriginalArr[0];\n        var midModified = midModifiedArr[0];\n        if (result !== null) {\n            // Result is not-null when there was enough memory to compute the changes while\n            // searching for the recursion point\n            return result;\n        }\n        else if (!quitEarlyArr[0]) {\n            // We can break the problem down recursively by finding the changes in the\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n            var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n            var rightChanges = [];\n            if (!quitEarlyArr[0]) {\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n            }\n            else {\n                // We did't have time to finish the first half, so we don't have time to compute this half.\n                // Consider the entire rest of the sequence different.\n                rightChanges = [\n                    new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n                ];\n            }\n            return this.ConcatenateChanges(leftChanges, rightChanges);\n        }\n        // If we hit here, we quit early, and so can't return anything meaningful\n        return [\n            new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n        ];\n    };\n    LcsDiff.prototype.WALKTRACE = function (diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n        var forwardChanges = null, reverseChanges = null;\n        // First, walk backward through the forward diagonals history\n        var changeHelper = new DiffChangeHelper();\n        var diagonalMin = diagonalForwardStart;\n        var diagonalMax = diagonalForwardEnd;\n        var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n        var lastOriginalIndex = Number.MIN_VALUE;\n        var historyIndex = this.m_forwardHistory.length - 1;\n        var diagonal;\n        do {\n            // Get the diagonal index from the relative diagonal number\n            diagonal = diagonalRelative + diagonalForwardBase;\n            // Figure out where we came from\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                // Vertical line (the element is an insert)\n                originalIndex = forwardPoints[diagonal + 1];\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex;\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            else {\n                // Horizontal line (the element is a deletion)\n                originalIndex = forwardPoints[diagonal - 1] + 1;\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex - 1;\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            if (historyIndex >= 0) {\n                forwardPoints = this.m_forwardHistory[historyIndex];\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n                diagonalMin = 1;\n                diagonalMax = forwardPoints.length - 1;\n            }\n        } while (--historyIndex >= -1);\n        // Ironically, we get the forward changes as the reverse of the\n        // order we added them since we technically added them backwards\n        forwardChanges = changeHelper.getReverseChanges();\n        if (quitEarlyArr[0]) {\n            // TODO: Calculate a partial from the reverse diagonals.\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\n            var originalStartPoint = midOriginalArr[0] + 1;\n            var modifiedStartPoint = midModifiedArr[0] + 1;\n            if (forwardChanges !== null && forwardChanges.length > 0) {\n                var lastForwardChange = forwardChanges[forwardChanges.length - 1];\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n            }\n            reverseChanges = [\n                new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n            ];\n        }\n        else {\n            // Now walk backward through the reverse diagonals history\n            changeHelper = new DiffChangeHelper();\n            diagonalMin = diagonalReverseStart;\n            diagonalMax = diagonalReverseEnd;\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n            lastOriginalIndex = Number.MAX_VALUE;\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n            do {\n                // Get the diagonal index from the relative diagonal number\n                diagonal = diagonalRelative + diagonalReverseBase;\n                // Figure out where we came from\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    // Horizontal line (the element is a deletion))\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex + 1;\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                else {\n                    // Vertical line (the element is an insertion)\n                    originalIndex = reversePoints[diagonal - 1];\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex;\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                if (historyIndex >= 0) {\n                    reversePoints = this.m_reverseHistory[historyIndex];\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n                    diagonalMin = 1;\n                    diagonalMax = reversePoints.length - 1;\n                }\n            } while (--historyIndex >= -1);\n            // There are cases where the reverse history will find diffs that\n            // are correct, but not intuitive, so we need shift them.\n            reverseChanges = changeHelper.getChanges();\n        }\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\n    };\n    /**\n     * Given the range to compute the diff on, this method finds the point:\n     * (midOriginal, midModified)\n     * that exists in the middle of the LCS of the two sequences and\n     * is the point at which the LCS problem may be broken down recursively.\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\n     * point is calculated and the full trace is available in memory, then this method\n     * will return the change list.\n     * @param originalStart The start bound of the original sequence range\n     * @param originalEnd The end bound of the original sequence range\n     * @param modifiedStart The start bound of the modified sequence range\n     * @param modifiedEnd The end bound of the modified sequence range\n     * @param midOriginal The middle point of the original sequence range\n     * @param midModified The middle point of the modified sequence range\n     * @returns The diff changes, if available, otherwise null\n     */\n    LcsDiff.prototype.ComputeRecursionPoint = function (originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n        var originalIndex = 0, modifiedIndex = 0;\n        var diagonalForwardStart = 0, diagonalForwardEnd = 0;\n        var diagonalReverseStart = 0, diagonalReverseEnd = 0;\n        var numDifferences;\n        // To traverse the edit graph and produce the proper LCS, our actual\n        // start position is just outside the given boundary\n        originalStart--;\n        modifiedStart--;\n        // We set these up to make the compiler happy, but they will\n        // be replaced before we return with the actual recursion point\n        midOriginalArr[0] = 0;\n        midModifiedArr[0] = 0;\n        // Clear out the history\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n        // The integer value in the cell represents the originalIndex of the furthest\n        // reaching point found so far that ends in that diagonal.\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n        var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n        var numDiagonals = maxDifferences + 1;\n        var forwardPoints = new Array(numDiagonals);\n        var reversePoints = new Array(numDiagonals);\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n        var diagonalForwardBase = (modifiedEnd - modifiedStart);\n        var diagonalReverseBase = (originalEnd - originalStart);\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalForwardBase)\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalReverseBase)\n        var diagonalForwardOffset = (originalStart - modifiedStart);\n        var diagonalReverseOffset = (originalEnd - modifiedEnd);\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n        var delta = diagonalReverseBase - diagonalForwardBase;\n        var deltaIsEven = (delta % 2 === 0);\n        // Here we set up the start and end points as the furthest points found so far\n        // in both the forward and reverse directions, respectively\n        forwardPoints[diagonalForwardBase] = originalStart;\n        reversePoints[diagonalReverseBase] = originalEnd;\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n        quitEarlyArr[0] = false;\n        // A couple of points:\n        // --With this method, we iterate on the number of differences between the two sequences.\n        //   The more differences there actually are, the longer this will take.\n        // --Also, as the number of differences increases, we have to search on diagonals further\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n        //   is even and odd diagonals only when numDifferences is odd.\n        var diagonal, tempOriginalIndex;\n        for (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n            var furthestOriginalIndex = 0;\n            var furthestModifiedIndex = 0;\n            // Run the algorithm in the forward direction\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            for (diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalStart, modifiedStart)\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                    originalIndex = forwardPoints[diagonal + 1];\n                }\n                else {\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n                // Save the current originalIndex so we can test for false overlap in step 3\n                tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // so long as the elements are equal.\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n                    originalIndex++;\n                    modifiedIndex++;\n                }\n                forwardPoints[diagonal] = originalIndex;\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n                    furthestOriginalIndex = originalIndex;\n                    furthestModifiedIndex = modifiedIndex;\n                }\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n                // then check for overlap.\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n                    if (originalIndex >= reversePoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex <= reversePoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Check to see if we should be quitting early, before moving on to the next iteration.\n            var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {\n                // We can't finish, so skip ahead to generating a result from what we have.\n                quitEarlyArr[0] = true;\n                // Use the furthest distance we got in the forward direction.\n                midOriginalArr[0] = furthestOriginalIndex;\n                midModifiedArr[0] = furthestModifiedIndex;\n                if (matchLengthOfLongest > 0 && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                    // Enough of the history is in memory to walk it backwards\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                }\n                else {\n                    // We didn't actually remember enough of the history.\n                    //Since we are quiting the diff early, we need to shift back the originalStart and modified start\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\n                    originalStart++;\n                    modifiedStart++;\n                    return [\n                        new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n                    ];\n                }\n            }\n            // Run the algorithm in the reverse direction\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            for (diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalEnd, modifiedEnd)\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                }\n                else {\n                    originalIndex = reversePoints[diagonal - 1];\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n                // Save the current originalIndex so we can test for false overlap\n                tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // as long as the elements are equal.\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n                    originalIndex--;\n                    modifiedIndex--;\n                }\n                reversePoints[diagonal] = originalIndex;\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n                // and diagonal is in the range of forward diagonals computed for numDifferences\n                // then check for overlap.\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n                    if (originalIndex <= forwardPoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Save current vectors to history before the next iteration\n            if (numDifferences <= MaxDifferencesHistory) {\n                // We are allocating space for one extra int, which we fill with\n                // the index of the diagonal base index\n                var temp = new Array(diagonalForwardEnd - diagonalForwardStart + 2);\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n                MyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n                this.m_forwardHistory.push(temp);\n                temp = new Array(diagonalReverseEnd - diagonalReverseStart + 2);\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n                MyArray.Copy(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n                this.m_reverseHistory.push(temp);\n            }\n        }\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\n        // NOTE: This part is a bit messy\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n    };\n    /**\n     * Shifts the given changes to provide a more intuitive diff.\n     * While the first element in a diff matches the first element after the diff,\n     * we shift the diff down.\n     *\n     * @param changes The list of changes to shift\n     * @returns The shifted changes\n     */\n    LcsDiff.prototype.PrettifyChanges = function (changes) {\n        // Shift all the changes down first\n        for (var i = 0; i < changes.length; i++) {\n            var change = changes[i];\n            var originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this.OriginalSequence.getLength();\n            var modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this.ModifiedSequence.getLength();\n            var checkOriginal = change.originalLength > 0;\n            var checkModified = change.modifiedLength > 0;\n            while (change.originalStart + change.originalLength < originalStop &&\n                change.modifiedStart + change.modifiedLength < modifiedStop &&\n                (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) &&\n                (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n                change.originalStart++;\n                change.modifiedStart++;\n            }\n            var mergedChangeArr = [null];\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n                changes[i] = mergedChangeArr[0];\n                changes.splice(i + 1, 1);\n                i--;\n                continue;\n            }\n        }\n        // Shift changes back up until we hit empty or whitespace-only lines\n        for (var i = changes.length - 1; i >= 0; i--) {\n            var change = changes[i];\n            var originalStop = 0;\n            var modifiedStop = 0;\n            if (i > 0) {\n                var prevChange = changes[i - 1];\n                if (prevChange.originalLength > 0) {\n                    originalStop = prevChange.originalStart + prevChange.originalLength;\n                }\n                if (prevChange.modifiedLength > 0) {\n                    modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n                }\n            }\n            var checkOriginal = change.originalLength > 0;\n            var checkModified = change.modifiedLength > 0;\n            var bestDelta = 0;\n            var bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n            for (var delta = 1;; delta++) {\n                var originalStart = change.originalStart - delta;\n                var modifiedStart = change.modifiedStart - delta;\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\n                    break;\n                }\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n                    break;\n                }\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n                    break;\n                }\n                var score = this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength);\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestDelta = delta;\n                }\n            }\n            change.originalStart -= bestDelta;\n            change.modifiedStart -= bestDelta;\n        }\n        return changes;\n    };\n    LcsDiff.prototype._OriginalIsBoundary = function (index) {\n        if (index <= 0 || index >= this.OriginalSequence.getLength() - 1) {\n            return true;\n        }\n        var element = this.OriginalSequence.getElementAtIndex(index);\n        return (typeof element === 'string' && /^\\s*$/.test(element));\n    };\n    LcsDiff.prototype._OriginalRegionIsBoundary = function (originalStart, originalLength) {\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n            return true;\n        }\n        if (originalLength > 0) {\n            var originalEnd = originalStart + originalLength;\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    LcsDiff.prototype._ModifiedIsBoundary = function (index) {\n        if (index <= 0 || index >= this.ModifiedSequence.getLength() - 1) {\n            return true;\n        }\n        var element = this.ModifiedSequence.getElementAtIndex(index);\n        return (typeof element === 'string' && /^\\s*$/.test(element));\n    };\n    LcsDiff.prototype._ModifiedRegionIsBoundary = function (modifiedStart, modifiedLength) {\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n            return true;\n        }\n        if (modifiedLength > 0) {\n            var modifiedEnd = modifiedStart + modifiedLength;\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    LcsDiff.prototype._boundaryScore = function (originalStart, originalLength, modifiedStart, modifiedLength) {\n        var originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n        var modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n        return (originalScore + modifiedScore);\n    };\n    /**\n     * Concatenates the two input DiffChange lists and returns the resulting\n     * list.\n     * @param The left changes\n     * @param The right changes\n     * @returns The concatenated list\n     */\n    LcsDiff.prototype.ConcatenateChanges = function (left, right) {\n        var mergedChangeArr = [];\n        if (left.length === 0 || right.length === 0) {\n            return (right.length > 0) ? right : left;\n        }\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n            // Since we break the problem down recursively, it is possible that we\n            // might recurse in the middle of a change thereby splitting it into\n            // two changes. Here in the combining stage, we detect and fuse those\n            // changes back together\n            var result = new Array(left.length + right.length - 1);\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\n            result[left.length - 1] = mergedChangeArr[0];\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\n            return result;\n        }\n        else {\n            var result = new Array(left.length + right.length);\n            MyArray.Copy(left, 0, result, 0, left.length);\n            MyArray.Copy(right, 0, result, left.length, right.length);\n            return result;\n        }\n    };\n    /**\n     * Returns true if the two changes overlap and can be merged into a single\n     * change\n     * @param left The left change\n     * @param right The right change\n     * @param mergedChange The merged change if the two overlap, null otherwise\n     * @returns True if the two changes overlap\n     */\n    LcsDiff.prototype.ChangesOverlap = function (left, right, mergedChangeArr) {\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n            var originalStart = left.originalStart;\n            var originalLength = left.originalLength;\n            var modifiedStart = left.modifiedStart;\n            var modifiedLength = left.modifiedLength;\n            if (left.originalStart + left.originalLength >= right.originalStart) {\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\n            }\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n            }\n            mergedChangeArr[0] = new _diffChange_js__WEBPACK_IMPORTED_MODULE_0__[\"DiffChange\"](originalStart, originalLength, modifiedStart, modifiedLength);\n            return true;\n        }\n        else {\n            mergedChangeArr[0] = null;\n            return false;\n        }\n    };\n    /**\n     * Helper method used to clip a diagonal index to the range of valid\n     * diagonals. This also decides whether or not the diagonal index,\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\n     * one inside the boundary depending on the Even/Odd status of the boundary\n     * and numDifferences.\n     * @param diagonal The index of the diagonal to clip.\n     * @param numDifferences The current number of differences being iterated upon.\n     * @param diagonalBaseIndex The base reference diagonal.\n     * @param numDiagonals The total number of diagonals.\n     * @returns The clipped diagonal index.\n     */\n    LcsDiff.prototype.ClipDiagonalBound = function (diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n        if (diagonal >= 0 && diagonal < numDiagonals) {\n            // Nothing to clip, its in range\n            return diagonal;\n        }\n        // diagonalsBelow: The number of diagonals below the reference diagonal\n        // diagonalsAbove: The number of diagonals above the reference diagonal\n        var diagonalsBelow = diagonalBaseIndex;\n        var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n        var diffEven = (numDifferences % 2 === 0);\n        if (diagonal < 0) {\n            var lowerBoundEven = (diagonalsBelow % 2 === 0);\n            return (diffEven === lowerBoundEven) ? 0 : 1;\n        }\n        else {\n            var upperBoundEven = (diagonalsAbove % 2 === 0);\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n        }\n    };\n    return LcsDiff;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diff.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diffChange.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiffChange", function() { return DiffChange; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nvar DiffChange = /** @class */ (function () {\n    /**\n     * Constructs a new DiffChange with the given sequence information\n     * and content.\n     */\n    function DiffChange(originalStart, originalLength, modifiedStart, modifiedLength) {\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");\n        this.originalStart = originalStart;\n        this.originalLength = originalLength;\n        this.modifiedStart = modifiedStart;\n        this.modifiedLength = modifiedLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the original sequence.\n     */\n    DiffChange.prototype.getOriginalEnd = function () {\n        return this.originalStart + this.originalLength;\n    };\n    /**\n     * The end point (exclusive) of the change in the modified sequence.\n     */\n    DiffChange.prototype.getModifiedEnd = function () {\n        return this.modifiedStart + this.modifiedLength;\n    };\n    return DiffChange;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diffChange.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/errors.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ErrorHandler", function() { return ErrorHandler; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "errorHandler", function() { return errorHandler; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "onUnexpectedError", function() { return onUnexpectedError; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "onUnexpectedExternalError", function() { return onUnexpectedExternalError; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformErrorForSerialization", function() { return transformErrorForSerialization; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isPromiseCanceledError", function() { return isPromiseCanceledError; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "canceled", function() { return canceled; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "illegalArgument", function() { return illegalArgument; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "illegalState", function() { return illegalState; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nvar ErrorHandler = /** @class */ (function () {\n    function ErrorHandler() {\n        this.listeners = [];\n        this.unexpectedErrorHandler = function (e) {\n            setTimeout(function () {\n                if (e.stack) {\n                    throw new Error(e.message + \'\\n\\n\' + e.stack);\n                }\n                throw e;\n            }, 0);\n        };\n    }\n    ErrorHandler.prototype.emit = function (e) {\n        this.listeners.forEach(function (listener) {\n            listener(e);\n        });\n    };\n    ErrorHandler.prototype.onUnexpectedError = function (e) {\n        this.unexpectedErrorHandler(e);\n        this.emit(e);\n    };\n    // For external errors, we don\'t want the listeners to be called\n    ErrorHandler.prototype.onUnexpectedExternalError = function (e) {\n        this.unexpectedErrorHandler(e);\n    };\n    return ErrorHandler;\n}());\n\nvar errorHandler = new ErrorHandler();\nfunction onUnexpectedError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedError(e);\n    }\n    return undefined;\n}\nfunction onUnexpectedExternalError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedExternalError(e);\n    }\n    return undefined;\n}\nfunction transformErrorForSerialization(error) {\n    if (error instanceof Error) {\n        var name_1 = error.name, message = error.message;\n        var stack = error.stacktrace || error.stack;\n        return {\n            $isError: true,\n            name: name_1,\n            message: message,\n            stack: stack\n        };\n    }\n    // return as is\n    return error;\n}\nvar canceledName = \'Canceled\';\n/**\n * Checks if the given error is a promise in canceled state\n */\nfunction isPromiseCanceledError(error) {\n    return error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n/**\n * Returns an error that signals cancellation.\n */\nfunction canceled() {\n    var error = new Error(canceledName);\n    error.name = error.message;\n    return error;\n}\nfunction illegalArgument(name) {\n    if (name) {\n        return new Error("Illegal argument: " + name);\n    }\n    else {\n        return new Error(\'Illegal argument\');\n    }\n}\nfunction illegalState(name) {\n    if (name) {\n        return new Error("Illegal state: " + name);\n    }\n    else {\n        return new Error(\'Illegal state\');\n    }\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/errors.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/event.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Event", function() { return Event; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Emitter", function() { return Emitter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PauseableEmitter", function() { return PauseableEmitter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EventMultiplexer", function() { return EventMultiplexer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EventBufferer", function() { return EventBufferer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Relay", function() { return Relay; });\n/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./errors.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/errors.js");\n/* harmony import */ var _functional_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./functional.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/functional.js");\n/* harmony import */ var _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./lifecycle.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/lifecycle.js");\n/* harmony import */ var _linkedList_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./linkedList.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/linkedList.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\nvar Event;\n(function (Event) {\n    var _disposable = { dispose: function () { } };\n    Event.None = function () { return _disposable; };\n    /**\n     * Given an event, returns another event which only fires once.\n     */\n    function once(event) {\n        return function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            // we need this, in case the event fires during the listener call\n            var didFire = false;\n            var result;\n            result = event(function (e) {\n                if (didFire) {\n                    return;\n                }\n                else if (result) {\n                    result.dispose();\n                }\n                else {\n                    didFire = true;\n                }\n                return listener.call(thisArgs, e);\n            }, null, disposables);\n            if (didFire) {\n                result.dispose();\n            }\n            return result;\n        };\n    }\n    Event.once = once;\n    /**\n     * Given an event and a `map` function, returns another event which maps each element\n     * throught the mapping function.\n     */\n    function map(event, map) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (i) { return listener.call(thisArgs, map(i)); }, null, disposables);\n        });\n    }\n    Event.map = map;\n    /**\n     * Given an event and an `each` function, returns another identical event and calls\n     * the `each` function per each element.\n     */\n    function forEach(event, each) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (i) { each(i); listener.call(thisArgs, i); }, null, disposables);\n        });\n    }\n    Event.forEach = forEach;\n    function filter(event, filter) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (e) { return filter(e) && listener.call(thisArgs, e); }, null, disposables);\n        });\n    }\n    Event.filter = filter;\n    /**\n     * Given an event, returns the same event but typed as `Event<void>`.\n     */\n    function signal(event) {\n        return event;\n    }\n    Event.signal = signal;\n    /**\n     * Given a collection of events, returns a single event which emits\n     * whenever any of the provided events emit.\n     */\n    function any() {\n        var events = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            events[_i] = arguments[_i];\n        }\n        return function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return Object(_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__["combinedDisposable"])(events.map(function (event) { return event(function (e) { return listener.call(thisArgs, e); }, null, disposables); }));\n        };\n    }\n    Event.any = any;\n    /**\n     * Given an event and a `merge` function, returns another event which maps each element\n     * and the cummulative result throught the `merge` function. Similar to `map`, but with memory.\n     */\n    function reduce(event, merge, initial) {\n        var output = initial;\n        return map(event, function (e) {\n            output = merge(output, e);\n            return output;\n        });\n    }\n    Event.reduce = reduce;\n    /**\n     * Given a chain of event processing functions (filter, map, etc), each\n     * function will be invoked per event & per listener. Snapshotting an event\n     * chain allows each function to be invoked just once per event.\n     */\n    function snapshot(event) {\n        var listener;\n        var emitter = new Emitter({\n            onFirstListenerAdd: function () {\n                listener = event(emitter.fire, emitter);\n            },\n            onLastListenerRemove: function () {\n                listener.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.snapshot = snapshot;\n    function debounce(event, merge, delay, leading, leakWarningThreshold) {\n        if (delay === void 0) { delay = 100; }\n        if (leading === void 0) { leading = false; }\n        var subscription;\n        var output = undefined;\n        var handle = undefined;\n        var numDebouncedCalls = 0;\n        var emitter = new Emitter({\n            leakWarningThreshold: leakWarningThreshold,\n            onFirstListenerAdd: function () {\n                subscription = event(function (cur) {\n                    numDebouncedCalls++;\n                    output = merge(output, cur);\n                    if (leading && !handle) {\n                        emitter.fire(output);\n                    }\n                    clearTimeout(handle);\n                    handle = setTimeout(function () {\n                        var _output = output;\n                        output = undefined;\n                        handle = undefined;\n                        if (!leading || numDebouncedCalls > 1) {\n                            emitter.fire(_output);\n                        }\n                        numDebouncedCalls = 0;\n                    }, delay);\n                });\n            },\n            onLastListenerRemove: function () {\n                subscription.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.debounce = debounce;\n    /**\n     * Given an event, it returns another event which fires only once and as soon as\n     * the input event emits. The event data is the number of millis it took for the\n     * event to fire.\n     */\n    function stopwatch(event) {\n        var start = new Date().getTime();\n        return map(once(event), function (_) { return new Date().getTime() - start; });\n    }\n    Event.stopwatch = stopwatch;\n    /**\n     * Given an event, it returns another event which fires only when the event\n     * element changes.\n     */\n    function latch(event) {\n        var firstCall = true;\n        var cache;\n        return filter(event, function (value) {\n            var shouldEmit = firstCall || value !== cache;\n            firstCall = false;\n            cache = value;\n            return shouldEmit;\n        });\n    }\n    Event.latch = latch;\n    /**\n     * Buffers the provided event until a first listener comes\n     * along, at which point fire all the events at once and\n     * pipe the event from then on.\n     *\n     * ```typescript\n     * const emitter = new Emitter<number>();\n     * const event = emitter.event;\n     * const bufferedEvent = buffer(event);\n     *\n     * emitter.fire(1);\n     * emitter.fire(2);\n     * emitter.fire(3);\n     * // nothing...\n     *\n     * const listener = bufferedEvent(num => console.log(num));\n     * // 1, 2, 3\n     *\n     * emitter.fire(4);\n     * // 4\n     * ```\n     */\n    function buffer(event, nextTick, _buffer) {\n        if (nextTick === void 0) { nextTick = false; }\n        if (_buffer === void 0) { _buffer = []; }\n        var buffer = _buffer.slice();\n        var listener = event(function (e) {\n            if (buffer) {\n                buffer.push(e);\n            }\n            else {\n                emitter.fire(e);\n            }\n        });\n        var flush = function () {\n            if (buffer) {\n                buffer.forEach(function (e) { return emitter.fire(e); });\n            }\n            buffer = null;\n        };\n        var emitter = new Emitter({\n            onFirstListenerAdd: function () {\n                if (!listener) {\n                    listener = event(function (e) { return emitter.fire(e); });\n                }\n            },\n            onFirstListenerDidAdd: function () {\n                if (buffer) {\n                    if (nextTick) {\n                        setTimeout(flush);\n                    }\n                    else {\n                        flush();\n                    }\n                }\n            },\n            onLastListenerRemove: function () {\n                if (listener) {\n                    listener.dispose();\n                }\n                listener = null;\n            }\n        });\n        return emitter.event;\n    }\n    Event.buffer = buffer;\n    var ChainableEvent = /** @class */ (function () {\n        function ChainableEvent(event) {\n            this.event = event;\n        }\n        ChainableEvent.prototype.map = function (fn) {\n            return new ChainableEvent(map(this.event, fn));\n        };\n        ChainableEvent.prototype.forEach = function (fn) {\n            return new ChainableEvent(forEach(this.event, fn));\n        };\n        ChainableEvent.prototype.filter = function (fn) {\n            return new ChainableEvent(filter(this.event, fn));\n        };\n        ChainableEvent.prototype.reduce = function (merge, initial) {\n            return new ChainableEvent(reduce(this.event, merge, initial));\n        };\n        ChainableEvent.prototype.latch = function () {\n            return new ChainableEvent(latch(this.event));\n        };\n        ChainableEvent.prototype.on = function (listener, thisArgs, disposables) {\n            return this.event(listener, thisArgs, disposables);\n        };\n        ChainableEvent.prototype.once = function (listener, thisArgs, disposables) {\n            return once(this.event)(listener, thisArgs, disposables);\n        };\n        return ChainableEvent;\n    }());\n    function chain(event) {\n        return new ChainableEvent(event);\n    }\n    Event.chain = chain;\n    function fromNodeEventEmitter(emitter, eventName, map) {\n        if (map === void 0) { map = function (id) { return id; }; }\n        var fn = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return result.fire(map.apply(void 0, args));\n        };\n        var onFirstListenerAdd = function () { return emitter.on(eventName, fn); };\n        var onLastListenerRemove = function () { return emitter.removeListener(eventName, fn); };\n        var result = new Emitter({ onFirstListenerAdd: onFirstListenerAdd, onLastListenerRemove: onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromNodeEventEmitter = fromNodeEventEmitter;\n    function fromPromise(promise) {\n        var emitter = new Emitter();\n        var shouldEmit = false;\n        promise\n            .then(undefined, function () { return null; })\n            .then(function () {\n            if (!shouldEmit) {\n                setTimeout(function () { return emitter.fire(undefined); }, 0);\n            }\n            else {\n                emitter.fire(undefined);\n            }\n        });\n        shouldEmit = true;\n        return emitter.event;\n    }\n    Event.fromPromise = fromPromise;\n    function toPromise(event) {\n        return new Promise(function (c) { return once(event)(c); });\n    }\n    Event.toPromise = toPromise;\n})(Event || (Event = {}));\nvar _globalLeakWarningThreshold = -1;\nvar LeakageMonitor = /** @class */ (function () {\n    function LeakageMonitor(customThreshold, name) {\n        if (name === void 0) { name = Math.random().toString(18).slice(2, 5); }\n        this.customThreshold = customThreshold;\n        this.name = name;\n        this._warnCountdown = 0;\n    }\n    LeakageMonitor.prototype.dispose = function () {\n        if (this._stacks) {\n            this._stacks.clear();\n        }\n    };\n    LeakageMonitor.prototype.check = function (listenerCount) {\n        var _this = this;\n        var threshold = _globalLeakWarningThreshold;\n        if (typeof this.customThreshold === \'number\') {\n            threshold = this.customThreshold;\n        }\n        if (threshold <= 0 || listenerCount < threshold) {\n            return undefined;\n        }\n        if (!this._stacks) {\n            this._stacks = new Map();\n        }\n        var stack = new Error().stack.split(\'\\n\').slice(3).join(\'\\n\');\n        var count = (this._stacks.get(stack) || 0);\n        this._stacks.set(stack, count + 1);\n        this._warnCountdown -= 1;\n        if (this._warnCountdown <= 0) {\n            // only warn on first exceed and then every time the limit\n            // is exceeded by 50% again\n            this._warnCountdown = threshold * 0.5;\n            // find most frequent listener and print warning\n            var topStack_1;\n            var topCount_1 = 0;\n            this._stacks.forEach(function (count, stack) {\n                if (!topStack_1 || topCount_1 < count) {\n                    topStack_1 = stack;\n                    topCount_1 = count;\n                }\n            });\n            console.warn("[" + this.name + "] potential listener LEAK detected, having " + listenerCount + " listeners already. MOST frequent listener (" + topCount_1 + "):");\n            console.warn(topStack_1);\n        }\n        return function () {\n            var count = (_this._stacks.get(stack) || 0);\n            _this._stacks.set(stack, count - 1);\n        };\n    };\n    return LeakageMonitor;\n}());\n/**\n * The Emitter can be used to expose an Event to the public\n * to fire it from the insides.\n * Sample:\n    class Document {\n\n        private _onDidChange = new Emitter<(value:string)=>any>();\n\n        public onDidChange = this._onDidChange.event;\n\n        // getter-style\n        // get onDidChange(): Event<(value:string)=>any> {\n        // \treturn this._onDidChange.event;\n        // }\n\n        private _doIt() {\n            //...\n            this._onDidChange.fire(value);\n        }\n    }\n */\nvar Emitter = /** @class */ (function () {\n    function Emitter(options) {\n        this._disposed = false;\n        this._options = options;\n        this._leakageMon = _globalLeakWarningThreshold > 0\n            ? new LeakageMonitor(this._options && this._options.leakWarningThreshold)\n            : undefined;\n    }\n    Object.defineProperty(Emitter.prototype, "event", {\n        /**\n         * For the public to allow to subscribe\n         * to events from this Emitter\n         */\n        get: function () {\n            var _this = this;\n            if (!this._event) {\n                this._event = function (listener, thisArgs, disposables) {\n                    if (!_this._listeners) {\n                        _this._listeners = new _linkedList_js__WEBPACK_IMPORTED_MODULE_3__["LinkedList"]();\n                    }\n                    var firstListener = _this._listeners.isEmpty();\n                    if (firstListener && _this._options && _this._options.onFirstListenerAdd) {\n                        _this._options.onFirstListenerAdd(_this);\n                    }\n                    var remove = _this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\n                    if (firstListener && _this._options && _this._options.onFirstListenerDidAdd) {\n                        _this._options.onFirstListenerDidAdd(_this);\n                    }\n                    if (_this._options && _this._options.onListenerDidAdd) {\n                        _this._options.onListenerDidAdd(_this, listener, thisArgs);\n                    }\n                    // check and record this emitter for potential leakage\n                    var removeMonitor;\n                    if (_this._leakageMon) {\n                        removeMonitor = _this._leakageMon.check(_this._listeners.size);\n                    }\n                    var result;\n                    result = {\n                        dispose: function () {\n                            if (removeMonitor) {\n                                removeMonitor();\n                            }\n                            result.dispose = Emitter._noop;\n                            if (!_this._disposed) {\n                                remove();\n                                if (_this._options && _this._options.onLastListenerRemove) {\n                                    var hasListeners = (_this._listeners && !_this._listeners.isEmpty());\n                                    if (!hasListeners) {\n                                        _this._options.onLastListenerRemove(_this);\n                                    }\n                                }\n                            }\n                        }\n                    };\n                    if (Array.isArray(disposables)) {\n                        disposables.push(result);\n                    }\n                    return result;\n                };\n            }\n            return this._event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * To be kept private to fire an event to\n     * subscribers\n     */\n    Emitter.prototype.fire = function (event) {\n        if (this._listeners) {\n            // put all [listener,event]-pairs into delivery queue\n            // then emit all event. an inner/nested event might be\n            // the driver of this\n            if (!this._deliveryQueue) {\n                this._deliveryQueue = new _linkedList_js__WEBPACK_IMPORTED_MODULE_3__["LinkedList"]();\n            }\n            for (var iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {\n                this._deliveryQueue.push([e.value, event]);\n            }\n            while (this._deliveryQueue.size > 0) {\n                var _a = this._deliveryQueue.shift(), listener = _a[0], event_1 = _a[1];\n                try {\n                    if (typeof listener === \'function\') {\n                        listener.call(undefined, event_1);\n                    }\n                    else {\n                        listener[0].call(listener[1], event_1);\n                    }\n                }\n                catch (e) {\n                    Object(_errors_js__WEBPACK_IMPORTED_MODULE_0__["onUnexpectedError"])(e);\n                }\n            }\n        }\n    };\n    Emitter.prototype.dispose = function () {\n        if (this._listeners) {\n            this._listeners.clear();\n        }\n        if (this._deliveryQueue) {\n            this._deliveryQueue.clear();\n        }\n        if (this._leakageMon) {\n            this._leakageMon.dispose();\n        }\n        this._disposed = true;\n    };\n    Emitter._noop = function () { };\n    return Emitter;\n}());\n\nvar PauseableEmitter = /** @class */ (function (_super) {\n    __extends(PauseableEmitter, _super);\n    function PauseableEmitter(options) {\n        var _this = _super.call(this, options) || this;\n        _this._isPaused = 0;\n        _this._eventQueue = new _linkedList_js__WEBPACK_IMPORTED_MODULE_3__["LinkedList"]();\n        _this._mergeFn = options && options.merge;\n        return _this;\n    }\n    PauseableEmitter.prototype.pause = function () {\n        this._isPaused++;\n    };\n    PauseableEmitter.prototype.resume = function () {\n        if (this._isPaused !== 0 && --this._isPaused === 0) {\n            if (this._mergeFn) {\n                // use the merge function to create a single composite\n                // event. make a copy in case firing pauses this emitter\n                var events = this._eventQueue.toArray();\n                this._eventQueue.clear();\n                _super.prototype.fire.call(this, this._mergeFn(events));\n            }\n            else {\n                // no merging, fire each event individually and test\n                // that this emitter isn\'t paused halfway through\n                while (!this._isPaused && this._eventQueue.size !== 0) {\n                    _super.prototype.fire.call(this, this._eventQueue.shift());\n                }\n            }\n        }\n    };\n    PauseableEmitter.prototype.fire = function (event) {\n        if (this._listeners) {\n            if (this._isPaused !== 0) {\n                this._eventQueue.push(event);\n            }\n            else {\n                _super.prototype.fire.call(this, event);\n            }\n        }\n    };\n    return PauseableEmitter;\n}(Emitter));\n\nvar EventMultiplexer = /** @class */ (function () {\n    function EventMultiplexer() {\n        var _this = this;\n        this.hasListeners = false;\n        this.events = [];\n        this.emitter = new Emitter({\n            onFirstListenerAdd: function () { return _this.onFirstListenerAdd(); },\n            onLastListenerRemove: function () { return _this.onLastListenerRemove(); }\n        });\n    }\n    Object.defineProperty(EventMultiplexer.prototype, "event", {\n        get: function () {\n            return this.emitter.event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    EventMultiplexer.prototype.add = function (event) {\n        var _this = this;\n        var e = { event: event, listener: null };\n        this.events.push(e);\n        if (this.hasListeners) {\n            this.hook(e);\n        }\n        var dispose = function () {\n            if (_this.hasListeners) {\n                _this.unhook(e);\n            }\n            var idx = _this.events.indexOf(e);\n            _this.events.splice(idx, 1);\n        };\n        return Object(_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__["toDisposable"])(Object(_functional_js__WEBPACK_IMPORTED_MODULE_1__["once"])(dispose));\n    };\n    EventMultiplexer.prototype.onFirstListenerAdd = function () {\n        var _this = this;\n        this.hasListeners = true;\n        this.events.forEach(function (e) { return _this.hook(e); });\n    };\n    EventMultiplexer.prototype.onLastListenerRemove = function () {\n        var _this = this;\n        this.hasListeners = false;\n        this.events.forEach(function (e) { return _this.unhook(e); });\n    };\n    EventMultiplexer.prototype.hook = function (e) {\n        var _this = this;\n        e.listener = e.event(function (r) { return _this.emitter.fire(r); });\n    };\n    EventMultiplexer.prototype.unhook = function (e) {\n        if (e.listener) {\n            e.listener.dispose();\n        }\n        e.listener = null;\n    };\n    EventMultiplexer.prototype.dispose = function () {\n        this.emitter.dispose();\n    };\n    return EventMultiplexer;\n}());\n\n/**\n * The EventBufferer is useful in situations in which you want\n * to delay firing your events during some code.\n * You can wrap that code and be sure that the event will not\n * be fired during that wrap.\n *\n * ```\n * const emitter: Emitter;\n * const delayer = new EventDelayer();\n * const delayedEvent = delayer.wrapEvent(emitter.event);\n *\n * delayedEvent(console.log);\n *\n * delayer.bufferEvents(() => {\n *   emitter.fire(); // event will not be fired yet\n * });\n *\n * // event will only be fired at this point\n * ```\n */\nvar EventBufferer = /** @class */ (function () {\n    function EventBufferer() {\n        this.buffers = [];\n    }\n    EventBufferer.prototype.wrapEvent = function (event) {\n        var _this = this;\n        return function (listener, thisArgs, disposables) {\n            return event(function (i) {\n                var buffer = _this.buffers[_this.buffers.length - 1];\n                if (buffer) {\n                    buffer.push(function () { return listener.call(thisArgs, i); });\n                }\n                else {\n                    listener.call(thisArgs, i);\n                }\n            }, undefined, disposables);\n        };\n    };\n    EventBufferer.prototype.bufferEvents = function (fn) {\n        var buffer = [];\n        this.buffers.push(buffer);\n        var r = fn();\n        this.buffers.pop();\n        buffer.forEach(function (flush) { return flush(); });\n        return r;\n    };\n    return EventBufferer;\n}());\n\n/**\n * A Relay is an event forwarder which functions as a replugabble event pipe.\n * Once created, you can connect an input event to it and it will simply forward\n * events from that input event through its own `event` property. The `input`\n * can be changed at any point in time.\n */\nvar Relay = /** @class */ (function () {\n    function Relay() {\n        var _this = this;\n        this.listening = false;\n        this.inputEvent = Event.None;\n        this.inputEventListener = _lifecycle_js__WEBPACK_IMPORTED_MODULE_2__["Disposable"].None;\n        this.emitter = new Emitter({\n            onFirstListenerDidAdd: function () {\n                _this.listening = true;\n                _this.inputEventListener = _this.inputEvent(_this.emitter.fire, _this.emitter);\n            },\n            onLastListenerRemove: function () {\n                _this.listening = false;\n                _this.inputEventListener.dispose();\n            }\n        });\n        this.event = this.emitter.event;\n    }\n    Object.defineProperty(Relay.prototype, "input", {\n        set: function (event) {\n            this.inputEvent = event;\n            if (this.listening) {\n                this.inputEventListener.dispose();\n                this.inputEventListener = event(this.emitter.fire, this.emitter);\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Relay.prototype.dispose = function () {\n        this.inputEventListener.dispose();\n        this.emitter.dispose();\n    };\n    return Relay;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/event.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/functional.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "once", function() { return once; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nfunction once(fn) {\n    var _this = this;\n    var didCall = false;\n    var result;\n    return function () {\n        if (didCall) {\n            return result;\n        }\n        didCall = true;\n        result = fn.apply(_this, arguments);\n        return result;\n    };\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/functional.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/iterator.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FIN", function() { return FIN; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Iterator", function() { return Iterator; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getSequenceIterator", function() { return getSequenceIterator; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ArrayIterator", function() { return ArrayIterator; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ArrayNavigator", function() { return ArrayNavigator; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MappedIterator", function() { return MappedIterator; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar FIN = { done: true, value: undefined };\nvar Iterator;\n(function (Iterator) {\n    var _empty = {\n        next: function () {\n            return FIN;\n        }\n    };\n    function empty() {\n        return _empty;\n    }\n    Iterator.empty = empty;\n    function fromArray(array, index, length) {\n        if (index === void 0) { index = 0; }\n        if (length === void 0) { length = array.length; }\n        return {\n            next: function () {\n                if (index >= length) {\n                    return FIN;\n                }\n                return { done: false, value: array[index++] };\n            }\n        };\n    }\n    Iterator.fromArray = fromArray;\n    function from(elements) {\n        if (!elements) {\n            return Iterator.empty();\n        }\n        else if (Array.isArray(elements)) {\n            return Iterator.fromArray(elements);\n        }\n        else {\n            return elements;\n        }\n    }\n    Iterator.from = from;\n    function map(iterator, fn) {\n        return {\n            next: function () {\n                var element = iterator.next();\n                if (element.done) {\n                    return FIN;\n                }\n                else {\n                    return { done: false, value: fn(element.value) };\n                }\n            }\n        };\n    }\n    Iterator.map = map;\n    function filter(iterator, fn) {\n        return {\n            next: function () {\n                while (true) {\n                    var element = iterator.next();\n                    if (element.done) {\n                        return FIN;\n                    }\n                    if (fn(element.value)) {\n                        return { done: false, value: element.value };\n                    }\n                }\n            }\n        };\n    }\n    Iterator.filter = filter;\n    function forEach(iterator, fn) {\n        for (var next = iterator.next(); !next.done; next = iterator.next()) {\n            fn(next.value);\n        }\n    }\n    Iterator.forEach = forEach;\n    function collect(iterator) {\n        var result = [];\n        forEach(iterator, function (value) { return result.push(value); });\n        return result;\n    }\n    Iterator.collect = collect;\n})(Iterator || (Iterator = {}));\nfunction getSequenceIterator(arg) {\n    if (Array.isArray(arg)) {\n        return Iterator.fromArray(arg);\n    }\n    else {\n        return arg;\n    }\n}\nvar ArrayIterator = /** @class */ (function () {\n    function ArrayIterator(items, start, end, index) {\n        if (start === void 0) { start = 0; }\n        if (end === void 0) { end = items.length; }\n        if (index === void 0) { index = start - 1; }\n        this.items = items;\n        this.start = start;\n        this.end = end;\n        this.index = index;\n    }\n    ArrayIterator.prototype.next = function () {\n        this.index = Math.min(this.index + 1, this.end);\n        return this.current();\n    };\n    ArrayIterator.prototype.current = function () {\n        if (this.index === this.start - 1 || this.index === this.end) {\n            return null;\n        }\n        return this.items[this.index];\n    };\n    return ArrayIterator;\n}());\n\nvar ArrayNavigator = /** @class */ (function (_super) {\n    __extends(ArrayNavigator, _super);\n    function ArrayNavigator(items, start, end, index) {\n        if (start === void 0) { start = 0; }\n        if (end === void 0) { end = items.length; }\n        if (index === void 0) { index = start - 1; }\n        return _super.call(this, items, start, end, index) || this;\n    }\n    ArrayNavigator.prototype.current = function () {\n        return _super.prototype.current.call(this);\n    };\n    ArrayNavigator.prototype.previous = function () {\n        this.index = Math.max(this.index - 1, this.start - 1);\n        return this.current();\n    };\n    ArrayNavigator.prototype.first = function () {\n        this.index = this.start;\n        return this.current();\n    };\n    ArrayNavigator.prototype.last = function () {\n        this.index = this.end - 1;\n        return this.current();\n    };\n    ArrayNavigator.prototype.parent = function () {\n        return null;\n    };\n    return ArrayNavigator;\n}(ArrayIterator));\n\nvar MappedIterator = /** @class */ (function () {\n    function MappedIterator(iterator, fn) {\n        this.iterator = iterator;\n        this.fn = fn;\n        // noop\n    }\n    MappedIterator.prototype.next = function () { return this.fn(this.iterator.next()); };\n    return MappedIterator;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/iterator.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/keyCodes.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"KeyCodeUtils\", function() { return KeyCodeUtils; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"KeyChord\", function() { return KeyChord; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"createKeybinding\", function() { return createKeybinding; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"createSimpleKeybinding\", function() { return createSimpleKeybinding; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"SimpleKeybinding\", function() { return SimpleKeybinding; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ChordKeybinding\", function() { return ChordKeybinding; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ResolvedKeybindingPart\", function() { return ResolvedKeybindingPart; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ResolvedKeybinding\", function() { return ResolvedKeybinding; });\n/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./errors.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/errors.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nvar KeyCodeStrMap = /** @class */ (function () {\n    function KeyCodeStrMap() {\n        this._keyCodeToStr = [];\n        this._strToKeyCode = Object.create(null);\n    }\n    KeyCodeStrMap.prototype.define = function (keyCode, str) {\n        this._keyCodeToStr[keyCode] = str;\n        this._strToKeyCode[str.toLowerCase()] = keyCode;\n    };\n    KeyCodeStrMap.prototype.keyCodeToStr = function (keyCode) {\n        return this._keyCodeToStr[keyCode];\n    };\n    KeyCodeStrMap.prototype.strToKeyCode = function (str) {\n        return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;\n    };\n    return KeyCodeStrMap;\n}());\nvar uiMap = new KeyCodeStrMap();\nvar userSettingsUSMap = new KeyCodeStrMap();\nvar userSettingsGeneralMap = new KeyCodeStrMap();\n(function () {\n    function define(keyCode, uiLabel, usUserSettingsLabel, generalUserSettingsLabel) {\n        if (usUserSettingsLabel === void 0) { usUserSettingsLabel = uiLabel; }\n        if (generalUserSettingsLabel === void 0) { generalUserSettingsLabel = usUserSettingsLabel; }\n        uiMap.define(keyCode, uiLabel);\n        userSettingsUSMap.define(keyCode, usUserSettingsLabel);\n        userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel);\n    }\n    define(0 /* Unknown */, 'unknown');\n    define(1 /* Backspace */, 'Backspace');\n    define(2 /* Tab */, 'Tab');\n    define(3 /* Enter */, 'Enter');\n    define(4 /* Shift */, 'Shift');\n    define(5 /* Ctrl */, 'Ctrl');\n    define(6 /* Alt */, 'Alt');\n    define(7 /* PauseBreak */, 'PauseBreak');\n    define(8 /* CapsLock */, 'CapsLock');\n    define(9 /* Escape */, 'Escape');\n    define(10 /* Space */, 'Space');\n    define(11 /* PageUp */, 'PageUp');\n    define(12 /* PageDown */, 'PageDown');\n    define(13 /* End */, 'End');\n    define(14 /* Home */, 'Home');\n    define(15 /* LeftArrow */, 'LeftArrow', 'Left');\n    define(16 /* UpArrow */, 'UpArrow', 'Up');\n    define(17 /* RightArrow */, 'RightArrow', 'Right');\n    define(18 /* DownArrow */, 'DownArrow', 'Down');\n    define(19 /* Insert */, 'Insert');\n    define(20 /* Delete */, 'Delete');\n    define(21 /* KEY_0 */, '0');\n    define(22 /* KEY_1 */, '1');\n    define(23 /* KEY_2 */, '2');\n    define(24 /* KEY_3 */, '3');\n    define(25 /* KEY_4 */, '4');\n    define(26 /* KEY_5 */, '5');\n    define(27 /* KEY_6 */, '6');\n    define(28 /* KEY_7 */, '7');\n    define(29 /* KEY_8 */, '8');\n    define(30 /* KEY_9 */, '9');\n    define(31 /* KEY_A */, 'A');\n    define(32 /* KEY_B */, 'B');\n    define(33 /* KEY_C */, 'C');\n    define(34 /* KEY_D */, 'D');\n    define(35 /* KEY_E */, 'E');\n    define(36 /* KEY_F */, 'F');\n    define(37 /* KEY_G */, 'G');\n    define(38 /* KEY_H */, 'H');\n    define(39 /* KEY_I */, 'I');\n    define(40 /* KEY_J */, 'J');\n    define(41 /* KEY_K */, 'K');\n    define(42 /* KEY_L */, 'L');\n    define(43 /* KEY_M */, 'M');\n    define(44 /* KEY_N */, 'N');\n    define(45 /* KEY_O */, 'O');\n    define(46 /* KEY_P */, 'P');\n    define(47 /* KEY_Q */, 'Q');\n    define(48 /* KEY_R */, 'R');\n    define(49 /* KEY_S */, 'S');\n    define(50 /* KEY_T */, 'T');\n    define(51 /* KEY_U */, 'U');\n    define(52 /* KEY_V */, 'V');\n    define(53 /* KEY_W */, 'W');\n    define(54 /* KEY_X */, 'X');\n    define(55 /* KEY_Y */, 'Y');\n    define(56 /* KEY_Z */, 'Z');\n    define(57 /* Meta */, 'Meta');\n    define(58 /* ContextMenu */, 'ContextMenu');\n    define(59 /* F1 */, 'F1');\n    define(60 /* F2 */, 'F2');\n    define(61 /* F3 */, 'F3');\n    define(62 /* F4 */, 'F4');\n    define(63 /* F5 */, 'F5');\n    define(64 /* F6 */, 'F6');\n    define(65 /* F7 */, 'F7');\n    define(66 /* F8 */, 'F8');\n    define(67 /* F9 */, 'F9');\n    define(68 /* F10 */, 'F10');\n    define(69 /* F11 */, 'F11');\n    define(70 /* F12 */, 'F12');\n    define(71 /* F13 */, 'F13');\n    define(72 /* F14 */, 'F14');\n    define(73 /* F15 */, 'F15');\n    define(74 /* F16 */, 'F16');\n    define(75 /* F17 */, 'F17');\n    define(76 /* F18 */, 'F18');\n    define(77 /* F19 */, 'F19');\n    define(78 /* NumLock */, 'NumLock');\n    define(79 /* ScrollLock */, 'ScrollLock');\n    define(80 /* US_SEMICOLON */, ';', ';', 'OEM_1');\n    define(81 /* US_EQUAL */, '=', '=', 'OEM_PLUS');\n    define(82 /* US_COMMA */, ',', ',', 'OEM_COMMA');\n    define(83 /* US_MINUS */, '-', '-', 'OEM_MINUS');\n    define(84 /* US_DOT */, '.', '.', 'OEM_PERIOD');\n    define(85 /* US_SLASH */, '/', '/', 'OEM_2');\n    define(86 /* US_BACKTICK */, '`', '`', 'OEM_3');\n    define(110 /* ABNT_C1 */, 'ABNT_C1');\n    define(111 /* ABNT_C2 */, 'ABNT_C2');\n    define(87 /* US_OPEN_SQUARE_BRACKET */, '[', '[', 'OEM_4');\n    define(88 /* US_BACKSLASH */, '\\\\', '\\\\', 'OEM_5');\n    define(89 /* US_CLOSE_SQUARE_BRACKET */, ']', ']', 'OEM_6');\n    define(90 /* US_QUOTE */, '\\'', '\\'', 'OEM_7');\n    define(91 /* OEM_8 */, 'OEM_8');\n    define(92 /* OEM_102 */, 'OEM_102');\n    define(93 /* NUMPAD_0 */, 'NumPad0');\n    define(94 /* NUMPAD_1 */, 'NumPad1');\n    define(95 /* NUMPAD_2 */, 'NumPad2');\n    define(96 /* NUMPAD_3 */, 'NumPad3');\n    define(97 /* NUMPAD_4 */, 'NumPad4');\n    define(98 /* NUMPAD_5 */, 'NumPad5');\n    define(99 /* NUMPAD_6 */, 'NumPad6');\n    define(100 /* NUMPAD_7 */, 'NumPad7');\n    define(101 /* NUMPAD_8 */, 'NumPad8');\n    define(102 /* NUMPAD_9 */, 'NumPad9');\n    define(103 /* NUMPAD_MULTIPLY */, 'NumPad_Multiply');\n    define(104 /* NUMPAD_ADD */, 'NumPad_Add');\n    define(105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator');\n    define(106 /* NUMPAD_SUBTRACT */, 'NumPad_Subtract');\n    define(107 /* NUMPAD_DECIMAL */, 'NumPad_Decimal');\n    define(108 /* NUMPAD_DIVIDE */, 'NumPad_Divide');\n})();\nvar KeyCodeUtils;\n(function (KeyCodeUtils) {\n    function toString(keyCode) {\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toString = toString;\n    function fromString(key) {\n        return uiMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromString = fromString;\n    function toUserSettingsUS(keyCode) {\n        return userSettingsUSMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\n    function toUserSettingsGeneral(keyCode) {\n        return userSettingsGeneralMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\n    function fromUserSettings(key) {\n        return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromUserSettings = fromUserSettings;\n})(KeyCodeUtils || (KeyCodeUtils = {}));\nfunction KeyChord(firstPart, secondPart) {\n    var chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\n    return (firstPart | chordPart) >>> 0;\n}\nfunction createKeybinding(keybinding, OS) {\n    if (keybinding === 0) {\n        return null;\n    }\n    var firstPart = (keybinding & 0x0000FFFF) >>> 0;\n    var chordPart = (keybinding & 0xFFFF0000) >>> 16;\n    if (chordPart !== 0) {\n        return new ChordKeybinding([\n            createSimpleKeybinding(firstPart, OS),\n            createSimpleKeybinding(chordPart, OS)\n        ]);\n    }\n    return new ChordKeybinding([createSimpleKeybinding(firstPart, OS)]);\n}\nfunction createSimpleKeybinding(keybinding, OS) {\n    var ctrlCmd = (keybinding & 2048 /* CtrlCmd */ ? true : false);\n    var winCtrl = (keybinding & 256 /* WinCtrl */ ? true : false);\n    var ctrlKey = (OS === 2 /* Macintosh */ ? winCtrl : ctrlCmd);\n    var shiftKey = (keybinding & 1024 /* Shift */ ? true : false);\n    var altKey = (keybinding & 512 /* Alt */ ? true : false);\n    var metaKey = (OS === 2 /* Macintosh */ ? ctrlCmd : winCtrl);\n    var keyCode = (keybinding & 255 /* KeyCode */);\n    return new SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode);\n}\nvar SimpleKeybinding = /** @class */ (function () {\n    function SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode) {\n        this.ctrlKey = ctrlKey;\n        this.shiftKey = shiftKey;\n        this.altKey = altKey;\n        this.metaKey = metaKey;\n        this.keyCode = keyCode;\n    }\n    SimpleKeybinding.prototype.equals = function (other) {\n        return (this.ctrlKey === other.ctrlKey\n            && this.shiftKey === other.shiftKey\n            && this.altKey === other.altKey\n            && this.metaKey === other.metaKey\n            && this.keyCode === other.keyCode);\n    };\n    SimpleKeybinding.prototype.isModifierKey = function () {\n        return (this.keyCode === 0 /* Unknown */\n            || this.keyCode === 5 /* Ctrl */\n            || this.keyCode === 57 /* Meta */\n            || this.keyCode === 6 /* Alt */\n            || this.keyCode === 4 /* Shift */);\n    };\n    SimpleKeybinding.prototype.toChord = function () {\n        return new ChordKeybinding([this]);\n    };\n    /**\n     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?\n     */\n    SimpleKeybinding.prototype.isDuplicateModifierCase = function () {\n        return ((this.ctrlKey && this.keyCode === 5 /* Ctrl */)\n            || (this.shiftKey && this.keyCode === 4 /* Shift */)\n            || (this.altKey && this.keyCode === 6 /* Alt */)\n            || (this.metaKey && this.keyCode === 57 /* Meta */));\n    };\n    return SimpleKeybinding;\n}());\n\nvar ChordKeybinding = /** @class */ (function () {\n    function ChordKeybinding(parts) {\n        if (parts.length === 0) {\n            throw Object(_errors_js__WEBPACK_IMPORTED_MODULE_0__[\"illegalArgument\"])(\"parts\");\n        }\n        this.parts = parts;\n    }\n    ChordKeybinding.prototype.equals = function (other) {\n        if (other === null) {\n            return false;\n        }\n        if (this.parts.length !== other.parts.length) {\n            return false;\n        }\n        for (var i = 0; i < this.parts.length; i++) {\n            if (!this.parts[i].equals(other.parts[i])) {\n                return false;\n            }\n        }\n        return true;\n    };\n    return ChordKeybinding;\n}());\n\nvar ResolvedKeybindingPart = /** @class */ (function () {\n    function ResolvedKeybindingPart(ctrlKey, shiftKey, altKey, metaKey, kbLabel, kbAriaLabel) {\n        this.ctrlKey = ctrlKey;\n        this.shiftKey = shiftKey;\n        this.altKey = altKey;\n        this.metaKey = metaKey;\n        this.keyLabel = kbLabel;\n        this.keyAriaLabel = kbAriaLabel;\n    }\n    return ResolvedKeybindingPart;\n}());\n\n/**\n * A resolved keybinding. Can be a simple keybinding or a chord keybinding.\n */\nvar ResolvedKeybinding = /** @class */ (function () {\n    function ResolvedKeybinding() {\n    }\n    return ResolvedKeybinding;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/keyCodes.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/lifecycle.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isDisposable", function() { return isDisposable; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dispose", function() { return dispose; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "combinedDisposable", function() { return combinedDisposable; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toDisposable", function() { return toDisposable; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Disposable", function() { return Disposable; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ImmortalReference", function() { return ImmortalReference; });\nfunction isDisposable(thing) {\n    return typeof thing.dispose === \'function\'\n        && thing.dispose.length === 0;\n}\nfunction dispose(first) {\n    var rest = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        rest[_i - 1] = arguments[_i];\n    }\n    if (Array.isArray(first)) {\n        first.forEach(function (d) { return d && d.dispose(); });\n        return [];\n    }\n    else if (rest.length === 0) {\n        if (first) {\n            first.dispose();\n            return first;\n        }\n        return undefined;\n    }\n    else {\n        dispose(first);\n        dispose(rest);\n        return [];\n    }\n}\nfunction combinedDisposable(disposables) {\n    return { dispose: function () { return dispose(disposables); } };\n}\nfunction toDisposable(fn) {\n    return { dispose: function () { fn(); } };\n}\nvar Disposable = /** @class */ (function () {\n    function Disposable() {\n        this._toDispose = [];\n        this._lifecycle_disposable_isDisposed = false;\n    }\n    Disposable.prototype.dispose = function () {\n        this._lifecycle_disposable_isDisposed = true;\n        this._toDispose = dispose(this._toDispose);\n    };\n    Disposable.prototype._register = function (t) {\n        if (this._lifecycle_disposable_isDisposed) {\n            console.warn(\'Registering disposable on object that has already been disposed.\');\n            t.dispose();\n        }\n        else {\n            this._toDispose.push(t);\n        }\n        return t;\n    };\n    Disposable.None = Object.freeze({ dispose: function () { } });\n    return Disposable;\n}());\n\nvar ImmortalReference = /** @class */ (function () {\n    function ImmortalReference(object) {\n        this.object = object;\n    }\n    ImmortalReference.prototype.dispose = function () { };\n    return ImmortalReference;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/lifecycle.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/linkedList.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LinkedList", function() { return LinkedList; });\n/* harmony import */ var _iterator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./iterator.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/iterator.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nvar Node = /** @class */ (function () {\n    function Node(element) {\n        this.element = element;\n        this.next = Node.Undefined;\n        this.prev = Node.Undefined;\n    }\n    Node.Undefined = new Node(undefined);\n    return Node;\n}());\nvar LinkedList = /** @class */ (function () {\n    function LinkedList() {\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    }\n    Object.defineProperty(LinkedList.prototype, "size", {\n        get: function () {\n            return this._size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    LinkedList.prototype.isEmpty = function () {\n        return this._first === Node.Undefined;\n    };\n    LinkedList.prototype.clear = function () {\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    };\n    LinkedList.prototype.unshift = function (element) {\n        return this._insert(element, false);\n    };\n    LinkedList.prototype.push = function (element) {\n        return this._insert(element, true);\n    };\n    LinkedList.prototype._insert = function (element, atTheEnd) {\n        var _this = this;\n        var newNode = new Node(element);\n        if (this._first === Node.Undefined) {\n            this._first = newNode;\n            this._last = newNode;\n        }\n        else if (atTheEnd) {\n            // push\n            var oldLast = this._last;\n            this._last = newNode;\n            newNode.prev = oldLast;\n            oldLast.next = newNode;\n        }\n        else {\n            // unshift\n            var oldFirst = this._first;\n            this._first = newNode;\n            newNode.next = oldFirst;\n            oldFirst.prev = newNode;\n        }\n        this._size += 1;\n        var didRemove = false;\n        return function () {\n            if (!didRemove) {\n                didRemove = true;\n                _this._remove(newNode);\n            }\n        };\n    };\n    LinkedList.prototype.shift = function () {\n        if (this._first === Node.Undefined) {\n            return undefined;\n        }\n        else {\n            var res = this._first.element;\n            this._remove(this._first);\n            return res;\n        }\n    };\n    LinkedList.prototype._remove = function (node) {\n        if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {\n            // middle\n            var anchor = node.prev;\n            anchor.next = node.next;\n            node.next.prev = anchor;\n        }\n        else if (node.prev === Node.Undefined && node.next === Node.Undefined) {\n            // only node\n            this._first = Node.Undefined;\n            this._last = Node.Undefined;\n        }\n        else if (node.next === Node.Undefined) {\n            // last\n            this._last = this._last.prev;\n            this._last.next = Node.Undefined;\n        }\n        else if (node.prev === Node.Undefined) {\n            // first\n            this._first = this._first.next;\n            this._first.prev = Node.Undefined;\n        }\n        // done\n        this._size -= 1;\n    };\n    LinkedList.prototype.iterator = function () {\n        var element;\n        var node = this._first;\n        return {\n            next: function () {\n                if (node === Node.Undefined) {\n                    return _iterator_js__WEBPACK_IMPORTED_MODULE_0__["FIN"];\n                }\n                if (!element) {\n                    element = { done: false, value: node.element };\n                }\n                else {\n                    element.value = node.element;\n                }\n                node = node.next;\n                return element;\n            }\n        };\n    };\n    LinkedList.prototype.toArray = function () {\n        var result = [];\n        for (var node = this._first; node !== Node.Undefined; node = node.next) {\n            result.push(node.element);\n        }\n        return result;\n    };\n    return LinkedList;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/linkedList.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/platform.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* WEBPACK VAR INJECTION */(function(process, global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isWindows\", function() { return isWindows; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isMacintosh\", function() { return isMacintosh; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isLinux\", function() { return isLinux; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isNative\", function() { return isNative; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isWeb\", function() { return isWeb; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"globals\", function() { return globals; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"setImmediate\", function() { return setImmediate; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"OS\", function() { return OS; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar LANGUAGE_DEFAULT = 'en';\nvar _isWindows = false;\nvar _isMacintosh = false;\nvar _isLinux = false;\nvar _isNative = false;\nvar _isWeb = false;\nvar _locale = undefined;\nvar _language = LANGUAGE_DEFAULT;\nvar _translationsConfigFile = undefined;\nvar isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\n// OS detection\nif (typeof navigator === 'object' && !isElectronRenderer) {\n    var userAgent = navigator.userAgent;\n    _isWindows = userAgent.indexOf('Windows') >= 0;\n    _isMacintosh = userAgent.indexOf('Macintosh') >= 0;\n    _isLinux = userAgent.indexOf('Linux') >= 0;\n    _isWeb = true;\n    _locale = navigator.language;\n    _language = _locale;\n}\nelse if (typeof process === 'object') {\n    _isWindows = (process.platform === 'win32');\n    _isMacintosh = (process.platform === 'darwin');\n    _isLinux = (process.platform === 'linux');\n    _locale = LANGUAGE_DEFAULT;\n    _language = LANGUAGE_DEFAULT;\n    var rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];\n    if (rawNlsConfig) {\n        try {\n            var nlsConfig = JSON.parse(rawNlsConfig);\n            var resolved = nlsConfig.availableLanguages['*'];\n            _locale = nlsConfig.locale;\n            // VSCode's default language is 'en'\n            _language = resolved ? resolved : LANGUAGE_DEFAULT;\n            _translationsConfigFile = nlsConfig._translationsConfigFile;\n        }\n        catch (e) {\n        }\n    }\n    _isNative = true;\n}\nvar _platform = 0 /* Web */;\nif (_isNative) {\n    if (_isMacintosh) {\n        _platform = 1 /* Mac */;\n    }\n    else if (_isWindows) {\n        _platform = 3 /* Windows */;\n    }\n    else if (_isLinux) {\n        _platform = 2 /* Linux */;\n    }\n}\nvar isWindows = _isWindows;\nvar isMacintosh = _isMacintosh;\nvar isLinux = _isLinux;\nvar isNative = _isNative;\nvar isWeb = _isWeb;\nvar _globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});\nvar globals = _globals;\nvar _setImmediate = null;\nfunction setImmediate(callback) {\n    if (_setImmediate === null) {\n        if (globals.setImmediate) {\n            _setImmediate = globals.setImmediate.bind(globals);\n        }\n        else if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {\n            _setImmediate = process.nextTick.bind(process);\n        }\n        else {\n            _setImmediate = globals.setTimeout.bind(globals);\n        }\n    }\n    return _setImmediate(callback);\n}\nvar OS = (_isMacintosh ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../../_process@0.11.10@process/browser.js */ \"../node_modules/_process@0.11.10@process/browser.js\"), __webpack_require__(/*! ./../../../../../_webpack@4.41.2@webpack/buildin/global.js */ \"../node_modules/_webpack@4.41.2@webpack/buildin/global.js\")))\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/platform.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/strings.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"empty\", function() { return empty; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isFalsyOrWhitespace\", function() { return isFalsyOrWhitespace; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"pad\", function() { return pad; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"format\", function() { return format; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"escape\", function() { return escape; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"escapeRegExpCharacters\", function() { return escapeRegExpCharacters; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"trim\", function() { return trim; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ltrim\", function() { return ltrim; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"rtrim\", function() { return rtrim; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"convertSimple2RegExpPattern\", function() { return convertSimple2RegExpPattern; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"startsWith\", function() { return startsWith; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"endsWith\", function() { return endsWith; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"createRegExp\", function() { return createRegExp; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"regExpLeadsToEndlessLoop\", function() { return regExpLeadsToEndlessLoop; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"regExpFlags\", function() { return regExpFlags; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"firstNonWhitespaceIndex\", function() { return firstNonWhitespaceIndex; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"getLeadingWhitespace\", function() { return getLeadingWhitespace; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"lastNonWhitespaceIndex\", function() { return lastNonWhitespaceIndex; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"compare\", function() { return compare; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isLowerAsciiLetter\", function() { return isLowerAsciiLetter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isUpperAsciiLetter\", function() { return isUpperAsciiLetter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"equalsIgnoreCase\", function() { return equalsIgnoreCase; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"startsWithIgnoreCase\", function() { return startsWithIgnoreCase; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"commonPrefixLength\", function() { return commonPrefixLength; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"commonSuffixLength\", function() { return commonSuffixLength; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isHighSurrogate\", function() { return isHighSurrogate; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isLowSurrogate\", function() { return isLowSurrogate; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"containsRTL\", function() { return containsRTL; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"containsEmoji\", function() { return containsEmoji; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isBasicASCII\", function() { return isBasicASCII; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"containsFullWidthCharacter\", function() { return containsFullWidthCharacter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"isFullWidthCharacter\", function() { return isFullWidthCharacter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"UTF8_BOM_CHARACTER\", function() { return UTF8_BOM_CHARACTER; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"startsWithUTF8BOM\", function() { return startsWithUTF8BOM; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"safeBtoa\", function() { return safeBtoa; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"repeat\", function() { return repeat; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * The empty string.\n */\nvar empty = '';\nfunction isFalsyOrWhitespace(str) {\n    if (!str || typeof str !== 'string') {\n        return true;\n    }\n    return str.trim().length === 0;\n}\n/**\n * @returns the provided number with the given number of preceding zeros.\n */\nfunction pad(n, l, char) {\n    if (char === void 0) { char = '0'; }\n    var str = '' + n;\n    var r = [str];\n    for (var i = str.length; i < l; i++) {\n        r.push(char);\n    }\n    return r.reverse().join('');\n}\nvar _formatRegexp = /{(\\d+)}/g;\n/**\n * Helper to produce a string with a variable number of arguments. Insert variable segments\n * into the string using the {n} notation where N is the index of the argument following the string.\n * @param value string to which formatting is applied\n * @param args replacements for {n}-entries\n */\nfunction format(value) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (args.length === 0) {\n        return value;\n    }\n    return value.replace(_formatRegexp, function (match, group) {\n        var idx = parseInt(group, 10);\n        return isNaN(idx) || idx < 0 || idx >= args.length ?\n            match :\n            args[idx];\n    });\n}\n/**\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\n * being used e.g. in HTMLElement.innerHTML.\n */\nfunction escape(html) {\n    return html.replace(/[<>&]/g, function (match) {\n        switch (match) {\n            case '<': return '&lt;';\n            case '>': return '&gt;';\n            case '&': return '&amp;';\n            default: return match;\n        }\n    });\n}\n/**\n * Escapes regular expression characters in a given string\n */\nfunction escapeRegExpCharacters(value) {\n    return value.replace(/[\\-\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)\\#]/g, '\\\\$&');\n}\n/**\n * Removes all occurrences of needle from the beginning and end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim (default is a blank)\n */\nfunction trim(haystack, needle) {\n    if (needle === void 0) { needle = ' '; }\n    var trimmed = ltrim(haystack, needle);\n    return rtrim(trimmed, needle);\n}\n/**\n * Removes all occurrences of needle from the beginning of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nfunction ltrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    var needleLen = needle.length;\n    if (needleLen === 0 || haystack.length === 0) {\n        return haystack;\n    }\n    var offset = 0;\n    while (haystack.indexOf(needle, offset) === offset) {\n        offset = offset + needleLen;\n    }\n    return haystack.substring(offset);\n}\n/**\n * Removes all occurrences of needle from the end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nfunction rtrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    var needleLen = needle.length, haystackLen = haystack.length;\n    if (needleLen === 0 || haystackLen === 0) {\n        return haystack;\n    }\n    var offset = haystackLen, idx = -1;\n    while (true) {\n        idx = haystack.lastIndexOf(needle, offset - 1);\n        if (idx === -1 || idx + needleLen !== offset) {\n            break;\n        }\n        if (idx === 0) {\n            return '';\n        }\n        offset = idx;\n    }\n    return haystack.substring(0, offset);\n}\nfunction convertSimple2RegExpPattern(pattern) {\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\n/**\n * Determines if haystack starts with needle.\n */\nfunction startsWith(haystack, needle) {\n    if (haystack.length < needle.length) {\n        return false;\n    }\n    if (haystack === needle) {\n        return true;\n    }\n    for (var i = 0; i < needle.length; i++) {\n        if (haystack[i] !== needle[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Determines if haystack ends with needle.\n */\nfunction endsWith(haystack, needle) {\n    var diff = haystack.length - needle.length;\n    if (diff > 0) {\n        return haystack.indexOf(needle, diff) === diff;\n    }\n    else if (diff === 0) {\n        return haystack === needle;\n    }\n    else {\n        return false;\n    }\n}\nfunction createRegExp(searchString, isRegex, options) {\n    if (options === void 0) { options = {}; }\n    if (!searchString) {\n        throw new Error('Cannot create regex from empty string');\n    }\n    if (!isRegex) {\n        searchString = escapeRegExpCharacters(searchString);\n    }\n    if (options.wholeWord) {\n        if (!/\\B/.test(searchString.charAt(0))) {\n            searchString = '\\\\b' + searchString;\n        }\n        if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n            searchString = searchString + '\\\\b';\n        }\n    }\n    var modifiers = '';\n    if (options.global) {\n        modifiers += 'g';\n    }\n    if (!options.matchCase) {\n        modifiers += 'i';\n    }\n    if (options.multiline) {\n        modifiers += 'm';\n    }\n    if (options.unicode) {\n        modifiers += 'u';\n    }\n    return new RegExp(searchString, modifiers);\n}\nfunction regExpLeadsToEndlessLoop(regexp) {\n    // Exit early if it's one of these special cases which are meant to match\n    // against an empty string\n    if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n        return false;\n    }\n    // We check against an empty string. If the regular expression doesn't advance\n    // (e.g. ends in an endless loop) it will match an empty string.\n    var match = regexp.exec('');\n    return !!(match && regexp.lastIndex === 0);\n}\nfunction regExpFlags(regexp) {\n    return (regexp.global ? 'g' : '')\n        + (regexp.ignoreCase ? 'i' : '')\n        + (regexp.multiline ? 'm' : '')\n        + (regexp.unicode ? 'u' : '');\n}\n/**\n * Returns first index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nfunction firstNonWhitespaceIndex(str) {\n    for (var i = 0, len = str.length; i < len; i++) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\n/**\n * Returns the leading whitespace of the string.\n * If the string contains only whitespaces, returns entire string\n */\nfunction getLeadingWhitespace(str, start, end) {\n    if (start === void 0) { start = 0; }\n    if (end === void 0) { end = str.length; }\n    for (var i = start; i < end; i++) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return str.substring(start, i);\n        }\n    }\n    return str.substring(start, end);\n}\n/**\n * Returns last index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nfunction lastNonWhitespaceIndex(str, startIndex) {\n    if (startIndex === void 0) { startIndex = str.length - 1; }\n    for (var i = startIndex; i >= 0; i--) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\nfunction compare(a, b) {\n    if (a < b) {\n        return -1;\n    }\n    else if (a > b) {\n        return 1;\n    }\n    else {\n        return 0;\n    }\n}\nfunction isLowerAsciiLetter(code) {\n    return code >= 97 /* a */ && code <= 122 /* z */;\n}\nfunction isUpperAsciiLetter(code) {\n    return code >= 65 /* A */ && code <= 90 /* Z */;\n}\nfunction isAsciiLetter(code) {\n    return isLowerAsciiLetter(code) || isUpperAsciiLetter(code);\n}\nfunction equalsIgnoreCase(a, b) {\n    var len1 = a ? a.length : 0;\n    var len2 = b ? b.length : 0;\n    if (len1 !== len2) {\n        return false;\n    }\n    return doEqualsIgnoreCase(a, b);\n}\nfunction doEqualsIgnoreCase(a, b, stopAt) {\n    if (stopAt === void 0) { stopAt = a.length; }\n    if (typeof a !== 'string' || typeof b !== 'string') {\n        return false;\n    }\n    for (var i = 0; i < stopAt; i++) {\n        var codeA = a.charCodeAt(i);\n        var codeB = b.charCodeAt(i);\n        if (codeA === codeB) {\n            continue;\n        }\n        // a-z A-Z\n        if (isAsciiLetter(codeA) && isAsciiLetter(codeB)) {\n            var diff = Math.abs(codeA - codeB);\n            if (diff !== 0 && diff !== 32) {\n                return false;\n            }\n        }\n        // Any other charcode\n        else {\n            if (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\nfunction startsWithIgnoreCase(str, candidate) {\n    var candidateLength = candidate.length;\n    if (candidate.length > str.length) {\n        return false;\n    }\n    return doEqualsIgnoreCase(str, candidate, candidateLength);\n}\n/**\n * @returns the length of the common prefix of the two strings.\n */\nfunction commonPrefixLength(a, b) {\n    var i, len = Math.min(a.length, b.length);\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(i) !== b.charCodeAt(i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * @returns the length of the common suffix of the two strings.\n */\nfunction commonSuffixLength(a, b) {\n    var i, len = Math.min(a.length, b.length);\n    var aLastIndex = a.length - 1;\n    var bLastIndex = b.length - 1;\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n            return i;\n        }\n    }\n    return len;\n}\n// --- unicode\n// http://en.wikipedia.org/wiki/Surrogate_pair\n// Returns the code point starting at a specified index in a string\n// Code points U+0000 to U+D7FF and U+E000 to U+FFFF are represented on a single character\n// Code points U+10000 to U+10FFFF are represented on two consecutive characters\n//export function getUnicodePoint(str:string, index:number, len:number):number {\n//\tconst chrCode = str.charCodeAt(index);\n//\tif (0xD800 <= chrCode && chrCode <= 0xDBFF && index + 1 < len) {\n//\t\tconst nextChrCode = str.charCodeAt(index + 1);\n//\t\tif (0xDC00 <= nextChrCode && nextChrCode <= 0xDFFF) {\n//\t\t\treturn (chrCode - 0xD800) << 10 + (nextChrCode - 0xDC00) + 0x10000;\n//\t\t}\n//\t}\n//\treturn chrCode;\n//}\nfunction isHighSurrogate(charCode) {\n    return (0xD800 <= charCode && charCode <= 0xDBFF);\n}\nfunction isLowSurrogate(charCode) {\n    return (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n/**\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-rtl-test.js\n */\nvar 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])/;\n/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nfunction containsRTL(str) {\n    return CONTAINS_RTL.test(str);\n}\n/**\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-emoji-test.js\n */\nvar CONTAINS_EMOJI = /(?:[\\u231A\\u231B\\u23F0\\u23F3\\u2600-\\u27BF\\u2B50\\u2B55]|\\uD83C[\\uDDE6-\\uDDFF\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDE4F\\uDE80-\\uDEF8]|\\uD83E[\\uDD00-\\uDDE6])/;\nfunction containsEmoji(str) {\n    return CONTAINS_EMOJI.test(str);\n}\nvar IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\n/**\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\n */\nfunction isBasicASCII(str) {\n    return IS_BASIC_ASCII.test(str);\n}\nfunction containsFullWidthCharacter(str) {\n    for (var i = 0, len = str.length; i < len; i++) {\n        if (isFullWidthCharacter(str.charCodeAt(i))) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction isFullWidthCharacter(charCode) {\n    // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n    // http://jrgraphix.net/research/unicode_blocks.php\n    //          2E80 — 2EFF   CJK Radicals Supplement\n    //          2F00 — 2FDF   Kangxi Radicals\n    //          2FF0 — 2FFF   Ideographic Description Characters\n    //          3000 — 303F   CJK Symbols and Punctuation\n    //          3040 — 309F   Hiragana\n    //          30A0 — 30FF   Katakana\n    //          3100 — 312F   Bopomofo\n    //          3130 — 318F   Hangul Compatibility Jamo\n    //          3190 — 319F   Kanbun\n    //          31A0 — 31BF   Bopomofo Extended\n    //          31F0 — 31FF   Katakana Phonetic Extensions\n    //          3200 — 32FF   Enclosed CJK Letters and Months\n    //          3300 — 33FF   CJK Compatibility\n    //          3400 — 4DBF   CJK Unified Ideographs Extension A\n    //          4DC0 — 4DFF   Yijing Hexagram Symbols\n    //          4E00 — 9FFF   CJK Unified Ideographs\n    //          A000 — A48F   Yi Syllables\n    //          A490 — A4CF   Yi Radicals\n    //          AC00 — D7AF   Hangul Syllables\n    // [IGNORE] D800 — DB7F   High Surrogates\n    // [IGNORE] DB80 — DBFF   High Private Use Surrogates\n    // [IGNORE] DC00 — DFFF   Low Surrogates\n    // [IGNORE] E000 — F8FF   Private Use Area\n    //          F900 — FAFF   CJK Compatibility Ideographs\n    // [IGNORE] FB00 — FB4F   Alphabetic Presentation Forms\n    // [IGNORE] FB50 — FDFF   Arabic Presentation Forms-A\n    // [IGNORE] FE00 — FE0F   Variation Selectors\n    // [IGNORE] FE20 — FE2F   Combining Half Marks\n    // [IGNORE] FE30 — FE4F   CJK Compatibility Forms\n    // [IGNORE] FE50 — FE6F   Small Form Variants\n    // [IGNORE] FE70 — FEFF   Arabic Presentation Forms-B\n    //          FF00 — FFEF   Halfwidth and Fullwidth Forms\n    //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n    //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n    // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul\n    // [IGNORE] FFF0 — FFFF   Specials\n    charCode = +charCode; // @perf\n    return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\n        || (charCode >= 0xF900 && charCode <= 0xFAFF)\n        || (charCode >= 0xFF01 && charCode <= 0xFF5E));\n}\n// -- UTF-8 BOM\nvar UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);\nfunction startsWithUTF8BOM(str) {\n    return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);\n}\nfunction safeBtoa(str) {\n    return btoa(encodeURIComponent(str)); // we use encodeURIComponent because btoa fails for non Latin 1 values\n}\nfunction repeat(s, count) {\n    var result = '';\n    for (var i = 0; i < count; i++) {\n        result += s;\n    }\n    return result;\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/strings.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/types.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isArray", function() { return isArray; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isString", function() { return isString; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isObject", function() { return isObject; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isNumber", function() { return isNumber; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isBoolean", function() { return isBoolean; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isUndefined", function() { return isUndefined; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isUndefinedOrNull", function() { return isUndefinedOrNull; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isEmptyObject", function() { return isEmptyObject; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFunction", function() { return isFunction; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateConstraints", function() { return validateConstraints; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validateConstraint", function() { return validateConstraint; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getAllPropertyNames", function() { return getAllPropertyNames; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "withNullAsUndefined", function() { return withNullAsUndefined; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "withUndefinedAsNull", function() { return withUndefinedAsNull; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _typeof = {\n    number: \'number\',\n    string: \'string\',\n    undefined: \'undefined\',\n    object: \'object\',\n    function: \'function\'\n};\n/**\n * @returns whether the provided parameter is a JavaScript Array or not.\n */\nfunction isArray(array) {\n    if (Array.isArray) {\n        return Array.isArray(array);\n    }\n    if (array && typeof (array.length) === _typeof.number && array.constructor === Array) {\n        return true;\n    }\n    return false;\n}\n/**\n * @returns whether the provided parameter is a JavaScript String or not.\n */\nfunction isString(str) {\n    if (typeof (str) === _typeof.string || str instanceof String) {\n        return true;\n    }\n    return false;\n}\n/**\n *\n * @returns whether the provided parameter is of type `object` but **not**\n *\t`null`, an `array`, a `regexp`, nor a `date`.\n */\nfunction isObject(obj) {\n    // The method can\'t do a type cast since there are type (like strings) which\n    // are subclasses of any put not positvely matched by the function. Hence type\n    // narrowing results in wrong results.\n    return typeof obj === _typeof.object\n        && obj !== null\n        && !Array.isArray(obj)\n        && !(obj instanceof RegExp)\n        && !(obj instanceof Date);\n}\n/**\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\n * @returns whether the provided parameter is a JavaScript Number or not.\n */\nfunction isNumber(obj) {\n    if ((typeof (obj) === _typeof.number || obj instanceof Number) && !isNaN(obj)) {\n        return true;\n    }\n    return false;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Boolean or not.\n */\nfunction isBoolean(obj) {\n    return obj === true || obj === false;\n}\n/**\n * @returns whether the provided parameter is undefined.\n */\nfunction isUndefined(obj) {\n    return typeof (obj) === _typeof.undefined;\n}\n/**\n * @returns whether the provided parameter is undefined or null.\n */\nfunction isUndefinedOrNull(obj) {\n    return isUndefined(obj) || obj === null;\n}\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * @returns whether the provided parameter is an empty JavaScript Object or not.\n */\nfunction isEmptyObject(obj) {\n    if (!isObject(obj)) {\n        return false;\n    }\n    for (var key in obj) {\n        if (hasOwnProperty.call(obj, key)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Function or not.\n */\nfunction isFunction(obj) {\n    return typeof obj === _typeof.function;\n}\nfunction validateConstraints(args, constraints) {\n    var len = Math.min(args.length, constraints.length);\n    for (var i = 0; i < len; i++) {\n        validateConstraint(args[i], constraints[i]);\n    }\n}\nfunction validateConstraint(arg, constraint) {\n    if (isString(constraint)) {\n        if (typeof arg !== constraint) {\n            throw new Error("argument does not match constraint: typeof " + constraint);\n        }\n    }\n    else if (isFunction(constraint)) {\n        try {\n            if (arg instanceof constraint) {\n                return;\n            }\n        }\n        catch (_a) {\n            // ignore\n        }\n        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\n            return;\n        }\n        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\n            return;\n        }\n        throw new Error("argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true");\n    }\n}\nfunction getAllPropertyNames(obj) {\n    var res = [];\n    var proto = Object.getPrototypeOf(obj);\n    while (Object.prototype !== proto) {\n        res = res.concat(Object.getOwnPropertyNames(proto));\n        proto = Object.getPrototypeOf(proto);\n    }\n    return res;\n}\n/**\n * Converts null to undefined, passes all other values through.\n */\nfunction withNullAsUndefined(x) {\n    return x === null ? undefined : x;\n}\n/**\n * Converts undefined to null, passes all other values through.\n */\nfunction withUndefinedAsNull(x) {\n    return typeof x === \'undefined\' ? null : x;\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/types.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/uri.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"URI\", function() { return URI; });\n/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./platform.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/platform.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar _a;\n\nvar _schemePattern = /^\\w[\\w\\d+.-]*$/;\nvar _singleSlashStart = /^\\//;\nvar _doubleSlashStart = /^\\/\\//;\nvar _throwOnMissingSchema = true;\nfunction _validateUri(ret, _strict) {\n    // scheme, must be set\n    if (!ret.scheme) {\n        if (_strict || _throwOnMissingSchema) {\n            throw new Error(\"[UriError]: Scheme is missing: {scheme: \\\"\\\", authority: \\\"\" + ret.authority + \"\\\", path: \\\"\" + ret.path + \"\\\", query: \\\"\" + ret.query + \"\\\", fragment: \\\"\" + ret.fragment + \"\\\"}\");\n        }\n        else {\n            console.warn(\"[UriError]: Scheme is missing: {scheme: \\\"\\\", authority: \\\"\" + ret.authority + \"\\\", path: \\\"\" + ret.path + \"\\\", query: \\\"\" + ret.query + \"\\\", fragment: \\\"\" + ret.fragment + \"\\\"}\");\n        }\n    }\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n        throw new Error('[UriError]: Scheme contains illegal characters.');\n    }\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\n    // If a URI contains an authority component, then the path component\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\n    // does not contain an authority component, then the path cannot begin\n    // with two slash characters (\"//\").\n    if (ret.path) {\n        if (ret.authority) {\n            if (!_singleSlashStart.test(ret.path)) {\n                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');\n            }\n        }\n        else {\n            if (_doubleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n            }\n        }\n    }\n}\n// for a while we allowed uris *without* schemes and this is the migration\n// for them, e.g. an uri without scheme and without strict-mode warns and falls\n// back to the file-scheme. that should cause the least carnage and still be a\n// clear warning\nfunction _schemeFix(scheme, _strict) {\n    if (_strict || _throwOnMissingSchema) {\n        return scheme || _empty;\n    }\n    if (!scheme) {\n        console.trace('BAD uri lacks scheme, falling back to file-scheme.');\n        scheme = 'file';\n    }\n    return scheme;\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n    // the slash-character is our 'default base' as we don't\n    // support constructing URIs relative to other URIs. This\n    // also means that we alter and potentially break paths.\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n    switch (scheme) {\n        case 'https':\n        case 'http':\n        case 'file':\n            if (!path) {\n                path = _slash;\n            }\n            else if (path[0] !== _slash) {\n                path = _slash + path;\n            }\n            break;\n    }\n    return path;\n}\nvar _empty = '';\nvar _slash = '/';\nvar _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n *       foo://example.com:8042/over/there?name=ferret#nose\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\n *        |           |            |            |        |\n *     scheme     authority       path        query   fragment\n *        |   _____________________|__\n *       / \\ /                        \\\n *       urn:example:animal:ferret:nose\n */\nvar URI = /** @class */ (function () {\n    /**\n     * @internal\n     */\n    function URI(schemeOrData, authority, path, query, fragment, _strict) {\n        if (_strict === void 0) { _strict = false; }\n        if (typeof schemeOrData === 'object') {\n            this.scheme = schemeOrData.scheme || _empty;\n            this.authority = schemeOrData.authority || _empty;\n            this.path = schemeOrData.path || _empty;\n            this.query = schemeOrData.query || _empty;\n            this.fragment = schemeOrData.fragment || _empty;\n            // no validation because it's this URI\n            // that creates uri components.\n            // _validateUri(this);\n        }\n        else {\n            this.scheme = _schemeFix(schemeOrData, _strict);\n            this.authority = authority || _empty;\n            this.path = _referenceResolution(this.scheme, path || _empty);\n            this.query = query || _empty;\n            this.fragment = fragment || _empty;\n            _validateUri(this, _strict);\n        }\n    }\n    URI.isUri = function (thing) {\n        if (thing instanceof URI) {\n            return true;\n        }\n        if (!thing) {\n            return false;\n        }\n        return typeof thing.authority === 'string'\n            && typeof thing.fragment === 'string'\n            && typeof thing.path === 'string'\n            && typeof thing.query === 'string'\n            && typeof thing.scheme === 'string'\n            && typeof thing.fsPath === 'function'\n            && typeof thing.with === 'function'\n            && typeof thing.toString === 'function';\n    };\n    Object.defineProperty(URI.prototype, \"fsPath\", {\n        // ---- filesystem path -----------------------\n        /**\n         * Returns a string representing the corresponding file system path of this URI.\n         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n         * platform specific path separator.\n         *\n         * * Will *not* validate the path for invalid characters and semantics.\n         * * Will *not* look at the scheme of this URI.\n         * * The result shall *not* be used for display purposes but for accessing a file on disk.\n         *\n         *\n         * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n         *\n         * ```ts\n            const u = URI.parse('file://server/c$/folder/file.txt')\n            u.authority === 'server'\n            u.path === '/shares/c$/file.txt'\n            u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n        ```\n         *\n         * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n         * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n         * with URIs that represent files on disk (`file` scheme).\n         */\n        get: function () {\n            // if (this.scheme !== 'file') {\n            // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n            // }\n            return _makeFsPath(this);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // ---- modify to new -------------------------\n    URI.prototype.with = function (change) {\n        if (!change) {\n            return this;\n        }\n        var scheme = change.scheme, authority = change.authority, path = change.path, query = change.query, fragment = change.fragment;\n        if (scheme === undefined) {\n            scheme = this.scheme;\n        }\n        else if (scheme === null) {\n            scheme = _empty;\n        }\n        if (authority === undefined) {\n            authority = this.authority;\n        }\n        else if (authority === null) {\n            authority = _empty;\n        }\n        if (path === undefined) {\n            path = this.path;\n        }\n        else if (path === null) {\n            path = _empty;\n        }\n        if (query === undefined) {\n            query = this.query;\n        }\n        else if (query === null) {\n            query = _empty;\n        }\n        if (fragment === undefined) {\n            fragment = this.fragment;\n        }\n        else if (fragment === null) {\n            fragment = _empty;\n        }\n        if (scheme === this.scheme\n            && authority === this.authority\n            && path === this.path\n            && query === this.query\n            && fragment === this.fragment) {\n            return this;\n        }\n        return new _URI(scheme, authority, path, query, fragment);\n    };\n    // ---- parse & validate ------------------------\n    /**\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\n     * `file:///usr/home`, or `scheme:with/path`.\n     *\n     * @param value A string which represents an URI (see `URI#toString`).\n     */\n    URI.parse = function (value, _strict) {\n        if (_strict === void 0) { _strict = false; }\n        var match = _regexp.exec(value);\n        if (!match) {\n            return new _URI(_empty, _empty, _empty, _empty, _empty);\n        }\n        return new _URI(match[2] || _empty, decodeURIComponent(match[4] || _empty), decodeURIComponent(match[5] || _empty), decodeURIComponent(match[7] || _empty), decodeURIComponent(match[9] || _empty), _strict);\n    };\n    /**\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\n     *\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n     * `URI.parse('file://' + path)` because the path might contain characters that are\n     * interpreted (# and ?). See the following sample:\n     * ```ts\n    const good = URI.file('/coding/c#/project1');\n    good.scheme === 'file';\n    good.path === '/coding/c#/project1';\n    good.fragment === '';\n    const bad = URI.parse('file://' + '/coding/c#/project1');\n    bad.scheme === 'file';\n    bad.path === '/coding/c'; // path is now broken\n    bad.fragment === '/project1';\n    ```\n     *\n     * @param path A file system path (see `URI#fsPath`)\n     */\n    URI.file = function (path) {\n        var authority = _empty;\n        // normalize to fwd-slashes on windows,\n        // on other systems bwd-slashes are valid\n        // filename character, eg /f\\oo/ba\\r.txt\n        if (_platform_js__WEBPACK_IMPORTED_MODULE_0__[\"isWindows\"]) {\n            path = path.replace(/\\\\/g, _slash);\n        }\n        // check for authority as used in UNC shares\n        // or use the path as given\n        if (path[0] === _slash && path[1] === _slash) {\n            var idx = path.indexOf(_slash, 2);\n            if (idx === -1) {\n                authority = path.substring(2);\n                path = _slash;\n            }\n            else {\n                authority = path.substring(2, idx);\n                path = path.substring(idx) || _slash;\n            }\n        }\n        return new _URI('file', authority, path, _empty, _empty);\n    };\n    URI.from = function (components) {\n        return new _URI(components.scheme, components.authority, components.path, components.query, components.fragment);\n    };\n    // ---- printing/externalize ---------------------------\n    /**\n     * Creates a string representation for this URI. It's guaranteed that calling\n     * `URI.parse` with the result of this function creates an URI which is equal\n     * to this URI.\n     *\n     * * The result shall *not* be used for display purposes but for externalization or transport.\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\n     * ignore the scheme-specific encoding rules.\n     *\n     * @param skipEncoding Do not encode the result, default is `false`\n     */\n    URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        return _asFormatted(this, skipEncoding);\n    };\n    URI.prototype.toJSON = function () {\n        return this;\n    };\n    URI.revive = function (data) {\n        if (!data) {\n            return data;\n        }\n        else if (data instanceof URI) {\n            return data;\n        }\n        else {\n            var result = new _URI(data);\n            result._fsPath = data.fsPath;\n            result._formatted = data.external;\n            return result;\n        }\n    };\n    return URI;\n}());\n\n// tslint:disable-next-line:class-name\nvar _URI = /** @class */ (function (_super) {\n    __extends(_URI, _super);\n    function _URI() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this._formatted = null;\n        _this._fsPath = null;\n        return _this;\n    }\n    Object.defineProperty(_URI.prototype, \"fsPath\", {\n        get: function () {\n            if (!this._fsPath) {\n                this._fsPath = _makeFsPath(this);\n            }\n            return this._fsPath;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    _URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        if (!skipEncoding) {\n            if (!this._formatted) {\n                this._formatted = _asFormatted(this, false);\n            }\n            return this._formatted;\n        }\n        else {\n            // we don't cache that\n            return _asFormatted(this, true);\n        }\n    };\n    _URI.prototype.toJSON = function () {\n        var res = {\n            $mid: 1\n        };\n        // cached state\n        if (this._fsPath) {\n            res.fsPath = this._fsPath;\n        }\n        if (this._formatted) {\n            res.external = this._formatted;\n        }\n        // uri components\n        if (this.path) {\n            res.path = this.path;\n        }\n        if (this.scheme) {\n            res.scheme = this.scheme;\n        }\n        if (this.authority) {\n            res.authority = this.authority;\n        }\n        if (this.query) {\n            res.query = this.query;\n        }\n        if (this.fragment) {\n            res.fragment = this.fragment;\n        }\n        return res;\n    };\n    return _URI;\n}(URI));\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nvar encodeTable = (_a = {},\n    _a[58 /* Colon */] = '%3A',\n    _a[47 /* Slash */] = '%2F',\n    _a[63 /* QuestionMark */] = '%3F',\n    _a[35 /* Hash */] = '%23',\n    _a[91 /* OpenSquareBracket */] = '%5B',\n    _a[93 /* CloseSquareBracket */] = '%5D',\n    _a[64 /* AtSign */] = '%40',\n    _a[33 /* ExclamationMark */] = '%21',\n    _a[36 /* DollarSign */] = '%24',\n    _a[38 /* Ampersand */] = '%26',\n    _a[39 /* SingleQuote */] = '%27',\n    _a[40 /* OpenParen */] = '%28',\n    _a[41 /* CloseParen */] = '%29',\n    _a[42 /* Asterisk */] = '%2A',\n    _a[43 /* Plus */] = '%2B',\n    _a[44 /* Comma */] = '%2C',\n    _a[59 /* Semicolon */] = '%3B',\n    _a[61 /* Equals */] = '%3D',\n    _a[32 /* Space */] = '%20',\n    _a);\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\n    var res = undefined;\n    var nativeEncodePos = -1;\n    for (var pos = 0; pos < uriComponent.length; pos++) {\n        var code = uriComponent.charCodeAt(pos);\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\n            || code === 45 /* Dash */\n            || code === 46 /* Period */\n            || code === 95 /* Underline */\n            || code === 126 /* Tilde */\n            || (allowSlash && code === 47 /* Slash */)) {\n            // check if we are delaying native encode\n            if (nativeEncodePos !== -1) {\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                nativeEncodePos = -1;\n            }\n            // check if we write into a new string (by default we try to return the param)\n            if (res !== undefined) {\n                res += uriComponent.charAt(pos);\n            }\n        }\n        else {\n            // encoding needed, we need to allocate a new string\n            if (res === undefined) {\n                res = uriComponent.substr(0, pos);\n            }\n            // check with default table first\n            var escaped = encodeTable[code];\n            if (escaped !== undefined) {\n                // check if we are delaying native encode\n                if (nativeEncodePos !== -1) {\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                    nativeEncodePos = -1;\n                }\n                // append escaped variant to result\n                res += escaped;\n            }\n            else if (nativeEncodePos === -1) {\n                // use native encode only when needed\n                nativeEncodePos = pos;\n            }\n        }\n    }\n    if (nativeEncodePos !== -1) {\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n    }\n    return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n    var res = undefined;\n    for (var pos = 0; pos < path.length; pos++) {\n        var code = path.charCodeAt(pos);\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\n            if (res === undefined) {\n                res = path.substr(0, pos);\n            }\n            res += encodeTable[code];\n        }\n        else {\n            if (res !== undefined) {\n                res += path[pos];\n            }\n        }\n    }\n    return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n */\nfunction _makeFsPath(uri) {\n    var value;\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n        // unc path: file://shares/c$/far/boo\n        value = \"//\" + uri.authority + uri.path;\n    }\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\n        && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */)\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\n        // windows drive letter: file:///c:/far/boo\n        value = uri.path[1].toLowerCase() + uri.path.substr(2);\n    }\n    else {\n        // other path\n        value = uri.path;\n    }\n    if (_platform_js__WEBPACK_IMPORTED_MODULE_0__[\"isWindows\"]) {\n        value = value.replace(/\\//g, '\\\\');\n    }\n    return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n    var encoder = !skipEncoding\n        ? encodeURIComponentFast\n        : encodeURIComponentMinimal;\n    var res = '';\n    var scheme = uri.scheme, authority = uri.authority, path = uri.path, query = uri.query, fragment = uri.fragment;\n    if (scheme) {\n        res += scheme;\n        res += ':';\n    }\n    if (authority || scheme === 'file') {\n        res += _slash;\n        res += _slash;\n    }\n    if (authority) {\n        var idx = authority.indexOf('@');\n        if (idx !== -1) {\n            // <user>@<auth>\n            var userinfo = authority.substr(0, idx);\n            authority = authority.substr(idx + 1);\n            idx = userinfo.indexOf(':');\n            if (idx === -1) {\n                res += encoder(userinfo, false);\n            }\n            else {\n                // <user>:<pass>@<auth>\n                res += encoder(userinfo.substr(0, idx), false);\n                res += ':';\n                res += encoder(userinfo.substr(idx + 1), false);\n            }\n            res += '@';\n        }\n        authority = authority.toLowerCase();\n        idx = authority.indexOf(':');\n        if (idx === -1) {\n            res += encoder(authority, false);\n        }\n        else {\n            // <auth>:<port>\n            res += encoder(authority.substr(0, idx), false);\n            res += authority.substr(idx);\n        }\n    }\n    if (path) {\n        // lower-case windows drive letters in /C:/fff or C:/fff\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\n            var code = path.charCodeAt(1);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = \"/\" + String.fromCharCode(code + 32) + \":\" + path.substr(3); // \"/c:\".length === 3\n            }\n        }\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\n            var code = path.charCodeAt(0);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = String.fromCharCode(code + 32) + \":\" + path.substr(2); // \"/c:\".length === 3\n            }\n        }\n        // encode the rest of the path\n        res += encoder(path, true);\n    }\n    if (query) {\n        res += '?';\n        res += encoder(query, false);\n    }\n    if (fragment) {\n        res += '#';\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\n    }\n    return res;\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/uri.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/worker/simpleWorker.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"logOnceWebWorkerWarning\", function() { return logOnceWebWorkerWarning; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"SimpleWorkerClient\", function() { return SimpleWorkerClient; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"SimpleWorkerServer\", function() { return SimpleWorkerServer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"create\", function() { return create; });\n/* harmony import */ var _errors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../errors.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/errors.js\");\n/* harmony import */ var _lifecycle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../lifecycle.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/lifecycle.js\");\n/* harmony import */ var _platform_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../platform.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/platform.js\");\n/* harmony import */ var _types_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../types.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/types.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\nvar INITIALIZE = '$initialize';\nvar webWorkerWarningLogged = false;\nfunction logOnceWebWorkerWarning(err) {\n    if (!_platform_js__WEBPACK_IMPORTED_MODULE_2__[\"isWeb\"]) {\n        // running tests\n        return;\n    }\n    if (!webWorkerWarningLogged) {\n        webWorkerWarningLogged = true;\n        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');\n    }\n    console.warn(err.message);\n}\nvar SimpleWorkerProtocol = /** @class */ (function () {\n    function SimpleWorkerProtocol(handler) {\n        this._workerId = -1;\n        this._handler = handler;\n        this._lastSentReq = 0;\n        this._pendingReplies = Object.create(null);\n    }\n    SimpleWorkerProtocol.prototype.setWorkerId = function (workerId) {\n        this._workerId = workerId;\n    };\n    SimpleWorkerProtocol.prototype.sendMessage = function (method, args) {\n        var _this = this;\n        var req = String(++this._lastSentReq);\n        return new Promise(function (resolve, reject) {\n            _this._pendingReplies[req] = {\n                resolve: resolve,\n                reject: reject\n            };\n            _this._send({\n                vsWorker: _this._workerId,\n                req: req,\n                method: method,\n                args: args\n            });\n        });\n    };\n    SimpleWorkerProtocol.prototype.handleMessage = function (serializedMessage) {\n        var message;\n        try {\n            message = JSON.parse(serializedMessage);\n        }\n        catch (e) {\n            // nothing\n            return;\n        }\n        if (!message || !message.vsWorker) {\n            return;\n        }\n        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n            return;\n        }\n        this._handleMessage(message);\n    };\n    SimpleWorkerProtocol.prototype._handleMessage = function (msg) {\n        var _this = this;\n        if (msg.seq) {\n            var replyMessage = msg;\n            if (!this._pendingReplies[replyMessage.seq]) {\n                console.warn('Got reply to unknown seq');\n                return;\n            }\n            var reply = this._pendingReplies[replyMessage.seq];\n            delete this._pendingReplies[replyMessage.seq];\n            if (replyMessage.err) {\n                var err = replyMessage.err;\n                if (replyMessage.err.$isError) {\n                    err = new Error();\n                    err.name = replyMessage.err.name;\n                    err.message = replyMessage.err.message;\n                    err.stack = replyMessage.err.stack;\n                }\n                reply.reject(err);\n                return;\n            }\n            reply.resolve(replyMessage.res);\n            return;\n        }\n        var requestMessage = msg;\n        var req = requestMessage.req;\n        var result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n        result.then(function (r) {\n            _this._send({\n                vsWorker: _this._workerId,\n                seq: req,\n                res: r,\n                err: undefined\n            });\n        }, function (e) {\n            if (e.detail instanceof Error) {\n                // Loading errors have a detail property that points to the actual error\n                e.detail = Object(_errors_js__WEBPACK_IMPORTED_MODULE_0__[\"transformErrorForSerialization\"])(e.detail);\n            }\n            _this._send({\n                vsWorker: _this._workerId,\n                seq: req,\n                res: undefined,\n                err: Object(_errors_js__WEBPACK_IMPORTED_MODULE_0__[\"transformErrorForSerialization\"])(e)\n            });\n        });\n    };\n    SimpleWorkerProtocol.prototype._send = function (msg) {\n        var strMsg = JSON.stringify(msg);\n        // console.log('SENDING: ' + strMsg);\n        this._handler.sendMessage(strMsg);\n    };\n    return SimpleWorkerProtocol;\n}());\n/**\n * Main thread side\n */\nvar SimpleWorkerClient = /** @class */ (function (_super) {\n    __extends(SimpleWorkerClient, _super);\n    function SimpleWorkerClient(workerFactory, moduleId) {\n        var _this = _super.call(this) || this;\n        var lazyProxyReject = null;\n        _this._worker = _this._register(workerFactory.create('vs/base/common/worker/simpleWorker', function (msg) {\n            _this._protocol.handleMessage(msg);\n        }, function (err) {\n            // in Firefox, web workers fail lazily :(\n            // we will reject the proxy\n            if (lazyProxyReject) {\n                lazyProxyReject(err);\n            }\n        }));\n        _this._protocol = new SimpleWorkerProtocol({\n            sendMessage: function (msg) {\n                _this._worker.postMessage(msg);\n            },\n            handleMessage: function (method, args) {\n                // Intentionally not supporting worker -> main requests\n                return Promise.resolve(null);\n            }\n        });\n        _this._protocol.setWorkerId(_this._worker.getId());\n        // Gather loader configuration\n        var loaderConfiguration = null;\n        if (typeof self.require !== 'undefined' && typeof self.require.getConfig === 'function') {\n            // Get the configuration from the Monaco AMD Loader\n            loaderConfiguration = self.require.getConfig();\n        }\n        else if (typeof self.requirejs !== 'undefined') {\n            // Get the configuration from requirejs\n            loaderConfiguration = self.requirejs.s.contexts._.config;\n        }\n        // Send initialize message\n        _this._onModuleLoaded = _this._protocol.sendMessage(INITIALIZE, [\n            _this._worker.getId(),\n            moduleId,\n            loaderConfiguration\n        ]);\n        _this._lazyProxy = new Promise(function (resolve, reject) {\n            lazyProxyReject = reject;\n            _this._onModuleLoaded.then(function (availableMethods) {\n                var proxy = {};\n                for (var _i = 0, availableMethods_1 = availableMethods; _i < availableMethods_1.length; _i++) {\n                    var methodName = availableMethods_1[_i];\n                    proxy[methodName] = createProxyMethod(methodName, proxyMethodRequest);\n                }\n                resolve(proxy);\n            }, function (e) {\n                reject(e);\n                _this._onError('Worker failed to load ' + moduleId, e);\n            });\n        });\n        // Create proxy to loaded code\n        var proxyMethodRequest = function (method, args) {\n            return _this._request(method, args);\n        };\n        var createProxyMethod = function (method, proxyMethodRequest) {\n            return function () {\n                var args = Array.prototype.slice.call(arguments, 0);\n                return proxyMethodRequest(method, args);\n            };\n        };\n        return _this;\n    }\n    SimpleWorkerClient.prototype.getProxyObject = function () {\n        return this._lazyProxy;\n    };\n    SimpleWorkerClient.prototype._request = function (method, args) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this._onModuleLoaded.then(function () {\n                _this._protocol.sendMessage(method, args).then(resolve, reject);\n            }, reject);\n        });\n    };\n    SimpleWorkerClient.prototype._onError = function (message, error) {\n        console.error(message);\n        console.info(error);\n    };\n    return SimpleWorkerClient;\n}(_lifecycle_js__WEBPACK_IMPORTED_MODULE_1__[\"Disposable\"]));\n\n/**\n * Worker side\n */\nvar SimpleWorkerServer = /** @class */ (function () {\n    function SimpleWorkerServer(postSerializedMessage, requestHandler) {\n        var _this = this;\n        this._requestHandler = requestHandler;\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: function (msg) {\n                postSerializedMessage(msg);\n            },\n            handleMessage: function (method, args) { return _this._handleMessage(method, args); }\n        });\n    }\n    SimpleWorkerServer.prototype.onmessage = function (msg) {\n        this._protocol.handleMessage(msg);\n    };\n    SimpleWorkerServer.prototype._handleMessage = function (method, args) {\n        if (method === INITIALIZE) {\n            return this.initialize(args[0], args[1], args[2]);\n        }\n        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    };\n    SimpleWorkerServer.prototype.initialize = function (workerId, moduleId, loaderConfig) {\n        var _this = this;\n        this._protocol.setWorkerId(workerId);\n        if (this._requestHandler) {\n            // static request handler\n            var methods = [];\n            for (var _i = 0, _a = Object(_types_js__WEBPACK_IMPORTED_MODULE_3__[\"getAllPropertyNames\"])(this._requestHandler); _i < _a.length; _i++) {\n                var prop = _a[_i];\n                if (typeof this._requestHandler[prop] === 'function') {\n                    methods.push(prop);\n                }\n            }\n            return Promise.resolve(methods);\n        }\n        if (loaderConfig) {\n            // Remove 'baseUrl', handling it is beyond scope for now\n            if (typeof loaderConfig.baseUrl !== 'undefined') {\n                delete loaderConfig['baseUrl'];\n            }\n            if (typeof loaderConfig.paths !== 'undefined') {\n                if (typeof loaderConfig.paths.vs !== 'undefined') {\n                    delete loaderConfig.paths['vs'];\n                }\n            }\n            // Since this is in a web worker, enable catching errors\n            loaderConfig.catchError = true;\n            self.require.config(loaderConfig);\n        }\n        return new Promise(function (resolve, reject) {\n            // Use the global require to be sure to get the global config\n            self.require([moduleId], function () {\n                var result = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    result[_i] = arguments[_i];\n                }\n                var handlerModule = result[0];\n                _this._requestHandler = handlerModule.create();\n                if (!_this._requestHandler) {\n                    reject(new Error(\"No RequestHandler!\"));\n                    return;\n                }\n                var methods = [];\n                for (var _a = 0, _b = Object(_types_js__WEBPACK_IMPORTED_MODULE_3__[\"getAllPropertyNames\"])(_this._requestHandler); _a < _b.length; _a++) {\n                    var prop = _b[_a];\n                    if (typeof _this._requestHandler[prop] === 'function') {\n                        methods.push(prop);\n                    }\n                }\n                resolve(methods);\n            }, reject);\n        });\n    };\n    return SimpleWorkerServer;\n}());\n\n/**\n * Called on the worker side\n */\nfunction create(postMessage) {\n    return new SimpleWorkerServer(postMessage, null);\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/worker/simpleWorker.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/characterClassifier.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CharacterClassifier", function() { return CharacterClassifier; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CharacterSet", function() { return CharacterSet; });\n/* harmony import */ var _uint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./uint.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/uint.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nvar CharacterClassifier = /** @class */ (function () {\n    function CharacterClassifier(_defaultValue) {\n        var defaultValue = Object(_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint8"])(_defaultValue);\n        this._defaultValue = defaultValue;\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n        this._map = new Map();\n    }\n    CharacterClassifier._createAsciiMap = function (defaultValue) {\n        var asciiMap = new Uint8Array(256);\n        for (var i = 0; i < 256; i++) {\n            asciiMap[i] = defaultValue;\n        }\n        return asciiMap;\n    };\n    CharacterClassifier.prototype.set = function (charCode, _value) {\n        var value = Object(_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint8"])(_value);\n        if (charCode >= 0 && charCode < 256) {\n            this._asciiMap[charCode] = value;\n        }\n        else {\n            this._map.set(charCode, value);\n        }\n    };\n    CharacterClassifier.prototype.get = function (charCode) {\n        if (charCode >= 0 && charCode < 256) {\n            return this._asciiMap[charCode];\n        }\n        else {\n            return (this._map.get(charCode) || this._defaultValue);\n        }\n    };\n    return CharacterClassifier;\n}());\n\nvar CharacterSet = /** @class */ (function () {\n    function CharacterSet() {\n        this._actual = new CharacterClassifier(0 /* False */);\n    }\n    CharacterSet.prototype.add = function (charCode) {\n        this._actual.set(charCode, 1 /* True */);\n    };\n    CharacterSet.prototype.has = function (charCode) {\n        return (this._actual.get(charCode) === 1 /* True */);\n    };\n    return CharacterSet;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/characterClassifier.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Position\", function() { return Position; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nvar Position = /** @class */ (function () {\n    function Position(lineNumber, column) {\n        this.lineNumber = lineNumber;\n        this.column = column;\n    }\n    /**\n     * Create a new postion from this position.\n     *\n     * @param newLineNumber new line number\n     * @param newColumn new column\n     */\n    Position.prototype.with = function (newLineNumber, newColumn) {\n        if (newLineNumber === void 0) { newLineNumber = this.lineNumber; }\n        if (newColumn === void 0) { newColumn = this.column; }\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\n            return this;\n        }\n        else {\n            return new Position(newLineNumber, newColumn);\n        }\n    };\n    /**\n     * Derive a new position from this position.\n     *\n     * @param deltaLineNumber line number delta\n     * @param deltaColumn column delta\n     */\n    Position.prototype.delta = function (deltaLineNumber, deltaColumn) {\n        if (deltaLineNumber === void 0) { deltaLineNumber = 0; }\n        if (deltaColumn === void 0) { deltaColumn = 0; }\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n    };\n    /**\n     * Test if this position equals other position\n     */\n    Position.prototype.equals = function (other) {\n        return Position.equals(this, other);\n    };\n    /**\n     * Test if position `a` equals position `b`\n     */\n    Position.equals = function (a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.lineNumber === b.lineNumber &&\n            a.column === b.column);\n    };\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be false.\n     */\n    Position.prototype.isBefore = function (other) {\n        return Position.isBefore(this, other);\n    };\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be false.\n     */\n    Position.isBefore = function (a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column < b.column;\n    };\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be true.\n     */\n    Position.prototype.isBeforeOrEqual = function (other) {\n        return Position.isBeforeOrEqual(this, other);\n    };\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be true.\n     */\n    Position.isBeforeOrEqual = function (a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column <= b.column;\n    };\n    /**\n     * A function that compares positions, useful for sorting\n     */\n    Position.compare = function (a, b) {\n        var aLineNumber = a.lineNumber | 0;\n        var bLineNumber = b.lineNumber | 0;\n        if (aLineNumber === bLineNumber) {\n            var aColumn = a.column | 0;\n            var bColumn = b.column | 0;\n            return aColumn - bColumn;\n        }\n        return aLineNumber - bLineNumber;\n    };\n    /**\n     * Clone this position.\n     */\n    Position.prototype.clone = function () {\n        return new Position(this.lineNumber, this.column);\n    };\n    /**\n     * Convert to a human-readable representation.\n     */\n    Position.prototype.toString = function () {\n        return '(' + this.lineNumber + ',' + this.column + ')';\n    };\n    // ---\n    /**\n     * Create a `Position` from an `IPosition`.\n     */\n    Position.lift = function (pos) {\n        return new Position(pos.lineNumber, pos.column);\n    };\n    /**\n     * Test if `obj` is an `IPosition`.\n     */\n    Position.isIPosition = function (obj) {\n        return (obj\n            && (typeof obj.lineNumber === 'number')\n            && (typeof obj.column === 'number'));\n    };\n    return Position;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/range.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Range\", function() { return Range; });\n/* harmony import */ var _position_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./position.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nvar Range = /** @class */ (function () {\n    function Range(startLineNumber, startColumn, endLineNumber, endColumn) {\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n            this.startLineNumber = endLineNumber;\n            this.startColumn = endColumn;\n            this.endLineNumber = startLineNumber;\n            this.endColumn = startColumn;\n        }\n        else {\n            this.startLineNumber = startLineNumber;\n            this.startColumn = startColumn;\n            this.endLineNumber = endLineNumber;\n            this.endColumn = endColumn;\n        }\n    }\n    /**\n     * Test if this range is empty.\n     */\n    Range.prototype.isEmpty = function () {\n        return Range.isEmpty(this);\n    };\n    /**\n     * Test if `range` is empty.\n     */\n    Range.isEmpty = function (range) {\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n    };\n    /**\n     * Test if position is in this range. If the position is at the edges, will return true.\n     */\n    Range.prototype.containsPosition = function (position) {\n        return Range.containsPosition(this, position);\n    };\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\n     */\n    Range.containsPosition = function (range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n            return false;\n        }\n        return true;\n    };\n    /**\n     * Test if range is in this range. If the range is equal to this range, will return true.\n     */\n    Range.prototype.containsRange = function (range) {\n        return Range.containsRange(this, range);\n    };\n    /**\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n     */\n    Range.containsRange = function (range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n            return false;\n        }\n        return true;\n    };\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    Range.prototype.plusRange = function (range) {\n        return Range.plusRange(this, range);\n    };\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    Range.plusRange = function (a, b) {\n        var startLineNumber;\n        var startColumn;\n        var endLineNumber;\n        var endColumn;\n        if (b.startLineNumber < a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = b.startColumn;\n        }\n        else if (b.startLineNumber === a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = Math.min(b.startColumn, a.startColumn);\n        }\n        else {\n            startLineNumber = a.startLineNumber;\n            startColumn = a.startColumn;\n        }\n        if (b.endLineNumber > a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = b.endColumn;\n        }\n        else if (b.endLineNumber === a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = Math.max(b.endColumn, a.endColumn);\n        }\n        else {\n            endLineNumber = a.endLineNumber;\n            endColumn = a.endColumn;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    };\n    /**\n     * A intersection of the two ranges.\n     */\n    Range.prototype.intersectRanges = function (range) {\n        return Range.intersectRanges(this, range);\n    };\n    /**\n     * A intersection of the two ranges.\n     */\n    Range.intersectRanges = function (a, b) {\n        var resultStartLineNumber = a.startLineNumber;\n        var resultStartColumn = a.startColumn;\n        var resultEndLineNumber = a.endLineNumber;\n        var resultEndColumn = a.endColumn;\n        var otherStartLineNumber = b.startLineNumber;\n        var otherStartColumn = b.startColumn;\n        var otherEndLineNumber = b.endLineNumber;\n        var otherEndColumn = b.endColumn;\n        if (resultStartLineNumber < otherStartLineNumber) {\n            resultStartLineNumber = otherStartLineNumber;\n            resultStartColumn = otherStartColumn;\n        }\n        else if (resultStartLineNumber === otherStartLineNumber) {\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n        }\n        if (resultEndLineNumber > otherEndLineNumber) {\n            resultEndLineNumber = otherEndLineNumber;\n            resultEndColumn = otherEndColumn;\n        }\n        else if (resultEndLineNumber === otherEndLineNumber) {\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n        }\n        // Check if selection is now empty\n        if (resultStartLineNumber > resultEndLineNumber) {\n            return null;\n        }\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n            return null;\n        }\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n    };\n    /**\n     * Test if this range equals other.\n     */\n    Range.prototype.equalsRange = function (other) {\n        return Range.equalsRange(this, other);\n    };\n    /**\n     * Test if range `a` equals `b`.\n     */\n    Range.equalsRange = function (a, b) {\n        return (!!a &&\n            !!b &&\n            a.startLineNumber === b.startLineNumber &&\n            a.startColumn === b.startColumn &&\n            a.endLineNumber === b.endLineNumber &&\n            a.endColumn === b.endColumn);\n    };\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    Range.prototype.getEndPosition = function () {\n        return new _position_js__WEBPACK_IMPORTED_MODULE_0__[\"Position\"](this.endLineNumber, this.endColumn);\n    };\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    Range.prototype.getStartPosition = function () {\n        return new _position_js__WEBPACK_IMPORTED_MODULE_0__[\"Position\"](this.startLineNumber, this.startColumn);\n    };\n    /**\n     * Transform to a user presentable string representation.\n     */\n    Range.prototype.toString = function () {\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n    };\n    /**\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n     */\n    Range.prototype.setEndPosition = function (endLineNumber, endColumn) {\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n    };\n    /**\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n     */\n    Range.prototype.setStartPosition = function (startLineNumber, startColumn) {\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n    };\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    Range.prototype.collapseToStart = function () {\n        return Range.collapseToStart(this);\n    };\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    Range.collapseToStart = function (range) {\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n    };\n    // ---\n    Range.fromPositions = function (start, end) {\n        if (end === void 0) { end = start; }\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n    };\n    Range.lift = function (range) {\n        if (!range) {\n            return null;\n        }\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n    };\n    /**\n     * Test if `obj` is an `IRange`.\n     */\n    Range.isIRange = function (obj) {\n        return (obj\n            && (typeof obj.startLineNumber === 'number')\n            && (typeof obj.startColumn === 'number')\n            && (typeof obj.endLineNumber === 'number')\n            && (typeof obj.endColumn === 'number'));\n    };\n    /**\n     * Test if the two ranges are touching in any way.\n     */\n    Range.areIntersectingOrTouching = function (a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    };\n    /**\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n     */\n    Range.areIntersecting = function (a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    };\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the startPosition and then on the endPosition\n     */\n    Range.compareRangesUsingStarts = function (a, b) {\n        if (a && b) {\n            var aStartLineNumber = a.startLineNumber | 0;\n            var bStartLineNumber = b.startLineNumber | 0;\n            if (aStartLineNumber === bStartLineNumber) {\n                var aStartColumn = a.startColumn | 0;\n                var bStartColumn = b.startColumn | 0;\n                if (aStartColumn === bStartColumn) {\n                    var aEndLineNumber = a.endLineNumber | 0;\n                    var bEndLineNumber = b.endLineNumber | 0;\n                    if (aEndLineNumber === bEndLineNumber) {\n                        var aEndColumn = a.endColumn | 0;\n                        var bEndColumn = b.endColumn | 0;\n                        return aEndColumn - bEndColumn;\n                    }\n                    return aEndLineNumber - bEndLineNumber;\n                }\n                return aStartColumn - bStartColumn;\n            }\n            return aStartLineNumber - bStartLineNumber;\n        }\n        var aExists = (a ? 1 : 0);\n        var bExists = (b ? 1 : 0);\n        return aExists - bExists;\n    };\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the endPosition and then on the startPosition\n     */\n    Range.compareRangesUsingEnds = function (a, b) {\n        if (a.endLineNumber === b.endLineNumber) {\n            if (a.endColumn === b.endColumn) {\n                if (a.startLineNumber === b.startLineNumber) {\n                    return a.startColumn - b.startColumn;\n                }\n                return a.startLineNumber - b.startLineNumber;\n            }\n            return a.endColumn - b.endColumn;\n        }\n        return a.endLineNumber - b.endLineNumber;\n    };\n    /**\n     * Test if the range spans multiple lines.\n     */\n    Range.spansMultipleLines = function (range) {\n        return range.endLineNumber > range.startLineNumber;\n    };\n    return Range;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/range.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/selection.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Selection\", function() { return Selection; });\n/* harmony import */ var _position_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./position.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js\");\n/* harmony import */ var _range_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./range.js */ \"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/range.js\");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nvar Selection = /** @class */ (function (_super) {\n    __extends(Selection, _super);\n    function Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n        var _this = _super.call(this, selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) || this;\n        _this.selectionStartLineNumber = selectionStartLineNumber;\n        _this.selectionStartColumn = selectionStartColumn;\n        _this.positionLineNumber = positionLineNumber;\n        _this.positionColumn = positionColumn;\n        return _this;\n    }\n    /**\n     * Clone this selection.\n     */\n    Selection.prototype.clone = function () {\n        return new Selection(this.selectionStartLineNumber, this.selectionStartColumn, this.positionLineNumber, this.positionColumn);\n    };\n    /**\n     * Transform to a human-readable representation.\n     */\n    Selection.prototype.toString = function () {\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n    };\n    /**\n     * Test if equals other selection.\n     */\n    Selection.prototype.equalsSelection = function (other) {\n        return (Selection.selectionsEqual(this, other));\n    };\n    /**\n     * Test if the two selections are equal.\n     */\n    Selection.selectionsEqual = function (a, b) {\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n            a.selectionStartColumn === b.selectionStartColumn &&\n            a.positionLineNumber === b.positionLineNumber &&\n            a.positionColumn === b.positionColumn);\n    };\n    /**\n     * Get directions (LTR or RTL).\n     */\n    Selection.prototype.getDirection = function () {\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n            return 0 /* LTR */;\n        }\n        return 1 /* RTL */;\n    };\n    /**\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n     */\n    Selection.prototype.setEndPosition = function (endLineNumber, endColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n    };\n    /**\n     * Get the position at `positionLineNumber` and `positionColumn`.\n     */\n    Selection.prototype.getPosition = function () {\n        return new _position_js__WEBPACK_IMPORTED_MODULE_0__[\"Position\"](this.positionLineNumber, this.positionColumn);\n    };\n    /**\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n     */\n    Selection.prototype.setStartPosition = function (startLineNumber, startColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n        }\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n    };\n    // ----\n    /**\n     * Create a `Selection` from one or two positions\n     */\n    Selection.fromPositions = function (start, end) {\n        if (end === void 0) { end = start; }\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n    };\n    /**\n     * Create a `Selection` from an `ISelection`.\n     */\n    Selection.liftSelection = function (sel) {\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n    };\n    /**\n     * `a` equals `b`.\n     */\n    Selection.selectionsArrEqual = function (a, b) {\n        if (a && !b || !a && b) {\n            return false;\n        }\n        if (!a && !b) {\n            return true;\n        }\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (var i = 0, len = a.length; i < len; i++) {\n            if (!this.selectionsEqual(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * Test if `obj` is an `ISelection`.\n     */\n    Selection.isISelection = function (obj) {\n        return (obj\n            && (typeof obj.selectionStartLineNumber === 'number')\n            && (typeof obj.selectionStartColumn === 'number')\n            && (typeof obj.positionLineNumber === 'number')\n            && (typeof obj.positionColumn === 'number'));\n    };\n    /**\n     * Create with a direction.\n     */\n    Selection.createWithDirection = function (startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n        if (direction === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n    };\n    return Selection;\n}(_range_js__WEBPACK_IMPORTED_MODULE_1__[\"Range\"]));\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/selection.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/token.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"Token\", function() { return Token; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"TokenizationResult\", function() { return TokenizationResult; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"TokenizationResult2\", function() { return TokenizationResult2; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar Token = /** @class */ (function () {\n    function Token(offset, type, language) {\n        this.offset = offset | 0; // @perf\n        this.type = type;\n        this.language = language;\n    }\n    Token.prototype.toString = function () {\n        return '(' + this.offset + ', ' + this.type + ')';\n    };\n    return Token;\n}());\n\nvar TokenizationResult = /** @class */ (function () {\n    function TokenizationResult(tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n    return TokenizationResult;\n}());\n\nvar TokenizationResult2 = /** @class */ (function () {\n    function TokenizationResult2(tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n    return TokenizationResult2;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/token.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/uint.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Uint8Matrix", function() { return Uint8Matrix; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUint8", function() { return toUint8; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUint32", function() { return toUint32; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUint32Array", function() { return toUint32Array; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar Uint8Matrix = /** @class */ (function () {\n    function Uint8Matrix(rows, cols, defaultValue) {\n        var data = new Uint8Array(rows * cols);\n        for (var i = 0, len = rows * cols; i < len; i++) {\n            data[i] = defaultValue;\n        }\n        this._data = data;\n        this.rows = rows;\n        this.cols = cols;\n    }\n    Uint8Matrix.prototype.get = function (row, col) {\n        return this._data[row * this.cols + col];\n    };\n    Uint8Matrix.prototype.set = function (row, col, value) {\n        this._data[row * this.cols + col] = value;\n    };\n    return Uint8Matrix;\n}());\n\nfunction toUint8(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 255 /* MAX_UINT_8 */) {\n        return 255 /* MAX_UINT_8 */;\n    }\n    return v | 0;\n}\nfunction toUint32(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 4294967295 /* MAX_UINT_32 */) {\n        return 4294967295 /* MAX_UINT_32 */;\n    }\n    return v | 0;\n}\nfunction toUint32Array(arr) {\n    var len = arr.length;\n    var r = new Uint32Array(len);\n    for (var i = 0; i < len; i++) {\n        r[i] = toUint32(arr[i]);\n    }\n    return r;\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/uint.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/diff/diffComputer.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiffComputer", function() { return DiffComputer; });\n/* harmony import */ var _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/diff/diff.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diff.js");\n/* harmony import */ var _base_common_strings_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/strings.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/strings.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\nvar MAXIMUM_RUN_TIME = 5000; // 5 seconds\nvar MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n    var diffAlgo = new _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_0__["LcsDiff"](originalSequence, modifiedSequence, continueProcessingPredicate);\n    return diffAlgo.ComputeDiff(pretty);\n}\nvar LineMarkerSequence = /** @class */ (function () {\n    function LineMarkerSequence(lines) {\n        var startColumns = [];\n        var endColumns = [];\n        for (var i = 0, length_1 = lines.length; i < length_1; i++) {\n            startColumns[i] = LineMarkerSequence._getFirstNonBlankColumn(lines[i], 1);\n            endColumns[i] = LineMarkerSequence._getLastNonBlankColumn(lines[i], 1);\n        }\n        this._lines = lines;\n        this._startColumns = startColumns;\n        this._endColumns = endColumns;\n    }\n    LineMarkerSequence.prototype.getLength = function () {\n        return this._lines.length;\n    };\n    LineMarkerSequence.prototype.getElementAtIndex = function (i) {\n        return this._lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n    };\n    LineMarkerSequence.prototype.getStartLineNumber = function (i) {\n        return i + 1;\n    };\n    LineMarkerSequence.prototype.getEndLineNumber = function (i) {\n        return i + 1;\n    };\n    LineMarkerSequence._getFirstNonBlankColumn = function (txt, defaultValue) {\n        var r = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_1__["firstNonWhitespaceIndex"](txt);\n        if (r === -1) {\n            return defaultValue;\n        }\n        return r + 1;\n    };\n    LineMarkerSequence._getLastNonBlankColumn = function (txt, defaultValue) {\n        var r = _base_common_strings_js__WEBPACK_IMPORTED_MODULE_1__["lastNonWhitespaceIndex"](txt);\n        if (r === -1) {\n            return defaultValue;\n        }\n        return r + 2;\n    };\n    LineMarkerSequence.prototype.getCharSequence = function (shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n        var charCodes = [];\n        var lineNumbers = [];\n        var columns = [];\n        var len = 0;\n        for (var index = startIndex; index <= endIndex; index++) {\n            var lineContent = this._lines[index];\n            var startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n            var endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n            for (var col = startColumn; col < endColumn; col++) {\n                charCodes[len] = lineContent.charCodeAt(col - 1);\n                lineNumbers[len] = index + 1;\n                columns[len] = col;\n                len++;\n            }\n        }\n        return new CharSequence(charCodes, lineNumbers, columns);\n    };\n    return LineMarkerSequence;\n}());\nvar CharSequence = /** @class */ (function () {\n    function CharSequence(charCodes, lineNumbers, columns) {\n        this._charCodes = charCodes;\n        this._lineNumbers = lineNumbers;\n        this._columns = columns;\n    }\n    CharSequence.prototype.getLength = function () {\n        return this._charCodes.length;\n    };\n    CharSequence.prototype.getElementAtIndex = function (i) {\n        return this._charCodes[i];\n    };\n    CharSequence.prototype.getStartLineNumber = function (i) {\n        return this._lineNumbers[i];\n    };\n    CharSequence.prototype.getStartColumn = function (i) {\n        return this._columns[i];\n    };\n    CharSequence.prototype.getEndLineNumber = function (i) {\n        return this._lineNumbers[i];\n    };\n    CharSequence.prototype.getEndColumn = function (i) {\n        return this._columns[i] + 1;\n    };\n    return CharSequence;\n}());\nvar CharChange = /** @class */ (function () {\n    function CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalStartColumn = originalStartColumn;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.originalEndColumn = originalEndColumn;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedStartColumn = modifiedStartColumn;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.modifiedEndColumn = modifiedEndColumn;\n    }\n    CharChange.createFromDiffChange = function (diffChange, originalCharSequence, modifiedCharSequence) {\n        var originalStartLineNumber;\n        var originalStartColumn;\n        var originalEndLineNumber;\n        var originalEndColumn;\n        var modifiedStartLineNumber;\n        var modifiedStartColumn;\n        var modifiedEndLineNumber;\n        var modifiedEndColumn;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = 0;\n            originalStartColumn = 0;\n            originalEndLineNumber = 0;\n            originalEndColumn = 0;\n        }\n        else {\n            originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n            originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n            originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n            originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = 0;\n            modifiedStartColumn = 0;\n            modifiedEndLineNumber = 0;\n            modifiedEndColumn = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n    };\n    return CharChange;\n}());\nfunction postProcessCharChanges(rawChanges) {\n    if (rawChanges.length <= 1) {\n        return rawChanges;\n    }\n    var result = [rawChanges[0]];\n    var prevChange = result[0];\n    for (var i = 1, len = rawChanges.length; i < len; i++) {\n        var currChange = rawChanges[i];\n        var originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n        var modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n        var matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n            // Merge the current change into the previous one\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n        }\n        else {\n            // Add the current change\n            result.push(currChange);\n            prevChange = currChange;\n        }\n    }\n    return result;\n}\nvar LineChange = /** @class */ (function () {\n    function LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.charChanges = charChanges;\n    }\n    LineChange.createFromDiffResult = function (shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueProcessingPredicate, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n        var originalStartLineNumber;\n        var originalEndLineNumber;\n        var modifiedStartLineNumber;\n        var modifiedEndLineNumber;\n        var charChanges = undefined;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n            originalEndLineNumber = 0;\n        }\n        else {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n            modifiedEndLineNumber = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        if (shouldComputeCharChanges && diffChange.originalLength !== 0 && diffChange.modifiedLength !== 0 && continueProcessingPredicate()) {\n            var originalCharSequence = originalLineSequence.getCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n            var modifiedCharSequence = modifiedLineSequence.getCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            var rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueProcessingPredicate, true);\n            if (shouldPostProcessCharChanges) {\n                rawChanges = postProcessCharChanges(rawChanges);\n            }\n            charChanges = [];\n            for (var i = 0, length_2 = rawChanges.length; i < length_2; i++) {\n                charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n            }\n        }\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n    };\n    return LineChange;\n}());\nvar DiffComputer = /** @class */ (function () {\n    function DiffComputer(originalLines, modifiedLines, opts) {\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n        this.maximumRunTimeMs = MAXIMUM_RUN_TIME;\n        this.originalLines = originalLines;\n        this.modifiedLines = modifiedLines;\n        this.original = new LineMarkerSequence(originalLines);\n        this.modified = new LineMarkerSequence(modifiedLines);\n    }\n    DiffComputer.prototype.computeDiff = function () {\n        if (this.original.getLength() === 1 && this.original.getElementAtIndex(0).length === 0) {\n            // empty original => fast path\n            return [{\n                    originalStartLineNumber: 1,\n                    originalEndLineNumber: 1,\n                    modifiedStartLineNumber: 1,\n                    modifiedEndLineNumber: this.modified.getLength(),\n                    charChanges: [{\n                            modifiedEndColumn: 0,\n                            modifiedEndLineNumber: 0,\n                            modifiedStartColumn: 0,\n                            modifiedStartLineNumber: 0,\n                            originalEndColumn: 0,\n                            originalEndLineNumber: 0,\n                            originalStartColumn: 0,\n                            originalStartLineNumber: 0\n                        }]\n                }];\n        }\n        if (this.modified.getLength() === 1 && this.modified.getElementAtIndex(0).length === 0) {\n            // empty modified => fast path\n            return [{\n                    originalStartLineNumber: 1,\n                    originalEndLineNumber: this.original.getLength(),\n                    modifiedStartLineNumber: 1,\n                    modifiedEndLineNumber: 1,\n                    charChanges: [{\n                            modifiedEndColumn: 0,\n                            modifiedEndLineNumber: 0,\n                            modifiedStartColumn: 0,\n                            modifiedStartLineNumber: 0,\n                            originalEndColumn: 0,\n                            originalEndLineNumber: 0,\n                            originalStartColumn: 0,\n                            originalStartLineNumber: 0\n                        }]\n                }];\n        }\n        this.computationStartTime = (new Date()).getTime();\n        var rawChanges = computeDiff(this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldMakePrettyDiff);\n        // The diff is always computed with ignoring trim whitespace\n        // This ensures we get the prettiest diff\n        if (this.shouldIgnoreTrimWhitespace) {\n            var lineChanges = [];\n            for (var i = 0, length_3 = rawChanges.length; i < length_3; i++) {\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n            }\n            return lineChanges;\n        }\n        // Need to post-process and introduce changes where the trim whitespace is different\n        // Note that we are looping starting at -1 to also cover the lines before the first change\n        var result = [];\n        var originalLineIndex = 0;\n        var modifiedLineIndex = 0;\n        for (var i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n            var nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n            var originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n            var modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n                var originalLine = this.originalLines[originalLineIndex];\n                var modifiedLine = this.modifiedLines[modifiedLineIndex];\n                if (originalLine !== modifiedLine) {\n                    // These lines differ only in trim whitespace\n                    // Check the leading whitespace\n                    {\n                        var originalStartColumn = LineMarkerSequence._getFirstNonBlankColumn(originalLine, 1);\n                        var modifiedStartColumn = LineMarkerSequence._getFirstNonBlankColumn(modifiedLine, 1);\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n                            var originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n                            var modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalStartColumn--;\n                            modifiedStartColumn--;\n                        }\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n                        }\n                    }\n                    // Check the trailing whitespace\n                    {\n                        var originalEndColumn = LineMarkerSequence._getLastNonBlankColumn(originalLine, 1);\n                        var modifiedEndColumn = LineMarkerSequence._getLastNonBlankColumn(modifiedLine, 1);\n                        var originalMaxColumn = originalLine.length + 1;\n                        var modifiedMaxColumn = modifiedLine.length + 1;\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n                            var originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n                            var modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalEndColumn++;\n                            modifiedEndColumn++;\n                        }\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n                        }\n                    }\n                }\n                originalLineIndex++;\n                modifiedLineIndex++;\n            }\n            if (nextChange) {\n                // Emit the actual change\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n                originalLineIndex += nextChange.originalLength;\n                modifiedLineIndex += nextChange.modifiedLength;\n            }\n        }\n        return result;\n    };\n    DiffComputer.prototype._pushTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n            // Merged into previous\n            return;\n        }\n        var charChanges = undefined;\n        if (this.shouldComputeCharChanges) {\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n        }\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n    };\n    DiffComputer.prototype._mergeTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        var len = result.length;\n        if (len === 0) {\n            return false;\n        }\n        var prevChange = result[len - 1];\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n            // Don\'t merge with inserts/deletes\n            return false;\n        }\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n            prevChange.originalEndLineNumber = originalLineNumber;\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\n            if (this.shouldComputeCharChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        return false;\n    };\n    DiffComputer.prototype._continueProcessingPredicate = function () {\n        if (this.maximumRunTimeMs === 0) {\n            return true;\n        }\n        var now = (new Date()).getTime();\n        return now - this.computationStartTime < this.maximumRunTimeMs;\n    };\n    return DiffComputer;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/diff/diffComputer.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MirrorTextModel", function() { return MirrorTextModel; });\n/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/position.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js");\n/* harmony import */ var _viewModel_prefixSumComputer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../viewModel/prefixSumComputer.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\nvar MirrorTextModel = /** @class */ (function () {\n    function MirrorTextModel(uri, lines, eol, versionId) {\n        this._uri = uri;\n        this._lines = lines;\n        this._eol = eol;\n        this._versionId = versionId;\n        this._lineStarts = null;\n    }\n    MirrorTextModel.prototype.dispose = function () {\n        this._lines.length = 0;\n    };\n    MirrorTextModel.prototype.getText = function () {\n        return this._lines.join(this._eol);\n    };\n    MirrorTextModel.prototype.onEvents = function (e) {\n        if (e.eol && e.eol !== this._eol) {\n            this._eol = e.eol;\n            this._lineStarts = null;\n        }\n        // Update my lines\n        var changes = e.changes;\n        for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {\n            var change = changes_1[_i];\n            this._acceptDeleteRange(change.range);\n            this._acceptInsertText(new _core_position_js__WEBPACK_IMPORTED_MODULE_0__["Position"](change.range.startLineNumber, change.range.startColumn), change.text);\n        }\n        this._versionId = e.versionId;\n    };\n    MirrorTextModel.prototype._ensureLineStarts = function () {\n        if (!this._lineStarts) {\n            var eolLength = this._eol.length;\n            var linesLength = this._lines.length;\n            var lineStartValues = new Uint32Array(linesLength);\n            for (var i = 0; i < linesLength; i++) {\n                lineStartValues[i] = this._lines[i].length + eolLength;\n            }\n            this._lineStarts = new _viewModel_prefixSumComputer_js__WEBPACK_IMPORTED_MODULE_1__["PrefixSumComputer"](lineStartValues);\n        }\n    };\n    /**\n     * All changes to a line\'s text go through this method\n     */\n    MirrorTextModel.prototype._setLineText = function (lineIndex, newValue) {\n        this._lines[lineIndex] = newValue;\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n        }\n    };\n    MirrorTextModel.prototype._acceptDeleteRange = function (range) {\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            // Delete text on the affected line\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n            return;\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n        // Delete middle lines\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        }\n    };\n    MirrorTextModel.prototype._acceptInsertText = function (position, insertText) {\n        if (insertText.length === 0) {\n            // Nothing to insert\n            return;\n        }\n        var insertLines = insertText.split(/\\r\\n|\\r|\\n/);\n        if (insertLines.length === 1) {\n            // Inserting text on one line\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n                + insertLines[0]\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\n            return;\n        }\n        // Append overflowing text from first line to the end of text to insert\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n        // Delete overflowing text from first line and insert text on first line\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n            + insertLines[0]);\n        // Insert new lines & store lengths\n        var newLengths = new Uint32Array(insertLines.length - 1);\n        for (var i = 1; i < insertLines.length; i++) {\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\n        }\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\n        }\n    };\n    return MirrorTextModel;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/wordHelper.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"USUAL_WORD_SEPARATORS\", function() { return USUAL_WORD_SEPARATORS; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"DEFAULT_WORD_REGEXP\", function() { return DEFAULT_WORD_REGEXP; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ensureValidWordDefinition\", function() { return ensureValidWordDefinition; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"getWordAtText\", function() { return getWordAtText; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords) {\n    if (allowInWords === void 0) { allowInWords = ''; }\n    var source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n    for (var _i = 0, USUAL_WORD_SEPARATORS_1 = USUAL_WORD_SEPARATORS; _i < USUAL_WORD_SEPARATORS_1.length; _i++) {\n        var sep = USUAL_WORD_SEPARATORS_1[_i];\n        if (allowInWords.indexOf(sep) >= 0) {\n            continue;\n        }\n        source += '\\\\' + sep;\n    }\n    source += '\\\\s]+)';\n    return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nvar DEFAULT_WORD_REGEXP = createWordRegExp();\nfunction ensureValidWordDefinition(wordDefinition) {\n    var result = DEFAULT_WORD_REGEXP;\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\n        if (!wordDefinition.global) {\n            var flags = 'g';\n            if (wordDefinition.ignoreCase) {\n                flags += 'i';\n            }\n            if (wordDefinition.multiline) {\n                flags += 'm';\n            }\n            if (wordDefinition.unicode) {\n                flags += 'u';\n            }\n            result = new RegExp(wordDefinition.source, flags);\n        }\n        else {\n            result = wordDefinition;\n        }\n    }\n    result.lastIndex = 0;\n    return result;\n}\nfunction getWordAtPosFast(column, wordDefinition, text, textOffset) {\n    // find whitespace enclosed text around column and match from there\n    var pos = column - 1 - textOffset;\n    var start = text.lastIndexOf(' ', pos - 1) + 1;\n    wordDefinition.lastIndex = start;\n    var match;\n    while (match = wordDefinition.exec(text)) {\n        var matchIndex = match.index || 0;\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n            return {\n                word: match[0],\n                startColumn: textOffset + 1 + matchIndex,\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\n            };\n        }\n    }\n    return null;\n}\nfunction getWordAtPosSlow(column, wordDefinition, text, textOffset) {\n    // matches all words starting at the beginning\n    // of the input until it finds a match that encloses\n    // the desired column. slow but correct\n    var pos = column - 1 - textOffset;\n    wordDefinition.lastIndex = 0;\n    var match;\n    while (match = wordDefinition.exec(text)) {\n        var matchIndex = match.index || 0;\n        if (matchIndex > pos) {\n            // |nW -> matched only after the pos\n            return null;\n        }\n        else if (wordDefinition.lastIndex >= pos) {\n            // W|W -> match encloses pos\n            return {\n                word: match[0],\n                startColumn: textOffset + 1 + matchIndex,\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\n            };\n        }\n    }\n    return null;\n}\nfunction getWordAtText(column, wordDefinition, text, textOffset) {\n    // if `words` can contain whitespace character we have to use the slow variant\n    // otherwise we use the fast variant of finding a word\n    wordDefinition.lastIndex = 0;\n    var match = wordDefinition.exec(text);\n    if (!match) {\n        return null;\n    }\n    // todo@joh the `match` could already be the (first) word\n    var ret = match[0].indexOf(' ') >= 0\n        // did match a word which contains a space character -> use slow word find\n        ? getWordAtPosSlow(column, wordDefinition, text, textOffset)\n        // sane word definition -> use fast word find\n        : getWordAtPosFast(column, wordDefinition, text, textOffset);\n    // both (getWordAtPosFast and getWordAtPosSlow) leave the wordDefinition-RegExp\n    // in an undefined state and to not confuse other users of the wordDefinition\n    // we reset the lastIndex\n    wordDefinition.lastIndex = 0;\n    return ret;\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/wordHelper.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/linkComputer.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StateMachine", function() { return StateMachine; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LinkComputer", function() { return LinkComputer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeLinks", function() { return computeLinks; });\n/* harmony import */ var _core_characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/characterClassifier.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/characterClassifier.js");\n/* harmony import */ var _core_uint_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/uint.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/uint.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\nvar StateMachine = /** @class */ (function () {\n    function StateMachine(edges) {\n        var maxCharCode = 0;\n        var maxState = 0 /* Invalid */;\n        for (var i = 0, len = edges.length; i < len; i++) {\n            var _a = edges[i], from = _a[0], chCode = _a[1], to = _a[2];\n            if (chCode > maxCharCode) {\n                maxCharCode = chCode;\n            }\n            if (from > maxState) {\n                maxState = from;\n            }\n            if (to > maxState) {\n                maxState = to;\n            }\n        }\n        maxCharCode++;\n        maxState++;\n        var states = new _core_uint_js__WEBPACK_IMPORTED_MODULE_1__["Uint8Matrix"](maxState, maxCharCode, 0 /* Invalid */);\n        for (var i = 0, len = edges.length; i < len; i++) {\n            var _b = edges[i], from = _b[0], chCode = _b[1], to = _b[2];\n            states.set(from, chCode, to);\n        }\n        this._states = states;\n        this._maxCharCode = maxCharCode;\n    }\n    StateMachine.prototype.nextState = function (currentState, chCode) {\n        if (chCode < 0 || chCode >= this._maxCharCode) {\n            return 0 /* Invalid */;\n        }\n        return this._states.get(currentState, chCode);\n    };\n    return StateMachine;\n}());\n\n// State machine for http:// or https:// or file://\nvar _stateMachine = null;\nfunction getStateMachine() {\n    if (_stateMachine === null) {\n        _stateMachine = new StateMachine([\n            [1 /* Start */, 104 /* h */, 2 /* H */],\n            [1 /* Start */, 72 /* H */, 2 /* H */],\n            [1 /* Start */, 102 /* f */, 6 /* F */],\n            [1 /* Start */, 70 /* F */, 6 /* F */],\n            [2 /* H */, 116 /* t */, 3 /* HT */],\n            [2 /* H */, 84 /* T */, 3 /* HT */],\n            [3 /* HT */, 116 /* t */, 4 /* HTT */],\n            [3 /* HT */, 84 /* T */, 4 /* HTT */],\n            [4 /* HTT */, 112 /* p */, 5 /* HTTP */],\n            [4 /* HTT */, 80 /* P */, 5 /* HTTP */],\n            [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],\n            [6 /* F */, 105 /* i */, 7 /* FI */],\n            [6 /* F */, 73 /* I */, 7 /* FI */],\n            [7 /* FI */, 108 /* l */, 8 /* FIL */],\n            [7 /* FI */, 76 /* L */, 8 /* FIL */],\n            [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],\n            [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],\n            [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],\n            [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],\n            [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],\n        ]);\n    }\n    return _stateMachine;\n}\nvar _classifier = null;\nfunction getClassifier() {\n    if (_classifier === null) {\n        _classifier = new _core_characterClassifier_js__WEBPACK_IMPORTED_MODULE_0__["CharacterClassifier"](0 /* None */);\n        var FORCE_TERMINATION_CHARACTERS = \' \\t<>\\\'\\"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…\';\n        for (var i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);\n        }\n        var CANNOT_END_WITH_CHARACTERS = \'.,;\';\n        for (var i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);\n        }\n    }\n    return _classifier;\n}\nvar LinkComputer = /** @class */ (function () {\n    function LinkComputer() {\n    }\n    LinkComputer._createLink = function (classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n        // Do not allow to end link in certain characters...\n        var lastIncludedCharIndex = linkEndIndex - 1;\n        do {\n            var chCode = line.charCodeAt(lastIncludedCharIndex);\n            var chClass = classifier.get(chCode);\n            if (chClass !== 2 /* CannotEndIn */) {\n                break;\n            }\n            lastIncludedCharIndex--;\n        } while (lastIncludedCharIndex > linkBeginIndex);\n        // Handle links enclosed in parens, square brackets and curlys.\n        if (linkBeginIndex > 0) {\n            var charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n            var lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n            if ((charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */)\n                || (charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */)\n                || (charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */)) {\n                // Do not end in ) if ( is before the link start\n                // Do not end in ] if [ is before the link start\n                // Do not end in } if { is before the link start\n                lastIncludedCharIndex--;\n            }\n        }\n        return {\n            range: {\n                startLineNumber: lineNumber,\n                startColumn: linkBeginIndex + 1,\n                endLineNumber: lineNumber,\n                endColumn: lastIncludedCharIndex + 2\n            },\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n        };\n    };\n    LinkComputer.computeLinks = function (model, stateMachine) {\n        if (stateMachine === void 0) { stateMachine = getStateMachine(); }\n        var classifier = getClassifier();\n        var result = [];\n        for (var i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n            var line = model.getLineContent(i);\n            var len = line.length;\n            var j = 0;\n            var linkBeginIndex = 0;\n            var linkBeginChCode = 0;\n            var state = 1 /* Start */;\n            var hasOpenParens = false;\n            var hasOpenSquareBracket = false;\n            var hasOpenCurlyBracket = false;\n            while (j < len) {\n                var resetStateMachine = false;\n                var chCode = line.charCodeAt(j);\n                if (state === 13 /* Accept */) {\n                    var chClass = void 0;\n                    switch (chCode) {\n                        case 40 /* OpenParen */:\n                            hasOpenParens = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 41 /* CloseParen */:\n                            chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 91 /* OpenSquareBracket */:\n                            hasOpenSquareBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 93 /* CloseSquareBracket */:\n                            chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 123 /* OpenCurlyBrace */:\n                            hasOpenCurlyBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 125 /* CloseCurlyBrace */:\n                            chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        /* The following three rules make it that \' or " or ` are allowed inside links if the link began with a different one */\n                        case 39 /* SingleQuote */:\n                            chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 34 /* DoubleQuote */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 96 /* BackTick */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        default:\n                            chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n                        resetStateMachine = true;\n                    }\n                }\n                else if (state === 12 /* End */) {\n                    var chClass = void 0;\n                    if (chCode === 91 /* OpenSquareBracket */) {\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n                        hasOpenSquareBracket = true;\n                        chClass = 0 /* None */;\n                    }\n                    else {\n                        chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        resetStateMachine = true;\n                    }\n                    else {\n                        state = 13 /* Accept */;\n                    }\n                }\n                else {\n                    state = stateMachine.nextState(state, chCode);\n                    if (state === 0 /* Invalid */) {\n                        resetStateMachine = true;\n                    }\n                }\n                if (resetStateMachine) {\n                    state = 1 /* Start */;\n                    hasOpenParens = false;\n                    hasOpenSquareBracket = false;\n                    hasOpenCurlyBracket = false;\n                    // Record where the link started\n                    linkBeginIndex = j + 1;\n                    linkBeginChCode = chCode;\n                }\n                j++;\n            }\n            if (state === 13 /* Accept */) {\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n            }\n        }\n        return result;\n    };\n    return LinkComputer;\n}());\n\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nfunction computeLinks(model) {\n    if (!model || typeof model.getLineCount !== \'function\' || typeof model.getLineContent !== \'function\') {\n        // Unknown caller!\n        return [];\n    }\n    return LinkComputer.computeLinks(model);\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/linkComputer.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"BasicInplaceReplace\", function() { return BasicInplaceReplace; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar BasicInplaceReplace = /** @class */ (function () {\n    function BasicInplaceReplace() {\n        this._defaultValueSet = [\n            ['true', 'false'],\n            ['True', 'False'],\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n            ['public', 'protected', 'private'],\n        ];\n    }\n    BasicInplaceReplace.prototype.navigateValueSet = function (range1, text1, range2, text2, up) {\n        if (range1 && text1) {\n            var result = this.doNavigateValueSet(text1, up);\n            if (result) {\n                return {\n                    range: range1,\n                    value: result\n                };\n            }\n        }\n        if (range2 && text2) {\n            var result = this.doNavigateValueSet(text2, up);\n            if (result) {\n                return {\n                    range: range2,\n                    value: result\n                };\n            }\n        }\n        return null;\n    };\n    BasicInplaceReplace.prototype.doNavigateValueSet = function (text, up) {\n        var numberResult = this.numberReplace(text, up);\n        if (numberResult !== null) {\n            return numberResult;\n        }\n        return this.textReplace(text, up);\n    };\n    BasicInplaceReplace.prototype.numberReplace = function (value, up) {\n        var precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n        var n1 = Number(value);\n        var n2 = parseFloat(value);\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n            if (n1 === 0 && !up) {\n                return null; // don't do negative\n                //\t\t\t} else if(n1 === 9 && up) {\n                //\t\t\t\treturn null; // don't insert 10 into a number\n            }\n            else {\n                n1 = Math.floor(n1 * precision);\n                n1 += up ? precision : -precision;\n                return String(n1 / precision);\n            }\n        }\n        return null;\n    };\n    BasicInplaceReplace.prototype.textReplace = function (value, up) {\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\n    };\n    BasicInplaceReplace.prototype.valueSetsReplace = function (valueSets, value, up) {\n        var result = null;\n        for (var i = 0, len = valueSets.length; result === null && i < len; i++) {\n            result = this.valueSetReplace(valueSets[i], value, up);\n        }\n        return result;\n    };\n    BasicInplaceReplace.prototype.valueSetReplace = function (valueSet, value, up) {\n        var idx = valueSet.indexOf(value);\n        if (idx >= 0) {\n            idx += up ? +1 : -1;\n            if (idx < 0) {\n                idx = valueSet.length - 1;\n            }\n            else {\n                idx %= valueSet.length;\n            }\n            return valueSet[idx];\n        }\n        return null;\n    };\n    BasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n    return BasicInplaceReplace;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BaseEditorSimpleWorker", function() { return BaseEditorSimpleWorker; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EditorSimpleWorkerImpl", function() { return EditorSimpleWorkerImpl; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; });\n/* harmony import */ var _base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../base/common/arrays.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/arrays.js");\n/* harmony import */ var _base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/diff/diff.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/diff/diff.js");\n/* harmony import */ var _base_common_iterator_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../base/common/iterator.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/iterator.js");\n/* harmony import */ var _base_common_platform_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/platform.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/platform.js");\n/* harmony import */ var _base_common_uri_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../../base/common/uri.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/uri.js");\n/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/position.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js");\n/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../core/range.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/range.js");\n/* harmony import */ var _diff_diffComputer_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../diff/diffComputer.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/diff/diffComputer.js");\n/* harmony import */ var _model_mirrorTextModel_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../model/mirrorTextModel.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js");\n/* harmony import */ var _model_wordHelper_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../model/wordHelper.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/model/wordHelper.js");\n/* harmony import */ var _modes_linkComputer_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../modes/linkComputer.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/linkComputer.js");\n/* harmony import */ var _modes_supports_inplaceReplaceSupport_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../modes/supports/inplaceReplaceSupport.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js");\n/* harmony import */ var _standalone_standaloneBase_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../standalone/standaloneBase.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js");\n/* harmony import */ var _base_common_types_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../../../base/common/types.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/types.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (undefined && undefined.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n/**\n * @internal\n */\nvar MirrorModel = /** @class */ (function (_super) {\n    __extends(MirrorModel, _super);\n    function MirrorModel() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Object.defineProperty(MirrorModel.prototype, "uri", {\n        get: function () {\n            return this._uri;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MirrorModel.prototype, "version", {\n        get: function () {\n            return this._versionId;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MirrorModel.prototype, "eol", {\n        get: function () {\n            return this._eol;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MirrorModel.prototype.getValue = function () {\n        return this.getText();\n    };\n    MirrorModel.prototype.getLinesContent = function () {\n        return this._lines.slice(0);\n    };\n    MirrorModel.prototype.getLineCount = function () {\n        return this._lines.length;\n    };\n    MirrorModel.prototype.getLineContent = function (lineNumber) {\n        return this._lines[lineNumber - 1];\n    };\n    MirrorModel.prototype.getWordAtPosition = function (position, wordDefinition) {\n        var wordAtText = Object(_model_wordHelper_js__WEBPACK_IMPORTED_MODULE_9__["getWordAtText"])(position.column, Object(_model_wordHelper_js__WEBPACK_IMPORTED_MODULE_9__["ensureValidWordDefinition"])(wordDefinition), this._lines[position.lineNumber - 1], 0);\n        if (wordAtText) {\n            return new _core_range_js__WEBPACK_IMPORTED_MODULE_6__["Range"](position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n        }\n        return null;\n    };\n    MirrorModel.prototype.getWordUntilPosition = function (position, wordDefinition) {\n        var wordAtPosition = this.getWordAtPosition(position, wordDefinition);\n        if (!wordAtPosition) {\n            return {\n                word: \'\',\n                startColumn: position.column,\n                endColumn: position.column\n            };\n        }\n        return {\n            word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),\n            startColumn: wordAtPosition.startColumn,\n            endColumn: position.column\n        };\n    };\n    MirrorModel.prototype.createWordIterator = function (wordDefinition) {\n        var _this = this;\n        var obj;\n        var lineNumber = 0;\n        var lineText;\n        var wordRangesIdx = 0;\n        var wordRanges = [];\n        var next = function () {\n            if (wordRangesIdx < wordRanges.length) {\n                var value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n                wordRangesIdx += 1;\n                if (!obj) {\n                    obj = { done: false, value: value };\n                }\n                else {\n                    obj.value = value;\n                }\n                return obj;\n            }\n            else if (lineNumber >= _this._lines.length) {\n                return _base_common_iterator_js__WEBPACK_IMPORTED_MODULE_2__["FIN"];\n            }\n            else {\n                lineText = _this._lines[lineNumber];\n                wordRanges = _this._wordenize(lineText, wordDefinition);\n                wordRangesIdx = 0;\n                lineNumber += 1;\n                return next();\n            }\n        };\n        return { next: next };\n    };\n    MirrorModel.prototype.getLineWords = function (lineNumber, wordDefinition) {\n        var content = this._lines[lineNumber - 1];\n        var ranges = this._wordenize(content, wordDefinition);\n        var words = [];\n        for (var _i = 0, ranges_1 = ranges; _i < ranges_1.length; _i++) {\n            var range = ranges_1[_i];\n            words.push({\n                word: content.substring(range.start, range.end),\n                startColumn: range.start + 1,\n                endColumn: range.end + 1\n            });\n        }\n        return words;\n    };\n    MirrorModel.prototype._wordenize = function (content, wordDefinition) {\n        var result = [];\n        var match;\n        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n        while (match = wordDefinition.exec(content)) {\n            if (match[0].length === 0) {\n                // it did match the empty string\n                break;\n            }\n            result.push({ start: match.index, end: match.index + match[0].length });\n        }\n        return result;\n    };\n    MirrorModel.prototype.getValueInRange = function (range) {\n        range = this._validateRange(range);\n        if (range.startLineNumber === range.endLineNumber) {\n            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n        }\n        var lineEnding = this._eol;\n        var startLineIndex = range.startLineNumber - 1;\n        var endLineIndex = range.endLineNumber - 1;\n        var resultLines = [];\n        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n        for (var i = startLineIndex + 1; i < endLineIndex; i++) {\n            resultLines.push(this._lines[i]);\n        }\n        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n        return resultLines.join(lineEnding);\n    };\n    MirrorModel.prototype.offsetAt = function (position) {\n        position = this._validatePosition(position);\n        this._ensureLineStarts();\n        return this._lineStarts.getAccumulatedValue(position.lineNumber - 2) + (position.column - 1);\n    };\n    MirrorModel.prototype.positionAt = function (offset) {\n        offset = Math.floor(offset);\n        offset = Math.max(0, offset);\n        this._ensureLineStarts();\n        var out = this._lineStarts.getIndexOf(offset);\n        var lineLength = this._lines[out.index].length;\n        // Ensure we return a valid position\n        return {\n            lineNumber: 1 + out.index,\n            column: 1 + Math.min(out.remainder, lineLength)\n        };\n    };\n    MirrorModel.prototype._validateRange = function (range) {\n        var start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n        var end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n        if (start.lineNumber !== range.startLineNumber\n            || start.column !== range.startColumn\n            || end.lineNumber !== range.endLineNumber\n            || end.column !== range.endColumn) {\n            return {\n                startLineNumber: start.lineNumber,\n                startColumn: start.column,\n                endLineNumber: end.lineNumber,\n                endColumn: end.column\n            };\n        }\n        return range;\n    };\n    MirrorModel.prototype._validatePosition = function (position) {\n        if (!_core_position_js__WEBPACK_IMPORTED_MODULE_5__["Position"].isIPosition(position)) {\n            throw new Error(\'bad position\');\n        }\n        var lineNumber = position.lineNumber, column = position.column;\n        var hasChanged = false;\n        if (lineNumber < 1) {\n            lineNumber = 1;\n            column = 1;\n            hasChanged = true;\n        }\n        else if (lineNumber > this._lines.length) {\n            lineNumber = this._lines.length;\n            column = this._lines[lineNumber - 1].length + 1;\n            hasChanged = true;\n        }\n        else {\n            var maxCharacter = this._lines[lineNumber - 1].length + 1;\n            if (column < 1) {\n                column = 1;\n                hasChanged = true;\n            }\n            else if (column > maxCharacter) {\n                column = maxCharacter;\n                hasChanged = true;\n            }\n        }\n        if (!hasChanged) {\n            return position;\n        }\n        else {\n            return { lineNumber: lineNumber, column: column };\n        }\n    };\n    return MirrorModel;\n}(_model_mirrorTextModel_js__WEBPACK_IMPORTED_MODULE_8__["MirrorTextModel"]));\n/**\n * @internal\n */\nvar BaseEditorSimpleWorker = /** @class */ (function () {\n    function BaseEditorSimpleWorker(foreignModuleFactory) {\n        this._foreignModuleFactory = foreignModuleFactory;\n        this._foreignModule = null;\n    }\n    // ---- BEGIN diff --------------------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.computeDiff = function (originalUrl, modifiedUrl, ignoreTrimWhitespace) {\n        var original = this._getModel(originalUrl);\n        var modified = this._getModel(modifiedUrl);\n        if (!original || !modified) {\n            return Promise.resolve(null);\n        }\n        var originalLines = original.getLinesContent();\n        var modifiedLines = modified.getLinesContent();\n        var diffComputer = new _diff_diffComputer_js__WEBPACK_IMPORTED_MODULE_7__["DiffComputer"](originalLines, modifiedLines, {\n            shouldComputeCharChanges: true,\n            shouldPostProcessCharChanges: true,\n            shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n            shouldMakePrettyDiff: true\n        });\n        var changes = diffComputer.computeDiff();\n        var identical = (changes.length > 0 ? false : this._modelsAreIdentical(original, modified));\n        return Promise.resolve({\n            identical: identical,\n            changes: changes\n        });\n    };\n    BaseEditorSimpleWorker.prototype._modelsAreIdentical = function (original, modified) {\n        var originalLineCount = original.getLineCount();\n        var modifiedLineCount = modified.getLineCount();\n        if (originalLineCount !== modifiedLineCount) {\n            return false;\n        }\n        for (var line = 1; line <= originalLineCount; line++) {\n            var originalLine = original.getLineContent(line);\n            var modifiedLine = modified.getLineContent(line);\n            if (originalLine !== modifiedLine) {\n                return false;\n            }\n        }\n        return true;\n    };\n    BaseEditorSimpleWorker.prototype.computeMoreMinimalEdits = function (modelUrl, edits) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(edits);\n        }\n        var result = [];\n        var lastEol = undefined;\n        edits = Object(_base_common_arrays_js__WEBPACK_IMPORTED_MODULE_0__["mergeSort"])(edits, function (a, b) {\n            if (a.range && b.range) {\n                return _core_range_js__WEBPACK_IMPORTED_MODULE_6__["Range"].compareRangesUsingStarts(a.range, b.range);\n            }\n            // eol only changes should go to the end\n            var aRng = a.range ? 0 : 1;\n            var bRng = b.range ? 0 : 1;\n            return aRng - bRng;\n        });\n        for (var _i = 0, edits_1 = edits; _i < edits_1.length; _i++) {\n            var _a = edits_1[_i], range = _a.range, text = _a.text, eol = _a.eol;\n            if (typeof eol === \'number\') {\n                lastEol = eol;\n            }\n            if (_core_range_js__WEBPACK_IMPORTED_MODULE_6__["Range"].isEmpty(range) && !text) {\n                // empty change\n                continue;\n            }\n            var original = model.getValueInRange(range);\n            text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n            if (original === text) {\n                // noop\n                continue;\n            }\n            // make sure diff won\'t take too long\n            if (Math.max(text.length, original.length) > BaseEditorSimpleWorker._diffLimit) {\n                result.push({ range: range, text: text });\n                continue;\n            }\n            // compute diff between original and edit.text\n            var changes = Object(_base_common_diff_diff_js__WEBPACK_IMPORTED_MODULE_1__["stringDiff"])(original, text, false);\n            var editOffset = model.offsetAt(_core_range_js__WEBPACK_IMPORTED_MODULE_6__["Range"].lift(range).getStartPosition());\n            for (var _b = 0, changes_1 = changes; _b < changes_1.length; _b++) {\n                var change = changes_1[_b];\n                var start = model.positionAt(editOffset + change.originalStart);\n                var end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n                var newEdit = {\n                    text: text.substr(change.modifiedStart, change.modifiedLength),\n                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n                };\n                if (model.getValueInRange(newEdit.range) !== newEdit.text) {\n                    result.push(newEdit);\n                }\n            }\n        }\n        if (typeof lastEol === \'number\') {\n            result.push({ eol: lastEol, text: \'\', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\n        }\n        return Promise.resolve(result);\n    };\n    // ---- END minimal edits ---------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.computeLinks = function (modelUrl) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        return Promise.resolve(Object(_modes_linkComputer_js__WEBPACK_IMPORTED_MODULE_10__["computeLinks"])(model));\n    };\n    BaseEditorSimpleWorker.prototype.textualSuggest = function (modelUrl, position, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        var seen = Object.create(null);\n        var suggestions = [];\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        var wordUntil = model.getWordUntilPosition(position, wordDefRegExp);\n        var wordAt = model.getWordAtPosition(position, wordDefRegExp);\n        if (wordAt) {\n            seen[model.getValueInRange(wordAt)] = true;\n        }\n        for (var iter = model.createWordIterator(wordDefRegExp), e = iter.next(); !e.done && suggestions.length <= BaseEditorSimpleWorker._suggestionsLimit; e = iter.next()) {\n            var word = e.value;\n            if (seen[word]) {\n                continue;\n            }\n            seen[word] = true;\n            if (!isNaN(Number(word))) {\n                continue;\n            }\n            suggestions.push({\n                kind: 18 /* Text */,\n                label: word,\n                insertText: word,\n                range: { startLineNumber: position.lineNumber, startColumn: wordUntil.startColumn, endLineNumber: position.lineNumber, endColumn: wordUntil.endColumn }\n            });\n        }\n        return Promise.resolve({ suggestions: suggestions });\n    };\n    // ---- END suggest --------------------------------------------------------------------------\n    //#region -- word ranges --\n    BaseEditorSimpleWorker.prototype.computeWordRanges = function (modelUrl, range, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(Object.create(null));\n        }\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        var result = Object.create(null);\n        for (var line = range.startLineNumber; line < range.endLineNumber; line++) {\n            var words = model.getLineWords(line, wordDefRegExp);\n            for (var _i = 0, words_1 = words; _i < words_1.length; _i++) {\n                var word = words_1[_i];\n                if (!isNaN(Number(word.word))) {\n                    continue;\n                }\n                var array = result[word.word];\n                if (!array) {\n                    array = [];\n                    result[word.word] = array;\n                }\n                array.push({\n                    startLineNumber: line,\n                    startColumn: word.startColumn,\n                    endLineNumber: line,\n                    endColumn: word.endColumn\n                });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    //#endregion\n    BaseEditorSimpleWorker.prototype.navigateValueSet = function (modelUrl, range, up, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        if (range.startColumn === range.endColumn) {\n            range = {\n                startLineNumber: range.startLineNumber,\n                startColumn: range.startColumn,\n                endLineNumber: range.endLineNumber,\n                endColumn: range.endColumn + 1\n            };\n        }\n        var selectionText = model.getValueInRange(range);\n        var wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n        if (!wordRange) {\n            return Promise.resolve(null);\n        }\n        var word = model.getValueInRange(wordRange);\n        var result = _modes_supports_inplaceReplaceSupport_js__WEBPACK_IMPORTED_MODULE_11__["BasicInplaceReplace"].INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n        return Promise.resolve(result);\n    };\n    // ---- BEGIN foreign module support --------------------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.loadForeignModule = function (moduleId, createData) {\n        var _this = this;\n        var ctx = {\n            getMirrorModels: function () {\n                return _this._getModels();\n            }\n        };\n        if (this._foreignModuleFactory) {\n            this._foreignModule = this._foreignModuleFactory(ctx, createData);\n            // static foreing module\n            var methods = [];\n            for (var _i = 0, _a = Object(_base_common_types_js__WEBPACK_IMPORTED_MODULE_13__["getAllPropertyNames"])(this._foreignModule); _i < _a.length; _i++) {\n                var prop = _a[_i];\n                if (typeof this._foreignModule[prop] === \'function\') {\n                    methods.push(prop);\n                }\n            }\n            return Promise.resolve(methods);\n        }\n        // ESM-comment-begin\n        // \t\treturn new Promise<any>((resolve, reject) => {\n        // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n        // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n        // \n        // \t\t\t\tlet methods: string[] = [];\n        // \t\t\t\tfor (const prop of getAllPropertyNames(this._foreignModule)) {\n        // \t\t\t\t\tif (typeof this._foreignModule[prop] === \'function\') {\n        // \t\t\t\t\t\tmethods.push(prop);\n        // \t\t\t\t\t}\n        // \t\t\t\t}\n        // \n        // \t\t\t\tresolve(methods);\n        // \n        // \t\t\t}, reject);\n        // \t\t});\n        // ESM-comment-end\n        // ESM-uncomment-begin\n        return Promise.reject(new Error("Unexpected usage"));\n        // ESM-uncomment-end\n    };\n    // foreign method request\n    BaseEditorSimpleWorker.prototype.fmr = function (method, args) {\n        if (!this._foreignModule || typeof this._foreignModule[method] !== \'function\') {\n            return Promise.reject(new Error(\'Missing requestHandler or method: \' + method));\n        }\n        try {\n            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    };\n    // ---- END diff --------------------------------------------------------------------------\n    // ---- BEGIN minimal edits ---------------------------------------------------------------\n    BaseEditorSimpleWorker._diffLimit = 100000;\n    // ---- BEGIN suggest --------------------------------------------------------------------------\n    BaseEditorSimpleWorker._suggestionsLimit = 10000;\n    return BaseEditorSimpleWorker;\n}());\n\n/**\n * @internal\n */\nvar EditorSimpleWorkerImpl = /** @class */ (function (_super) {\n    __extends(EditorSimpleWorkerImpl, _super);\n    function EditorSimpleWorkerImpl(foreignModuleFactory) {\n        var _this = _super.call(this, foreignModuleFactory) || this;\n        _this._models = Object.create(null);\n        return _this;\n    }\n    EditorSimpleWorkerImpl.prototype.dispose = function () {\n        this._models = Object.create(null);\n    };\n    EditorSimpleWorkerImpl.prototype._getModel = function (uri) {\n        return this._models[uri];\n    };\n    EditorSimpleWorkerImpl.prototype._getModels = function () {\n        var _this = this;\n        var all = [];\n        Object.keys(this._models).forEach(function (key) { return all.push(_this._models[key]); });\n        return all;\n    };\n    EditorSimpleWorkerImpl.prototype.acceptNewModel = function (data) {\n        this._models[data.url] = new MirrorModel(_base_common_uri_js__WEBPACK_IMPORTED_MODULE_4__["URI"].parse(data.url), data.lines, data.EOL, data.versionId);\n    };\n    EditorSimpleWorkerImpl.prototype.acceptModelChanged = function (strURL, e) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        var model = this._models[strURL];\n        model.onEvents(e);\n    };\n    EditorSimpleWorkerImpl.prototype.acceptRemovedModel = function (strURL) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        delete this._models[strURL];\n    };\n    return EditorSimpleWorkerImpl;\n}(BaseEditorSimpleWorker));\n\n/**\n * Called on the worker side\n * @internal\n */\nfunction create() {\n    return new EditorSimpleWorkerImpl(null);\n}\nif (typeof importScripts === \'function\') {\n    // Running in a web worker\n    _base_common_platform_js__WEBPACK_IMPORTED_MODULE_3__["globals"].monaco = Object(_standalone_standaloneBase_js__WEBPACK_IMPORTED_MODULE_12__["createMonacoBaseAPI"])();\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/promise-polyfill/polyfill.js":function(module,exports,__webpack_require__){eval("/* WEBPACK VAR INJECTION */(function(setImmediate, global) {/*!\nCopyright (c) 2014 Taylor Hakes\nCopyright (c) 2014 Forbes Lindesay\n */\n(function (global, factory) {\n\t true ? factory() :\n\t\tundefined;\n}(this, (function () {\n\t'use strict';\n\n\t/**\n\t * @this {Promise}\n\t */\n\tfunction finallyConstructor(callback) {\n\t\tvar constructor = this.constructor;\n\t\treturn this.then(\n\t\t\tfunction (value) {\n\t\t\t\treturn constructor.resolve(callback()).then(function () {\n\t\t\t\t\treturn value;\n\t\t\t\t});\n\t\t\t},\n\t\t\tfunction (reason) {\n\t\t\t\treturn constructor.resolve(callback()).then(function () {\n\t\t\t\t\treturn constructor.reject(reason);\n\t\t\t\t});\n\t\t\t}\n\t\t);\n\t}\n\n\t// Store setTimeout reference so promise-polyfill will be unaffected by\n\t// other code modifying setTimeout (like sinon.useFakeTimers())\n\tvar setTimeoutFunc = setTimeout;\n\n\tfunction noop() { }\n\n\t// Polyfill for Function.prototype.bind\n\tfunction bind(fn, thisArg) {\n\t\treturn function () {\n\t\t\tfn.apply(thisArg, arguments);\n\t\t};\n\t}\n\n\t/**\n\t * @constructor\n\t * @param {Function} fn\n\t */\n\tfunction Promise(fn) {\n\t\tif (!(this instanceof Promise))\n\t\t\tthrow new TypeError('Promises must be constructed via new');\n\t\tif (typeof fn !== 'function') throw new TypeError('not a function');\n\t\t/** @type {!number} */\n\t\tthis._state = 0;\n\t\t/** @type {!boolean} */\n\t\tthis._handled = false;\n\t\t/** @type {Promise|undefined} */\n\t\tthis._value = undefined;\n\t\t/** @type {!Array<!Function>} */\n\t\tthis._deferreds = [];\n\n\t\tdoResolve(fn, this);\n\t}\n\n\tfunction handle(self, deferred) {\n\t\twhile (self._state === 3) {\n\t\t\tself = self._value;\n\t\t}\n\t\tif (self._state === 0) {\n\t\t\tself._deferreds.push(deferred);\n\t\t\treturn;\n\t\t}\n\t\tself._handled = true;\n\t\tPromise._immediateFn(function () {\n\t\t\tvar cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n\t\t\tif (cb === null) {\n\t\t\t\t(self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvar ret;\n\t\t\ttry {\n\t\t\t\tret = cb(self._value);\n\t\t\t} catch (e) {\n\t\t\t\treject(deferred.promise, e);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresolve(deferred.promise, ret);\n\t\t});\n\t}\n\n\tfunction resolve(self, newValue) {\n\t\ttry {\n\t\t\t// Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n\t\t\tif (newValue === self)\n\t\t\t\tthrow new TypeError('A promise cannot be resolved with itself.');\n\t\t\tif (\n\t\t\t\tnewValue &&\n\t\t\t\t(typeof newValue === 'object' || typeof newValue === 'function')\n\t\t\t) {\n\t\t\t\tvar then = newValue.then;\n\t\t\t\tif (newValue instanceof Promise) {\n\t\t\t\t\tself._state = 3;\n\t\t\t\t\tself._value = newValue;\n\t\t\t\t\tfinale(self);\n\t\t\t\t\treturn;\n\t\t\t\t} else if (typeof then === 'function') {\n\t\t\t\t\tdoResolve(bind(then, newValue), self);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tself._state = 1;\n\t\t\tself._value = newValue;\n\t\t\tfinale(self);\n\t\t} catch (e) {\n\t\t\treject(self, e);\n\t\t}\n\t}\n\n\tfunction reject(self, newValue) {\n\t\tself._state = 2;\n\t\tself._value = newValue;\n\t\tfinale(self);\n\t}\n\n\tfunction finale(self) {\n\t\tif (self._state === 2 && self._deferreds.length === 0) {\n\t\t\tPromise._immediateFn(function () {\n\t\t\t\tif (!self._handled) {\n\t\t\t\t\tPromise._unhandledRejectionFn(self._value);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tfor (var i = 0, len = self._deferreds.length; i < len; i++) {\n\t\t\thandle(self, self._deferreds[i]);\n\t\t}\n\t\tself._deferreds = null;\n\t}\n\n\t/**\n\t * @constructor\n\t */\n\tfunction Handler(onFulfilled, onRejected, promise) {\n\t\tthis.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n\t\tthis.onRejected = typeof onRejected === 'function' ? onRejected : null;\n\t\tthis.promise = promise;\n\t}\n\n\t/**\n\t * Take a potentially misbehaving resolver function and make sure\n\t * onFulfilled and onRejected are only called once.\n\t *\n\t * Makes no guarantees about asynchrony.\n\t */\n\tfunction doResolve(fn, self) {\n\t\tvar done = false;\n\t\ttry {\n\t\t\tfn(\n\t\t\t\tfunction (value) {\n\t\t\t\t\tif (done) return;\n\t\t\t\t\tdone = true;\n\t\t\t\t\tresolve(self, value);\n\t\t\t\t},\n\t\t\t\tfunction (reason) {\n\t\t\t\t\tif (done) return;\n\t\t\t\t\tdone = true;\n\t\t\t\t\treject(self, reason);\n\t\t\t\t}\n\t\t\t);\n\t\t} catch (ex) {\n\t\t\tif (done) return;\n\t\t\tdone = true;\n\t\t\treject(self, ex);\n\t\t}\n\t}\n\n\tPromise.prototype['catch'] = function (onRejected) {\n\t\treturn this.then(null, onRejected);\n\t};\n\n\tPromise.prototype.then = function (onFulfilled, onRejected) {\n\t\t// @ts-ignore\n\t\tvar prom = new this.constructor(noop);\n\n\t\thandle(this, new Handler(onFulfilled, onRejected, prom));\n\t\treturn prom;\n\t};\n\n\tPromise.prototype['finally'] = finallyConstructor;\n\n\tPromise.all = function (arr) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\tif (!arr || typeof arr.length === 'undefined')\n\t\t\t\tthrow new TypeError('Promise.all accepts an array');\n\t\t\tvar args = Array.prototype.slice.call(arr);\n\t\t\tif (args.length === 0) return resolve([]);\n\t\t\tvar remaining = args.length;\n\n\t\t\tfunction res(i, val) {\n\t\t\t\ttry {\n\t\t\t\t\tif (val && (typeof val === 'object' || typeof val === 'function')) {\n\t\t\t\t\t\tvar then = val.then;\n\t\t\t\t\t\tif (typeof then === 'function') {\n\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\tval,\n\t\t\t\t\t\t\t\tfunction (val) {\n\t\t\t\t\t\t\t\t\tres(i, val);\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\treject\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\targs[i] = val;\n\t\t\t\t\tif (--remaining === 0) {\n\t\t\t\t\t\tresolve(args);\n\t\t\t\t\t}\n\t\t\t\t} catch (ex) {\n\t\t\t\t\treject(ex);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (var i = 0; i < args.length; i++) {\n\t\t\t\tres(i, args[i]);\n\t\t\t}\n\t\t});\n\t};\n\n\tPromise.resolve = function (value) {\n\t\tif (value && typeof value === 'object' && value.constructor === Promise) {\n\t\t\treturn value;\n\t\t}\n\n\t\treturn new Promise(function (resolve) {\n\t\t\tresolve(value);\n\t\t});\n\t};\n\n\tPromise.reject = function (value) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\treject(value);\n\t\t});\n\t};\n\n\tPromise.race = function (values) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\tfor (var i = 0, len = values.length; i < len; i++) {\n\t\t\t\tvalues[i].then(resolve, reject);\n\t\t\t}\n\t\t});\n\t};\n\n\t// Use polyfill for setImmediate for performance gains\n\tPromise._immediateFn =\n\t\t(typeof setImmediate === 'function' &&\n\t\t\tfunction (fn) {\n\t\t\t\tsetImmediate(fn);\n\t\t\t}) ||\n\t\tfunction (fn) {\n\t\t\tsetTimeoutFunc(fn, 0);\n\t\t};\n\n\tPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n\t\tif (typeof console !== 'undefined' && console) {\n\t\t\tconsole.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n\t\t}\n\t};\n\n\t/** @suppress {undefinedVars} */\n\tvar globalNS = (function () {\n\t\t// the only reliable means to get the global object is\n\t\t// `Function('return this')()`\n\t\t// However, this causes CSP violations in Chrome apps.\n\t\tif (typeof self !== 'undefined') {\n\t\t\treturn self;\n\t\t}\n\t\tif (typeof window !== 'undefined') {\n\t\t\treturn window;\n\t\t}\n\t\tif (typeof global !== 'undefined') {\n\t\t\treturn global;\n\t\t}\n\t\tthrow new Error('unable to locate global object');\n\t})();\n\n\tif (!('Promise' in globalNS)) {\n\t\tglobalNS['Promise'] = Promise;\n\t} else if (!globalNS.Promise.prototype['finally']) {\n\t\tglobalNS.Promise.prototype['finally'] = finallyConstructor;\n\t}\n\n})));\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../../../../_timers-browserify@2.0.11@timers-browserify/main.js */ \"../node_modules/_timers-browserify@2.0.11@timers-browserify/main.js\").setImmediate, __webpack_require__(/*! ./../../../../../../../_webpack@4.41.2@webpack/buildin/global.js */ \"../node_modules/_webpack@4.41.2@webpack/buildin/global.js\")))\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/promise-polyfill/polyfill.js?")},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "KeyMod", function() { return KeyMod; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createMonacoBaseAPI", function() { return createMonacoBaseAPI; });\n/* harmony import */ var _promise_polyfill_polyfill_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./promise-polyfill/polyfill.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/promise-polyfill/polyfill.js");\n/* harmony import */ var _promise_polyfill_polyfill_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_promise_polyfill_polyfill_js__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _base_common_cancellation_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../base/common/cancellation.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/cancellation.js");\n/* harmony import */ var _base_common_event_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../../base/common/event.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/event.js");\n/* harmony import */ var _base_common_keyCodes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../../base/common/keyCodes.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/keyCodes.js");\n/* harmony import */ var _base_common_uri_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../../base/common/uri.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/uri.js");\n/* harmony import */ var _core_position_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/position.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/position.js");\n/* harmony import */ var _core_range_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../core/range.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/range.js");\n/* harmony import */ var _core_selection_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../core/selection.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/selection.js");\n/* harmony import */ var _core_token_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../core/token.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/token.js");\n/* harmony import */ var _standaloneEnums_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./standaloneEnums.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\n\n\n\n\n\n\n\n\nvar KeyMod = /** @class */ (function () {\n    function KeyMod() {\n    }\n    KeyMod.chord = function (firstPart, secondPart) {\n        return Object(_base_common_keyCodes_js__WEBPACK_IMPORTED_MODULE_3__["KeyChord"])(firstPart, secondPart);\n    };\n    KeyMod.CtrlCmd = 2048 /* CtrlCmd */;\n    KeyMod.Shift = 1024 /* Shift */;\n    KeyMod.Alt = 512 /* Alt */;\n    KeyMod.WinCtrl = 256 /* WinCtrl */;\n    return KeyMod;\n}());\n\nfunction createMonacoBaseAPI() {\n    return {\n        editor: undefined,\n        languages: undefined,\n        CancellationTokenSource: _base_common_cancellation_js__WEBPACK_IMPORTED_MODULE_1__["CancellationTokenSource"],\n        Emitter: _base_common_event_js__WEBPACK_IMPORTED_MODULE_2__["Emitter"],\n        KeyCode: _standaloneEnums_js__WEBPACK_IMPORTED_MODULE_9__["KeyCode"],\n        KeyMod: KeyMod,\n        Position: _core_position_js__WEBPACK_IMPORTED_MODULE_5__["Position"],\n        Range: _core_range_js__WEBPACK_IMPORTED_MODULE_6__["Range"],\n        Selection: _core_selection_js__WEBPACK_IMPORTED_MODULE_7__["Selection"],\n        SelectionDirection: _standaloneEnums_js__WEBPACK_IMPORTED_MODULE_9__["SelectionDirection"],\n        MarkerSeverity: _standaloneEnums_js__WEBPACK_IMPORTED_MODULE_9__["MarkerSeverity"],\n        MarkerTag: _standaloneEnums_js__WEBPACK_IMPORTED_MODULE_9__["MarkerTag"],\n        Uri: _base_common_uri_js__WEBPACK_IMPORTED_MODULE_4__["URI"],\n        Token: _core_token_js__WEBPACK_IMPORTED_MODULE_8__["Token"]\n    };\n}\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkerTag", function() { return MarkerTag; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkerSeverity", function() { return MarkerSeverity; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "KeyCode", function() { return KeyCode; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SelectionDirection", function() { return SelectionDirection; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ScrollbarVisibility", function() { return ScrollbarVisibility; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "OverviewRulerLane", function() { return OverviewRulerLane; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EndOfLinePreference", function() { return EndOfLinePreference; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DefaultEndOfLine", function() { return DefaultEndOfLine; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EndOfLineSequence", function() { return EndOfLineSequence; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TrackedRangeStickiness", function() { return TrackedRangeStickiness; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ScrollType", function() { return ScrollType; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CursorChangeReason", function() { return CursorChangeReason; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RenderMinimap", function() { return RenderMinimap; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WrappingIndent", function() { return WrappingIndent; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextEditorCursorBlinkingStyle", function() { return TextEditorCursorBlinkingStyle; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextEditorCursorStyle", function() { return TextEditorCursorStyle; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RenderLineNumbersType", function() { return RenderLineNumbersType; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ContentWidgetPositionPreference", function() { return ContentWidgetPositionPreference; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "OverlayWidgetPositionPreference", function() { return OverlayWidgetPositionPreference; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MouseTargetType", function() { return MouseTargetType; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "IndentAction", function() { return IndentAction; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItemKind", function() { return CompletionItemKind; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItemInsertTextRule", function() { return CompletionItemInsertTextRule; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionTriggerKind", function() { return CompletionTriggerKind; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SignatureHelpTriggerKind", function() { return SignatureHelpTriggerKind; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentHighlightKind", function() { return DocumentHighlightKind; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolKind", function() { return SymbolKind; });\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\nvar MarkerTag;\n(function (MarkerTag) {\n    MarkerTag[MarkerTag["Unnecessary"] = 1] = "Unnecessary";\n})(MarkerTag || (MarkerTag = {}));\nvar MarkerSeverity;\n(function (MarkerSeverity) {\n    MarkerSeverity[MarkerSeverity["Hint"] = 1] = "Hint";\n    MarkerSeverity[MarkerSeverity["Info"] = 2] = "Info";\n    MarkerSeverity[MarkerSeverity["Warning"] = 4] = "Warning";\n    MarkerSeverity[MarkerSeverity["Error"] = 8] = "Error";\n})(MarkerSeverity || (MarkerSeverity = {}));\n/**\n * Virtual Key Codes, the value does not hold any inherent meaning.\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n * But these are "more general", as they should work across browsers & OS`s.\n */\nvar KeyCode;\n(function (KeyCode) {\n    /**\n     * Placed first to cover the 0 value of the enum.\n     */\n    KeyCode[KeyCode["Unknown"] = 0] = "Unknown";\n    KeyCode[KeyCode["Backspace"] = 1] = "Backspace";\n    KeyCode[KeyCode["Tab"] = 2] = "Tab";\n    KeyCode[KeyCode["Enter"] = 3] = "Enter";\n    KeyCode[KeyCode["Shift"] = 4] = "Shift";\n    KeyCode[KeyCode["Ctrl"] = 5] = "Ctrl";\n    KeyCode[KeyCode["Alt"] = 6] = "Alt";\n    KeyCode[KeyCode["PauseBreak"] = 7] = "PauseBreak";\n    KeyCode[KeyCode["CapsLock"] = 8] = "CapsLock";\n    KeyCode[KeyCode["Escape"] = 9] = "Escape";\n    KeyCode[KeyCode["Space"] = 10] = "Space";\n    KeyCode[KeyCode["PageUp"] = 11] = "PageUp";\n    KeyCode[KeyCode["PageDown"] = 12] = "PageDown";\n    KeyCode[KeyCode["End"] = 13] = "End";\n    KeyCode[KeyCode["Home"] = 14] = "Home";\n    KeyCode[KeyCode["LeftArrow"] = 15] = "LeftArrow";\n    KeyCode[KeyCode["UpArrow"] = 16] = "UpArrow";\n    KeyCode[KeyCode["RightArrow"] = 17] = "RightArrow";\n    KeyCode[KeyCode["DownArrow"] = 18] = "DownArrow";\n    KeyCode[KeyCode["Insert"] = 19] = "Insert";\n    KeyCode[KeyCode["Delete"] = 20] = "Delete";\n    KeyCode[KeyCode["KEY_0"] = 21] = "KEY_0";\n    KeyCode[KeyCode["KEY_1"] = 22] = "KEY_1";\n    KeyCode[KeyCode["KEY_2"] = 23] = "KEY_2";\n    KeyCode[KeyCode["KEY_3"] = 24] = "KEY_3";\n    KeyCode[KeyCode["KEY_4"] = 25] = "KEY_4";\n    KeyCode[KeyCode["KEY_5"] = 26] = "KEY_5";\n    KeyCode[KeyCode["KEY_6"] = 27] = "KEY_6";\n    KeyCode[KeyCode["KEY_7"] = 28] = "KEY_7";\n    KeyCode[KeyCode["KEY_8"] = 29] = "KEY_8";\n    KeyCode[KeyCode["KEY_9"] = 30] = "KEY_9";\n    KeyCode[KeyCode["KEY_A"] = 31] = "KEY_A";\n    KeyCode[KeyCode["KEY_B"] = 32] = "KEY_B";\n    KeyCode[KeyCode["KEY_C"] = 33] = "KEY_C";\n    KeyCode[KeyCode["KEY_D"] = 34] = "KEY_D";\n    KeyCode[KeyCode["KEY_E"] = 35] = "KEY_E";\n    KeyCode[KeyCode["KEY_F"] = 36] = "KEY_F";\n    KeyCode[KeyCode["KEY_G"] = 37] = "KEY_G";\n    KeyCode[KeyCode["KEY_H"] = 38] = "KEY_H";\n    KeyCode[KeyCode["KEY_I"] = 39] = "KEY_I";\n    KeyCode[KeyCode["KEY_J"] = 40] = "KEY_J";\n    KeyCode[KeyCode["KEY_K"] = 41] = "KEY_K";\n    KeyCode[KeyCode["KEY_L"] = 42] = "KEY_L";\n    KeyCode[KeyCode["KEY_M"] = 43] = "KEY_M";\n    KeyCode[KeyCode["KEY_N"] = 44] = "KEY_N";\n    KeyCode[KeyCode["KEY_O"] = 45] = "KEY_O";\n    KeyCode[KeyCode["KEY_P"] = 46] = "KEY_P";\n    KeyCode[KeyCode["KEY_Q"] = 47] = "KEY_Q";\n    KeyCode[KeyCode["KEY_R"] = 48] = "KEY_R";\n    KeyCode[KeyCode["KEY_S"] = 49] = "KEY_S";\n    KeyCode[KeyCode["KEY_T"] = 50] = "KEY_T";\n    KeyCode[KeyCode["KEY_U"] = 51] = "KEY_U";\n    KeyCode[KeyCode["KEY_V"] = 52] = "KEY_V";\n    KeyCode[KeyCode["KEY_W"] = 53] = "KEY_W";\n    KeyCode[KeyCode["KEY_X"] = 54] = "KEY_X";\n    KeyCode[KeyCode["KEY_Y"] = 55] = "KEY_Y";\n    KeyCode[KeyCode["KEY_Z"] = 56] = "KEY_Z";\n    KeyCode[KeyCode["Meta"] = 57] = "Meta";\n    KeyCode[KeyCode["ContextMenu"] = 58] = "ContextMenu";\n    KeyCode[KeyCode["F1"] = 59] = "F1";\n    KeyCode[KeyCode["F2"] = 60] = "F2";\n    KeyCode[KeyCode["F3"] = 61] = "F3";\n    KeyCode[KeyCode["F4"] = 62] = "F4";\n    KeyCode[KeyCode["F5"] = 63] = "F5";\n    KeyCode[KeyCode["F6"] = 64] = "F6";\n    KeyCode[KeyCode["F7"] = 65] = "F7";\n    KeyCode[KeyCode["F8"] = 66] = "F8";\n    KeyCode[KeyCode["F9"] = 67] = "F9";\n    KeyCode[KeyCode["F10"] = 68] = "F10";\n    KeyCode[KeyCode["F11"] = 69] = "F11";\n    KeyCode[KeyCode["F12"] = 70] = "F12";\n    KeyCode[KeyCode["F13"] = 71] = "F13";\n    KeyCode[KeyCode["F14"] = 72] = "F14";\n    KeyCode[KeyCode["F15"] = 73] = "F15";\n    KeyCode[KeyCode["F16"] = 74] = "F16";\n    KeyCode[KeyCode["F17"] = 75] = "F17";\n    KeyCode[KeyCode["F18"] = 76] = "F18";\n    KeyCode[KeyCode["F19"] = 77] = "F19";\n    KeyCode[KeyCode["NumLock"] = 78] = "NumLock";\n    KeyCode[KeyCode["ScrollLock"] = 79] = "ScrollLock";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \';:\' key\n     */\n    KeyCode[KeyCode["US_SEMICOLON"] = 80] = "US_SEMICOLON";\n    /**\n     * For any country/region, the \'+\' key\n     * For the US standard keyboard, the \'=+\' key\n     */\n    KeyCode[KeyCode["US_EQUAL"] = 81] = "US_EQUAL";\n    /**\n     * For any country/region, the \',\' key\n     * For the US standard keyboard, the \',<\' key\n     */\n    KeyCode[KeyCode["US_COMMA"] = 82] = "US_COMMA";\n    /**\n     * For any country/region, the \'-\' key\n     * For the US standard keyboard, the \'-_\' key\n     */\n    KeyCode[KeyCode["US_MINUS"] = 83] = "US_MINUS";\n    /**\n     * For any country/region, the \'.\' key\n     * For the US standard keyboard, the \'.>\' key\n     */\n    KeyCode[KeyCode["US_DOT"] = 84] = "US_DOT";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \'/?\' key\n     */\n    KeyCode[KeyCode["US_SLASH"] = 85] = "US_SLASH";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \'`~\' key\n     */\n    KeyCode[KeyCode["US_BACKTICK"] = 86] = "US_BACKTICK";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \'[{\' key\n     */\n    KeyCode[KeyCode["US_OPEN_SQUARE_BRACKET"] = 87] = "US_OPEN_SQUARE_BRACKET";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \'\\|\' key\n     */\n    KeyCode[KeyCode["US_BACKSLASH"] = 88] = "US_BACKSLASH";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \']}\' key\n     */\n    KeyCode[KeyCode["US_CLOSE_SQUARE_BRACKET"] = 89] = "US_CLOSE_SQUARE_BRACKET";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the \'\'"\' key\n     */\n    KeyCode[KeyCode["US_QUOTE"] = 90] = "US_QUOTE";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     */\n    KeyCode[KeyCode["OEM_8"] = 91] = "OEM_8";\n    /**\n     * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n     */\n    KeyCode[KeyCode["OEM_102"] = 92] = "OEM_102";\n    KeyCode[KeyCode["NUMPAD_0"] = 93] = "NUMPAD_0";\n    KeyCode[KeyCode["NUMPAD_1"] = 94] = "NUMPAD_1";\n    KeyCode[KeyCode["NUMPAD_2"] = 95] = "NUMPAD_2";\n    KeyCode[KeyCode["NUMPAD_3"] = 96] = "NUMPAD_3";\n    KeyCode[KeyCode["NUMPAD_4"] = 97] = "NUMPAD_4";\n    KeyCode[KeyCode["NUMPAD_5"] = 98] = "NUMPAD_5";\n    KeyCode[KeyCode["NUMPAD_6"] = 99] = "NUMPAD_6";\n    KeyCode[KeyCode["NUMPAD_7"] = 100] = "NUMPAD_7";\n    KeyCode[KeyCode["NUMPAD_8"] = 101] = "NUMPAD_8";\n    KeyCode[KeyCode["NUMPAD_9"] = 102] = "NUMPAD_9";\n    KeyCode[KeyCode["NUMPAD_MULTIPLY"] = 103] = "NUMPAD_MULTIPLY";\n    KeyCode[KeyCode["NUMPAD_ADD"] = 104] = "NUMPAD_ADD";\n    KeyCode[KeyCode["NUMPAD_SEPARATOR"] = 105] = "NUMPAD_SEPARATOR";\n    KeyCode[KeyCode["NUMPAD_SUBTRACT"] = 106] = "NUMPAD_SUBTRACT";\n    KeyCode[KeyCode["NUMPAD_DECIMAL"] = 107] = "NUMPAD_DECIMAL";\n    KeyCode[KeyCode["NUMPAD_DIVIDE"] = 108] = "NUMPAD_DIVIDE";\n    /**\n     * Cover all key codes when IME is processing input.\n     */\n    KeyCode[KeyCode["KEY_IN_COMPOSITION"] = 109] = "KEY_IN_COMPOSITION";\n    KeyCode[KeyCode["ABNT_C1"] = 110] = "ABNT_C1";\n    KeyCode[KeyCode["ABNT_C2"] = 111] = "ABNT_C2";\n    /**\n     * Placed last to cover the length of the enum.\n     * Please do not depend on this value!\n     */\n    KeyCode[KeyCode["MAX_VALUE"] = 112] = "MAX_VALUE";\n})(KeyCode || (KeyCode = {}));\n/**\n * The direction of a selection.\n */\nvar SelectionDirection;\n(function (SelectionDirection) {\n    /**\n     * The selection starts above where it ends.\n     */\n    SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR";\n    /**\n     * The selection starts below where it ends.\n     */\n    SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL";\n})(SelectionDirection || (SelectionDirection = {}));\nvar ScrollbarVisibility;\n(function (ScrollbarVisibility) {\n    ScrollbarVisibility[ScrollbarVisibility["Auto"] = 1] = "Auto";\n    ScrollbarVisibility[ScrollbarVisibility["Hidden"] = 2] = "Hidden";\n    ScrollbarVisibility[ScrollbarVisibility["Visible"] = 3] = "Visible";\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nvar OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";\n    OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";\n    OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";\n    OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\n/**\n * End of line character preference.\n */\nvar EndOfLinePreference;\n(function (EndOfLinePreference) {\n    /**\n     * Use the end of line character identified in the text buffer.\n     */\n    EndOfLinePreference[EndOfLinePreference["TextDefined"] = 0] = "TextDefined";\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference["LF"] = 1] = "LF";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference["CRLF"] = 2] = "CRLF";\n})(EndOfLinePreference || (EndOfLinePreference = {}));\n/**\n * The default end of line to use when instantiating models.\n */\nvar DefaultEndOfLine;\n(function (DefaultEndOfLine) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine["LF"] = 1] = "LF";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine["CRLF"] = 2] = "CRLF";\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\n/**\n * End of line character preference.\n */\nvar EndOfLineSequence;\n(function (EndOfLineSequence) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence["LF"] = 0] = "LF";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence["CRLF"] = 1] = "CRLF";\n})(EndOfLineSequence || (EndOfLineSequence = {}));\n/**\n * Describes the behavior of decorations when typing/editing near their edges.\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\n */\nvar TrackedRangeStickiness;\n(function (TrackedRangeStickiness) {\n    TrackedRangeStickiness[TrackedRangeStickiness["AlwaysGrowsWhenTypingAtEdges"] = 0] = "AlwaysGrowsWhenTypingAtEdges";\n    TrackedRangeStickiness[TrackedRangeStickiness["NeverGrowsWhenTypingAtEdges"] = 1] = "NeverGrowsWhenTypingAtEdges";\n    TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingBefore"] = 2] = "GrowsOnlyWhenTypingBefore";\n    TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingAfter"] = 3] = "GrowsOnlyWhenTypingAfter";\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\nvar ScrollType;\n(function (ScrollType) {\n    ScrollType[ScrollType["Smooth"] = 0] = "Smooth";\n    ScrollType[ScrollType["Immediate"] = 1] = "Immediate";\n})(ScrollType || (ScrollType = {}));\n/**\n * Describes the reason the cursor has changed its position.\n */\nvar CursorChangeReason;\n(function (CursorChangeReason) {\n    /**\n     * Unknown or not set.\n     */\n    CursorChangeReason[CursorChangeReason["NotSet"] = 0] = "NotSet";\n    /**\n     * A `model.setValue()` was called.\n     */\n    CursorChangeReason[CursorChangeReason["ContentFlush"] = 1] = "ContentFlush";\n    /**\n     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\n     */\n    CursorChangeReason[CursorChangeReason["RecoverFromMarkers"] = 2] = "RecoverFromMarkers";\n    /**\n     * There was an explicit user gesture.\n     */\n    CursorChangeReason[CursorChangeReason["Explicit"] = 3] = "Explicit";\n    /**\n     * There was a Paste.\n     */\n    CursorChangeReason[CursorChangeReason["Paste"] = 4] = "Paste";\n    /**\n     * There was an Undo.\n     */\n    CursorChangeReason[CursorChangeReason["Undo"] = 5] = "Undo";\n    /**\n     * There was a Redo.\n     */\n    CursorChangeReason[CursorChangeReason["Redo"] = 6] = "Redo";\n})(CursorChangeReason || (CursorChangeReason = {}));\nvar RenderMinimap;\n(function (RenderMinimap) {\n    RenderMinimap[RenderMinimap["None"] = 0] = "None";\n    RenderMinimap[RenderMinimap["Small"] = 1] = "Small";\n    RenderMinimap[RenderMinimap["Large"] = 2] = "Large";\n    RenderMinimap[RenderMinimap["SmallBlocks"] = 3] = "SmallBlocks";\n    RenderMinimap[RenderMinimap["LargeBlocks"] = 4] = "LargeBlocks";\n})(RenderMinimap || (RenderMinimap = {}));\n/**\n * Describes how to indent wrapped lines.\n */\nvar WrappingIndent;\n(function (WrappingIndent) {\n    /**\n     * No indentation => wrapped lines begin at column 1.\n     */\n    WrappingIndent[WrappingIndent["None"] = 0] = "None";\n    /**\n     * Same => wrapped lines get the same indentation as the parent.\n     */\n    WrappingIndent[WrappingIndent["Same"] = 1] = "Same";\n    /**\n     * Indent => wrapped lines get +1 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent["Indent"] = 2] = "Indent";\n    /**\n     * DeepIndent => wrapped lines get +2 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent["DeepIndent"] = 3] = "DeepIndent";\n})(WrappingIndent || (WrappingIndent = {}));\n/**\n * The kind of animation in which the editor\'s cursor should be rendered.\n */\nvar TextEditorCursorBlinkingStyle;\n(function (TextEditorCursorBlinkingStyle) {\n    /**\n     * Hidden\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Hidden"] = 0] = "Hidden";\n    /**\n     * Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Blink"] = 1] = "Blink";\n    /**\n     * Blinking with smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Smooth"] = 2] = "Smooth";\n    /**\n     * Blinking with prolonged filled state and smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Phase"] = 3] = "Phase";\n    /**\n     * Expand collapse animation on the y axis\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Expand"] = 4] = "Expand";\n    /**\n     * No-Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle["Solid"] = 5] = "Solid";\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\n/**\n * The style in which the editor\'s cursor should be rendered.\n */\nvar TextEditorCursorStyle;\n(function (TextEditorCursorStyle) {\n    /**\n     * As a vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["Line"] = 1] = "Line";\n    /**\n     * As a block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["Block"] = 2] = "Block";\n    /**\n     * As a horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["Underline"] = 3] = "Underline";\n    /**\n     * As a thin vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["LineThin"] = 4] = "LineThin";\n    /**\n     * As an outlined block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["BlockOutline"] = 5] = "BlockOutline";\n    /**\n     * As a thin horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle["UnderlineThin"] = 6] = "UnderlineThin";\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\nvar RenderLineNumbersType;\n(function (RenderLineNumbersType) {\n    RenderLineNumbersType[RenderLineNumbersType["Off"] = 0] = "Off";\n    RenderLineNumbersType[RenderLineNumbersType["On"] = 1] = "On";\n    RenderLineNumbersType[RenderLineNumbersType["Relative"] = 2] = "Relative";\n    RenderLineNumbersType[RenderLineNumbersType["Interval"] = 3] = "Interval";\n    RenderLineNumbersType[RenderLineNumbersType["Custom"] = 4] = "Custom";\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\n/**\n * A positioning preference for rendering content widgets.\n */\nvar ContentWidgetPositionPreference;\n(function (ContentWidgetPositionPreference) {\n    /**\n     * Place the content widget exactly at a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference["EXACT"] = 0] = "EXACT";\n    /**\n     * Place the content widget above a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference["ABOVE"] = 1] = "ABOVE";\n    /**\n     * Place the content widget below a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference["BELOW"] = 2] = "BELOW";\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\n/**\n * A positioning preference for rendering overlay widgets.\n */\nvar OverlayWidgetPositionPreference;\n(function (OverlayWidgetPositionPreference) {\n    /**\n     * Position the overlay widget in the top right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_RIGHT_CORNER"] = 0] = "TOP_RIGHT_CORNER";\n    /**\n     * Position the overlay widget in the bottom right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["BOTTOM_RIGHT_CORNER"] = 1] = "BOTTOM_RIGHT_CORNER";\n    /**\n     * Position the overlay widget in the top center\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference["TOP_CENTER"] = 2] = "TOP_CENTER";\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\n/**\n * Type of hit element with the mouse in the editor.\n */\nvar MouseTargetType;\n(function (MouseTargetType) {\n    /**\n     * Mouse is on top of an unknown element.\n     */\n    MouseTargetType[MouseTargetType["UNKNOWN"] = 0] = "UNKNOWN";\n    /**\n     * Mouse is on top of the textarea used for input.\n     */\n    MouseTargetType[MouseTargetType["TEXTAREA"] = 1] = "TEXTAREA";\n    /**\n     * Mouse is on top of the glyph margin\n     */\n    MouseTargetType[MouseTargetType["GUTTER_GLYPH_MARGIN"] = 2] = "GUTTER_GLYPH_MARGIN";\n    /**\n     * Mouse is on top of the line numbers\n     */\n    MouseTargetType[MouseTargetType["GUTTER_LINE_NUMBERS"] = 3] = "GUTTER_LINE_NUMBERS";\n    /**\n     * Mouse is on top of the line decorations\n     */\n    MouseTargetType[MouseTargetType["GUTTER_LINE_DECORATIONS"] = 4] = "GUTTER_LINE_DECORATIONS";\n    /**\n     * Mouse is on top of the whitespace left in the gutter by a view zone.\n     */\n    MouseTargetType[MouseTargetType["GUTTER_VIEW_ZONE"] = 5] = "GUTTER_VIEW_ZONE";\n    /**\n     * Mouse is on top of text in the content.\n     */\n    MouseTargetType[MouseTargetType["CONTENT_TEXT"] = 6] = "CONTENT_TEXT";\n    /**\n     * Mouse is on top of empty space in the content (e.g. after line text or below last line)\n     */\n    MouseTargetType[MouseTargetType["CONTENT_EMPTY"] = 7] = "CONTENT_EMPTY";\n    /**\n     * Mouse is on top of a view zone in the content.\n     */\n    MouseTargetType[MouseTargetType["CONTENT_VIEW_ZONE"] = 8] = "CONTENT_VIEW_ZONE";\n    /**\n     * Mouse is on top of a content widget.\n     */\n    MouseTargetType[MouseTargetType["CONTENT_WIDGET"] = 9] = "CONTENT_WIDGET";\n    /**\n     * Mouse is on top of the decorations overview ruler.\n     */\n    MouseTargetType[MouseTargetType["OVERVIEW_RULER"] = 10] = "OVERVIEW_RULER";\n    /**\n     * Mouse is on top of a scrollbar.\n     */\n    MouseTargetType[MouseTargetType["SCROLLBAR"] = 11] = "SCROLLBAR";\n    /**\n     * Mouse is on top of an overlay widget.\n     */\n    MouseTargetType[MouseTargetType["OVERLAY_WIDGET"] = 12] = "OVERLAY_WIDGET";\n    /**\n     * Mouse is outside of the editor.\n     */\n    MouseTargetType[MouseTargetType["OUTSIDE_EDITOR"] = 13] = "OUTSIDE_EDITOR";\n})(MouseTargetType || (MouseTargetType = {}));\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nvar IndentAction;\n(function (IndentAction) {\n    /**\n     * Insert new line and copy the previous line\'s indentation.\n     */\n    IndentAction[IndentAction["None"] = 0] = "None";\n    /**\n     * Insert new line and indent once (relative to the previous line\'s indentation).\n     */\n    IndentAction[IndentAction["Indent"] = 1] = "Indent";\n    /**\n     * Insert two new lines:\n     *  - the first one indented which will hold the cursor\n     *  - the second one at the same indentation level\n     */\n    IndentAction[IndentAction["IndentOutdent"] = 2] = "IndentOutdent";\n    /**\n     * Insert new line and outdent once (relative to the previous line\'s indentation).\n     */\n    IndentAction[IndentAction["Outdent"] = 3] = "Outdent";\n})(IndentAction || (IndentAction = {}));\nvar CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind[CompletionItemKind["Method"] = 0] = "Method";\n    CompletionItemKind[CompletionItemKind["Function"] = 1] = "Function";\n    CompletionItemKind[CompletionItemKind["Constructor"] = 2] = "Constructor";\n    CompletionItemKind[CompletionItemKind["Field"] = 3] = "Field";\n    CompletionItemKind[CompletionItemKind["Variable"] = 4] = "Variable";\n    CompletionItemKind[CompletionItemKind["Class"] = 5] = "Class";\n    CompletionItemKind[CompletionItemKind["Struct"] = 6] = "Struct";\n    CompletionItemKind[CompletionItemKind["Interface"] = 7] = "Interface";\n    CompletionItemKind[CompletionItemKind["Module"] = 8] = "Module";\n    CompletionItemKind[CompletionItemKind["Property"] = 9] = "Property";\n    CompletionItemKind[CompletionItemKind["Event"] = 10] = "Event";\n    CompletionItemKind[CompletionItemKind["Operator"] = 11] = "Operator";\n    CompletionItemKind[CompletionItemKind["Unit"] = 12] = "Unit";\n    CompletionItemKind[CompletionItemKind["Value"] = 13] = "Value";\n    CompletionItemKind[CompletionItemKind["Constant"] = 14] = "Constant";\n    CompletionItemKind[CompletionItemKind["Enum"] = 15] = "Enum";\n    CompletionItemKind[CompletionItemKind["EnumMember"] = 16] = "EnumMember";\n    CompletionItemKind[CompletionItemKind["Keyword"] = 17] = "Keyword";\n    CompletionItemKind[CompletionItemKind["Text"] = 18] = "Text";\n    CompletionItemKind[CompletionItemKind["Color"] = 19] = "Color";\n    CompletionItemKind[CompletionItemKind["File"] = 20] = "File";\n    CompletionItemKind[CompletionItemKind["Reference"] = 21] = "Reference";\n    CompletionItemKind[CompletionItemKind["Customcolor"] = 22] = "Customcolor";\n    CompletionItemKind[CompletionItemKind["Folder"] = 23] = "Folder";\n    CompletionItemKind[CompletionItemKind["TypeParameter"] = 24] = "TypeParameter";\n    CompletionItemKind[CompletionItemKind["Snippet"] = 25] = "Snippet";\n})(CompletionItemKind || (CompletionItemKind = {}));\nvar CompletionItemInsertTextRule;\n(function (CompletionItemInsertTextRule) {\n    /**\n     * Adjust whitespace/indentation of multiline insert texts to\n     * match the current line indentation.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule["KeepWhitespace"] = 1] = "KeepWhitespace";\n    /**\n     * `insertText` is a snippet.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule["InsertAsSnippet"] = 4] = "InsertAsSnippet";\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\n/**\n * How a suggest provider was triggered.\n */\nvar CompletionTriggerKind;\n(function (CompletionTriggerKind) {\n    CompletionTriggerKind[CompletionTriggerKind["Invoke"] = 0] = "Invoke";\n    CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 1] = "TriggerCharacter";\n    CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 2] = "TriggerForIncompleteCompletions";\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\nvar SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoke"] = 1] = "Invoke";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A document highlight kind.\n */\nvar DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind[DocumentHighlightKind["Text"] = 0] = "Text";\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind["Read"] = 1] = "Read";\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind["Write"] = 2] = "Write";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * A symbol kind.\n */\nvar SymbolKind;\n(function (SymbolKind) {\n    SymbolKind[SymbolKind["File"] = 0] = "File";\n    SymbolKind[SymbolKind["Module"] = 1] = "Module";\n    SymbolKind[SymbolKind["Namespace"] = 2] = "Namespace";\n    SymbolKind[SymbolKind["Package"] = 3] = "Package";\n    SymbolKind[SymbolKind["Class"] = 4] = "Class";\n    SymbolKind[SymbolKind["Method"] = 5] = "Method";\n    SymbolKind[SymbolKind["Property"] = 6] = "Property";\n    SymbolKind[SymbolKind["Field"] = 7] = "Field";\n    SymbolKind[SymbolKind["Constructor"] = 8] = "Constructor";\n    SymbolKind[SymbolKind["Enum"] = 9] = "Enum";\n    SymbolKind[SymbolKind["Interface"] = 10] = "Interface";\n    SymbolKind[SymbolKind["Function"] = 11] = "Function";\n    SymbolKind[SymbolKind["Variable"] = 12] = "Variable";\n    SymbolKind[SymbolKind["Constant"] = 13] = "Constant";\n    SymbolKind[SymbolKind["String"] = 14] = "String";\n    SymbolKind[SymbolKind["Number"] = 15] = "Number";\n    SymbolKind[SymbolKind["Boolean"] = 16] = "Boolean";\n    SymbolKind[SymbolKind["Array"] = 17] = "Array";\n    SymbolKind[SymbolKind["Object"] = 18] = "Object";\n    SymbolKind[SymbolKind["Key"] = 19] = "Key";\n    SymbolKind[SymbolKind["Null"] = 20] = "Null";\n    SymbolKind[SymbolKind["EnumMember"] = 21] = "EnumMember";\n    SymbolKind[SymbolKind["Struct"] = 22] = "Struct";\n    SymbolKind[SymbolKind["Event"] = 23] = "Event";\n    SymbolKind[SymbolKind["Operator"] = 24] = "Operator";\n    SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";\n})(SymbolKind || (SymbolKind = {}));\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PrefixSumIndexOfResult", function() { return PrefixSumIndexOfResult; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PrefixSumComputer", function() { return PrefixSumComputer; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PrefixSumComputerWithCache", function() { return PrefixSumComputerWithCache; });\n/* harmony import */ var _core_uint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/uint.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/core/uint.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nvar PrefixSumIndexOfResult = /** @class */ (function () {\n    function PrefixSumIndexOfResult(index, remainder) {\n        this.index = index;\n        this.remainder = remainder;\n    }\n    return PrefixSumIndexOfResult;\n}());\n\nvar PrefixSumComputer = /** @class */ (function () {\n    function PrefixSumComputer(values) {\n        this.values = values;\n        this.prefixSum = new Uint32Array(values.length);\n        this.prefixSumValidIndex = new Int32Array(1);\n        this.prefixSumValidIndex[0] = -1;\n    }\n    PrefixSumComputer.prototype.getCount = function () {\n        return this.values.length;\n    };\n    PrefixSumComputer.prototype.insertValues = function (insertIndex, insertValues) {\n        insertIndex = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(insertIndex);\n        var oldValues = this.values;\n        var oldPrefixSum = this.prefixSum;\n        var insertValuesLen = insertValues.length;\n        if (insertValuesLen === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n        this.values.set(insertValues, insertIndex);\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = insertIndex - 1;\n        }\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.changeValue = function (index, value) {\n        index = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(index);\n        value = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(value);\n        if (this.values[index] === value) {\n            return false;\n        }\n        this.values[index] = value;\n        if (index - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = index - 1;\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.removeValues = function (startIndex, cnt) {\n        startIndex = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(startIndex);\n        cnt = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(cnt);\n        var oldValues = this.values;\n        var oldPrefixSum = this.prefixSum;\n        if (startIndex >= oldValues.length) {\n            return false;\n        }\n        var maxCnt = oldValues.length - startIndex;\n        if (cnt >= maxCnt) {\n            cnt = maxCnt;\n        }\n        if (cnt === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length - cnt);\n        this.values.set(oldValues.subarray(0, startIndex), 0);\n        this.values.set(oldValues.subarray(startIndex + cnt), startIndex);\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = startIndex - 1;\n        }\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.getTotalValue = function () {\n        if (this.values.length === 0) {\n            return 0;\n        }\n        return this._getAccumulatedValue(this.values.length - 1);\n    };\n    PrefixSumComputer.prototype.getAccumulatedValue = function (index) {\n        if (index < 0) {\n            return 0;\n        }\n        index = Object(_core_uint_js__WEBPACK_IMPORTED_MODULE_0__["toUint32"])(index);\n        return this._getAccumulatedValue(index);\n    };\n    PrefixSumComputer.prototype._getAccumulatedValue = function (index) {\n        if (index <= this.prefixSumValidIndex[0]) {\n            return this.prefixSum[index];\n        }\n        var startIndex = this.prefixSumValidIndex[0] + 1;\n        if (startIndex === 0) {\n            this.prefixSum[0] = this.values[0];\n            startIndex++;\n        }\n        if (index >= this.values.length) {\n            index = this.values.length - 1;\n        }\n        for (var i = startIndex; i <= index; i++) {\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n        }\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n        return this.prefixSum[index];\n    };\n    PrefixSumComputer.prototype.getIndexOf = function (accumulatedValue) {\n        accumulatedValue = Math.floor(accumulatedValue); //@perf\n        // Compute all sums (to get a fully valid prefixSum)\n        this.getTotalValue();\n        var low = 0;\n        var high = this.values.length - 1;\n        var mid = 0;\n        var midStop = 0;\n        var midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStop = this.prefixSum[mid];\n            midStart = midStop - this.values[mid];\n            if (accumulatedValue < midStart) {\n                high = mid - 1;\n            }\n            else if (accumulatedValue >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        return new PrefixSumIndexOfResult(mid, accumulatedValue - midStart);\n    };\n    return PrefixSumComputer;\n}());\n\nvar PrefixSumComputerWithCache = /** @class */ (function () {\n    function PrefixSumComputerWithCache(values) {\n        this._cacheAccumulatedValueStart = 0;\n        this._cache = null;\n        this._actual = new PrefixSumComputer(values);\n        this._bustCache();\n    }\n    PrefixSumComputerWithCache.prototype._bustCache = function () {\n        this._cacheAccumulatedValueStart = 0;\n        this._cache = null;\n    };\n    PrefixSumComputerWithCache.prototype.insertValues = function (insertIndex, insertValues) {\n        if (this._actual.insertValues(insertIndex, insertValues)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.changeValue = function (index, value) {\n        if (this._actual.changeValue(index, value)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.removeValues = function (startIndex, cnt) {\n        if (this._actual.removeValues(startIndex, cnt)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.getTotalValue = function () {\n        return this._actual.getTotalValue();\n    };\n    PrefixSumComputerWithCache.prototype.getAccumulatedValue = function (index) {\n        return this._actual.getAccumulatedValue(index);\n    };\n    PrefixSumComputerWithCache.prototype.getIndexOf = function (accumulatedValue) {\n        accumulatedValue = Math.floor(accumulatedValue); //@perf\n        if (this._cache !== null) {\n            var cacheIndex = accumulatedValue - this._cacheAccumulatedValueStart;\n            if (cacheIndex >= 0 && cacheIndex < this._cache.length) {\n                // Cache hit!\n                return this._cache[cacheIndex];\n            }\n        }\n        // Cache miss!\n        return this._actual.getIndexOf(accumulatedValue);\n    };\n    /**\n     * Gives a hint that a lot of requests are about to come in for these accumulated values.\n     */\n    PrefixSumComputerWithCache.prototype.warmUpCache = function (accumulatedValueStart, accumulatedValueEnd) {\n        var newCache = [];\n        for (var accumulatedValue = accumulatedValueStart; accumulatedValue <= accumulatedValueEnd; accumulatedValue++) {\n            newCache[accumulatedValue - accumulatedValueStart] = this.getIndexOf(accumulatedValue);\n        }\n        this._cache = newCache;\n        this._cacheAccumulatedValueStart = accumulatedValueStart;\n    };\n    return PrefixSumComputerWithCache;\n}());\n\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js?')},"../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/editor.worker.js":function(module,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "initialize", function() { return initialize; });\n/* harmony import */ var _base_common_worker_simpleWorker_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../base/common/worker/simpleWorker.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/base/common/worker/simpleWorker.js");\n/* harmony import */ var _common_services_editorSimpleWorker_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./common/services/editorSimpleWorker.js */ "../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js");\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\nvar initialized = false;\nfunction initialize(foreignModule) {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    var editorWorker = new _common_services_editorSimpleWorker_js__WEBPACK_IMPORTED_MODULE_1__["EditorSimpleWorkerImpl"](foreignModule);\n    var simpleWorker = new _base_common_worker_simpleWorker_js__WEBPACK_IMPORTED_MODULE_0__["SimpleWorkerServer"](function (msg) {\n        self.postMessage(msg);\n    }, editorWorker);\n    self.onmessage = function (e) {\n        simpleWorker.onmessage(e.data);\n    };\n}\nself.onmessage = function (e) {\n    // Ignore first message in this case and initialize if not yet initialized\n    if (!initialized) {\n        initialize(null);\n    }\n};\n\n\n//# sourceURL=webpack:///../node_modules/_monaco-editor@0.17.1@monaco-editor/esm/vs/editor/editor.worker.js?')},"../node_modules/_process@0.11.10@process/browser.js":function(module,exports){eval("// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n//# sourceURL=webpack:///../node_modules/_process@0.11.10@process/browser.js?")},"../node_modules/_setimmediate@1.0.5@setimmediate/setImmediate.js":function(module,exports,__webpack_require__){eval('/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    "use strict";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== "function") {\n        callback = new Function("" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."\n        // So if we\'re currently running a task, we\'ll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // "too much recursion" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can\'t be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage("", "*");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = "setImmediate$" + Math.random() + "$";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === "string" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener("message", onGlobalMessage, false);\n        } else {\n            global.attachEvent("onmessage", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, "*");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it\'s been called.\n            var script = doc.createElement("script");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don\'t get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === "[object process]") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && "onreadystatechange" in doc.createElement("script")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../_webpack@4.41.2@webpack/buildin/global.js */ "../node_modules/_webpack@4.41.2@webpack/buildin/global.js"), __webpack_require__(/*! ./../_process@0.11.10@process/browser.js */ "../node_modules/_process@0.11.10@process/browser.js")))\n\n//# sourceURL=webpack:///../node_modules/_setimmediate@1.0.5@setimmediate/setImmediate.js?')},"../node_modules/_timers-browserify@2.0.11@timers-browserify/main.js":function(module,exports,__webpack_require__){eval('/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||\n            (typeof self !== "undefined" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(/*! setimmediate */ "../node_modules/_setimmediate@1.0.5@setimmediate/setImmediate.js");\n// On some exotic environments, it\'s not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||\n                       (typeof global !== "undefined" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||\n                         (typeof global !== "undefined" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../_webpack@4.41.2@webpack/buildin/global.js */ "../node_modules/_webpack@4.41.2@webpack/buildin/global.js")))\n\n//# sourceURL=webpack:///../node_modules/_timers-browserify@2.0.11@timers-browserify/main.js?')},"../node_modules/_webpack@4.41.2@webpack/buildin/global.js":function(module,exports){eval('var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function("return this")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === "object") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it\'s\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n//# sourceURL=webpack:///../node_modules/_webpack@4.41.2@webpack/buildin/global.js?')}});