vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/umd/services/jsonDocumentSymbols.js

@@ -14,72 +14,68 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONDocumentSymbols = void 0;
-    var Parser = require("../parser/jsonParser");
-    var Strings = require("../utils/strings");
-    var colors_1 = require("../utils/colors");
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var JSONDocumentSymbols = /** @class */ (function () {
-        function JSONDocumentSymbols(schemaService) {
+    const Parser = require("../parser/jsonParser");
+    const Strings = require("../utils/strings");
+    const colors_1 = require("../utils/colors");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    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 = jsonLanguageTypes_1.Location.create(document.uri, getRange(document, item));
-                                    result_1.push({ name: Parser.getNodeValue(property.valueNode), kind: jsonLanguageTypes_1.SymbolKind.Function, location: location });
+                                    const location = jsonLanguageTypes_1.Location.create(document.uri, getRange(document, item));
+                                    result.push({ name: Parser.getNodeValue(property.valueNode), kind: jsonLanguageTypes_1.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 = jsonLanguageTypes_1.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 = jsonLanguageTypes_1.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 {
@@ -91,68 +87,64 @@
             };
             // 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: jsonLanguageTypes_1.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: jsonLanguageTypes_1.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;
@@ -161,15 +153,15 @@
                     });
                 }
                 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 });
                             }
@@ -182,15 +174,15 @@
             };
             // 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 jsonLanguageTypes_1.SymbolKind.Module;
@@ -205,18 +197,18 @@
                 default: // 'null'
                     return jsonLanguageTypes_1.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;
             }
@@ -232,23 +224,22 @@
                 }
             }
             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 = (0, colors_1.colorFromHex)(Parser.getNodeValue(s.node));
+                                const color = (0, colors_1.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--;
@@ -264,26 +255,25 @@
                 }
                 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: jsonLanguageTypes_1.TextEdit.replace(range, JSON.stringify(label)) });
             return result;
-        };
-        return JSONDocumentSymbols;
-    }());
+        }
+    }
     exports.JSONDocumentSymbols = JSONDocumentSymbols;
     function getRange(document, node) {
         return jsonLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));

package/lib/umd/services/jsonFolding.js

@@ -14,34 +14,34 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getFoldingRanges = void 0;
-    var jsonc_parser_1 = require("jsonc-parser");
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    const jsonc_parser_1 = require("jsonc-parser");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
     function getFoldingRanges(document, context) {
-        var ranges = [];
-        var nestingLevels = [];
-        var stack = [];
-        var prevStart = -1;
-        var scanner = (0, jsonc_parser_1.createScanner)(document.getText(), false);
-        var token = scanner.scan();
+        const ranges = [];
+        const nestingLevels = [];
+        const stack = [];
+        let prevStart = -1;
+        const scanner = (0, jsonc_parser_1.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);
@@ -50,36 +50,36 @@
                     }
                     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(jsonLanguageTypes_1.Position.create(startLine + 1, 0)));
                     }
                     else {
                         if (startLine < endLine) {
-                            addRange({ startLine: startLine, endLine: endLine, kind: jsonLanguageTypes_1.FoldingRangeKind.Comment });
+                            addRange({ startLine, endLine, kind: jsonLanguageTypes_1.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: jsonLanguageTypes_1.FoldingRangeKind.Region };
+                            const range = { startLine: line, endLine: line, kind: jsonLanguageTypes_1.FoldingRangeKind.Region };
                             stack.push(range);
                         }
                         else {
-                            var i = stack.length - 1;
+                            let i = stack.length - 1;
                             while (i >= 0 && stack[i].kind !== jsonLanguageTypes_1.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;
@@ -94,24 +94,23 @@
             }
             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;
@@ -120,9 +119,9 @@
                 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/umd/services/jsonHover.js

@@ -14,25 +14,24 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONHover = void 0;
-    var Parser = require("../parser/jsonParser");
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var JSONHover = /** @class */ (function () {
-        function JSONHover(schemaService, contributions, promiseConstructor) {
-            if (contributions === void 0) { contributions = []; }
+    const Parser = require("../parser/jsonParser");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    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) {
@@ -40,77 +39,76 @@
                     }
                 }
             }
-            var hoverRange = jsonLanguageTypes_1.Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-            var createHover = function (contents) {
-                var result = {
+            const hoverRange = jsonLanguageTypes_1.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;
-    }());
+        }
+    }
     exports.JSONHover = 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;