Gitlink
/
forgeplus
Not watched
1
0
Fork 0
Code
Releases 16 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: e8df65e489
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e8df65e489'
${ noResults }
forgeplus/public/react/build/static/js/197.bf516239.chunk.js

3255 lines
130 kB
Raw Blame History 

  1. webpackJsonp([197],{

  2. 

  3. /***/ 3235:

  4. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  5. 

  6. "use strict";

  7. /* harmony export (immutable) */ __webpack_exports__["a"] = createScanner;

  8. /*---------------------------------------------------------------------------------------------

  9.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  10.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  11.  *--------------------------------------------------------------------------------------------*/

  12. 

  13. /**

  14.  * Creates a JSON scanner on the given text.

  15.  * If ignoreTrivia is set, whitespaces or comments are ignored.

  16.  */

  17. function createScanner(text, ignoreTrivia) {

  18.     if (ignoreTrivia === void 0) { ignoreTrivia = false; }

  19.     var pos = 0, len = text.length, value = '', tokenOffset = 0, token = 16 /* Unknown */, scanError = 0 /* None */;

  20.     function scanHexDigits(count, exact) {

  21.         var digits = 0;

  22.         var value = 0;

  23.         while (digits < count || !exact) {

  24.             var ch = text.charCodeAt(pos);

  25.             if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {

  26.                 value = value * 16 + ch - 48 /* _0 */;

  27.             }

  28.             else if (ch >= 65 /* A */ && ch <= 70 /* F */) {

  29.                 value = value * 16 + ch - 65 /* A */ + 10;

  30.             }

  31.             else if (ch >= 97 /* a */ && ch <= 102 /* f */) {

  32.                 value = value * 16 + ch - 97 /* a */ + 10;

  33.             }

  34.             else {

  35.                 break;

  36.             }

  37.             pos++;

  38.             digits++;

  39.         }

  40.         if (digits < count) {

  41.             value = -1;

  42.         }

  43.         return value;

  44.     }

  45.     function setPosition(newPosition) {

  46.         pos = newPosition;

  47.         value = '';

  48.         tokenOffset = 0;

  49.         token = 16 /* Unknown */;

  50.         scanError = 0 /* None */;

  51.     }

  52.     function scanNumber() {

  53.         var start = pos;

  54.         if (text.charCodeAt(pos) === 48 /* _0 */) {

  55.             pos++;

  56.         }

  57.         else {

  58.             pos++;

  59.             while (pos < text.length && isDigit(text.charCodeAt(pos))) {

  60.                 pos++;

  61.             }

  62.         }

  63.         if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {

  64.             pos++;

  65.             if (pos < text.length && isDigit(text.charCodeAt(pos))) {

  66.                 pos++;

  67.                 while (pos < text.length && isDigit(text.charCodeAt(pos))) {

  68.                     pos++;

  69.                 }

  70.             }

  71.             else {

  72.                 scanError = 3 /* UnexpectedEndOfNumber */;

  73.                 return text.substring(start, pos);

  74.             }

  75.         }

  76.         var end = pos;

  77.         if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {

  78.             pos++;

  79.             if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {

  80.                 pos++;

  81.             }

  82.             if (pos < text.length && isDigit(text.charCodeAt(pos))) {

  83.                 pos++;

  84.                 while (pos < text.length && isDigit(text.charCodeAt(pos))) {

  85.                     pos++;

  86.                 }

  87.                 end = pos;

  88.             }

  89.             else {

  90.                 scanError = 3 /* UnexpectedEndOfNumber */;

  91.             }

  92.         }

  93.         return text.substring(start, end);

  94.     }

  95.     function scanString() {

  96.         var result = '', start = pos;

  97.         while (true) {

  98.             if (pos >= len) {

  99.                 result += text.substring(start, pos);

  100.                 scanError = 2 /* UnexpectedEndOfString */;

  101.                 break;

  102.             }

  103.             var ch = text.charCodeAt(pos);

  104.             if (ch === 34 /* doubleQuote */) {

  105.                 result += text.substring(start, pos);

  106.                 pos++;

  107.                 break;

  108.             }

  109.             if (ch === 92 /* backslash */) {

  110.                 result += text.substring(start, pos);

  111.                 pos++;

  112.                 if (pos >= len) {

  113.                     scanError = 2 /* UnexpectedEndOfString */;

  114.                     break;

  115.                 }

  116.                 ch = text.charCodeAt(pos++);

  117.                 switch (ch) {

  118.                     case 34 /* doubleQuote */:

  119.                         result += '\"';

  120.                         break;

  121.                     case 92 /* backslash */:

  122.                         result += '\\';

  123.                         break;

  124.                     case 47 /* slash */:

  125.                         result += '/';

  126.                         break;

  127.                     case 98 /* b */:

  128.                         result += '\b';

  129.                         break;

  130.                     case 102 /* f */:

  131.                         result += '\f';

  132.                         break;

  133.                     case 110 /* n */:

  134.                         result += '\n';

  135.                         break;

  136.                     case 114 /* r */:

  137.                         result += '\r';

  138.                         break;

  139.                     case 116 /* t */:

  140.                         result += '\t';

  141.                         break;

  142.                     case 117 /* u */:

  143.                         var ch_1 = scanHexDigits(4, true);

  144.                         if (ch_1 >= 0) {

  145.                             result += String.fromCharCode(ch_1);

  146.                         }

  147.                         else {

  148.                             scanError = 4 /* InvalidUnicode */;

  149.                         }

  150.                         break;

  151.                     default:

  152.                         scanError = 5 /* InvalidEscapeCharacter */;

  153.                 }

  154.                 start = pos;

  155.                 continue;

  156.             }

  157.             if (ch >= 0 && ch <= 0x1f) {

  158.                 if (isLineBreak(ch)) {

  159.                     result += text.substring(start, pos);

  160.                     scanError = 2 /* UnexpectedEndOfString */;

  161.                     break;

  162.                 }

  163.                 else {

  164.                     scanError = 6 /* InvalidCharacter */;

  165.                     // mark as error but continue with string

  166.                 }

  167.             }

  168.             pos++;

  169.         }

  170.         return result;

  171.     }

  172.     function scanNext() {

  173.         value = '';

  174.         scanError = 0 /* None */;

  175.         tokenOffset = pos;

  176.         if (pos >= len) {

  177.             // at the end

  178.             tokenOffset = len;

  179.             return token = 17 /* EOF */;

  180.         }

  181.         var code = text.charCodeAt(pos);

  182.         // trivia: whitespace

  183.         if (isWhiteSpace(code)) {

  184.             do {

  185.                 pos++;

  186.                 value += String.fromCharCode(code);

  187.                 code = text.charCodeAt(pos);

  188.             } while (isWhiteSpace(code));

  189.             return token = 15 /* Trivia */;

  190.         }

  191.         // trivia: newlines

  192.         if (isLineBreak(code)) {

  193.             pos++;

  194.             value += String.fromCharCode(code);

  195.             if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {

  196.                 pos++;

  197.                 value += '\n';

  198.             }

  199.             return token = 14 /* LineBreakTrivia */;

  200.         }

  201.         switch (code) {

  202.             // tokens: []{}:,

  203.             case 123 /* openBrace */:

  204.                 pos++;

  205.                 return token = 1 /* OpenBraceToken */;

  206.             case 125 /* closeBrace */:

  207.                 pos++;

  208.                 return token = 2 /* CloseBraceToken */;

  209.             case 91 /* openBracket */:

  210.                 pos++;

  211.                 return token = 3 /* OpenBracketToken */;

  212.             case 93 /* closeBracket */:

  213.                 pos++;

  214.                 return token = 4 /* CloseBracketToken */;

  215.             case 58 /* colon */:

  216.                 pos++;

  217.                 return token = 6 /* ColonToken */;

  218.             case 44 /* comma */:

  219.                 pos++;

  220.                 return token = 5 /* CommaToken */;

  221.             // strings

  222.             case 34 /* doubleQuote */:

  223.                 pos++;

  224.                 value = scanString();

  225.                 return token = 10 /* StringLiteral */;

  226.             // comments

  227.             case 47 /* slash */:

  228.                 var start = pos - 1;

  229.                 // Single-line comment

  230.                 if (text.charCodeAt(pos + 1) === 47 /* slash */) {

  231.                     pos += 2;

  232.                     while (pos < len) {

  233.                         if (isLineBreak(text.charCodeAt(pos))) {

  234.                             break;

  235.                         }

  236.                         pos++;

  237.                     }

  238.                     value = text.substring(start, pos);

  239.                     return token = 12 /* LineCommentTrivia */;

  240.                 }

  241.                 // Multi-line comment

  242.                 if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {

  243.                     pos += 2;

  244.                     var commentClosed = false;

  245.                     while (pos < len) {

  246.                         var ch = text.charCodeAt(pos);

  247.                         if (ch === 42 /* asterisk */ && (pos + 1 < len) && text.charCodeAt(pos + 1) === 47 /* slash */) {

  248.                             pos += 2;

  249.                             commentClosed = true;

  250.                             break;

  251.                         }

  252.                         pos++;

  253.                     }

  254.                     if (!commentClosed) {

  255.                         pos++;

  256.                         scanError = 1 /* UnexpectedEndOfComment */;

  257.                     }

  258.                     value = text.substring(start, pos);

  259.                     return token = 13 /* BlockCommentTrivia */;

  260.                 }

  261.                 // just a single slash

  262.                 value += String.fromCharCode(code);

  263.                 pos++;

  264.                 return token = 16 /* Unknown */;

  265.             // numbers

  266.             case 45 /* minus */:

  267.                 value += String.fromCharCode(code);

  268.                 pos++;

  269.                 if (pos === len || !isDigit(text.charCodeAt(pos))) {

  270.                     return token = 16 /* Unknown */;

  271.                 }

  272.             // found a minus, followed by a number so

  273.             // we fall through to proceed with scanning

  274.             // numbers

  275.             case 48 /* _0 */:

  276.             case 49 /* _1 */:

  277.             case 50 /* _2 */:

  278.             case 51 /* _3 */:

  279.             case 52 /* _4 */:

  280.             case 53 /* _5 */:

  281.             case 54 /* _6 */:

  282.             case 55 /* _7 */:

  283.             case 56 /* _8 */:

  284.             case 57 /* _9 */:

  285.                 value += scanNumber();

  286.                 return token = 11 /* NumericLiteral */;

  287.             // literals and unknown symbols

  288.             default:

  289.                 // is a literal? Read the full word.

  290.                 while (pos < len && isUnknownContentCharacter(code)) {

  291.                     pos++;

  292.                     code = text.charCodeAt(pos);

  293.                 }

  294.                 if (tokenOffset !== pos) {

  295.                     value = text.substring(tokenOffset, pos);

  296.                     // keywords: true, false, null

  297.                     switch (value) {

  298.                         case 'true': return token = 8 /* TrueKeyword */;

  299.                         case 'false': return token = 9 /* FalseKeyword */;

  300.                         case 'null': return token = 7 /* NullKeyword */;

  301.                     }

  302.                     return token = 16 /* Unknown */;

  303.                 }

  304.                 // some

  305.                 value += String.fromCharCode(code);

  306.                 pos++;

  307.                 return token = 16 /* Unknown */;

  308.         }

  309.     }

  310.     function isUnknownContentCharacter(code) {

  311.         if (isWhiteSpace(code) || isLineBreak(code)) {

  312.             return false;

  313.         }

  314.         switch (code) {

  315.             case 125 /* closeBrace */:

  316.             case 93 /* closeBracket */:

  317.             case 123 /* openBrace */:

  318.             case 91 /* openBracket */:

  319.             case 34 /* doubleQuote */:

  320.             case 58 /* colon */:

  321.             case 44 /* comma */:

  322.                 return false;

  323.         }

  324.         return true;

  325.     }

  326.     function scanNextNonTrivia() {

  327.         var result;

  328.         do {

  329.             result = scanNext();

  330.         } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);

  331.         return result;

  332.     }

  333.     return {

  334.         setPosition: setPosition,

  335.         getPosition: function () { return pos; },

  336.         scan: ignoreTrivia ? scanNextNonTrivia : scanNext,

  337.         getToken: function () { return token; },

  338.         getTokenValue: function () { return value; },

  339.         getTokenOffset: function () { return tokenOffset; },

  340.         getTokenLength: function () { return pos - tokenOffset; },

  341.         getTokenError: function () { return scanError; }

  342.     };

  343. }

  344. function isWhiteSpace(ch) {

  345.     return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||

  346.         ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||

  347.         ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;

  348. }

  349. function isLineBreak(ch) {

  350.     return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;

  351. }

  352. function isDigit(ch) {

  353.     return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;

  354. }

  355. //# sourceMappingURL=scanner.js.map

  356. 

  357. /***/ }),

  358. 

  359. /***/ 3579:

  360. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  361. 

  362. "use strict";

  363. /* harmony export (immutable) */ __webpack_exports__["a"] = format;

  364. /* harmony export (immutable) */ __webpack_exports__["b"] = isEOL;

  365. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__scanner_js__ = __webpack_require__(3235);

  366. /*---------------------------------------------------------------------------------------------

  367.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  368.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  369.  *--------------------------------------------------------------------------------------------*/

  370. 

  371. 

  372. function format(documentText, range, options) {

  373.     var initialIndentLevel;

  374.     var formatText;

  375.     var formatTextStart;

  376.     var rangeStart;

  377.     var rangeEnd;

  378.     if (range) {

  379.         rangeStart = range.offset;

  380.         rangeEnd = rangeStart + range.length;

  381.         formatTextStart = rangeStart;

  382.         while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {

  383.             formatTextStart--;

  384.         }

  385.         var endOffset = rangeEnd;

  386.         while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {

  387.             endOffset++;

  388.         }

  389.         formatText = documentText.substring(formatTextStart, endOffset);

  390.         initialIndentLevel = computeIndentLevel(formatText, 0, options);

  391.     }

  392.     else {

  393.         formatText = documentText;

  394.         initialIndentLevel = 0;

  395.         formatTextStart = 0;

  396.         rangeStart = 0;

  397.         rangeEnd = documentText.length;

  398.     }

  399.     var eol = getEOL(options, documentText);

  400.     var lineBreak = false;

  401.     var indentLevel = 0;

  402.     var indentValue;

  403.     if (options.insertSpaces) {

  404.         indentValue = repeat(' ', options.tabSize || 4);

  405.     }

  406.     else {

  407.         indentValue = '\t';

  408.     }

  409.     var scanner = Object(__WEBPACK_IMPORTED_MODULE_0__scanner_js__["a" /* createScanner */])(formatText, false);

  410.     var hasError = false;

  411.     function newLineAndIndent() {

  412.         return eol + repeat(indentValue, initialIndentLevel + indentLevel);

  413.     }

  414.     function scanNext() {

  415.         var token = scanner.scan();

  416.         lineBreak = false;

  417.         while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {

  418.             lineBreak = lineBreak || (token === 14 /* LineBreakTrivia */);

  419.             token = scanner.scan();

  420.         }

  421.         hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;

  422.         return token;

  423.     }

  424.     var editOperations = [];

  425.     function addEdit(text, startOffset, endOffset) {

  426.         if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {

  427.             editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });

  428.         }

  429.     }

  430.     var firstToken = scanNext();

  431.     if (firstToken !== 17 /* EOF */) {

  432.         var firstTokenStart = scanner.getTokenOffset() + formatTextStart;

  433.         var initialIndent = repeat(indentValue, initialIndentLevel);

  434.         addEdit(initialIndent, formatTextStart, firstTokenStart);

  435.     }

  436.     while (firstToken !== 17 /* EOF */) {

  437.         var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;

  438.         var secondToken = scanNext();

  439.         var replaceContent = '';

  440.         while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {

  441.             // comments on the same line: keep them on the same line, but ignore them otherwise

  442.             var commentTokenStart = scanner.getTokenOffset() + formatTextStart;

  443.             addEdit(' ', firstTokenEnd, commentTokenStart);

  444.             firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;

  445.             replaceContent = secondToken === 12 /* LineCommentTrivia */ ? newLineAndIndent() : '';

  446.             secondToken = scanNext();

  447.         }

  448.         if (secondToken === 2 /* CloseBraceToken */) {

  449.             if (firstToken !== 1 /* OpenBraceToken */) {

  450.                 indentLevel--;

  451.                 replaceContent = newLineAndIndent();

  452.             }

  453.         }

  454.         else if (secondToken === 4 /* CloseBracketToken */) {

  455.             if (firstToken !== 3 /* OpenBracketToken */) {

  456.                 indentLevel--;

  457.                 replaceContent = newLineAndIndent();

  458.             }

  459.         }

  460.         else {

  461.             switch (firstToken) {

  462.                 case 3 /* OpenBracketToken */:

  463.                 case 1 /* OpenBraceToken */:

  464.                     indentLevel++;

  465.                     replaceContent = newLineAndIndent();

  466.                     break;

  467.                 case 5 /* CommaToken */:

  468.                 case 12 /* LineCommentTrivia */:

  469.                     replaceContent = newLineAndIndent();

  470.                     break;

  471.                 case 13 /* BlockCommentTrivia */:

  472.                     if (lineBreak) {

  473.                         replaceContent = newLineAndIndent();

  474.                     }

  475.                     else {

  476.                         // symbol following comment on the same line: keep on same line, separate with ' '

  477.                         replaceContent = ' ';

  478.                     }

  479.                     break;

  480.                 case 6 /* ColonToken */:

  481.                     replaceContent = ' ';

  482.                     break;

  483.                 case 10 /* StringLiteral */:

  484.                     if (secondToken === 6 /* ColonToken */) {

  485.                         replaceContent = '';

  486.                         break;

  487.                     }

  488.                 // fall through

  489.                 case 7 /* NullKeyword */:

  490.                 case 8 /* TrueKeyword */:

  491.                 case 9 /* FalseKeyword */:

  492.                 case 11 /* NumericLiteral */:

  493.                 case 2 /* CloseBraceToken */:

  494.                 case 4 /* CloseBracketToken */:

  495.                     if (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */) {

  496.                         replaceContent = ' ';

  497.                     }

  498.                     else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {

  499.                         hasError = true;

  500.                     }

  501.                     break;

  502.                 case 16 /* Unknown */:

  503.                     hasError = true;

  504.                     break;

  505.             }

  506.             if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {

  507.                 replaceContent = newLineAndIndent();

  508.             }

  509.         }

  510.         var secondTokenStart = scanner.getTokenOffset() + formatTextStart;

  511.         addEdit(replaceContent, firstTokenEnd, secondTokenStart);

  512.         firstToken = secondToken;

  513.     }

  514.     return editOperations;

  515. }

  516. function repeat(s, count) {

  517.     var result = '';

  518.     for (var i = 0; i < count; i++) {

  519.         result += s;

  520.     }

  521.     return result;

  522. }

  523. function computeIndentLevel(content, offset, options) {

  524.     var i = 0;

  525.     var nChars = 0;

  526.     var tabSize = options.tabSize || 4;

  527.     while (i < content.length) {

  528.         var ch = content.charAt(i);

  529.         if (ch === ' ') {

  530.             nChars++;

  531.         }

  532.         else if (ch === '\t') {

  533.             nChars += tabSize;

  534.         }

  535.         else {

  536.             break;

  537.         }

  538.         i++;

  539.     }

  540.     return Math.floor(nChars / tabSize);

  541. }

  542. function getEOL(options, text) {

  543.     for (var i = 0; i < text.length; i++) {

  544.         var ch = text.charAt(i);

  545.         if (ch === '\r') {

  546.             if (i + 1 < text.length && text.charAt(i + 1) === '\n') {

  547.                 return '\r\n';

  548.             }

  549.             return '\r';

  550.         }

  551.         else if (ch === '\n') {

  552.             return '\n';

  553.         }

  554.     }

  555.     return (options && options.eol) || '\n';

  556. }

  557. function isEOL(text, offset) {

  558.     return '\r\n'.indexOf(text.charAt(offset)) !== -1;

  559. }

  560. //# sourceMappingURL=format.js.map

  561. 

  562. /***/ }),

  563. 

  564. /***/ 3580:

  565. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  566. 

  567. "use strict";

  568. /* harmony export (immutable) */ __webpack_exports__["b"] = getLocation;

  569. /* harmony export (immutable) */ __webpack_exports__["d"] = parse;

  570. /* harmony export (immutable) */ __webpack_exports__["e"] = parseTree;

  571. /* harmony export (immutable) */ __webpack_exports__["a"] = findNodeAtLocation;

  572. /* harmony export (immutable) */ __webpack_exports__["c"] = getNodeValue;

  573. /* harmony export (immutable) */ __webpack_exports__["g"] = visit;

  574. /* harmony export (immutable) */ __webpack_exports__["f"] = stripComments;

  575. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__scanner_js__ = __webpack_require__(3235);

  576. /*---------------------------------------------------------------------------------------------

  577.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  578.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  579.  *--------------------------------------------------------------------------------------------*/

  580. 

  581. 

  582. /**

  583.  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.

  584.  */

  585. function getLocation(text, position) {

  586.     var segments = []; // strings or numbers

  587.     var earlyReturnException = new Object();

  588.     var previousNode = void 0;

  589.     var previousNodeInst = {

  590.         value: {},

  591.         offset: 0,

  592.         length: 0,

  593.         type: 'object'

  594.     };

  595.     var isAtPropertyKey = false;

  596.     function setPreviousNode(value, offset, length, type) {

  597.         previousNodeInst.value = value;

  598.         previousNodeInst.offset = offset;

  599.         previousNodeInst.length = length;

  600.         previousNodeInst.type = type;

  601.         previousNodeInst.columnOffset = void 0;

  602.         previousNode = previousNodeInst;

  603.     }

  604.     try {

  605.         visit(text, {

  606.             onObjectBegin: function (offset, length) {

  607.                 if (position <= offset) {

  608.                     throw earlyReturnException;

  609.                 }

  610.                 previousNode = void 0;

  611.                 isAtPropertyKey = position > offset;

  612.                 segments.push(''); // push a placeholder (will be replaced)

  613.             },

  614.             onObjectProperty: function (name, offset, length) {

  615.                 if (position < offset) {

  616.                     throw earlyReturnException;

  617.                 }

  618.                 setPreviousNode(name, offset, length, 'property');

  619.                 segments[segments.length - 1] = name;

  620.                 if (position <= offset + length) {

  621.                     throw earlyReturnException;

  622.                 }

  623.             },

  624.             onObjectEnd: function (offset, length) {

  625.                 if (position <= offset) {

  626.                     throw earlyReturnException;

  627.                 }

  628.                 previousNode = void 0;

  629.                 segments.pop();

  630.             },

  631.             onArrayBegin: function (offset, length) {

  632.                 if (position <= offset) {

  633.                     throw earlyReturnException;

  634.                 }

  635.                 previousNode = void 0;

  636.                 segments.push(0);

  637.             },

  638.             onArrayEnd: function (offset, length) {

  639.                 if (position <= offset) {

  640.                     throw earlyReturnException;

  641.                 }

  642.                 previousNode = void 0;

  643.                 segments.pop();

  644.             },

  645.             onLiteralValue: function (value, offset, length) {

  646.                 if (position < offset) {

  647.                     throw earlyReturnException;

  648.                 }

  649.                 setPreviousNode(value, offset, length, getLiteralNodeType(value));

  650.                 if (position <= offset + length) {

  651.                     throw earlyReturnException;

  652.                 }

  653.             },

  654.             onSeparator: function (sep, offset, length) {

  655.                 if (position <= offset) {

  656.                     throw earlyReturnException;

  657.                 }

  658.                 if (sep === ':' && previousNode && previousNode.type === 'property') {

  659.                     previousNode.columnOffset = offset;

  660.                     isAtPropertyKey = false;

  661.                     previousNode = void 0;

  662.                 }

  663.                 else if (sep === ',') {

  664.                     var last = segments[segments.length - 1];

  665.                     if (typeof last === 'number') {

  666.                         segments[segments.length - 1] = last + 1;

  667.                     }

  668.                     else {

  669.                         isAtPropertyKey = true;

  670.                         segments[segments.length - 1] = '';

  671.                     }

  672.                     previousNode = void 0;

  673.                 }

  674.             }

  675.         });

  676.     }

  677.     catch (e) {

  678.         if (e !== earlyReturnException) {

  679.             throw e;

  680.         }

  681.     }

  682.     return {

  683.         path: segments,

  684.         previousNode: previousNode,

  685.         isAtPropertyKey: isAtPropertyKey,

  686.         matches: function (pattern) {

  687.             var k = 0;

  688.             for (var i = 0; k < pattern.length && i < segments.length; i++) {

  689.                 if (pattern[k] === segments[i] || pattern[k] === '*') {

  690.                     k++;

  691.                 }

  692.                 else if (pattern[k] !== '**') {

  693.                     return false;

  694.                 }

  695.             }

  696.             return k === pattern.length;

  697.         }

  698.     };

  699. }

  700. /**

  701.  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.

  702.  * Therefore always check the errors list to find out if the input was valid.

  703.  */

  704. function parse(text, errors, options) {

  705.     if (errors === void 0) { errors = []; }

  706.     var currentProperty = null;

  707.     var currentParent = [];

  708.     var previousParents = [];

  709.     function onValue(value) {

  710.         if (Array.isArray(currentParent)) {

  711.             currentParent.push(value);

  712.         }

  713.         else if (currentProperty) {

  714.             currentParent[currentProperty] = value;

  715.         }

  716.     }

  717.     var visitor = {

  718.         onObjectBegin: function () {

  719.             var object = {};

  720.             onValue(object);

  721.             previousParents.push(currentParent);

  722.             currentParent = object;

  723.             currentProperty = null;

  724.         },

  725.         onObjectProperty: function (name) {

  726.             currentProperty = name;

  727.         },

  728.         onObjectEnd: function () {

  729.             currentParent = previousParents.pop();

  730.         },

  731.         onArrayBegin: function () {

  732.             var array = [];

  733.             onValue(array);

  734.             previousParents.push(currentParent);

  735.             currentParent = array;

  736.             currentProperty = null;

  737.         },

  738.         onArrayEnd: function () {

  739.             currentParent = previousParents.pop();

  740.         },

  741.         onLiteralValue: onValue,

  742.         onError: function (error, offset, length) {

  743.             errors.push({ error: error, offset: offset, length: length });

  744.         }

  745.     };

  746.     visit(text, visitor, options);

  747.     return currentParent[0];

  748. }

  749. /**

  750.  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.

  751.  */

  752. function parseTree(text, errors, options) {

  753.     if (errors === void 0) { errors = []; }

  754.     var currentParent = { type: 'array', offset: -1, length: -1, children: [] }; // artificial root

  755.     function ensurePropertyComplete(endOffset) {

  756.         if (currentParent.type === 'property') {

  757.             currentParent.length = endOffset - currentParent.offset;

  758.             currentParent = currentParent.parent;

  759.         }

  760.     }

  761.     function onValue(valueNode) {

  762.         currentParent.children.push(valueNode);

  763.         return valueNode;

  764.     }

  765.     var visitor = {

  766.         onObjectBegin: function (offset) {

  767.             currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });

  768.         },

  769.         onObjectProperty: function (name, offset, length) {

  770.             currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });

  771.             currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });

  772.         },

  773.         onObjectEnd: function (offset, length) {

  774.             currentParent.length = offset + length - currentParent.offset;

  775.             currentParent = currentParent.parent;

  776.             ensurePropertyComplete(offset + length);

  777.         },

  778.         onArrayBegin: function (offset, length) {

  779.             currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });

  780.         },

  781.         onArrayEnd: function (offset, length) {

  782.             currentParent.length = offset + length - currentParent.offset;

  783.             currentParent = currentParent.parent;

  784.             ensurePropertyComplete(offset + length);

  785.         },

  786.         onLiteralValue: function (value, offset, length) {

  787.             onValue({ type: getLiteralNodeType(value), offset: offset, length: length, parent: currentParent, value: value });

  788.             ensurePropertyComplete(offset + length);

  789.         },

  790.         onSeparator: function (sep, offset, length) {

  791.             if (currentParent.type === 'property') {

  792.                 if (sep === ':') {

  793.                     currentParent.columnOffset = offset;

  794.                 }

  795.                 else if (sep === ',') {

  796.                     ensurePropertyComplete(offset);

  797.                 }

  798.             }

  799.         },

  800.         onError: function (error, offset, length) {

  801.             errors.push({ error: error, offset: offset, length: length });

  802.         }

  803.     };

  804.     visit(text, visitor, options);

  805.     var result = currentParent.children[0];

  806.     if (result) {

  807.         delete result.parent;

  808.     }

  809.     return result;

  810. }

  811. /**

  812.  * Finds the node at the given path in a JSON DOM.

  813.  */

  814. function findNodeAtLocation(root, path) {

  815.     if (!root) {

  816.         return void 0;

  817.     }

  818.     var node = root;

  819.     for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {

  820.         var segment = path_1[_i];

  821.         if (typeof segment === 'string') {

  822.             if (node.type !== 'object' || !Array.isArray(node.children)) {

  823.                 return void 0;

  824.             }

  825.             var found = false;

  826.             for (var _a = 0, _b = node.children; _a < _b.length; _a++) {

  827.                 var propertyNode = _b[_a];

  828.                 if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {

  829.                     node = propertyNode.children[1];

  830.                     found = true;

  831.                     break;

  832.                 }

  833.             }

  834.             if (!found) {

  835.                 return void 0;

  836.             }

  837.         }

  838.         else {

  839.             var index = segment;

  840.             if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {

  841.                 return void 0;

  842.             }

  843.             node = node.children[index];

  844.         }

  845.     }

  846.     return node;

  847. }

  848. /**

  849.  * Evaluates the JavaScript object of the given JSON DOM node

  850.  */

  851. function getNodeValue(node) {

  852.     if (node.type === 'array') {

  853.         return node.children.map(getNodeValue);

  854.     }

  855.     else if (node.type === 'object') {

  856.         var obj = Object.create(null);

  857.         for (var _i = 0, _a = node.children; _i < _a.length; _i++) {

  858.             var prop = _a[_i];

  859.             obj[prop.children[0].value] = getNodeValue(prop.children[1]);

  860.         }

  861.         return obj;

  862.     }

  863.     return node.value;

  864. }

  865. /**

  866.  * Parses the given text and invokes the visitor functions for each object, array and literal reached.

  867.  */

  868. function visit(text, visitor, options) {

  869.     var _scanner = Object(__WEBPACK_IMPORTED_MODULE_0__scanner_js__["a" /* createScanner */])(text, false);

  870.     function toNoArgVisit(visitFunction) {

  871.         return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };

  872.     }

  873.     function toOneArgVisit(visitFunction) {

  874.         return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };

  875.     }

  876.     var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);

  877.     var disallowComments = options && options.disallowComments;

  878.     var allowTrailingComma = options && options.allowTrailingComma;

  879.     function scanNext() {

  880.         while (true) {

  881.             var token = _scanner.scan();

  882.             switch (_scanner.getTokenError()) {

  883.                 case 4 /* InvalidUnicode */:

  884.                     handleError(14 /* InvalidUnicode */);

  885.                     break;

  886.                 case 5 /* InvalidEscapeCharacter */:

  887.                     handleError(15 /* InvalidEscapeCharacter */);

  888.                     break;

  889.                 case 3 /* UnexpectedEndOfNumber */:

  890.                     handleError(13 /* UnexpectedEndOfNumber */);

  891.                     break;

  892.                 case 1 /* UnexpectedEndOfComment */:

  893.                     if (!disallowComments) {

  894.                         handleError(11 /* UnexpectedEndOfComment */);

  895.                     }

  896.                     break;

  897.                 case 2 /* UnexpectedEndOfString */:

  898.                     handleError(12 /* UnexpectedEndOfString */);

  899.                     break;

  900.                 case 6 /* InvalidCharacter */:

  901.                     handleError(16 /* InvalidCharacter */);

  902.                     break;

  903.             }

  904.             switch (token) {

  905.                 case 12 /* LineCommentTrivia */:

  906.                 case 13 /* BlockCommentTrivia */:

  907.                     if (disallowComments) {

  908.                         handleError(10 /* InvalidCommentToken */);

  909.                     }

  910.                     else {

  911.                         onComment();

  912.                     }

  913.                     break;

  914.                 case 16 /* Unknown */:

  915.                     handleError(1 /* InvalidSymbol */);

  916.                     break;

  917.                 case 15 /* Trivia */:

  918.                 case 14 /* LineBreakTrivia */:

  919.                     break;

  920.                 default:

  921.                     return token;

  922.             }

  923.         }

  924.     }

  925.     function handleError(error, skipUntilAfter, skipUntil) {

  926.         if (skipUntilAfter === void 0) { skipUntilAfter = []; }

  927.         if (skipUntil === void 0) { skipUntil = []; }

  928.         onError(error);

  929.         if (skipUntilAfter.length + skipUntil.length > 0) {

  930.             var token = _scanner.getToken();

  931.             while (token !== 17 /* EOF */) {

  932.                 if (skipUntilAfter.indexOf(token) !== -1) {

  933.                     scanNext();

  934.                     break;

  935.                 }

  936.                 else if (skipUntil.indexOf(token) !== -1) {

  937.                     break;

  938.                 }

  939.                 token = scanNext();

  940.             }

  941.         }

  942.     }

  943.     function parseString(isValue) {

  944.         var value = _scanner.getTokenValue();

  945.         if (isValue) {

  946.             onLiteralValue(value);

  947.         }

  948.         else {

  949.             onObjectProperty(value);

  950.         }

  951.         scanNext();

  952.         return true;

  953.     }

  954.     function parseLiteral() {

  955.         switch (_scanner.getToken()) {

  956.             case 11 /* NumericLiteral */:

  957.                 var value = 0;

  958.                 try {

  959.                     value = JSON.parse(_scanner.getTokenValue());

  960.                     if (typeof value !== 'number') {

  961.                         handleError(2 /* InvalidNumberFormat */);

  962.                         value = 0;

  963.                     }

  964.                 }

  965.                 catch (e) {

  966.                     handleError(2 /* InvalidNumberFormat */);

  967.                 }

  968.                 onLiteralValue(value);

  969.                 break;

  970.             case 7 /* NullKeyword */:

  971.                 onLiteralValue(null);

  972.                 break;

  973.             case 8 /* TrueKeyword */:

  974.                 onLiteralValue(true);

  975.                 break;

  976.             case 9 /* FalseKeyword */:

  977.                 onLiteralValue(false);

  978.                 break;

  979.             default:

  980.                 return false;

  981.         }

  982.         scanNext();

  983.         return true;

  984.     }

  985.     function parseProperty() {

  986.         if (_scanner.getToken() !== 10 /* StringLiteral */) {

  987.             handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);

  988.             return false;

  989.         }

  990.         parseString(false);

  991.         if (_scanner.getToken() === 6 /* ColonToken */) {

  992.             onSeparator(':');

  993.             scanNext(); // consume colon

  994.             if (!parseValue()) {

  995.                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);

  996.             }

  997.         }

  998.         else {

  999.             handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);

  1000.         }

  1001.         return true;

  1002.     }

  1003.     function parseObject() {

  1004.         onObjectBegin();

  1005.         scanNext(); // consume open brace

  1006.         var needsComma = false;

  1007.         while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {

  1008.             if (_scanner.getToken() === 5 /* CommaToken */) {

  1009.                 if (!needsComma) {

  1010.                     handleError(4 /* ValueExpected */, [], []);

  1011.                 }

  1012.                 onSeparator(',');

  1013.                 scanNext(); // consume comma

  1014.                 if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {

  1015.                     break;

  1016.                 }

  1017.             }

  1018.             else if (needsComma) {

  1019.                 handleError(6 /* CommaExpected */, [], []);

  1020.             }

  1021.             if (!parseProperty()) {

  1022.                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);

  1023.             }

  1024.             needsComma = true;

  1025.         }

  1026.         onObjectEnd();

  1027.         if (_scanner.getToken() !== 2 /* CloseBraceToken */) {

  1028.             handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);

  1029.         }

  1030.         else {

  1031.             scanNext(); // consume close brace

  1032.         }

  1033.         return true;

  1034.     }

  1035.     function parseArray() {

  1036.         onArrayBegin();

  1037.         scanNext(); // consume open bracket

  1038.         var needsComma = false;

  1039.         while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {

  1040.             if (_scanner.getToken() === 5 /* CommaToken */) {

  1041.                 if (!needsComma) {

  1042.                     handleError(4 /* ValueExpected */, [], []);

  1043.                 }

  1044.                 onSeparator(',');

  1045.                 scanNext(); // consume comma

  1046.                 if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {

  1047.                     break;

  1048.                 }

  1049.             }

  1050.             else if (needsComma) {

  1051.                 handleError(6 /* CommaExpected */, [], []);

  1052.             }

  1053.             if (!parseValue()) {

  1054.                 handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);

  1055.             }

  1056.             needsComma = true;

  1057.         }

  1058.         onArrayEnd();

  1059.         if (_scanner.getToken() !== 4 /* CloseBracketToken */) {

  1060.             handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);

  1061.         }

  1062.         else {

  1063.             scanNext(); // consume close bracket

  1064.         }

  1065.         return true;

  1066.     }

  1067.     function parseValue() {

  1068.         switch (_scanner.getToken()) {

  1069.             case 3 /* OpenBracketToken */:

  1070.                 return parseArray();

  1071.             case 1 /* OpenBraceToken */:

  1072.                 return parseObject();

  1073.             case 10 /* StringLiteral */:

  1074.                 return parseString(true);

  1075.             default:

  1076.                 return parseLiteral();

  1077.         }

  1078.     }

  1079.     scanNext();

  1080.     if (_scanner.getToken() === 17 /* EOF */) {

  1081.         return true;

  1082.     }

  1083.     if (!parseValue()) {

  1084.         handleError(4 /* ValueExpected */, [], []);

  1085.         return false;

  1086.     }

  1087.     if (_scanner.getToken() !== 17 /* EOF */) {

  1088.         handleError(9 /* EndOfFileExpected */, [], []);

  1089.     }

  1090.     return true;

  1091. }

  1092. /**

  1093.  * Takes JSON with JavaScript-style comments and remove

  1094.  * them. Optionally replaces every none-newline character

  1095.  * of comments with a replaceCharacter

  1096.  */

  1097. function stripComments(text, replaceCh) {

  1098.     var _scanner = Object(__WEBPACK_IMPORTED_MODULE_0__scanner_js__["a" /* createScanner */])(text), parts = [], kind, offset = 0, pos;

  1099.     do {

  1100.         pos = _scanner.getPosition();

  1101.         kind = _scanner.scan();

  1102.         switch (kind) {

  1103.             case 12 /* LineCommentTrivia */:

  1104.             case 13 /* BlockCommentTrivia */:

  1105.             case 17 /* EOF */:

  1106.                 if (offset !== pos) {

  1107.                     parts.push(text.substring(offset, pos));

  1108.                 }

  1109.                 if (replaceCh !== void 0) {

  1110.                     parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));

  1111.                 }

  1112.                 offset = _scanner.getPosition();

  1113.                 break;

  1114.         }

  1115.     } while (kind !== 17 /* EOF */);

  1116.     return parts.join('');

  1117. }

  1118. function getLiteralNodeType(value) {

  1119.     switch (typeof value) {

  1120.         case 'boolean': return 'boolean';

  1121.         case 'number': return 'number';

  1122.         case 'string': return 'string';

  1123.         default: return 'null';

  1124.     }

  1125. }

  1126. //# sourceMappingURL=parser.js.map

  1127. 

  1128. /***/ }),

  1129. 

  1130. /***/ 4068:

  1131. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  1132. 

  1133. "use strict";

  1134. Object.defineProperty(__webpack_exports__, "__esModule", { value: true });

  1135. /* harmony export (immutable) */ __webpack_exports__["setupMode"] = setupMode;

  1136. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__workerManager_js__ = __webpack_require__(4069);

  1137. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__ = __webpack_require__(4070);

  1138. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__tokenization_js__ = __webpack_require__(4072);

  1139. /*---------------------------------------------------------------------------------------------

  1140.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  1141.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  1142.  *--------------------------------------------------------------------------------------------*/

  1143. 

  1144. 

  1145. 

  1146. 

  1147. function setupMode(defaults) {

  1148.     var disposables = [];

  1149.     var client = new __WEBPACK_IMPORTED_MODULE_0__workerManager_js__["a" /* WorkerManager */](defaults);

  1150.     disposables.push(client);

  1151.     var worker = function () {

  1152.         var uris = [];

  1153.         for (var _i = 0; _i < arguments.length; _i++) {

  1154.             uris[_i] = arguments[_i];

  1155.         }

  1156.         return client.getLanguageServiceWorker.apply(client, uris);

  1157.     };

  1158.     var languageId = defaults.languageId;

  1159.     disposables.push(monaco.languages.registerCompletionItemProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["a" /* CompletionAdapter */](worker)));

  1160.     disposables.push(monaco.languages.registerHoverProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["g" /* HoverAdapter */](worker)));

  1161.     disposables.push(monaco.languages.registerDocumentSymbolProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["f" /* DocumentSymbolAdapter */](worker)));

  1162.     disposables.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["d" /* DocumentFormattingEditProvider */](worker)));

  1163.     disposables.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["e" /* DocumentRangeFormattingEditProvider */](worker)));

  1164.     disposables.push(new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["b" /* DiagnosticsAdapter */](languageId, worker, defaults));

  1165.     disposables.push(monaco.languages.setTokensProvider(languageId, Object(__WEBPACK_IMPORTED_MODULE_2__tokenization_js__["a" /* createTokenizationSupport */])(true)));

  1166.     disposables.push(monaco.languages.setLanguageConfiguration(languageId, richEditConfiguration));

  1167.     disposables.push(monaco.languages.registerColorProvider(languageId, new __WEBPACK_IMPORTED_MODULE_1__languageFeatures_js__["c" /* DocumentColorAdapter */](worker)));

  1168. }

  1169. var richEditConfiguration = {

  1170.     wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g,

  1171.     comments: {

  1172.         lineComment: '//',

  1173.         blockComment: ['/*', '*/']

  1174.     },

  1175.     brackets: [

  1176.         ['{', '}'],

  1177.         ['[', ']']

  1178.     ],

  1179.     autoClosingPairs: [

  1180.         { open: '{', close: '}', notIn: ['string'] },

  1181.         { open: '[', close: ']', notIn: ['string'] },

  1182.         { open: '"', close: '"', notIn: ['string'] }

  1183.     ]

  1184. };

  1185. 

  1186. 

  1187. /***/ }),

  1188. 

  1189. /***/ 4069:

  1190. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  1191. 

  1192. "use strict";

  1193. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return WorkerManager; });

  1194. /*---------------------------------------------------------------------------------------------

  1195.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  1196.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  1197.  *--------------------------------------------------------------------------------------------*/

  1198. 

  1199. var Promise = monaco.Promise;

  1200. var STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min

  1201. var WorkerManager = /** @class */ (function () {

  1202.     function WorkerManager(defaults) {

  1203.         var _this = this;

  1204.         this._defaults = defaults;

  1205.         this._worker = null;

  1206.         this._idleCheckInterval = setInterval(function () { return _this._checkIfIdle(); }, 30 * 1000);

  1207.         this._lastUsedTime = 0;

  1208.         this._configChangeListener = this._defaults.onDidChange(function () { return _this._stopWorker(); });

  1209.     }

  1210.     WorkerManager.prototype._stopWorker = function () {

  1211.         if (this._worker) {

  1212.             this._worker.dispose();

  1213.             this._worker = null;

  1214.         }

  1215.         this._client = null;

  1216.     };

  1217.     WorkerManager.prototype.dispose = function () {

  1218.         clearInterval(this._idleCheckInterval);

  1219.         this._configChangeListener.dispose();

  1220.         this._stopWorker();

  1221.     };

  1222.     WorkerManager.prototype._checkIfIdle = function () {

  1223.         if (!this._worker) {

  1224.             return;

  1225.         }

  1226.         var timePassedSinceLastUsed = Date.now() - this._lastUsedTime;

  1227.         if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {

  1228.             this._stopWorker();

  1229.         }

  1230.     };

  1231.     WorkerManager.prototype._getClient = function () {

  1232.         this._lastUsedTime = Date.now();

  1233.         if (!this._client) {

  1234.             this._worker = monaco.editor.createWebWorker({

  1235.                 // module that exports the create() method and returns a `JSONWorker` instance

  1236.                 moduleId: 'vs/language/json/jsonWorker',

  1237.                 label: this._defaults.languageId,

  1238.                 // passed in to the create() method

  1239.                 createData: {

  1240.                     languageSettings: this._defaults.diagnosticsOptions,

  1241.                     languageId: this._defaults.languageId

  1242.                 }

  1243.             });

  1244.             this._client = this._worker.getProxy();

  1245.         }

  1246.         return this._client;

  1247.     };

  1248.     WorkerManager.prototype.getLanguageServiceWorker = function () {

  1249.         var _this = this;

  1250.         var resources = [];

  1251.         for (var _i = 0; _i < arguments.length; _i++) {

  1252.             resources[_i] = arguments[_i];

  1253.         }

  1254.         var _client;

  1255.         return toShallowCancelPromise(this._getClient().then(function (client) {

  1256.             _client = client;

  1257.         }).then(function (_) {

  1258.             return _this._worker.withSyncedResources(resources);

  1259.         }).then(function (_) { return _client; }));

  1260.     };

  1261.     return WorkerManager;

  1262. }());

  1263. 

  1264. function toShallowCancelPromise(p) {

  1265.     var completeCallback;

  1266.     var errorCallback;

  1267.     var r = new Promise(function (c, e) {

  1268.         completeCallback = c;

  1269.         errorCallback = e;

  1270.     }, function () { });

  1271.     p.then(completeCallback, errorCallback);

  1272.     return r;

  1273. }

  1274. 

  1275. 

  1276. /***/ }),

  1277. 

  1278. /***/ 4070:

  1279. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  1280. 

  1281. "use strict";

  1282. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return DiagnosticsAdapter; });

  1283. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CompletionAdapter; });

  1284. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return HoverAdapter; });

  1285. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return DocumentSymbolAdapter; });

  1286. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return DocumentFormattingEditProvider; });

  1287. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return DocumentRangeFormattingEditProvider; });

  1288. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return DocumentColorAdapter; });

  1289. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__ = __webpack_require__(4071);

  1290. /*---------------------------------------------------------------------------------------------

  1291.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  1292.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  1293.  *--------------------------------------------------------------------------------------------*/

  1294. 

  1295. 

  1296. var Uri = monaco.Uri;

  1297. var Range = monaco.Range;

  1298. // --- diagnostics --- ---

  1299. var DiagnosticsAdapter = /** @class */ (function () {

  1300.     function DiagnosticsAdapter(_languageId, _worker, defaults) {

  1301.         var _this = this;

  1302.         this._languageId = _languageId;

  1303.         this._worker = _worker;

  1304.         this._disposables = [];

  1305.         this._listener = Object.create(null);

  1306.         var onModelAdd = function (model) {

  1307.             var modeId = model.getModeId();

  1308.             if (modeId !== _this._languageId) {

  1309.                 return;

  1310.             }

  1311.             var handle;

  1312.             _this._listener[model.uri.toString()] = model.onDidChangeContent(function () {

  1313.                 clearTimeout(handle);

  1314.                 handle = setTimeout(function () { return _this._doValidate(model.uri, modeId); }, 500);

  1315.             });

  1316.             _this._doValidate(model.uri, modeId);

  1317.         };

  1318.         var onModelRemoved = function (model) {

  1319.             monaco.editor.setModelMarkers(model, _this._languageId, []);

  1320.             var uriStr = model.uri.toString();

  1321.             var listener = _this._listener[uriStr];

  1322.             if (listener) {

  1323.                 listener.dispose();

  1324.                 delete _this._listener[uriStr];

  1325.             }

  1326.         };

  1327.         this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd));

  1328.         this._disposables.push(monaco.editor.onWillDisposeModel(function (model) {

  1329.             onModelRemoved(model);

  1330.             _this._resetSchema(model.uri);

  1331.         }));

  1332.         this._disposables.push(monaco.editor.onDidChangeModelLanguage(function (event) {

  1333.             onModelRemoved(event.model);

  1334.             onModelAdd(event.model);

  1335.             _this._resetSchema(event.model.uri);

  1336.         }));

  1337.         this._disposables.push(defaults.onDidChange(function (_) {

  1338.             monaco.editor.getModels().forEach(function (model) {

  1339.                 if (model.getModeId() === _this._languageId) {

  1340.                     onModelRemoved(model);

  1341.                     onModelAdd(model);

  1342.                 }

  1343.             });

  1344.         }));

  1345.         this._disposables.push({

  1346.             dispose: function () {

  1347.                 monaco.editor.getModels().forEach(onModelRemoved);

  1348.                 for (var key in _this._listener) {

  1349.                     _this._listener[key].dispose();

  1350.                 }

  1351.             }

  1352.         });

  1353.         monaco.editor.getModels().forEach(onModelAdd);

  1354.     }

  1355.     DiagnosticsAdapter.prototype.dispose = function () {

  1356.         this._disposables.forEach(function (d) { return d && d.dispose(); });

  1357.         this._disposables = [];

  1358.     };

  1359.     DiagnosticsAdapter.prototype._resetSchema = function (resource) {

  1360.         this._worker().then(function (worker) {

  1361.             worker.resetSchema(resource.toString());

  1362.         });

  1363.     };

  1364.     DiagnosticsAdapter.prototype._doValidate = function (resource, languageId) {

  1365.         this._worker(resource).then(function (worker) {

  1366.             return worker.doValidation(resource.toString()).then(function (diagnostics) {

  1367.                 var markers = diagnostics.map(function (d) { return toDiagnostics(resource, d); });

  1368.                 var model = monaco.editor.getModel(resource);

  1369.                 if (model.getModeId() === languageId) {

  1370.                     monaco.editor.setModelMarkers(model, languageId, markers);

  1371.                 }

  1372.             });

  1373.         }).then(undefined, function (err) {

  1374.             console.error(err);

  1375.         });

  1376.     };

  1377.     return DiagnosticsAdapter;

  1378. }());

  1379. 

  1380. function toSeverity(lsSeverity) {

  1381.     switch (lsSeverity) {

  1382.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["b" /* DiagnosticSeverity */].Error: return monaco.MarkerSeverity.Error;

  1383.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["b" /* DiagnosticSeverity */].Warning: return monaco.MarkerSeverity.Warning;

  1384.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["b" /* DiagnosticSeverity */].Information: return monaco.MarkerSeverity.Info;

  1385.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["b" /* DiagnosticSeverity */].Hint: return monaco.MarkerSeverity.Hint;

  1386.         default:

  1387.             return monaco.MarkerSeverity.Info;

  1388.     }

  1389. }

  1390. function toDiagnostics(resource, diag) {

  1391.     var code = typeof diag.code === 'number' ? String(diag.code) : diag.code;

  1392.     return {

  1393.         severity: toSeverity(diag.severity),

  1394.         startLineNumber: diag.range.start.line + 1,

  1395.         startColumn: diag.range.start.character + 1,

  1396.         endLineNumber: diag.range.end.line + 1,

  1397.         endColumn: diag.range.end.character + 1,

  1398.         message: diag.message,

  1399.         code: code,

  1400.         source: diag.source

  1401.     };

  1402. }

  1403. // --- completion ------

  1404. function fromPosition(position) {

  1405.     if (!position) {

  1406.         return void 0;

  1407.     }

  1408.     return { character: position.column - 1, line: position.lineNumber - 1 };

  1409. }

  1410. function fromRange(range) {

  1411.     if (!range) {

  1412.         return void 0;

  1413.     }

  1414.     return { start: { line: range.startLineNumber - 1, character: range.startColumn - 1 }, end: { line: range.endLineNumber - 1, character: range.endColumn - 1 } };

  1415. }

  1416. function toRange(range) {

  1417.     if (!range) {

  1418.         return void 0;

  1419.     }

  1420.     return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);

  1421. }

  1422. function toCompletionItemKind(kind) {

  1423.     var mItemKind = monaco.languages.CompletionItemKind;

  1424.     switch (kind) {

  1425.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Text: return mItemKind.Text;

  1426.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Method: return mItemKind.Method;

  1427.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Function: return mItemKind.Function;

  1428.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Constructor: return mItemKind.Constructor;

  1429.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Field: return mItemKind.Field;

  1430.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Variable: return mItemKind.Variable;

  1431.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Class: return mItemKind.Class;

  1432.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Interface: return mItemKind.Interface;

  1433.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Module: return mItemKind.Module;

  1434.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Property: return mItemKind.Property;

  1435.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Unit: return mItemKind.Unit;

  1436.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Value: return mItemKind.Value;

  1437.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Enum: return mItemKind.Enum;

  1438.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Keyword: return mItemKind.Keyword;

  1439.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Snippet: return mItemKind.Snippet;

  1440.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Color: return mItemKind.Color;

  1441.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].File: return mItemKind.File;

  1442.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Reference: return mItemKind.Reference;

  1443.     }

  1444.     return mItemKind.Property;

  1445. }

  1446. function fromCompletionItemKind(kind) {

  1447.     var mItemKind = monaco.languages.CompletionItemKind;

  1448.     switch (kind) {

  1449.         case mItemKind.Text: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Text;

  1450.         case mItemKind.Method: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Method;

  1451.         case mItemKind.Function: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Function;

  1452.         case mItemKind.Constructor: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Constructor;

  1453.         case mItemKind.Field: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Field;

  1454.         case mItemKind.Variable: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Variable;

  1455.         case mItemKind.Class: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Class;

  1456.         case mItemKind.Interface: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Interface;

  1457.         case mItemKind.Module: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Module;

  1458.         case mItemKind.Property: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Property;

  1459.         case mItemKind.Unit: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Unit;

  1460.         case mItemKind.Value: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Value;

  1461.         case mItemKind.Enum: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Enum;

  1462.         case mItemKind.Keyword: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Keyword;

  1463.         case mItemKind.Snippet: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Snippet;

  1464.         case mItemKind.Color: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Color;

  1465.         case mItemKind.File: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].File;

  1466.         case mItemKind.Reference: return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Reference;

  1467.     }

  1468.     return __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["a" /* CompletionItemKind */].Property;

  1469. }

  1470. function toTextEdit(textEdit) {

  1471.     if (!textEdit) {

  1472.         return void 0;

  1473.     }

  1474.     return {

  1475.         range: toRange(textEdit.range),

  1476.         text: textEdit.newText

  1477.     };

  1478. }

  1479. function toCompletionItem(entry) {

  1480.     return {

  1481.         label: entry.label,

  1482.         insertText: entry.insertText,

  1483.         sortText: entry.sortText,

  1484.         filterText: entry.filterText,

  1485.         documentation: entry.documentation,

  1486.         detail: entry.detail,

  1487.         kind: toCompletionItemKind(entry.kind),

  1488.         textEdit: toTextEdit(entry.textEdit),

  1489.         data: entry.data

  1490.     };

  1491. }

  1492. function fromMarkdownString(entry) {

  1493.     return {

  1494.         kind: (typeof entry === 'string' ? __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["d" /* MarkupKind */].PlainText : __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["d" /* MarkupKind */].Markdown),

  1495.         value: (typeof entry === 'string' ? entry : entry.value)

  1496.     };

  1497. }

  1498. function fromCompletionItem(entry) {

  1499.     var item = {

  1500.         label: entry.label,

  1501.         sortText: entry.sortText,

  1502.         filterText: entry.filterText,

  1503.         documentation: fromMarkdownString(entry.documentation),

  1504.         detail: entry.detail,

  1505.         kind: fromCompletionItemKind(entry.kind),

  1506.         data: entry.data

  1507.     };

  1508.     if (typeof entry.insertText === 'object' && typeof entry.insertText.value === 'string') {

  1509.         item.insertText = entry.insertText.value;

  1510.         item.insertTextFormat = __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["c" /* InsertTextFormat */].Snippet;

  1511.     }

  1512.     else {

  1513.         item.insertText = entry.insertText;

  1514.     }

  1515.     if (entry.range) {

  1516.         item.textEdit = __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["f" /* TextEdit */].replace(fromRange(entry.range), item.insertText);

  1517.     }

  1518.     return item;

  1519. }

  1520. var CompletionAdapter = /** @class */ (function () {

  1521.     function CompletionAdapter(_worker) {

  1522.         this._worker = _worker;

  1523.     }

  1524.     Object.defineProperty(CompletionAdapter.prototype, "triggerCharacters", {

  1525.         get: function () {

  1526.             return [' ', ':'];

  1527.         },

  1528.         enumerable: true,

  1529.         configurable: true

  1530.     });

  1531.     CompletionAdapter.prototype.provideCompletionItems = function (model, position, token) {

  1532.         var wordInfo = model.getWordUntilPosition(position);

  1533.         var resource = model.uri;

  1534.         return wireCancellationToken(token, this._worker(resource).then(function (worker) {

  1535.             return worker.doComplete(resource.toString(), fromPosition(position));

  1536.         }).then(function (info) {

  1537.             if (!info) {

  1538.                 return;

  1539.             }

  1540.             var items = info.items.map(function (entry) {

  1541.                 var item = {

  1542.                     label: entry.label,

  1543.                     insertText: entry.insertText,

  1544.                     sortText: entry.sortText,

  1545.                     filterText: entry.filterText,

  1546.                     documentation: entry.documentation,

  1547.                     detail: entry.detail,

  1548.                     kind: toCompletionItemKind(entry.kind),

  1549.                 };

  1550.                 if (entry.textEdit) {

  1551.                     item.range = toRange(entry.textEdit.range);

  1552.                     item.insertText = entry.textEdit.newText;

  1553.                 }

  1554.                 if (entry.insertTextFormat === __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["c" /* InsertTextFormat */].Snippet) {

  1555.                     item.insertText = { value: item.insertText };

  1556.                 }

  1557.                 return item;

  1558.             });

  1559.             return {

  1560.                 isIncomplete: info.isIncomplete,

  1561.                 items: items

  1562.             };

  1563.         }));

  1564.     };

  1565.     return CompletionAdapter;

  1566. }());

  1567. 

  1568. function isMarkupContent(thing) {

  1569.     return thing && typeof thing === 'object' && typeof thing.kind === 'string';

  1570. }

  1571. function toMarkdownString(entry) {

  1572.     if (typeof entry === 'string') {

  1573.         return {

  1574.             value: entry

  1575.         };

  1576.     }

  1577.     if (isMarkupContent(entry)) {

  1578.         if (entry.kind === 'plaintext') {

  1579.             return {

  1580.                 value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')

  1581.             };

  1582.         }

  1583.         return {

  1584.             value: entry.value

  1585.         };

  1586.     }

  1587.     return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };

  1588. }

  1589. function toMarkedStringArray(contents) {

  1590.     if (!contents) {

  1591.         return void 0;

  1592.     }

  1593.     if (Array.isArray(contents)) {

  1594.         return contents.map(toMarkdownString);

  1595.     }

  1596.     return [toMarkdownString(contents)];

  1597. }

  1598. // --- hover ------

  1599. var HoverAdapter = /** @class */ (function () {

  1600.     function HoverAdapter(_worker) {

  1601.         this._worker = _worker;

  1602.     }

  1603.     HoverAdapter.prototype.provideHover = function (model, position, token) {

  1604.         var resource = model.uri;

  1605.         return wireCancellationToken(token, this._worker(resource).then(function (worker) {

  1606.             return worker.doHover(resource.toString(), fromPosition(position));

  1607.         }).then(function (info) {

  1608.             if (!info) {

  1609.                 return;

  1610.             }

  1611.             return {

  1612.                 range: toRange(info.range),

  1613.                 contents: toMarkedStringArray(info.contents)

  1614.             };

  1615.         }));

  1616.     };

  1617.     return HoverAdapter;

  1618. }());

  1619. 

  1620. // --- definition ------

  1621. function toLocation(location) {

  1622.     return {

  1623.         uri: Uri.parse(location.uri),

  1624.         range: toRange(location.range)

  1625.     };

  1626. }

  1627. // --- document symbols ------

  1628. function toSymbolKind(kind) {

  1629.     var mKind = monaco.languages.SymbolKind;

  1630.     switch (kind) {

  1631.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].File: return mKind.Array;

  1632.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Module: return mKind.Module;

  1633.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Namespace: return mKind.Namespace;

  1634.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Package: return mKind.Package;

  1635.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Class: return mKind.Class;

  1636.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Method: return mKind.Method;

  1637.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Property: return mKind.Property;

  1638.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Field: return mKind.Field;

  1639.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Constructor: return mKind.Constructor;

  1640.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Enum: return mKind.Enum;

  1641.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Interface: return mKind.Interface;

  1642.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Function: return mKind.Function;

  1643.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Variable: return mKind.Variable;

  1644.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Constant: return mKind.Constant;

  1645.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].String: return mKind.String;

  1646.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Number: return mKind.Number;

  1647.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Boolean: return mKind.Boolean;

  1648.         case __WEBPACK_IMPORTED_MODULE_0__deps_vscode_languageserver_types_main_js__["e" /* SymbolKind */].Array: return mKind.Array;

  1649.     }

  1650.     return mKind.Function;

  1651. }

  1652. var DocumentSymbolAdapter = /** @class */ (function () {

  1653.     function DocumentSymbolAdapter(_worker) {

  1654.         this._worker = _worker;

  1655.     }

  1656.     DocumentSymbolAdapter.prototype.provideDocumentSymbols = function (model, token) {

  1657.         var resource = model.uri;

  1658.         return wireCancellationToken(token, this._worker(resource).then(function (worker) { return worker.findDocumentSymbols(resource.toString()); }).then(function (items) {

  1659.             if (!items) {

  1660.                 return;

  1661.             }

  1662.             return items.map(function (item) { return ({

  1663.                 name: item.name,

  1664.                 containerName: item.containerName,

  1665.                 kind: toSymbolKind(item.kind),

  1666.                 location: toLocation(item.location)

  1667.             }); });

  1668.         }));

  1669.     };

  1670.     return DocumentSymbolAdapter;

  1671. }());

  1672. 

  1673. function fromFormattingOptions(options) {

  1674.     return {

  1675.         tabSize: options.tabSize,

  1676.         insertSpaces: options.insertSpaces

  1677.     };

  1678. }

  1679. var DocumentFormattingEditProvider = /** @class */ (function () {

  1680.     function DocumentFormattingEditProvider(_worker) {

  1681.         this._worker = _worker;

  1682.     }

  1683.     DocumentFormattingEditProvider.prototype.provideDocumentFormattingEdits = function (model, options, token) {

  1684.         var resource = model.uri;

  1685.         return wireCancellationToken(token, this._worker(resource).then(function (worker) {

  1686.             return worker.format(resource.toString(), null, fromFormattingOptions(options)).then(function (edits) {

  1687.                 if (!edits || edits.length === 0) {

  1688.                     return;

  1689.                 }

  1690.                 return edits.map(toTextEdit);

  1691.             });

  1692.         }));

  1693.     };

  1694.     return DocumentFormattingEditProvider;

  1695. }());

  1696. 

  1697. var DocumentRangeFormattingEditProvider = /** @class */ (function () {

  1698.     function DocumentRangeFormattingEditProvider(_worker) {

  1699.         this._worker = _worker;

  1700.     }

  1701.     DocumentRangeFormattingEditProvider.prototype.provideDocumentRangeFormattingEdits = function (model, range, options, token) {

  1702.         var resource = model.uri;

  1703.         return wireCancellationToken(token, this._worker(resource).then(function (worker) {

  1704.             return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then(function (edits) {

  1705.                 if (!edits || edits.length === 0) {

  1706.                     return;

  1707.                 }

  1708.                 return edits.map(toTextEdit);

  1709.             });

  1710.         }));

  1711.     };

  1712.     return DocumentRangeFormattingEditProvider;

  1713. }());

  1714. 

  1715. var DocumentColorAdapter = /** @class */ (function () {

  1716.     function DocumentColorAdapter(_worker) {

  1717.         this._worker = _worker;

  1718.     }

  1719.     DocumentColorAdapter.prototype.provideDocumentColors = function (model, token) {

  1720.         var resource = model.uri;

  1721.         return wireCancellationToken(token, this._worker(resource).then(function (worker) { return worker.findDocumentColors(resource.toString()); }).then(function (infos) {

  1722.             if (!infos) {

  1723.                 return;

  1724.             }

  1725.             return infos.map(function (item) { return ({

  1726.                 color: item.color,

  1727.                 range: toRange(item.range)

  1728.             }); });

  1729.         }));

  1730.     };

  1731.     DocumentColorAdapter.prototype.provideColorPresentations = function (model, info, token) {

  1732.         var resource = model.uri;

  1733.         return wireCancellationToken(token, this._worker(resource).then(function (worker) { return worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range)); }).then(function (presentations) {

  1734.             if (!presentations) {

  1735.                 return;

  1736.             }

  1737.             return presentations.map(function (presentation) {

  1738.                 var item = {

  1739.                     label: presentation.label,

  1740.                 };

  1741.                 if (presentation.textEdit) {

  1742.                     item.textEdit = toTextEdit(presentation.textEdit);

  1743.                 }

  1744.                 if (presentation.additionalTextEdits) {

  1745.                     item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);

  1746.                 }

  1747.                 return item;

  1748.             });

  1749.         }));

  1750.     };

  1751.     return DocumentColorAdapter;

  1752. }());

  1753. 

  1754. /**

  1755.  * Hook a cancellation token to a WinJS Promise

  1756.  */

  1757. function wireCancellationToken(token, promise) {

  1758.     if (promise.cancel) {

  1759.         token.onCancellationRequested(function () { return promise.cancel(); });

  1760.     }

  1761.     return promise;

  1762. }

  1763. 

  1764. 

  1765. /***/ }),

  1766. 

  1767. /***/ 4071:

  1768. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  1769. 

  1770. "use strict";

  1771. /* unused harmony export Position */

  1772. /* unused harmony export Range */

  1773. /* unused harmony export Location */

  1774. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return DiagnosticSeverity; });

  1775. /* unused harmony export Diagnostic */

  1776. /* unused harmony export Command */

  1777. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return TextEdit; });

  1778. /* unused harmony export TextDocumentEdit */

  1779. /* unused harmony export WorkspaceChange */

  1780. /* unused harmony export TextDocumentIdentifier */

  1781. /* unused harmony export VersionedTextDocumentIdentifier */

  1782. /* unused harmony export TextDocumentItem */

  1783. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return MarkupKind; });

  1784. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CompletionItemKind; });

  1785. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return InsertTextFormat; });

  1786. /* unused harmony export CompletionItem */

  1787. /* unused harmony export CompletionList */

  1788. /* unused harmony export MarkedString */

  1789. /* unused harmony export ParameterInformation */

  1790. /* unused harmony export SignatureInformation */

  1791. /* unused harmony export DocumentHighlightKind */

  1792. /* unused harmony export DocumentHighlight */

  1793. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return SymbolKind; });

  1794. /* unused harmony export SymbolInformation */

  1795. /* unused harmony export CodeActionContext */

  1796. /* unused harmony export CodeLens */

  1797. /* unused harmony export FormattingOptions */

  1798. /* unused harmony export DocumentLink */

  1799. /* unused harmony export EOL */

  1800. /* unused harmony export TextDocument */

  1801. /* unused harmony export TextDocumentSaveReason */

  1802. /* --------------------------------------------------------------------------------------------

  1803.  * Copyright (c) Microsoft Corporation. All rights reserved.

  1804.  * Licensed under the MIT License. See License.txt in the project root for license information.

  1805.  * ------------------------------------------------------------------------------------------ */

  1806. 

  1807. /**

  1808.  * The Position namespace provides helper functions to work with

  1809.  * [Position](#Position) literals.

  1810.  */

  1811. var Position;

  1812. (function (Position) {

  1813.     /**

  1814.      * Creates a new Position literal from the given line and character.

  1815.      * @param line The position's line.

  1816.      * @param character The position's character.

  1817.      */

  1818.     function create(line, character) {

  1819.         return { line: line, character: character };

  1820.     }

  1821.     Position.create = create;

  1822.     /**

  1823.      * Checks whether the given liternal conforms to the [Position](#Position) interface.

  1824.      */

  1825.     function is(value) {

  1826.         var candidate = value;

  1827.         return Is.defined(candidate) && Is.number(candidate.line) && Is.number(candidate.character);

  1828.     }

  1829.     Position.is = is;

  1830. })(Position || (Position = {}));

  1831. /**

  1832.  * The Range namespace provides helper functions to work with

  1833.  * [Range](#Range) literals.

  1834.  */

  1835. var Range;

  1836. (function (Range) {

  1837.     function create(one, two, three, four) {

  1838.         if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {

  1839.             return { start: Position.create(one, two), end: Position.create(three, four) };

  1840.         }

  1841.         else if (Position.is(one) && Position.is(two)) {

  1842.             return { start: one, end: two };

  1843.         }

  1844.         else {

  1845.             throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");

  1846.         }

  1847.     }

  1848.     Range.create = create;

  1849.     /**

  1850.      * Checks whether the given literal conforms to the [Range](#Range) interface.

  1851.      */

  1852.     function is(value) {

  1853.         var candidate = value;

  1854.         return Is.defined(candidate) && Position.is(candidate.start) && Position.is(candidate.end);

  1855.     }

  1856.     Range.is = is;

  1857. })(Range || (Range = {}));

  1858. /**

  1859.  * The Location namespace provides helper functions to work with

  1860.  * [Location](#Location) literals.

  1861.  */

  1862. var Location;

  1863. (function (Location) {

  1864.     /**

  1865.      * Creates a Location literal.

  1866.      * @param uri The location's uri.

  1867.      * @param range The location's range.

  1868.      */

  1869.     function create(uri, range) {

  1870.         return { uri: uri, range: range };

  1871.     }

  1872.     Location.create = create;

  1873.     /**

  1874.      * Checks whether the given literal conforms to the [Location](#Location) interface.

  1875.      */

  1876.     function is(value) {

  1877.         var candidate = value;

  1878.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));

  1879.     }

  1880.     Location.is = is;

  1881. })(Location || (Location = {}));

  1882. /**

  1883.  * The diagnostic's serverity.

  1884.  */

  1885. var DiagnosticSeverity;

  1886. (function (DiagnosticSeverity) {

  1887.     /**

  1888.      * Reports an error.

  1889.      */

  1890.     DiagnosticSeverity.Error = 1;

  1891.     /**

  1892.      * Reports a warning.

  1893.      */

  1894.     DiagnosticSeverity.Warning = 2;

  1895.     /**

  1896.      * Reports an information.

  1897.      */

  1898.     DiagnosticSeverity.Information = 3;

  1899.     /**

  1900.      * Reports a hint.

  1901.      */

  1902.     DiagnosticSeverity.Hint = 4;

  1903. })(DiagnosticSeverity || (DiagnosticSeverity = {}));

  1904. /**

  1905.  * The Diagnostic namespace provides helper functions to work with

  1906.  * [Diagnostic](#Diagnostic) literals.

  1907.  */

  1908. var Diagnostic;

  1909. (function (Diagnostic) {

  1910.     /**

  1911.      * Creates a new Diagnostic literal.

  1912.      */

  1913.     function create(range, message, severity, code, source) {

  1914.         var result = { range: range, message: message };

  1915.         if (Is.defined(severity)) {

  1916.             result.severity = severity;

  1917.         }

  1918.         if (Is.defined(code)) {

  1919.             result.code = code;

  1920.         }

  1921.         if (Is.defined(source)) {

  1922.             result.source = source;

  1923.         }

  1924.         return result;

  1925.     }

  1926.     Diagnostic.create = create;

  1927.     /**

  1928.      * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.

  1929.      */

  1930.     function is(value) {

  1931.         var candidate = value;

  1932.         return Is.defined(candidate)

  1933.             && Range.is(candidate.range)

  1934.             && Is.string(candidate.message)

  1935.             && (Is.number(candidate.severity) || Is.undefined(candidate.severity))

  1936.             && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))

  1937.             && (Is.string(candidate.source) || Is.undefined(candidate.source));

  1938.     }

  1939.     Diagnostic.is = is;

  1940. })(Diagnostic || (Diagnostic = {}));

  1941. /**

  1942.  * The Command namespace provides helper functions to work with

  1943.  * [Command](#Command) literals.

  1944.  */

  1945. var Command;

  1946. (function (Command) {

  1947.     /**

  1948.      * Creates a new Command literal.

  1949.      */

  1950.     function create(title, command) {

  1951.         var args = [];

  1952.         for (var _i = 2; _i < arguments.length; _i++) {

  1953.             args[_i - 2] = arguments[_i];

  1954.         }

  1955.         var result = { title: title, command: command };

  1956.         if (Is.defined(args) && args.length > 0) {

  1957.             result.arguments = args;

  1958.         }

  1959.         return result;

  1960.     }

  1961.     Command.create = create;

  1962.     /**

  1963.      * Checks whether the given literal conforms to the [Command](#Command) interface.

  1964.      */

  1965.     function is(value) {

  1966.         var candidate = value;

  1967.         return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.title);

  1968.     }

  1969.     Command.is = is;

  1970. })(Command || (Command = {}));

  1971. /**

  1972.  * The TextEdit namespace provides helper function to create replace,

  1973.  * insert and delete edits more easily.

  1974.  */

  1975. var TextEdit;

  1976. (function (TextEdit) {

  1977.     /**

  1978.      * Creates a replace text edit.

  1979.      * @param range The range of text to be replaced.

  1980.      * @param newText The new text.

  1981.      */

  1982.     function replace(range, newText) {

  1983.         return { range: range, newText: newText };

  1984.     }

  1985.     TextEdit.replace = replace;

  1986.     /**

  1987.      * Creates a insert text edit.

  1988.      * @param position The position to insert the text at.

  1989.      * @param newText The text to be inserted.

  1990.      */

  1991.     function insert(position, newText) {

  1992.         return { range: { start: position, end: position }, newText: newText };

  1993.     }

  1994.     TextEdit.insert = insert;

  1995.     /**

  1996.      * Creates a delete text edit.

  1997.      * @param range The range of text to be deleted.

  1998.      */

  1999.     function del(range) {

  2000.         return { range: range, newText: '' };

  2001.     }

  2002.     TextEdit.del = del;

  2003. })(TextEdit || (TextEdit = {}));

  2004. /**

  2005.  * The TextDocumentEdit namespace provides helper function to create

  2006.  * an edit that manipulates a text document.

  2007.  */

  2008. var TextDocumentEdit;

  2009. (function (TextDocumentEdit) {

  2010.     /**

  2011.      * Creates a new `TextDocumentEdit`

  2012.      */

  2013.     function create(textDocument, edits) {

  2014.         return { textDocument: textDocument, edits: edits };

  2015.     }

  2016.     TextDocumentEdit.create = create;

  2017.     function is(value) {

  2018.         var candidate = value;

  2019.         return Is.defined(candidate)

  2020.             && VersionedTextDocumentIdentifier.is(candidate.textDocument)

  2021.             && Array.isArray(candidate.edits);

  2022.     }

  2023.     TextDocumentEdit.is = is;

  2024. })(TextDocumentEdit || (TextDocumentEdit = {}));

  2025. var TextEditChangeImpl = /** @class */ (function () {

  2026.     function TextEditChangeImpl(edits) {

  2027.         this.edits = edits;

  2028.     }

  2029.     TextEditChangeImpl.prototype.insert = function (position, newText) {

  2030.         this.edits.push(TextEdit.insert(position, newText));

  2031.     };

  2032.     TextEditChangeImpl.prototype.replace = function (range, newText) {

  2033.         this.edits.push(TextEdit.replace(range, newText));

  2034.     };

  2035.     TextEditChangeImpl.prototype.delete = function (range) {

  2036.         this.edits.push(TextEdit.del(range));

  2037.     };

  2038.     TextEditChangeImpl.prototype.add = function (edit) {

  2039.         this.edits.push(edit);

  2040.     };

  2041.     TextEditChangeImpl.prototype.all = function () {

  2042.         return this.edits;

  2043.     };

  2044.     TextEditChangeImpl.prototype.clear = function () {

  2045.         this.edits.splice(0, this.edits.length);

  2046.     };

  2047.     return TextEditChangeImpl;

  2048. }());

  2049. /**

  2050.  * A workspace change helps constructing changes to a workspace.

  2051.  */

  2052. var WorkspaceChange = /** @class */ (function () {

  2053.     function WorkspaceChange(workspaceEdit) {

  2054.         var _this = this;

  2055.         this._textEditChanges = Object.create(null);

  2056.         if (workspaceEdit) {

  2057.             this._workspaceEdit = workspaceEdit;

  2058.             if (workspaceEdit.documentChanges) {

  2059.                 workspaceEdit.documentChanges.forEach(function (textDocumentEdit) {

  2060.                     var textEditChange = new TextEditChangeImpl(textDocumentEdit.edits);

  2061.                     _this._textEditChanges[textDocumentEdit.textDocument.uri] = textEditChange;

  2062.                 });

  2063.             }

  2064.             else if (workspaceEdit.changes) {

  2065.                 Object.keys(workspaceEdit.changes).forEach(function (key) {

  2066.                     var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);

  2067.                     _this._textEditChanges[key] = textEditChange;

  2068.                 });

  2069.             }

  2070.         }

  2071.     }

  2072.     Object.defineProperty(WorkspaceChange.prototype, "edit", {

  2073.         /**

  2074.          * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal

  2075.          * use to be returned from a workspace edit operation like rename.

  2076.          */

  2077.         get: function () {

  2078.             return this._workspaceEdit;

  2079.         },

  2080.         enumerable: true,

  2081.         configurable: true

  2082.     });

  2083.     WorkspaceChange.prototype.getTextEditChange = function (key) {

  2084.         if (VersionedTextDocumentIdentifier.is(key)) {

  2085.             if (!this._workspaceEdit) {

  2086.                 this._workspaceEdit = {

  2087.                     documentChanges: []

  2088.                 };

  2089.             }

  2090.             if (!this._workspaceEdit.documentChanges) {

  2091.                 throw new Error('Workspace edit is not configured for versioned document changes.');

  2092.             }

  2093.             var textDocument = key;

  2094.             var result = this._textEditChanges[textDocument.uri];

  2095.             if (!result) {

  2096.                 var edits = [];

  2097.                 var textDocumentEdit = {

  2098.                     textDocument: textDocument,

  2099.                     edits: edits

  2100.                 };

  2101.                 this._workspaceEdit.documentChanges.push(textDocumentEdit);

  2102.                 result = new TextEditChangeImpl(edits);

  2103.                 this._textEditChanges[textDocument.uri] = result;

  2104.             }

  2105.             return result;

  2106.         }

  2107.         else {

  2108.             if (!this._workspaceEdit) {

  2109.                 this._workspaceEdit = {

  2110.                     changes: Object.create(null)

  2111.                 };

  2112.             }

  2113.             if (!this._workspaceEdit.changes) {

  2114.                 throw new Error('Workspace edit is not configured for normal text edit changes.');

  2115.             }

  2116.             var result = this._textEditChanges[key];

  2117.             if (!result) {

  2118.                 var edits = [];

  2119.                 this._workspaceEdit.changes[key] = edits;

  2120.                 result = new TextEditChangeImpl(edits);

  2121.                 this._textEditChanges[key] = result;

  2122.             }

  2123.             return result;

  2124.         }

  2125.     };

  2126.     return WorkspaceChange;

  2127. }());

  2128. 

  2129. /**

  2130.  * The TextDocumentIdentifier namespace provides helper functions to work with

  2131.  * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.

  2132.  */

  2133. var TextDocumentIdentifier;

  2134. (function (TextDocumentIdentifier) {

  2135.     /**

  2136.      * Creates a new TextDocumentIdentifier literal.

  2137.      * @param uri The document's uri.

  2138.      */

  2139.     function create(uri) {

  2140.         return { uri: uri };

  2141.     }

  2142.     TextDocumentIdentifier.create = create;

  2143.     /**

  2144.      * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.

  2145.      */

  2146.     function is(value) {

  2147.         var candidate = value;

  2148.         return Is.defined(candidate) && Is.string(candidate.uri);

  2149.     }

  2150.     TextDocumentIdentifier.is = is;

  2151. })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));

  2152. /**

  2153.  * The VersionedTextDocumentIdentifier namespace provides helper functions to work with

  2154.  * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.

  2155.  */

  2156. var VersionedTextDocumentIdentifier;

  2157. (function (VersionedTextDocumentIdentifier) {

  2158.     /**

  2159.      * Creates a new VersionedTextDocumentIdentifier literal.

  2160.      * @param uri The document's uri.

  2161.      * @param uri The document's text.

  2162.      */

  2163.     function create(uri, version) {

  2164.         return { uri: uri, version: version };

  2165.     }

  2166.     VersionedTextDocumentIdentifier.create = create;

  2167.     /**

  2168.      * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.

  2169.      */

  2170.     function is(value) {

  2171.         var candidate = value;

  2172.         return Is.defined(candidate) && Is.string(candidate.uri) && Is.number(candidate.version);

  2173.     }

  2174.     VersionedTextDocumentIdentifier.is = is;

  2175. })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));

  2176. /**

  2177.  * The TextDocumentItem namespace provides helper functions to work with

  2178.  * [TextDocumentItem](#TextDocumentItem) literals.

  2179.  */

  2180. var TextDocumentItem;

  2181. (function (TextDocumentItem) {

  2182.     /**

  2183.      * Creates a new TextDocumentItem literal.

  2184.      * @param uri The document's uri.

  2185.      * @param languageId The document's language identifier.

  2186.      * @param version The document's version number.

  2187.      * @param text The document's text.

  2188.      */

  2189.     function create(uri, languageId, version, text) {

  2190.         return { uri: uri, languageId: languageId, version: version, text: text };

  2191.     }

  2192.     TextDocumentItem.create = create;

  2193.     /**

  2194.      * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.

  2195.      */

  2196.     function is(value) {

  2197.         var candidate = value;

  2198.         return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);

  2199.     }

  2200.     TextDocumentItem.is = is;

  2201. })(TextDocumentItem || (TextDocumentItem = {}));

  2202. /**

  2203.  * Describes the content type that a client supports in various

  2204.  * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.

  2205.  *

  2206.  * Please note that `MarkupKinds` must not start with a `$`. This kinds

  2207.  * are reserved for internal usage.

  2208.  */

  2209. var MarkupKind;

  2210. (function (MarkupKind) {

  2211.     /**

  2212.      * Plain text is supported as a content format

  2213.      */

  2214.     MarkupKind.PlainText = 'plaintext';

  2215.     /**

  2216.      * Markdown is supported as a content format

  2217.      */

  2218.     MarkupKind.Markdown = 'markdown';

  2219. })(MarkupKind || (MarkupKind = {}));

  2220. /**

  2221.  * The kind of a completion entry.

  2222.  */

  2223. var CompletionItemKind;

  2224. (function (CompletionItemKind) {

  2225.     CompletionItemKind.Text = 1;

  2226.     CompletionItemKind.Method = 2;

  2227.     CompletionItemKind.Function = 3;

  2228.     CompletionItemKind.Constructor = 4;

  2229.     CompletionItemKind.Field = 5;

  2230.     CompletionItemKind.Variable = 6;

  2231.     CompletionItemKind.Class = 7;

  2232.     CompletionItemKind.Interface = 8;

  2233.     CompletionItemKind.Module = 9;

  2234.     CompletionItemKind.Property = 10;

  2235.     CompletionItemKind.Unit = 11;

  2236.     CompletionItemKind.Value = 12;

  2237.     CompletionItemKind.Enum = 13;

  2238.     CompletionItemKind.Keyword = 14;

  2239.     CompletionItemKind.Snippet = 15;

  2240.     CompletionItemKind.Color = 16;

  2241.     CompletionItemKind.File = 17;

  2242.     CompletionItemKind.Reference = 18;

  2243.     CompletionItemKind.Folder = 19;

  2244.     CompletionItemKind.EnumMember = 20;

  2245.     CompletionItemKind.Constant = 21;

  2246.     CompletionItemKind.Struct = 22;

  2247.     CompletionItemKind.Event = 23;

  2248.     CompletionItemKind.Operator = 24;

  2249.     CompletionItemKind.TypeParameter = 25;

  2250. })(CompletionItemKind || (CompletionItemKind = {}));

  2251. /**

  2252.  * Defines whether the insert text in a completion item should be interpreted as

  2253.  * plain text or a snippet.

  2254.  */

  2255. var InsertTextFormat;

  2256. (function (InsertTextFormat) {

  2257.     /**

  2258.      * The primary text to be inserted is treated as a plain string.

  2259.      */

  2260.     InsertTextFormat.PlainText = 1;

  2261.     /**

  2262.      * The primary text to be inserted is treated as a snippet.

  2263.      *

  2264.      * A snippet can define tab stops and placeholders with `$1`, `$2`

  2265.      * and `${3:foo}`. `$0` defines the final tab stop, it defaults to

  2266.      * the end of the snippet. Placeholders with equal identifiers are linked,

  2267.      * that is typing in one will update others too.

  2268.      *

  2269.      * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md

  2270.      */

  2271.     InsertTextFormat.Snippet = 2;

  2272. })(InsertTextFormat || (InsertTextFormat = {}));

  2273. /**

  2274.  * The CompletionItem namespace provides functions to deal with

  2275.  * completion items.

  2276.  */

  2277. var CompletionItem;

  2278. (function (CompletionItem) {

  2279.     /**

  2280.      * Create a completion item and seed it with a label.

  2281.      * @param label The completion item's label

  2282.      */

  2283.     function create(label) {

  2284.         return { label: label };

  2285.     }

  2286.     CompletionItem.create = create;

  2287. })(CompletionItem || (CompletionItem = {}));

  2288. /**

  2289.  * The CompletionList namespace provides functions to deal with

  2290.  * completion lists.

  2291.  */

  2292. var CompletionList;

  2293. (function (CompletionList) {

  2294.     /**

  2295.      * Creates a new completion list.

  2296.      *

  2297.      * @param items The completion items.

  2298.      * @param isIncomplete The list is not complete.

  2299.      */

  2300.     function create(items, isIncomplete) {

  2301.         return { items: items ? items : [], isIncomplete: !!isIncomplete };

  2302.     }

  2303.     CompletionList.create = create;

  2304. })(CompletionList || (CompletionList = {}));

  2305. var MarkedString;

  2306. (function (MarkedString) {

  2307.     /**

  2308.      * Creates a marked string from plain text.

  2309.      *

  2310.      * @param plainText The plain text.

  2311.      */

  2312.     function fromPlainText(plainText) {

  2313.         return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash

  2314.     }

  2315.     MarkedString.fromPlainText = fromPlainText;

  2316. })(MarkedString || (MarkedString = {}));

  2317. /**

  2318.  * The ParameterInformation namespace provides helper functions to work with

  2319.  * [ParameterInformation](#ParameterInformation) literals.

  2320.  */

  2321. var ParameterInformation;

  2322. (function (ParameterInformation) {

  2323.     /**

  2324.      * Creates a new parameter information literal.

  2325.      *

  2326.      * @param label A label string.

  2327.      * @param documentation A doc string.

  2328.      */

  2329.     function create(label, documentation) {

  2330.         return documentation ? { label: label, documentation: documentation } : { label: label };

  2331.     }

  2332.     ParameterInformation.create = create;

  2333.     ;

  2334. })(ParameterInformation || (ParameterInformation = {}));

  2335. /**

  2336.  * The SignatureInformation namespace provides helper functions to work with

  2337.  * [SignatureInformation](#SignatureInformation) literals.

  2338.  */

  2339. var SignatureInformation;

  2340. (function (SignatureInformation) {

  2341.     function create(label, documentation) {

  2342.         var parameters = [];

  2343.         for (var _i = 2; _i < arguments.length; _i++) {

  2344.             parameters[_i - 2] = arguments[_i];

  2345.         }

  2346.         var result = { label: label };

  2347.         if (Is.defined(documentation)) {

  2348.             result.documentation = documentation;

  2349.         }

  2350.         if (Is.defined(parameters)) {

  2351.             result.parameters = parameters;

  2352.         }

  2353.         else {

  2354.             result.parameters = [];

  2355.         }

  2356.         return result;

  2357.     }

  2358.     SignatureInformation.create = create;

  2359. })(SignatureInformation || (SignatureInformation = {}));

  2360. /**

  2361.  * A document highlight kind.

  2362.  */

  2363. var DocumentHighlightKind;

  2364. (function (DocumentHighlightKind) {

  2365.     /**

  2366.      * A textual occurrance.

  2367.      */

  2368.     DocumentHighlightKind.Text = 1;

  2369.     /**

  2370.      * Read-access of a symbol, like reading a variable.

  2371.      */

  2372.     DocumentHighlightKind.Read = 2;

  2373.     /**

  2374.      * Write-access of a symbol, like writing to a variable.

  2375.      */

  2376.     DocumentHighlightKind.Write = 3;

  2377. })(DocumentHighlightKind || (DocumentHighlightKind = {}));

  2378. /**

  2379.  * DocumentHighlight namespace to provide helper functions to work with

  2380.  * [DocumentHighlight](#DocumentHighlight) literals.

  2381.  */

  2382. var DocumentHighlight;

  2383. (function (DocumentHighlight) {

  2384.     /**

  2385.      * Create a DocumentHighlight object.

  2386.      * @param range The range the highlight applies to.

  2387.      */

  2388.     function create(range, kind) {

  2389.         var result = { range: range };

  2390.         if (Is.number(kind)) {

  2391.             result.kind = kind;

  2392.         }

  2393.         return result;

  2394.     }

  2395.     DocumentHighlight.create = create;

  2396. })(DocumentHighlight || (DocumentHighlight = {}));

  2397. /**

  2398.  * A symbol kind.

  2399.  */

  2400. var SymbolKind;

  2401. (function (SymbolKind) {

  2402.     SymbolKind.File = 1;

  2403.     SymbolKind.Module = 2;

  2404.     SymbolKind.Namespace = 3;

  2405.     SymbolKind.Package = 4;

  2406.     SymbolKind.Class = 5;

  2407.     SymbolKind.Method = 6;

  2408.     SymbolKind.Property = 7;

  2409.     SymbolKind.Field = 8;

  2410.     SymbolKind.Constructor = 9;

  2411.     SymbolKind.Enum = 10;

  2412.     SymbolKind.Interface = 11;

  2413.     SymbolKind.Function = 12;

  2414.     SymbolKind.Variable = 13;

  2415.     SymbolKind.Constant = 14;

  2416.     SymbolKind.String = 15;

  2417.     SymbolKind.Number = 16;

  2418.     SymbolKind.Boolean = 17;

  2419.     SymbolKind.Array = 18;

  2420.     SymbolKind.Object = 19;

  2421.     SymbolKind.Key = 20;

  2422.     SymbolKind.Null = 21;

  2423.     SymbolKind.EnumMember = 22;

  2424.     SymbolKind.Struct = 23;

  2425.     SymbolKind.Event = 24;

  2426.     SymbolKind.Operator = 25;

  2427.     SymbolKind.TypeParameter = 26;

  2428. })(SymbolKind || (SymbolKind = {}));

  2429. var SymbolInformation;

  2430. (function (SymbolInformation) {

  2431.     /**

  2432.      * Creates a new symbol information literal.

  2433.      *

  2434.      * @param name The name of the symbol.

  2435.      * @param kind The kind of the symbol.

  2436.      * @param range The range of the location of the symbol.

  2437.      * @param uri The resource of the location of symbol, defaults to the current document.

  2438.      * @param containerName The name of the symbol containg the symbol.

  2439.      */

  2440.     function create(name, kind, range, uri, containerName) {

  2441.         var result = {

  2442.             name: name,

  2443.             kind: kind,

  2444.             location: { uri: uri, range: range }

  2445.         };

  2446.         if (containerName) {

  2447.             result.containerName = containerName;

  2448.         }

  2449.         return result;

  2450.     }

  2451.     SymbolInformation.create = create;

  2452. })(SymbolInformation || (SymbolInformation = {}));

  2453. /**

  2454.  * The CodeActionContext namespace provides helper functions to work with

  2455.  * [CodeActionContext](#CodeActionContext) literals.

  2456.  */

  2457. var CodeActionContext;

  2458. (function (CodeActionContext) {

  2459.     /**

  2460.      * Creates a new CodeActionContext literal.

  2461.      */

  2462.     function create(diagnostics) {

  2463.         return { diagnostics: diagnostics };

  2464.     }

  2465.     CodeActionContext.create = create;

  2466.     /**

  2467.      * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.

  2468.      */

  2469.     function is(value) {

  2470.         var candidate = value;

  2471.         return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is);

  2472.     }

  2473.     CodeActionContext.is = is;

  2474. })(CodeActionContext || (CodeActionContext = {}));

  2475. /**

  2476.  * The CodeLens namespace provides helper functions to work with

  2477.  * [CodeLens](#CodeLens) literals.

  2478.  */

  2479. var CodeLens;

  2480. (function (CodeLens) {

  2481.     /**

  2482.      * Creates a new CodeLens literal.

  2483.      */

  2484.     function create(range, data) {

  2485.         var result = { range: range };

  2486.         if (Is.defined(data))

  2487.             result.data = data;

  2488.         return result;

  2489.     }

  2490.     CodeLens.create = create;

  2491.     /**

  2492.      * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.

  2493.      */

  2494.     function is(value) {

  2495.         var candidate = value;

  2496.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));

  2497.     }

  2498.     CodeLens.is = is;

  2499. })(CodeLens || (CodeLens = {}));

  2500. /**

  2501.  * The FormattingOptions namespace provides helper functions to work with

  2502.  * [FormattingOptions](#FormattingOptions) literals.

  2503.  */

  2504. var FormattingOptions;

  2505. (function (FormattingOptions) {

  2506.     /**

  2507.      * Creates a new FormattingOptions literal.

  2508.      */

  2509.     function create(tabSize, insertSpaces) {

  2510.         return { tabSize: tabSize, insertSpaces: insertSpaces };

  2511.     }

  2512.     FormattingOptions.create = create;

  2513.     /**

  2514.      * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.

  2515.      */

  2516.     function is(value) {

  2517.         var candidate = value;

  2518.         return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);

  2519.     }

  2520.     FormattingOptions.is = is;

  2521. })(FormattingOptions || (FormattingOptions = {}));

  2522. /**

  2523.  * A document link is a range in a text document that links to an internal or external resource, like another

  2524.  * text document or a web site.

  2525.  */

  2526. var DocumentLink = /** @class */ (function () {

  2527.     function DocumentLink() {

  2528.     }

  2529.     return DocumentLink;

  2530. }());

  2531. 

  2532. /**

  2533.  * The DocumentLink namespace provides helper functions to work with

  2534.  * [DocumentLink](#DocumentLink) literals.

  2535.  */

  2536. (function (DocumentLink) {

  2537.     /**

  2538.      * Creates a new DocumentLink literal.

  2539.      */

  2540.     function create(range, target) {

  2541.         return { range: range, target: target };

  2542.     }

  2543.     DocumentLink.create = create;

  2544.     /**

  2545.      * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.

  2546.      */

  2547.     function is(value) {

  2548.         var candidate = value;

  2549.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));

  2550.     }

  2551.     DocumentLink.is = is;

  2552. })(DocumentLink || (DocumentLink = {}));

  2553. var EOL = ['\n', '\r\n', '\r'];

  2554. var TextDocument;

  2555. (function (TextDocument) {

  2556.     /**

  2557.      * Creates a new ITextDocument literal from the given uri and content.

  2558.      * @param uri The document's uri.

  2559.      * @param languageId  The document's language Id.

  2560.      * @param content The document's content.

  2561.      */

  2562.     function create(uri, languageId, version, content) {

  2563.         return new FullTextDocument(uri, languageId, version, content);

  2564.     }

  2565.     TextDocument.create = create;

  2566.     /**

  2567.      * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.

  2568.      */

  2569.     function is(value) {

  2570.         var candidate = value;

  2571.         return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount)

  2572.             && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;

  2573.     }

  2574.     TextDocument.is = is;

  2575.     function applyEdits(document, edits) {

  2576.         var text = document.getText();

  2577.         var sortedEdits = mergeSort(edits, function (a, b) {

  2578.             var diff = a.range.start.line - b.range.start.line;

  2579.             if (diff === 0) {

  2580.                 return a.range.start.character - b.range.start.character;

  2581.             }

  2582.             return 0;

  2583.         });

  2584.         var lastModifiedOffset = text.length;

  2585.         for (var i = sortedEdits.length - 1; i >= 0; i--) {

  2586.             var e = sortedEdits[i];

  2587.             var startOffset = document.offsetAt(e.range.start);

  2588.             var endOffset = document.offsetAt(e.range.end);

  2589.             if (endOffset <= lastModifiedOffset) {

  2590.                 text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);

  2591.             }

  2592.             else {

  2593.                 throw new Error('Ovelapping edit');

  2594.             }

  2595.             lastModifiedOffset = startOffset;

  2596.         }

  2597.         return text;

  2598.     }

  2599.     TextDocument.applyEdits = applyEdits;

  2600.     function mergeSort(data, compare) {

  2601.         if (data.length <= 1) {

  2602.             // sorted

  2603.             return data;

  2604.         }

  2605.         var p = (data.length / 2) | 0;

  2606.         var left = data.slice(0, p);

  2607.         var right = data.slice(p);

  2608.         mergeSort(left, compare);

  2609.         mergeSort(right, compare);

  2610.         var leftIdx = 0;

  2611.         var rightIdx = 0;

  2612.         var i = 0;

  2613.         while (leftIdx < left.length && rightIdx < right.length) {

  2614.             var ret = compare(left[leftIdx], right[rightIdx]);

  2615.             if (ret <= 0) {

  2616.                 // smaller_equal -> take left to preserve order

  2617.                 data[i++] = left[leftIdx++];

  2618.             }

  2619.             else {

  2620.                 // greater -> take right

  2621.                 data[i++] = right[rightIdx++];

  2622.             }

  2623.         }

  2624.         while (leftIdx < left.length) {

  2625.             data[i++] = left[leftIdx++];

  2626.         }

  2627.         while (rightIdx < right.length) {

  2628.             data[i++] = right[rightIdx++];

  2629.         }

  2630.         return data;

  2631.     }

  2632. })(TextDocument || (TextDocument = {}));

  2633. /**

  2634.  * Represents reasons why a text document is saved.

  2635.  */

  2636. var TextDocumentSaveReason;

  2637. (function (TextDocumentSaveReason) {

  2638.     /**

  2639.      * Manually triggered, e.g. by the user pressing save, by starting debugging,

  2640.      * or by an API call.

  2641.      */

  2642.     TextDocumentSaveReason.Manual = 1;

  2643.     /**

  2644.      * Automatic after a delay.

  2645.      */

  2646.     TextDocumentSaveReason.AfterDelay = 2;

  2647.     /**

  2648.      * When the editor lost focus.

  2649.      */

  2650.     TextDocumentSaveReason.FocusOut = 3;

  2651. })(TextDocumentSaveReason || (TextDocumentSaveReason = {}));

  2652. var FullTextDocument = /** @class */ (function () {

  2653.     function FullTextDocument(uri, languageId, version, content) {

  2654.         this._uri = uri;

  2655.         this._languageId = languageId;

  2656.         this._version = version;

  2657.         this._content = content;

  2658.         this._lineOffsets = null;

  2659.     }

  2660.     Object.defineProperty(FullTextDocument.prototype, "uri", {

  2661.         get: function () {

  2662.             return this._uri;

  2663.         },

  2664.         enumerable: true,

  2665.         configurable: true

  2666.     });

  2667.     Object.defineProperty(FullTextDocument.prototype, "languageId", {

  2668.         get: function () {

  2669.             return this._languageId;

  2670.         },

  2671.         enumerable: true,

  2672.         configurable: true

  2673.     });

  2674.     Object.defineProperty(FullTextDocument.prototype, "version", {

  2675.         get: function () {

  2676.             return this._version;

  2677.         },

  2678.         enumerable: true,

  2679.         configurable: true

  2680.     });

  2681.     FullTextDocument.prototype.getText = function (range) {

  2682.         if (range) {

  2683.             var start = this.offsetAt(range.start);

  2684.             var end = this.offsetAt(range.end);

  2685.             return this._content.substring(start, end);

  2686.         }

  2687.         return this._content;

  2688.     };

  2689.     FullTextDocument.prototype.update = function (event, version) {

  2690.         this._content = event.text;

  2691.         this._version = version;

  2692.         this._lineOffsets = null;

  2693.     };

  2694.     FullTextDocument.prototype.getLineOffsets = function () {

  2695.         if (this._lineOffsets === null) {

  2696.             var lineOffsets = [];

  2697.             var text = this._content;

  2698.             var isLineStart = true;

  2699.             for (var i = 0; i < text.length; i++) {

  2700.                 if (isLineStart) {

  2701.                     lineOffsets.push(i);

  2702.                     isLineStart = false;

  2703.                 }

  2704.                 var ch = text.charAt(i);

  2705.                 isLineStart = (ch === '\r' || ch === '\n');

  2706.                 if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {

  2707.                     i++;

  2708.                 }

  2709.             }

  2710.             if (isLineStart && text.length > 0) {

  2711.                 lineOffsets.push(text.length);

  2712.             }

  2713.             this._lineOffsets = lineOffsets;

  2714.         }

  2715.         return this._lineOffsets;

  2716.     };

  2717.     FullTextDocument.prototype.positionAt = function (offset) {

  2718.         offset = Math.max(Math.min(offset, this._content.length), 0);

  2719.         var lineOffsets = this.getLineOffsets();

  2720.         var low = 0, high = lineOffsets.length;

  2721.         if (high === 0) {

  2722.             return Position.create(0, offset);

  2723.         }

  2724.         while (low < high) {

  2725.             var mid = Math.floor((low + high) / 2);

  2726.             if (lineOffsets[mid] > offset) {

  2727.                 high = mid;

  2728.             }

  2729.             else {

  2730.                 low = mid + 1;

  2731.             }

  2732.         }

  2733.         // low is the least x for which the line offset is larger than the current offset

  2734.         // or array.length if no line offset is larger than the current offset

  2735.         var line = low - 1;

  2736.         return Position.create(line, offset - lineOffsets[line]);

  2737.     };

  2738.     FullTextDocument.prototype.offsetAt = function (position) {

  2739.         var lineOffsets = this.getLineOffsets();

  2740.         if (position.line >= lineOffsets.length) {

  2741.             return this._content.length;

  2742.         }

  2743.         else if (position.line < 0) {

  2744.             return 0;

  2745.         }

  2746.         var lineOffset = lineOffsets[position.line];

  2747.         var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;

  2748.         return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);

  2749.     };

  2750.     Object.defineProperty(FullTextDocument.prototype, "lineCount", {

  2751.         get: function () {

  2752.             return this.getLineOffsets().length;

  2753.         },

  2754.         enumerable: true,

  2755.         configurable: true

  2756.     });

  2757.     return FullTextDocument;

  2758. }());

  2759. var Is;

  2760. (function (Is) {

  2761.     var toString = Object.prototype.toString;

  2762.     function defined(value) {

  2763.         return typeof value !== 'undefined';

  2764.     }

  2765.     Is.defined = defined;

  2766.     function undefined(value) {

  2767.         return typeof value === 'undefined';

  2768.     }

  2769.     Is.undefined = undefined;

  2770.     function boolean(value) {

  2771.         return value === true || value === false;

  2772.     }

  2773.     Is.boolean = boolean;

  2774.     function string(value) {

  2775.         return toString.call(value) === '[object String]';

  2776.     }

  2777.     Is.string = string;

  2778.     function number(value) {

  2779.         return toString.call(value) === '[object Number]';

  2780.     }

  2781.     Is.number = number;

  2782.     function func(value) {

  2783.         return toString.call(value) === '[object Function]';

  2784.     }

  2785.     Is.func = func;

  2786.     function typedArray(value, check) {

  2787.         return Array.isArray(value) && value.every(check);

  2788.     }

  2789.     Is.typedArray = typedArray;

  2790. })(Is || (Is = {}));

  2791. 

  2792. 

  2793. /***/ }),

  2794. 

  2795. /***/ 4072:

  2796. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  2797. 

  2798. "use strict";

  2799. /* harmony export (immutable) */ __webpack_exports__["a"] = createTokenizationSupport;

  2800. /* unused harmony export TOKEN_DELIM_OBJECT */

  2801. /* unused harmony export TOKEN_DELIM_ARRAY */

  2802. /* unused harmony export TOKEN_DELIM_COLON */

  2803. /* unused harmony export TOKEN_DELIM_COMMA */

  2804. /* unused harmony export TOKEN_VALUE_BOOLEAN */

  2805. /* unused harmony export TOKEN_VALUE_NULL */

  2806. /* unused harmony export TOKEN_VALUE_STRING */

  2807. /* unused harmony export TOKEN_VALUE_NUMBER */

  2808. /* unused harmony export TOKEN_PROPERTY_NAME */

  2809. /* unused harmony export TOKEN_COMMENT_BLOCK */

  2810. /* unused harmony export TOKEN_COMMENT_LINE */

  2811. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__deps_jsonc_parser_main_js__ = __webpack_require__(4073);

  2812. /*---------------------------------------------------------------------------------------------

  2813.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  2814.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  2815.  *--------------------------------------------------------------------------------------------*/

  2816. 

  2817. 

  2818. function createTokenizationSupport(supportComments) {

  2819.     return {

  2820.         getInitialState: function () { return new JSONState(null, null, false); },

  2821.         tokenize: function (line, state, offsetDelta, stopAtOffset) { return tokenize(supportComments, line, state, offsetDelta, stopAtOffset); }

  2822.     };

  2823. }

  2824. var TOKEN_DELIM_OBJECT = 'delimiter.bracket.json';

  2825. var TOKEN_DELIM_ARRAY = 'delimiter.array.json';

  2826. var TOKEN_DELIM_COLON = 'delimiter.colon.json';

  2827. var TOKEN_DELIM_COMMA = 'delimiter.comma.json';

  2828. var TOKEN_VALUE_BOOLEAN = 'keyword.json';

  2829. var TOKEN_VALUE_NULL = 'keyword.json';

  2830. var TOKEN_VALUE_STRING = 'string.value.json';

  2831. var TOKEN_VALUE_NUMBER = 'number.json';

  2832. var TOKEN_PROPERTY_NAME = 'string.key.json';

  2833. var TOKEN_COMMENT_BLOCK = 'comment.block.json';

  2834. var TOKEN_COMMENT_LINE = 'comment.line.json';

  2835. var JSONState = /** @class */ (function () {

  2836.     function JSONState(state, scanError, lastWasColon) {

  2837.         this._state = state;

  2838.         this.scanError = scanError;

  2839.         this.lastWasColon = lastWasColon;

  2840.     }

  2841.     JSONState.prototype.clone = function () {

  2842.         return new JSONState(this._state, this.scanError, this.lastWasColon);

  2843.     };

  2844.     JSONState.prototype.equals = function (other) {

  2845.         if (other === this) {

  2846.             return true;

  2847.         }

  2848.         if (!other || !(other instanceof JSONState)) {

  2849.             return false;

  2850.         }

  2851.         return this.scanError === other.scanError &&

  2852.             this.lastWasColon === other.lastWasColon;

  2853.     };

  2854.     JSONState.prototype.getStateData = function () {

  2855.         return this._state;

  2856.     };

  2857.     JSONState.prototype.setStateData = function (state) {

  2858.         this._state = state;

  2859.     };

  2860.     return JSONState;

  2861. }());

  2862. function tokenize(comments, line, state, offsetDelta, stopAtOffset) {

  2863.     if (offsetDelta === void 0) { offsetDelta = 0; }

  2864.     // handle multiline strings and block comments

  2865.     var numberOfInsertedCharacters = 0, adjustOffset = false;

  2866.     switch (state.scanError) {

  2867.         case 2 /* UnexpectedEndOfString */:

  2868.             line = '"' + line;

  2869.             numberOfInsertedCharacters = 1;

  2870.             break;

  2871.         case 1 /* UnexpectedEndOfComment */:

  2872.             line = '/*' + line;

  2873.             numberOfInsertedCharacters = 2;

  2874.             break;

  2875.     }

  2876.     var scanner = __WEBPACK_IMPORTED_MODULE_0__deps_jsonc_parser_main_js__["a" /* createScanner */](line), kind, ret, lastWasColon = state.lastWasColon;

  2877.     ret = {

  2878.         tokens: [],

  2879.         endState: state.clone()

  2880.     };

  2881.     while (true) {

  2882.         var offset = offsetDelta + scanner.getPosition(), type = '';

  2883.         kind = scanner.scan();

  2884.         if (kind === 17 /* EOF */) {

  2885.             break;

  2886.         }

  2887.         // Check that the scanner has advanced

  2888.         if (offset === offsetDelta + scanner.getPosition()) {

  2889.             throw new Error('Scanner did not advance, next 3 characters are: ' + line.substr(scanner.getPosition(), 3));

  2890.         }

  2891.         // In case we inserted /* or " character, we need to

  2892.         // adjust the offset of all tokens (except the first)

  2893.         if (adjustOffset) {

  2894.             offset -= numberOfInsertedCharacters;

  2895.         }

  2896.         adjustOffset = numberOfInsertedCharacters > 0;

  2897.         // brackets and type

  2898.         switch (kind) {

  2899.             case 1 /* OpenBraceToken */:

  2900.                 type = TOKEN_DELIM_OBJECT;

  2901.                 lastWasColon = false;

  2902.                 break;

  2903.             case 2 /* CloseBraceToken */:

  2904.                 type = TOKEN_DELIM_OBJECT;

  2905.                 lastWasColon = false;

  2906.                 break;

  2907.             case 3 /* OpenBracketToken */:

  2908.                 type = TOKEN_DELIM_ARRAY;

  2909.                 lastWasColon = false;

  2910.                 break;

  2911.             case 4 /* CloseBracketToken */:

  2912.                 type = TOKEN_DELIM_ARRAY;

  2913.                 lastWasColon = false;

  2914.                 break;

  2915.             case 6 /* ColonToken */:

  2916.                 type = TOKEN_DELIM_COLON;

  2917.                 lastWasColon = true;

  2918.                 break;

  2919.             case 5 /* CommaToken */:

  2920.                 type = TOKEN_DELIM_COMMA;

  2921.                 lastWasColon = false;

  2922.                 break;

  2923.             case 8 /* TrueKeyword */:

  2924.             case 9 /* FalseKeyword */:

  2925.                 type = TOKEN_VALUE_BOOLEAN;

  2926.                 lastWasColon = false;

  2927.                 break;

  2928.             case 7 /* NullKeyword */:

  2929.                 type = TOKEN_VALUE_NULL;

  2930.                 lastWasColon = false;

  2931.                 break;

  2932.             case 10 /* StringLiteral */:

  2933.                 type = lastWasColon ? TOKEN_VALUE_STRING : TOKEN_PROPERTY_NAME;

  2934.                 lastWasColon = false;

  2935.                 break;

  2936.             case 11 /* NumericLiteral */:

  2937.                 type = TOKEN_VALUE_NUMBER;

  2938.                 lastWasColon = false;

  2939.                 break;

  2940.         }

  2941.         // comments, iff enabled

  2942.         if (comments) {

  2943.             switch (kind) {

  2944.                 case 12 /* LineCommentTrivia */:

  2945.                     type = TOKEN_COMMENT_LINE;

  2946.                     break;

  2947.                 case 13 /* BlockCommentTrivia */:

  2948.                     type = TOKEN_COMMENT_BLOCK;

  2949.                     break;

  2950.             }

  2951.         }

  2952.         ret.endState = new JSONState(state.getStateData(), scanner.getTokenError(), lastWasColon);

  2953.         ret.tokens.push({

  2954.             startIndex: offset,

  2955.             scopes: type

  2956.         });

  2957.     }

  2958.     return ret;

  2959. }

  2960. 

  2961. 

  2962. /***/ }),

  2963. 

  2964. /***/ 4073:

  2965. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  2966. 

  2967. "use strict";

  2968. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return createScanner; });

  2969. /* unused harmony export getLocation */

  2970. /* unused harmony export parse */

  2971. /* unused harmony export parseTree */

  2972. /* unused harmony export findNodeAtLocation */

  2973. /* unused harmony export getNodeValue */

  2974. /* unused harmony export visit */

  2975. /* unused harmony export stripComments */

  2976. /* unused harmony export format */

  2977. /* unused harmony export modify */

  2978. /* unused harmony export applyEdits */

  2979. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__impl_format_js__ = __webpack_require__(3579);

  2980. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__impl_edit_js__ = __webpack_require__(4074);

  2981. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__impl_scanner_js__ = __webpack_require__(3235);

  2982. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__ = __webpack_require__(3580);

  2983. /*---------------------------------------------------------------------------------------------

  2984.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  2985.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  2986.  *--------------------------------------------------------------------------------------------*/

  2987. 

  2988. 

  2989. 

  2990. 

  2991. 

  2992. /**

  2993.  * Creates a JSON scanner on the given text.

  2994.  * If ignoreTrivia is set, whitespaces or comments are ignored.

  2995.  */

  2996. var createScanner = __WEBPACK_IMPORTED_MODULE_2__impl_scanner_js__["a" /* createScanner */];

  2997. /**

  2998.  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.

  2999.  */

  3000. var getLocation = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["b" /* getLocation */];

  3001. /**

  3002.  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.

  3003.  * Therefore always check the errors list to find out if the input was valid.

  3004.  */

  3005. var parse = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["d" /* parse */];

  3006. /**

  3007.  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.

  3008.  */

  3009. var parseTree = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["e" /* parseTree */];

  3010. /**

  3011.  * Finds the node at the given path in a JSON DOM.

  3012.  */

  3013. var findNodeAtLocation = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["a" /* findNodeAtLocation */];

  3014. /**

  3015.  * Evaluates the JavaScript object of the given JSON DOM node

  3016.  */

  3017. var getNodeValue = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["c" /* getNodeValue */];

  3018. /**

  3019.  * Parses the given text and invokes the visitor functions for each object, array and literal reached.

  3020.  */

  3021. var visit = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["g" /* visit */];

  3022. /**

  3023.  * Takes JSON with JavaScript-style comments and remove

  3024.  * them. Optionally replaces every none-newline character

  3025.  * of comments with a replaceCharacter

  3026.  */

  3027. var stripComments = __WEBPACK_IMPORTED_MODULE_3__impl_parser_js__["f" /* stripComments */];

  3028. /**

  3029.  * Computes the edits needed to format a JSON document.

  3030.  *

  3031.  * @param documentText The input text

  3032.  * @param range The range to format or `undefined` to format the full content

  3033.  * @param options The formatting options

  3034.  * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or

  3035.  * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of

  3036.  * text in the original document. However, multiple edits can have

  3037.  * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.

  3038.  * To apply edits to an input, you can use `applyEdits`

  3039.  */

  3040. function format(documentText, range, options) {

  3041.     return __WEBPACK_IMPORTED_MODULE_0__impl_format_js__["a" /* format */](documentText, range, options);

  3042. }

  3043. /**

  3044.  * Computes the edits needed to modify a value in the JSON document.

  3045.  *

  3046.  * @param documentText The input text

  3047.  * @param path The path of the value to change. The path represents either to the document root, a property or an array item.

  3048.  * If the path points to an non-existing property or item, it will be created.

  3049.  * @param value The new value for the specified property or item. If the value is undefined,

  3050.  * the property or item will be removed.

  3051.  * @param options Options

  3052.  * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or

  3053.  * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of

  3054.  * text in the original document. However, multiple edits can have

  3055.  * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.

  3056.  * To apply edits to an input, you can use `applyEdits`

  3057.  */

  3058. function modify(text, path, value, options) {

  3059.     return __WEBPACK_IMPORTED_MODULE_1__impl_edit_js__["b" /* setProperty */](text, path, value, options.formattingOptions, options.getInsertionIndex);

  3060. }

  3061. /**

  3062.  * Applies edits to a input string.

  3063.  */

  3064. function applyEdits(text, edits) {

  3065.     for (var i = edits.length - 1; i >= 0; i--) {

  3066.         text = __WEBPACK_IMPORTED_MODULE_1__impl_edit_js__["a" /* applyEdit */](text, edits[i]);

  3067.     }

  3068.     return text;

  3069. }

  3070. //# sourceMappingURL=main.js.map

  3071. 

  3072. /***/ }),

  3073. 

  3074. /***/ 4074:

  3075. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  3076. 

  3077. "use strict";

  3078. /* unused harmony export removeProperty */

  3079. /* harmony export (immutable) */ __webpack_exports__["b"] = setProperty;

  3080. /* harmony export (immutable) */ __webpack_exports__["a"] = applyEdit;

  3081. /* unused harmony export isWS */

  3082. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__format_js__ = __webpack_require__(3579);

  3083. /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__parser_js__ = __webpack_require__(3580);

  3084. /*---------------------------------------------------------------------------------------------

  3085.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  3086.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  3087.  *--------------------------------------------------------------------------------------------*/

  3088. 

  3089. 

  3090. 

  3091. function removeProperty(text, path, formattingOptions) {

  3092.     return setProperty(text, path, void 0, formattingOptions);

  3093. }

  3094. function setProperty(text, path, value, formattingOptions, getInsertionIndex) {

  3095.     var errors = [];

  3096.     var root = Object(__WEBPACK_IMPORTED_MODULE_1__parser_js__["e" /* parseTree */])(text, errors);

  3097.     var parent = void 0;

  3098.     var lastSegment = void 0;

  3099.     while (path.length > 0) {

  3100.         lastSegment = path.pop();

  3101.         parent = Object(__WEBPACK_IMPORTED_MODULE_1__parser_js__["a" /* findNodeAtLocation */])(root, path);

  3102.         if (parent === void 0 && value !== void 0) {

  3103.             if (typeof lastSegment === 'string') {

  3104.                 value = (_a = {}, _a[lastSegment] = value, _a);

  3105.             }

  3106.             else {

  3107.                 value = [value];

  3108.             }

  3109.         }

  3110.         else {

  3111.             break;

  3112.         }

  3113.     }

  3114.     if (!parent) {

  3115.         // empty document

  3116.         if (value === void 0) {

  3117.             throw new Error('Can not delete in empty document');

  3118.         }

  3119.         return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);

  3120.     }

  3121.     else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {

  3122.         var existing = Object(__WEBPACK_IMPORTED_MODULE_1__parser_js__["a" /* findNodeAtLocation */])(parent, [lastSegment]);

  3123.         if (existing !== void 0) {

  3124.             if (value === void 0) {

  3125.                 if (!existing.parent) {

  3126.                     throw new Error('Malformed AST');

  3127.                 }

  3128.                 var propertyIndex = parent.children.indexOf(existing.parent);

  3129.                 var removeBegin = void 0;

  3130.                 var removeEnd = existing.parent.offset + existing.parent.length;

  3131.                 if (propertyIndex > 0) {

  3132.                     // remove the comma of the previous node

  3133.                     var previous = parent.children[propertyIndex - 1];

  3134.                     removeBegin = previous.offset + previous.length;

  3135.                 }

  3136.                 else {

  3137.                     removeBegin = parent.offset + 1;

  3138.                     if (parent.children.length > 1) {

  3139.                         // remove the comma of the next node

  3140.                         var next = parent.children[1];

  3141.                         removeEnd = next.offset;

  3142.                     }

  3143.                 }

  3144.                 return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);

  3145.             }

  3146.             else {

  3147.                 // set value of existing property

  3148.                 return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);

  3149.             }

  3150.         }

  3151.         else {

  3152.             if (value === void 0) {

  3153.                 return []; // property does not exist, nothing to do

  3154.             }

  3155.             var newProperty = JSON.stringify(lastSegment) + ": " + JSON.stringify(value);

  3156.             var index = getInsertionIndex ? getInsertionIndex(parent.children.map(function (p) { return p.children[0].value; })) : parent.children.length;

  3157.             var edit = void 0;

  3158.             if (index > 0) {

  3159.                 var previous = parent.children[index - 1];

  3160.                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };

  3161.             }

  3162.             else if (parent.children.length === 0) {

  3163.                 edit = { offset: parent.offset + 1, length: 0, content: newProperty };

  3164.             }

  3165.             else {

  3166.                 edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };

  3167.             }

  3168.             return withFormatting(text, edit, formattingOptions);

  3169.         }

  3170.     }

  3171.     else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {

  3172.         var insertIndex = lastSegment;

  3173.         if (insertIndex === -1) {

  3174.             // Insert

  3175.             var newProperty = "" + JSON.stringify(value);

  3176.             var edit = void 0;

  3177.             if (parent.children.length === 0) {

  3178.                 edit = { offset: parent.offset + 1, length: 0, content: newProperty };

  3179.             }

  3180.             else {

  3181.                 var previous = parent.children[parent.children.length - 1];

  3182.                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };

  3183.             }

  3184.             return withFormatting(text, edit, formattingOptions);

  3185.         }

  3186.         else {

  3187.             if (value === void 0 && parent.children.length >= 0) {

  3188.                 //Removal

  3189.                 var removalIndex = lastSegment;

  3190.                 var toRemove = parent.children[removalIndex];

  3191.                 var edit = void 0;

  3192.                 if (parent.children.length === 1) {

  3193.                     // only item

  3194.                     edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };

  3195.                 }

  3196.                 else if (parent.children.length - 1 === removalIndex) {

  3197.                     // last item

  3198.                     var previous = parent.children[removalIndex - 1];

  3199.                     var offset = previous.offset + previous.length;

  3200.                     var parentEndOffset = parent.offset + parent.length;

  3201.                     edit = { offset: offset, length: parentEndOffset - 2 - offset, content: '' };

  3202.                 }

  3203.                 else {

  3204.                     edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };

  3205.                 }

  3206.                 return withFormatting(text, edit, formattingOptions);

  3207.             }

  3208.             else {

  3209.                 throw new Error('Array modification not supported yet');

  3210.             }

  3211.         }

  3212.     }

  3213.     else {

  3214.         throw new Error("Can not add " + (typeof lastSegment !== 'number' ? 'index' : 'property') + " to parent of type " + parent.type);

  3215.     }

  3216.     var _a;

  3217. }

  3218. function withFormatting(text, edit, formattingOptions) {

  3219.     // apply the edit

  3220.     var newText = applyEdit(text, edit);

  3221.     // format the new text

  3222.     var begin = edit.offset;

  3223.     var end = edit.offset + edit.content.length;

  3224.     if (edit.length === 0 || edit.content.length === 0) {

  3225.         while (begin > 0 && !Object(__WEBPACK_IMPORTED_MODULE_0__format_js__["b" /* isEOL */])(newText, begin - 1)) {

  3226.             begin--;

  3227.         }

  3228.         while (end < newText.length && !Object(__WEBPACK_IMPORTED_MODULE_0__format_js__["b" /* isEOL */])(newText, end)) {

  3229.             end++;

  3230.         }

  3231.     }

  3232.     var edits = Object(__WEBPACK_IMPORTED_MODULE_0__format_js__["a" /* format */])(newText, { offset: begin, length: end - begin }, formattingOptions);

  3233.     // apply the formatting edits and track the begin and end offsets of the changes

  3234.     for (var i = edits.length - 1; i >= 0; i--) {

  3235.         var edit_1 = edits[i];

  3236.         newText = applyEdit(newText, edit_1);

  3237.         begin = Math.min(begin, edit_1.offset);

  3238.         end = Math.max(end, edit_1.offset + edit_1.length);

  3239.         end += edit_1.content.length - edit_1.length;

  3240.     }

  3241.     // create a single edit with all changes

  3242.     var editLength = text.length - (newText.length - end) - begin;

  3243.     return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];

  3244. }

  3245. function applyEdit(text, edit) {

  3246.     return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);

  3247. }

  3248. function isWS(text, offset) {

  3249.     return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;

  3250. }

  3251. //# sourceMappingURL=edit.js.map

  3252. 

  3253. /***/ })

  3254. 

  3255. });