vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/esm/services/jsonDocumentSymbols.js

@@ -6,68 +6,64 @@ import * as Parser from '../parser/jsonParser';
 import * as Strings from '../utils/strings';
 import { colorFromHex } from '../utils/colors';
 import { Range, TextEdit, SymbolKind, Location } from "../jsonLanguageTypes";
-var JSONDocumentSymbols = /** @class */ (function () {
-    function JSONDocumentSymbols(schemaService) {
+export class JSONDocumentSymbols {
+    constructor(schemaService) {
         this.schemaService = schemaService;
     }
-    JSONDocumentSymbols.prototype.findDocumentSymbols = function (document, doc, context) {
-        var _this = this;
-        if (context === void 0) { context = { resultLimit: Number.MAX_VALUE }; }
-        var root = doc.root;
+    findDocumentSymbols(document, doc, context = { resultLimit: Number.MAX_VALUE }) {
+        const root = doc.root;
         if (!root) {
             return [];
         }
-        var limit = context.resultLimit || Number.MAX_VALUE;
+        let limit = context.resultLimit || Number.MAX_VALUE;
         // special handling for key bindings
-        var resourceString = document.uri;
+        const resourceString = document.uri;
         if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
             if (root.type === 'array') {
-                var result_1 = [];
-                for (var _i = 0, _a = root.items; _i < _a.length; _i++) {
-                    var item = _a[_i];
+                const result = [];
+                for (const item of root.items) {
                     if (item.type === 'object') {
-                        for (var _b = 0, _c = item.properties; _b < _c.length; _b++) {
-                            var property = _c[_b];
+                        for (const property of item.properties) {
                             if (property.keyNode.value === 'key' && property.valueNode) {
-                                var location = Location.create(document.uri, getRange(document, item));
-                                result_1.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, location: location });
+                                const location = Location.create(document.uri, getRange(document, item));
+                                result.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, location: location });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
                                         context.onResultLimitExceeded(resourceString);
                                     }
-                                    return result_1;
+                                    return result;
                                 }
                             }
                         }
                     }
                 }
-                return result_1;
+                return result;
             }
         }
-        var toVisit = [
+        const toVisit = [
             { node: root, containerName: '' }
         ];
-        var nextToVisit = 0;
-        var limitExceeded = false;
-        var result = [];
-        var collectOutlineEntries = function (node, containerName) {
+        let nextToVisit = 0;
+        let limitExceeded = false;
+        const result = [];
+        const collectOutlineEntries = (node, containerName) => {
             if (node.type === 'array') {
-                node.items.forEach(function (node) {
+                node.items.forEach(node => {
                     if (node) {
-                        toVisit.push({ node: node, containerName: containerName });
+                        toVisit.push({ node, containerName });
                     }
                 });
             }
             else if (node.type === 'object') {
-                node.properties.forEach(function (property) {
-                    var valueNode = property.valueNode;
+                node.properties.forEach((property) => {
+                    const valueNode = property.valueNode;
                     if (valueNode) {
                         if (limit > 0) {
                             limit--;
-                            var location = Location.create(document.uri, getRange(document, property));
-                            var childContainerName = containerName ? containerName + '.' + property.keyNode.value : property.keyNode.value;
-                            result.push({ name: _this.getKeyLabel(property), kind: _this.getSymbolKind(valueNode.type), location: location, containerName: containerName });
+                            const location = Location.create(document.uri, getRange(document, property));
+                            const childContainerName = containerName ? containerName + '.' + property.keyNode.value : property.keyNode.value;
+                            result.push({ name: this.getKeyLabel(property), kind: this.getSymbolKind(valueNode.type), location: location, containerName: containerName });
                             toVisit.push({ node: valueNode, containerName: childContainerName });
                         }
                         else {
@@ -79,68 +75,64 @@ var JSONDocumentSymbols = /** @class */ (function () {
         };
         // breath first traversal
         while (nextToVisit < toVisit.length) {
-            var next = toVisit[nextToVisit++];
+            const next = toVisit[nextToVisit++];
             collectOutlineEntries(next.node, next.containerName);
         }
         if (limitExceeded && context && context.onResultLimitExceeded) {
             context.onResultLimitExceeded(resourceString);
         }
         return result;
-    };
-    JSONDocumentSymbols.prototype.findDocumentSymbols2 = function (document, doc, context) {
-        var _this = this;
-        if (context === void 0) { context = { resultLimit: Number.MAX_VALUE }; }
-        var root = doc.root;
+    }
+    findDocumentSymbols2(document, doc, context = { resultLimit: Number.MAX_VALUE }) {
+        const root = doc.root;
         if (!root) {
             return [];
         }
-        var limit = context.resultLimit || Number.MAX_VALUE;
+        let limit = context.resultLimit || Number.MAX_VALUE;
         // special handling for key bindings
-        var resourceString = document.uri;
+        const resourceString = document.uri;
         if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {
             if (root.type === 'array') {
-                var result_2 = [];
-                for (var _i = 0, _a = root.items; _i < _a.length; _i++) {
-                    var item = _a[_i];
+                const result = [];
+                for (const item of root.items) {
                     if (item.type === 'object') {
-                        for (var _b = 0, _c = item.properties; _b < _c.length; _b++) {
-                            var property = _c[_b];
+                        for (const property of item.properties) {
                             if (property.keyNode.value === 'key' && property.valueNode) {
-                                var range = getRange(document, item);
-                                var selectionRange = getRange(document, property.keyNode);
-                                result_2.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, range: range, selectionRange: selectionRange });
+                                const range = getRange(document, item);
+                                const selectionRange = getRange(document, property.keyNode);
+                                result.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, range, selectionRange });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
                                         context.onResultLimitExceeded(resourceString);
                                     }
-                                    return result_2;
+                                    return result;
                                 }
                             }
                         }
                     }
                 }
-                return result_2;
+                return result;
             }
         }
-        var result = [];
-        var toVisit = [
-            { node: root, result: result }
+        const result = [];
+        const toVisit = [
+            { node: root, result }
         ];
-        var nextToVisit = 0;
-        var limitExceeded = false;
-        var collectOutlineEntries = function (node, result) {
+        let nextToVisit = 0;
+        let limitExceeded = false;
+        const collectOutlineEntries = (node, result) => {
             if (node.type === 'array') {
-                node.items.forEach(function (node, index) {
+                node.items.forEach((node, index) => {
                     if (node) {
                         if (limit > 0) {
                             limit--;
-                            var range = getRange(document, node);
-                            var selectionRange = range;
-                            var name = String(index);
-                            var symbol = { name: name, kind: _this.getSymbolKind(node.type), range: range, selectionRange: selectionRange, children: [] };
+                            const range = getRange(document, node);
+                            const selectionRange = range;
+                            const name = String(index);
+                            const symbol = { name, kind: this.getSymbolKind(node.type), range, selectionRange, children: [] };
                             result.push(symbol);
-                            toVisit.push({ result: symbol.children, node: node });
+                            toVisit.push({ result: symbol.children, node });
                         }
                         else {
                             limitExceeded = true;
@@ -149,15 +141,15 @@ var JSONDocumentSymbols = /** @class */ (function () {
                 });
             }
             else if (node.type === 'object') {
-                node.properties.forEach(function (property) {
-                    var valueNode = property.valueNode;
+                node.properties.forEach((property) => {
+                    const valueNode = property.valueNode;
                     if (valueNode) {
                         if (limit > 0) {
                             limit--;
-                            var range = getRange(document, property);
-                            var selectionRange = getRange(document, property.keyNode);
-                            var children = [];
-                            var symbol = { name: _this.getKeyLabel(property), kind: _this.getSymbolKind(valueNode.type), range: range, selectionRange: selectionRange, children: children, detail: _this.getDetail(valueNode) };
+                            const range = getRange(document, property);
+                            const selectionRange = getRange(document, property.keyNode);
+                            const children = [];
+                            const symbol = { name: this.getKeyLabel(property), kind: this.getSymbolKind(valueNode.type), range, selectionRange, children, detail: this.getDetail(valueNode) };
                             result.push(symbol);
                             toVisit.push({ result: children, node: valueNode });
                         }
@@ -170,15 +162,15 @@ var JSONDocumentSymbols = /** @class */ (function () {
         };
         // breath first traversal
         while (nextToVisit < toVisit.length) {
-            var next = toVisit[nextToVisit++];
+            const next = toVisit[nextToVisit++];
             collectOutlineEntries(next.node, next.result);
         }
         if (limitExceeded && context && context.onResultLimitExceeded) {
             context.onResultLimitExceeded(resourceString);
         }
         return result;
-    };
-    JSONDocumentSymbols.prototype.getSymbolKind = function (nodeType) {
+    }
+    getSymbolKind(nodeType) {
         switch (nodeType) {
             case 'object':
                 return SymbolKind.Module;
@@ -193,18 +185,18 @@ var JSONDocumentSymbols = /** @class */ (function () {
             default: // 'null'
                 return SymbolKind.Variable;
         }
-    };
-    JSONDocumentSymbols.prototype.getKeyLabel = function (property) {
-        var name = property.keyNode.value;
+    }
+    getKeyLabel(property) {
+        let name = property.keyNode.value;
         if (name) {
             name = name.replace(/[\n]/g, '↵');
         }
         if (name && name.trim()) {
             return name;
         }
-        return "\"".concat(name, "\"");
-    };
-    JSONDocumentSymbols.prototype.getDetail = function (node) {
+        return `"${name}"`;
+    }
+    getDetail(node) {
         if (!node) {
             return undefined;
         }
@@ -220,23 +212,22 @@ var JSONDocumentSymbols = /** @class */ (function () {
             }
         }
         return undefined;
-    };
-    JSONDocumentSymbols.prototype.findDocumentColors = function (document, doc, context) {
-        return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
-            var result = [];
+    }
+    findDocumentColors(document, doc, context) {
+        return this.schemaService.getSchemaForResource(document.uri, doc).then(schema => {
+            const result = [];
             if (schema) {
-                var limit = context && typeof context.resultLimit === 'number' ? context.resultLimit : Number.MAX_VALUE;
-                var matchingSchemas = doc.getMatchingSchemas(schema.schema);
-                var visitedNode = {};
-                for (var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++) {
-                    var s = matchingSchemas_1[_i];
+                let limit = context && typeof context.resultLimit === 'number' ? context.resultLimit : Number.MAX_VALUE;
+                const matchingSchemas = doc.getMatchingSchemas(schema.schema);
+                const visitedNode = {};
+                for (const s of matchingSchemas) {
                     if (!s.inverted && s.schema && (s.schema.format === 'color' || s.schema.format === 'color-hex') && s.node && s.node.type === 'string') {
-                        var nodeId = String(s.node.offset);
+                        const nodeId = String(s.node.offset);
                         if (!visitedNode[nodeId]) {
-                            var color = colorFromHex(Parser.getNodeValue(s.node));
+                            const color = colorFromHex(Parser.getNodeValue(s.node));
                             if (color) {
-                                var range = getRange(document, s.node);
-                                result.push({ color: color, range: range });
+                                const range = getRange(document, s.node);
+                                result.push({ color, range });
                             }
                             visitedNode[nodeId] = true;
                             limit--;
@@ -252,27 +243,25 @@ var JSONDocumentSymbols = /** @class */ (function () {
             }
             return result;
         });
-    };
-    JSONDocumentSymbols.prototype.getColorPresentations = function (document, doc, color, range) {
-        var result = [];
-        var red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);
+    }
+    getColorPresentations(document, doc, color, range) {
+        const result = [];
+        const red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);
         function toTwoDigitHex(n) {
-            var r = n.toString(16);
+            const r = n.toString(16);
             return r.length !== 2 ? '0' + r : r;
         }
-        var label;
+        let label;
         if (color.alpha === 1) {
-            label = "#".concat(toTwoDigitHex(red256)).concat(toTwoDigitHex(green256)).concat(toTwoDigitHex(blue256));
+            label = `#${toTwoDigitHex(red256)}${toTwoDigitHex(green256)}${toTwoDigitHex(blue256)}`;
         }
         else {
-            label = "#".concat(toTwoDigitHex(red256)).concat(toTwoDigitHex(green256)).concat(toTwoDigitHex(blue256)).concat(toTwoDigitHex(Math.round(color.alpha * 255)));
+            label = `#${toTwoDigitHex(red256)}${toTwoDigitHex(green256)}${toTwoDigitHex(blue256)}${toTwoDigitHex(Math.round(color.alpha * 255))}`;
         }
         result.push({ label: label, textEdit: TextEdit.replace(range, JSON.stringify(label)) });
         return result;
-    };
-    return JSONDocumentSymbols;
-}());
-export { JSONDocumentSymbols };
+    }
+}
 function getRange(document, node) {
     return Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
 }

package/lib/esm/services/jsonFolding.js

@@ -5,31 +5,31 @@
 import { createScanner } from 'jsonc-parser';
 import { FoldingRangeKind, Position } from '../jsonLanguageTypes';
 export function getFoldingRanges(document, context) {
-    var ranges = [];
-    var nestingLevels = [];
-    var stack = [];
-    var prevStart = -1;
-    var scanner = createScanner(document.getText(), false);
-    var token = scanner.scan();
+    const ranges = [];
+    const nestingLevels = [];
+    const stack = [];
+    let prevStart = -1;
+    const scanner = createScanner(document.getText(), false);
+    let token = scanner.scan();
     function addRange(range) {
         ranges.push(range);
         nestingLevels.push(stack.length);
     }
-    while (token !== 17 /* EOF */) {
+    while (token !== 17 /* SyntaxKind.EOF */) {
         switch (token) {
-            case 1 /* OpenBraceToken */:
-            case 3 /* OpenBracketToken */: {
-                var startLine = document.positionAt(scanner.getTokenOffset()).line;
-                var range = { startLine: startLine, endLine: startLine, kind: token === 1 /* OpenBraceToken */ ? 'object' : 'array' };
+            case 1 /* SyntaxKind.OpenBraceToken */:
+            case 3 /* SyntaxKind.OpenBracketToken */: {
+                const startLine = document.positionAt(scanner.getTokenOffset()).line;
+                const range = { startLine, endLine: startLine, kind: token === 1 /* SyntaxKind.OpenBraceToken */ ? 'object' : 'array' };
                 stack.push(range);
                 break;
             }
-            case 2 /* CloseBraceToken */:
-            case 4 /* CloseBracketToken */: {
-                var kind = token === 2 /* CloseBraceToken */ ? 'object' : 'array';
+            case 2 /* SyntaxKind.CloseBraceToken */:
+            case 4 /* SyntaxKind.CloseBracketToken */: {
+                const kind = token === 2 /* SyntaxKind.CloseBraceToken */ ? 'object' : 'array';
                 if (stack.length > 0 && stack[stack.length - 1].kind === kind) {
-                    var range = stack.pop();
-                    var line = document.positionAt(scanner.getTokenOffset()).line;
+                    const range = stack.pop();
+                    const line = document.positionAt(scanner.getTokenOffset()).line;
                     if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
                         range.endLine = line - 1;
                         addRange(range);
@@ -38,36 +38,36 @@ export function getFoldingRanges(document, context) {
                 }
                 break;
             }
-            case 13 /* BlockCommentTrivia */: {
-                var startLine = document.positionAt(scanner.getTokenOffset()).line;
-                var endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
-                if (scanner.getTokenError() === 1 /* UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {
+            case 13 /* SyntaxKind.BlockCommentTrivia */: {
+                const startLine = document.positionAt(scanner.getTokenOffset()).line;
+                const endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
+                if (scanner.getTokenError() === 1 /* ScanError.UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {
                     scanner.setPosition(document.offsetAt(Position.create(startLine + 1, 0)));
                 }
                 else {
                     if (startLine < endLine) {
-                        addRange({ startLine: startLine, endLine: endLine, kind: FoldingRangeKind.Comment });
+                        addRange({ startLine, endLine, kind: FoldingRangeKind.Comment });
                         prevStart = startLine;
                     }
                 }
                 break;
             }
-            case 12 /* LineCommentTrivia */: {
-                var text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
-                var m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
+            case 12 /* SyntaxKind.LineCommentTrivia */: {
+                const text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
+                const m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
                 if (m) {
-                    var line = document.positionAt(scanner.getTokenOffset()).line;
+                    const line = document.positionAt(scanner.getTokenOffset()).line;
                     if (m[1]) { // start pattern match
-                        var range = { startLine: line, endLine: line, kind: FoldingRangeKind.Region };
+                        const range = { startLine: line, endLine: line, kind: FoldingRangeKind.Region };
                         stack.push(range);
                     }
                     else {
-                        var i = stack.length - 1;
+                        let i = stack.length - 1;
                         while (i >= 0 && stack[i].kind !== FoldingRangeKind.Region) {
                             i--;
                         }
                         if (i >= 0) {
-                            var range = stack[i];
+                            const range = stack[i];
                             stack.length = i;
                             if (line > range.startLine && prevStart !== range.startLine) {
                                 range.endLine = line;
@@ -82,24 +82,23 @@ export function getFoldingRanges(document, context) {
         }
         token = scanner.scan();
     }
-    var rangeLimit = context && context.rangeLimit;
+    const rangeLimit = context && context.rangeLimit;
     if (typeof rangeLimit !== 'number' || ranges.length <= rangeLimit) {
         return ranges;
     }
     if (context && context.onRangeLimitExceeded) {
         context.onRangeLimitExceeded(document.uri);
     }
-    var counts = [];
-    for (var _i = 0, nestingLevels_1 = nestingLevels; _i < nestingLevels_1.length; _i++) {
-        var level = nestingLevels_1[_i];
+    const counts = [];
+    for (let level of nestingLevels) {
         if (level < 30) {
             counts[level] = (counts[level] || 0) + 1;
         }
     }
-    var entries = 0;
-    var maxLevel = 0;
-    for (var i = 0; i < counts.length; i++) {
-        var n = counts[i];
+    let entries = 0;
+    let maxLevel = 0;
+    for (let i = 0; i < counts.length; i++) {
+        const n = counts[i];
         if (n) {
             if (n + entries > rangeLimit) {
                 maxLevel = i;
@@ -108,9 +107,9 @@ export function getFoldingRanges(document, context) {
             entries += n;
         }
     }
-    var result = [];
-    for (var i = 0; i < ranges.length; i++) {
-        var level = nestingLevels[i];
+    const result = [];
+    for (let i = 0; i < ranges.length; i++) {
+        const level = nestingLevels[i];
         if (typeof level === 'number') {
             if (level < maxLevel || (level === maxLevel && entries++ < rangeLimit)) {
                 result.push(ranges[i]);

package/lib/esm/services/jsonHover.js

@@ -4,23 +4,22 @@
  *--------------------------------------------------------------------------------------------*/
 import * as Parser from '../parser/jsonParser';
 import { Range } from '../jsonLanguageTypes';
-var JSONHover = /** @class */ (function () {
-    function JSONHover(schemaService, contributions, promiseConstructor) {
-        if (contributions === void 0) { contributions = []; }
+export class JSONHover {
+    constructor(schemaService, contributions = [], promiseConstructor) {
         this.schemaService = schemaService;
         this.contributions = contributions;
         this.promise = promiseConstructor || Promise;
     }
-    JSONHover.prototype.doHover = function (document, position, doc) {
-        var offset = document.offsetAt(position);
-        var node = doc.getNodeFromOffset(offset);
+    doHover(document, position, doc) {
+        const offset = document.offsetAt(position);
+        let node = doc.getNodeFromOffset(offset);
         if (!node || (node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
             return this.promise.resolve(null);
         }
-        var hoverRangeNode = node;
+        const hoverRangeNode = node;
         // use the property description when hovering over an object key
         if (node.type === 'string') {
-            var parent = node.parent;
+            const parent = node.parent;
             if (parent && parent.type === 'property' && parent.keyNode === node) {
                 node = parent.valueNode;
                 if (!node) {
@@ -28,77 +27,75 @@ var JSONHover = /** @class */ (function () {
                 }
             }
         }
-        var hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-        var createHover = function (contents) {
-            var result = {
+        const hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
+        var createHover = (contents) => {
+            const result = {
                 contents: contents,
                 range: hoverRange
             };
             return result;
         };
-        var location = Parser.getNodePath(node);
-        for (var i = this.contributions.length - 1; i >= 0; i--) {
-            var contribution = this.contributions[i];
-            var promise = contribution.getInfoContribution(document.uri, location);
+        const location = Parser.getNodePath(node);
+        for (let i = this.contributions.length - 1; i >= 0; i--) {
+            const contribution = this.contributions[i];
+            const promise = contribution.getInfoContribution(document.uri, location);
             if (promise) {
-                return promise.then(function (htmlContent) { return createHover(htmlContent); });
+                return promise.then(htmlContent => createHover(htmlContent));
             }
         }
-        return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
+        return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
             if (schema && node) {
-                var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
-                var title_1 = undefined;
-                var markdownDescription_1 = undefined;
-                var markdownEnumValueDescription_1 = undefined, enumValue_1 = undefined;
-                matchingSchemas.every(function (s) {
+                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
+                let title = undefined;
+                let markdownDescription = undefined;
+                let markdownEnumValueDescription = undefined, enumValue = undefined;
+                matchingSchemas.every((s) => {
                     if (s.node === node && !s.inverted && s.schema) {
-                        title_1 = title_1 || s.schema.title;
-                        markdownDescription_1 = markdownDescription_1 || s.schema.markdownDescription || toMarkdown(s.schema.description);
+                        title = title || s.schema.title;
+                        markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown(s.schema.description);
                         if (s.schema.enum) {
-                            var idx = s.schema.enum.indexOf(Parser.getNodeValue(node));
+                            const idx = s.schema.enum.indexOf(Parser.getNodeValue(node));
                             if (s.schema.markdownEnumDescriptions) {
-                                markdownEnumValueDescription_1 = s.schema.markdownEnumDescriptions[idx];
+                                markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
                             }
                             else if (s.schema.enumDescriptions) {
-                                markdownEnumValueDescription_1 = toMarkdown(s.schema.enumDescriptions[idx]);
+                                markdownEnumValueDescription = toMarkdown(s.schema.enumDescriptions[idx]);
                             }
-                            if (markdownEnumValueDescription_1) {
-                                enumValue_1 = s.schema.enum[idx];
-                                if (typeof enumValue_1 !== 'string') {
-                                    enumValue_1 = JSON.stringify(enumValue_1);
+                            if (markdownEnumValueDescription) {
+                                enumValue = s.schema.enum[idx];
+                                if (typeof enumValue !== 'string') {
+                                    enumValue = JSON.stringify(enumValue);
                                 }
                             }
                         }
                     }
                     return true;
                 });
-                var result = '';
-                if (title_1) {
-                    result = toMarkdown(title_1);
+                let result = '';
+                if (title) {
+                    result = toMarkdown(title);
                 }
-                if (markdownDescription_1) {
+                if (markdownDescription) {
                     if (result.length > 0) {
                         result += "\n\n";
                     }
-                    result += markdownDescription_1;
+                    result += markdownDescription;
                 }
-                if (markdownEnumValueDescription_1) {
+                if (markdownEnumValueDescription) {
                     if (result.length > 0) {
                         result += "\n\n";
                     }
-                    result += "`".concat(toMarkdownCodeBlock(enumValue_1), "`: ").concat(markdownEnumValueDescription_1);
+                    result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
                 }
                 return createHover([result]);
             }
             return null;
         });
-    };
-    return JSONHover;
-}());
-export { JSONHover };
+    }
+}
 function toMarkdown(plain) {
     if (plain) {
-        var res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
+        const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
         return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
     }
     return undefined;