vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/umd/services/jsonCompletion.js

@@ -14,79 +14,75 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONCompletion = void 0;
-    var Parser = require("../parser/jsonParser");
-    var Json = require("jsonc-parser");
-    var json_1 = require("../utils/json");
-    var strings_1 = require("../utils/strings");
-    var objects_1 = require("../utils/objects");
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var nls = require("vscode-nls");
-    var localize = nls.loadMessageBundle();
-    var valueCommitCharacters = [',', '}', ']'];
-    var propertyCommitCharacters = [':'];
-    var JSONCompletion = /** @class */ (function () {
-        function JSONCompletion(schemaService, contributions, promiseConstructor, clientCapabilities) {
-            if (contributions === void 0) { contributions = []; }
-            if (promiseConstructor === void 0) { promiseConstructor = Promise; }
-            if (clientCapabilities === void 0) { clientCapabilities = {}; }
+    const Parser = require("../parser/jsonParser");
+    const Json = require("jsonc-parser");
+    const json_1 = require("../utils/json");
+    const strings_1 = require("../utils/strings");
+    const objects_1 = require("../utils/objects");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    const nls = require("vscode-nls");
+    const localize = nls.loadMessageBundle();
+    const valueCommitCharacters = [',', '}', ']'];
+    const propertyCommitCharacters = [':'];
+    class JSONCompletion {
+        constructor(schemaService, contributions = [], promiseConstructor = Promise, clientCapabilities = {}) {
             this.schemaService = schemaService;
             this.contributions = contributions;
             this.promiseConstructor = promiseConstructor;
             this.clientCapabilities = clientCapabilities;
         }
-        JSONCompletion.prototype.doResolve = function (item) {
-            for (var i = this.contributions.length - 1; i >= 0; i--) {
-                var resolveCompletion = this.contributions[i].resolveCompletion;
+        doResolve(item) {
+            for (let i = this.contributions.length - 1; i >= 0; i--) {
+                const resolveCompletion = this.contributions[i].resolveCompletion;
                 if (resolveCompletion) {
-                    var resolver = resolveCompletion(item);
+                    const resolver = resolveCompletion(item);
                     if (resolver) {
                         return resolver;
                     }
                 }
             }
             return this.promiseConstructor.resolve(item);
-        };
-        JSONCompletion.prototype.doComplete = function (document, position, doc) {
-            var _this = this;
-            var result = {
+        }
+        doComplete(document, position, doc) {
+            const result = {
                 items: [],
                 isIncomplete: false
             };
-            var text = document.getText();
-            var offset = document.offsetAt(position);
-            var node = doc.getNodeFromOffset(offset, true);
+            const text = document.getText();
+            const offset = document.offsetAt(position);
+            let node = doc.getNodeFromOffset(offset, true);
             if (this.isInComment(document, node ? node.offset : 0, offset)) {
                 return Promise.resolve(result);
             }
             if (node && (offset === node.offset + node.length) && offset > 0) {
-                var ch = text[offset - 1];
+                const ch = text[offset - 1];
                 if (node.type === 'object' && ch === '}' || node.type === 'array' && ch === ']') {
                     // after ] or }
                     node = node.parent;
                 }
             }
-            var currentWord = this.getCurrentWord(document, offset);
-            var overwriteRange;
+            const currentWord = this.getCurrentWord(document, offset);
+            let overwriteRange;
             if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
                 overwriteRange = jsonLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
             }
             else {
-                var overwriteStart = offset - currentWord.length;
+                let overwriteStart = offset - currentWord.length;
                 if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
                     overwriteStart--;
                 }
                 overwriteRange = jsonLanguageTypes_1.Range.create(document.positionAt(overwriteStart), position);
             }
-            var supportsCommitCharacters = false; //this.doesSupportsCommitCharacters(); disabled for now, waiting for new API: https://github.com/microsoft/vscode/issues/42544
-            var proposed = {};
-            var collector = {
-                add: function (suggestion) {
-                    var label = suggestion.label;
-                    var existing = proposed[label];
+            const supportsCommitCharacters = false; //this.doesSupportsCommitCharacters(); disabled for now, waiting for new API: https://github.com/microsoft/vscode/issues/42544
+            const proposed = {};
+            const collector = {
+                add: (suggestion) => {
+                    let label = suggestion.label;
+                    const existing = proposed[label];
                     if (!existing) {
                         label = label.replace(/[\n]/g, '↵');
                         if (label.length > 60) {
-                            var shortendedLabel = label.substr(0, 57).trim() + '...';
+                            const shortendedLabel = label.substr(0, 57).trim() + '...';
                             if (!proposed[shortendedLabel]) {
                                 label = shortendedLabel;
                             }
@@ -110,27 +106,27 @@
                         }
                     }
                 },
-                setAsIncomplete: function () {
+                setAsIncomplete: () => {
                     result.isIncomplete = true;
                 },
-                error: function (message) {
+                error: (message) => {
                     console.error(message);
                 },
-                log: function (message) {
+                log: (message) => {
                     console.log(message);
                 },
-                getNumberOfProposals: function () {
+                getNumberOfProposals: () => {
                     return result.items.length;
                 }
             };
-            return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {
-                var collectionPromises = [];
-                var addValue = true;
-                var currentKey = '';
-                var currentProperty = undefined;
+            return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
+                const collectionPromises = [];
+                let addValue = true;
+                let currentKey = '';
+                let currentProperty = undefined;
                 if (node) {
                     if (node.type === 'string') {
-                        var parent = node.parent;
+                        const parent = node.parent;
                         if (parent && parent.type === 'property' && parent.keyNode === node) {
                             addValue = !parent.valueNode;
                             currentProperty = parent;
@@ -148,27 +144,27 @@
                         return result;
                     }
                     // don't suggest properties that are already present
-                    var properties = node.properties;
-                    properties.forEach(function (p) {
+                    const properties = node.properties;
+                    properties.forEach(p => {
                         if (!currentProperty || currentProperty !== p) {
                             proposed[p.keyNode.value] = jsonLanguageTypes_1.CompletionItem.create('__');
                         }
                     });
-                    var separatorAfter_1 = '';
+                    let separatorAfter = '';
                     if (addValue) {
-                        separatorAfter_1 = _this.evaluateSeparatorAfter(document, document.offsetAt(overwriteRange.end));
+                        separatorAfter = this.evaluateSeparatorAfter(document, document.offsetAt(overwriteRange.end));
                     }
                     if (schema) {
                         // property proposals with schema
-                        _this.getPropertyCompletions(schema, doc, node, addValue, separatorAfter_1, collector);
+                        this.getPropertyCompletions(schema, doc, node, addValue, separatorAfter, collector);
                     }
                     else {
                         // property proposals without schema
-                        _this.getSchemaLessPropertyCompletions(doc, node, currentKey, collector);
+                        this.getSchemaLessPropertyCompletions(doc, node, currentKey, collector);
                     }
-                    var location_1 = Parser.getNodePath(node);
-                    _this.contributions.forEach(function (contribution) {
-                        var collectPromise = contribution.collectPropertyCompletions(document.uri, location_1, currentWord, addValue, separatorAfter_1 === '', collector);
+                    const location = Parser.getNodePath(node);
+                    this.contributions.forEach((contribution) => {
+                        const collectPromise = contribution.collectPropertyCompletions(document.uri, location, currentWord, addValue, separatorAfter === '', collector);
                         if (collectPromise) {
                             collectionPromises.push(collectPromise);
                         }
@@ -176,61 +172,60 @@
                     if ((!schema && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"')) {
                         collector.add({
                             kind: jsonLanguageTypes_1.CompletionItemKind.Property,
-                            label: _this.getLabelForValue(currentWord),
-                            insertText: _this.getInsertTextForProperty(currentWord, undefined, false, separatorAfter_1),
+                            label: this.getLabelForValue(currentWord),
+                            insertText: this.getInsertTextForProperty(currentWord, undefined, false, separatorAfter),
                             insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet, documentation: '',
                         });
                         collector.setAsIncomplete();
                     }
                 }
                 // proposals for values
-                var types = {};
+                const types = {};
                 if (schema) {
                     // value proposals with schema
-                    _this.getValueCompletions(schema, doc, node, offset, document, collector, types);
+                    this.getValueCompletions(schema, doc, node, offset, document, collector, types);
                 }
                 else {
                     // value proposals without schema
-                    _this.getSchemaLessValueCompletions(doc, node, offset, document, collector);
+                    this.getSchemaLessValueCompletions(doc, node, offset, document, collector);
                 }
-                if (_this.contributions.length > 0) {
-                    _this.getContributedValueCompletions(doc, node, offset, document, collector, collectionPromises);
+                if (this.contributions.length > 0) {
+                    this.getContributedValueCompletions(doc, node, offset, document, collector, collectionPromises);
                 }
-                return _this.promiseConstructor.all(collectionPromises).then(function () {
+                return this.promiseConstructor.all(collectionPromises).then(() => {
                     if (collector.getNumberOfProposals() === 0) {
-                        var offsetForSeparator = offset;
+                        let offsetForSeparator = offset;
                         if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
                             offsetForSeparator = node.offset + node.length;
                         }
-                        var separatorAfter = _this.evaluateSeparatorAfter(document, offsetForSeparator);
-                        _this.addFillerValueCompletions(types, separatorAfter, collector);
+                        const separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
+                        this.addFillerValueCompletions(types, separatorAfter, collector);
                     }
                     return result;
                 });
             });
-        };
-        JSONCompletion.prototype.getPropertyCompletions = function (schema, doc, node, addValue, separatorAfter, collector) {
-            var _this = this;
-            var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
-            matchingSchemas.forEach(function (s) {
+        }
+        getPropertyCompletions(schema, doc, node, addValue, separatorAfter, collector) {
+            const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
+            matchingSchemas.forEach((s) => {
                 if (s.node === node && !s.inverted) {
-                    var schemaProperties_1 = s.schema.properties;
-                    if (schemaProperties_1) {
-                        Object.keys(schemaProperties_1).forEach(function (key) {
-                            var propertySchema = schemaProperties_1[key];
+                    const schemaProperties = s.schema.properties;
+                    if (schemaProperties) {
+                        Object.keys(schemaProperties).forEach((key) => {
+                            const propertySchema = schemaProperties[key];
                             if (typeof propertySchema === 'object' && !propertySchema.deprecationMessage && !propertySchema.doNotSuggest) {
-                                var proposal = {
+                                const proposal = {
                                     kind: jsonLanguageTypes_1.CompletionItemKind.Property,
                                     label: key,
-                                    insertText: _this.getInsertTextForProperty(key, propertySchema, addValue, separatorAfter),
+                                    insertText: this.getInsertTextForProperty(key, propertySchema, addValue, separatorAfter),
                                     insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
-                                    filterText: _this.getFilterTextForValue(key),
-                                    documentation: _this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
+                                    filterText: this.getFilterTextForValue(key),
+                                    documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',
                                 };
                                 if (propertySchema.suggestSortText !== undefined) {
                                     proposal.sortText = propertySchema.suggestSortText;
                                 }
-                                if (proposal.insertText && (0, strings_1.endsWith)(proposal.insertText, "$1".concat(separatorAfter))) {
+                                if (proposal.insertText && (0, strings_1.endsWith)(proposal.insertText, `$1${separatorAfter}`)) {
                                     proposal.command = {
                                         title: 'Suggest',
                                         command: 'editor.action.triggerSuggest'
@@ -240,22 +235,21 @@
                             }
                         });
                     }
-                    var schemaPropertyNames_1 = s.schema.propertyNames;
-                    if (typeof schemaPropertyNames_1 === 'object' && !schemaPropertyNames_1.deprecationMessage && !schemaPropertyNames_1.doNotSuggest) {
-                        var propertyNameCompletionItem = function (name, enumDescription) {
-                            if (enumDescription === void 0) { enumDescription = undefined; }
-                            var proposal = {
+                    const schemaPropertyNames = s.schema.propertyNames;
+                    if (typeof schemaPropertyNames === 'object' && !schemaPropertyNames.deprecationMessage && !schemaPropertyNames.doNotSuggest) {
+                        const propertyNameCompletionItem = (name, enumDescription = undefined) => {
+                            const proposal = {
                                 kind: jsonLanguageTypes_1.CompletionItemKind.Property,
                                 label: name,
-                                insertText: _this.getInsertTextForProperty(name, undefined, addValue, separatorAfter),
+                                insertText: this.getInsertTextForProperty(name, undefined, addValue, separatorAfter),
                                 insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
-                                filterText: _this.getFilterTextForValue(name),
-                                documentation: enumDescription || _this.fromMarkup(schemaPropertyNames_1.markdownDescription) || schemaPropertyNames_1.description || '',
+                                filterText: this.getFilterTextForValue(name),
+                                documentation: enumDescription || this.fromMarkup(schemaPropertyNames.markdownDescription) || schemaPropertyNames.description || '',
                             };
-                            if (schemaPropertyNames_1.suggestSortText !== undefined) {
-                                proposal.sortText = schemaPropertyNames_1.suggestSortText;
+                            if (schemaPropertyNames.suggestSortText !== undefined) {
+                                proposal.sortText = schemaPropertyNames.suggestSortText;
                             }
-                            if (proposal.insertText && (0, strings_1.endsWith)(proposal.insertText, "$1".concat(separatorAfter))) {
+                            if (proposal.insertText && (0, strings_1.endsWith)(proposal.insertText, `$1${separatorAfter}`)) {
                                 proposal.command = {
                                     title: 'Suggest',
                                     command: 'editor.action.triggerSuggest'
@@ -263,36 +257,35 @@
                             }
                             collector.add(proposal);
                         };
-                        if (schemaPropertyNames_1.enum) {
-                            for (var i = 0; i < schemaPropertyNames_1.enum.length; i++) {
-                                var enumDescription = undefined;
-                                if (schemaPropertyNames_1.markdownEnumDescriptions && i < schemaPropertyNames_1.markdownEnumDescriptions.length) {
-                                    enumDescription = _this.fromMarkup(schemaPropertyNames_1.markdownEnumDescriptions[i]);
+                        if (schemaPropertyNames.enum) {
+                            for (let i = 0; i < schemaPropertyNames.enum.length; i++) {
+                                let enumDescription = undefined;
+                                if (schemaPropertyNames.markdownEnumDescriptions && i < schemaPropertyNames.markdownEnumDescriptions.length) {
+                                    enumDescription = this.fromMarkup(schemaPropertyNames.markdownEnumDescriptions[i]);
                                 }
-                                else if (schemaPropertyNames_1.enumDescriptions && i < schemaPropertyNames_1.enumDescriptions.length) {
-                                    enumDescription = schemaPropertyNames_1.enumDescriptions[i];
+                                else if (schemaPropertyNames.enumDescriptions && i < schemaPropertyNames.enumDescriptions.length) {
+                                    enumDescription = schemaPropertyNames.enumDescriptions[i];
                                 }
-                                propertyNameCompletionItem(schemaPropertyNames_1.enum[i], enumDescription);
+                                propertyNameCompletionItem(schemaPropertyNames.enum[i], enumDescription);
                             }
                         }
-                        if (schemaPropertyNames_1.const) {
-                            propertyNameCompletionItem(schemaPropertyNames_1.const);
+                        if (schemaPropertyNames.const) {
+                            propertyNameCompletionItem(schemaPropertyNames.const);
                         }
                     }
                 }
             });
-        };
-        JSONCompletion.prototype.getSchemaLessPropertyCompletions = function (doc, node, currentKey, collector) {
-            var _this = this;
-            var collectCompletionsForSimilarObject = function (obj) {
-                obj.properties.forEach(function (p) {
-                    var key = p.keyNode.value;
+        }
+        getSchemaLessPropertyCompletions(doc, node, currentKey, collector) {
+            const collectCompletionsForSimilarObject = (obj) => {
+                obj.properties.forEach((p) => {
+                    const key = p.keyNode.value;
                     collector.add({
                         kind: jsonLanguageTypes_1.CompletionItemKind.Property,
                         label: key,
-                        insertText: _this.getInsertTextForValue(key, ''),
+                        insertText: this.getInsertTextForValue(key, ''),
                         insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
-                        filterText: _this.getFilterTextForValue(key),
+                        filterText: this.getFilterTextForValue(key),
                         documentation: ''
                     });
                 });
@@ -300,9 +293,9 @@
             if (node.parent) {
                 if (node.parent.type === 'property') {
                     // if the object is a property value, check the tree for other objects that hang under a property of the same name
-                    var parentKey_1 = node.parent.keyNode.value;
-                    doc.visit(function (n) {
-                        if (n.type === 'property' && n !== node.parent && n.keyNode.value === parentKey_1 && n.valueNode && n.valueNode.type === 'object') {
+                    const parentKey = node.parent.keyNode.value;
+                    doc.visit(n => {
+                        if (n.type === 'property' && n !== node.parent && n.keyNode.value === parentKey && n.valueNode && n.valueNode.type === 'object') {
                             collectCompletionsForSimilarObject(n.valueNode);
                         }
                         return true;
@@ -310,7 +303,7 @@
                 }
                 else if (node.parent.type === 'array') {
                     // if the object is in an array, use all other array elements as similar objects
-                    node.parent.items.forEach(function (n) {
+                    node.parent.items.forEach(n => {
                         if (n.type === 'object' && n !== node) {
                             collectCompletionsForSimilarObject(n);
                         }
@@ -326,10 +319,9 @@
                     filterText: this.getFilterTextForValue("$schema")
                 });
             }
-        };
-        JSONCompletion.prototype.getSchemaLessValueCompletions = function (doc, node, offset, document, collector) {
-            var _this = this;
-            var offsetForSeparator = offset;
+        }
+        getSchemaLessValueCompletions(doc, node, offset, document, collector) {
+            let offsetForSeparator = offset;
             if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
                 offsetForSeparator = node.offset + node.length;
                 node = node.parent;
@@ -351,35 +343,35 @@
                 });
                 return;
             }
-            var separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
-            var collectSuggestionsForValues = function (value) {
+            const separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
+            const collectSuggestionsForValues = (value) => {
                 if (value.parent && !Parser.contains(value.parent, offset, true)) {
                     collector.add({
-                        kind: _this.getSuggestionKind(value.type),
-                        label: _this.getLabelTextForMatchingNode(value, document),
-                        insertText: _this.getInsertTextForMatchingNode(value, document, separatorAfter),
+                        kind: this.getSuggestionKind(value.type),
+                        label: this.getLabelTextForMatchingNode(value, document),
+                        insertText: this.getInsertTextForMatchingNode(value, document, separatorAfter),
                         insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet, documentation: ''
                     });
                 }
                 if (value.type === 'boolean') {
-                    _this.addBooleanValueCompletion(!value.value, separatorAfter, collector);
+                    this.addBooleanValueCompletion(!value.value, separatorAfter, collector);
                 }
             };
             if (node.type === 'property') {
                 if (offset > (node.colonOffset || 0)) {
-                    var valueNode = node.valueNode;
+                    const valueNode = node.valueNode;
                     if (valueNode && (offset > (valueNode.offset + valueNode.length) || valueNode.type === 'object' || valueNode.type === 'array')) {
                         return;
                     }
                     // suggest values at the same key
-                    var parentKey_2 = node.keyNode.value;
-                    doc.visit(function (n) {
-                        if (n.type === 'property' && n.keyNode.value === parentKey_2 && n.valueNode) {
+                    const parentKey = node.keyNode.value;
+                    doc.visit(n => {
+                        if (n.type === 'property' && n.keyNode.value === parentKey && n.valueNode) {
                             collectSuggestionsForValues(n.valueNode);
                         }
                         return true;
                     });
-                    if (parentKey_2 === '$schema' && node.parent && !node.parent.parent) {
+                    if (parentKey === '$schema' && node.parent && !node.parent.parent) {
                         this.addDollarSchemaCompletions(separatorAfter, collector);
                     }
                 }
@@ -387,9 +379,9 @@
             if (node.type === 'array') {
                 if (node.parent && node.parent.type === 'property') {
                     // suggest items of an array at the same key
-                    var parentKey_3 = node.parent.keyNode.value;
-                    doc.visit(function (n) {
-                        if (n.type === 'property' && n.keyNode.value === parentKey_3 && n.valueNode && n.valueNode.type === 'array') {
+                    const parentKey = node.parent.keyNode.value;
+                    doc.visit((n) => {
+                        if (n.type === 'property' && n.keyNode.value === parentKey && n.valueNode && n.valueNode.type === 'array') {
                             n.valueNode.items.forEach(collectSuggestionsForValues);
                         }
                         return true;
@@ -400,11 +392,11 @@
                     node.items.forEach(collectSuggestionsForValues);
                 }
             }
-        };
-        JSONCompletion.prototype.getValueCompletions = function (schema, doc, node, offset, document, collector, types) {
-            var offsetForSeparator = offset;
-            var parentKey = undefined;
-            var valueNode = undefined;
+        }
+        getValueCompletions(schema, doc, node, offset, document, collector, types) {
+            let offsetForSeparator = offset;
+            let parentKey = undefined;
+            let valueNode = undefined;
             if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {
                 offsetForSeparator = node.offset + node.length;
                 valueNode = node;
@@ -415,22 +407,21 @@
                 return;
             }
             if ((node.type === 'property') && offset > (node.colonOffset || 0)) {
-                var valueNode_1 = node.valueNode;
-                if (valueNode_1 && offset > (valueNode_1.offset + valueNode_1.length)) {
+                const valueNode = node.valueNode;
+                if (valueNode && offset > (valueNode.offset + valueNode.length)) {
                     return; // we are past the value node
                 }
                 parentKey = node.keyNode.value;
                 node = node.parent;
             }
             if (node && (parentKey !== undefined || node.type === 'array')) {
-                var separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
-                var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset, valueNode);
-                for (var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++) {
-                    var s = matchingSchemas_1[_i];
+                const separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
+                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset, valueNode);
+                for (const s of matchingSchemas) {
                     if (s.node === node && !s.inverted && s.schema) {
                         if (node.type === 'array' && s.schema.items) {
                             if (Array.isArray(s.schema.items)) {
-                                var index = this.findItemAtOffset(node, document, offset);
+                                const index = this.findItemAtOffset(node, document, offset);
                                 if (index < s.schema.items.length) {
                                     this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types);
                                 }
@@ -440,27 +431,26 @@
                             }
                         }
                         if (parentKey !== undefined) {
-                            var propertyMatched = false;
+                            let propertyMatched = false;
                             if (s.schema.properties) {
-                                var propertySchema = s.schema.properties[parentKey];
+                                const propertySchema = s.schema.properties[parentKey];
                                 if (propertySchema) {
                                     propertyMatched = true;
                                     this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                                 }
                             }
                             if (s.schema.patternProperties && !propertyMatched) {
-                                for (var _a = 0, _b = Object.keys(s.schema.patternProperties); _a < _b.length; _a++) {
-                                    var pattern = _b[_a];
-                                    var regex = (0, strings_1.extendedRegExp)(pattern);
-                                    if (regex === null || regex === void 0 ? void 0 : regex.test(parentKey)) {
+                                for (const pattern of Object.keys(s.schema.patternProperties)) {
+                                    const regex = (0, strings_1.extendedRegExp)(pattern);
+                                    if (regex?.test(parentKey)) {
                                         propertyMatched = true;
-                                        var propertySchema = s.schema.patternProperties[pattern];
+                                        const propertySchema = s.schema.patternProperties[pattern];
                                         this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                                     }
                                 }
                             }
                             if (s.schema.additionalProperties && !propertyMatched) {
-                                var propertySchema = s.schema.additionalProperties;
+                                const propertySchema = s.schema.additionalProperties;
                                 this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                             }
                         }
@@ -477,11 +467,11 @@
                     this.addNullValueCompletion(separatorAfter, collector);
                 }
             }
-        };
-        JSONCompletion.prototype.getContributedValueCompletions = function (doc, node, offset, document, collector, collectionPromises) {
+        }
+        getContributedValueCompletions(doc, node, offset, document, collector, collectionPromises) {
             if (!node) {
-                this.contributions.forEach(function (contribution) {
-                    var collectPromise = contribution.collectDefaultCompletions(document.uri, collector);
+                this.contributions.forEach((contribution) => {
+                    const collectPromise = contribution.collectDefaultCompletions(document.uri, collector);
                     if (collectPromise) {
                         collectionPromises.push(collectPromise);
                     }
@@ -492,12 +482,12 @@
                     node = node.parent;
                 }
                 if (node && (node.type === 'property') && offset > (node.colonOffset || 0)) {
-                    var parentKey_4 = node.keyNode.value;
-                    var valueNode = node.valueNode;
+                    const parentKey = node.keyNode.value;
+                    const valueNode = node.valueNode;
                     if ((!valueNode || offset <= (valueNode.offset + valueNode.length)) && node.parent) {
-                        var location_2 = Parser.getNodePath(node.parent);
-                        this.contributions.forEach(function (contribution) {
-                            var collectPromise = contribution.collectValueCompletions(document.uri, location_2, parentKey_4, collector);
+                        const location = Parser.getNodePath(node.parent);
+                        this.contributions.forEach((contribution) => {
+                            const collectPromise = contribution.collectValueCompletions(document.uri, location, parentKey, collector);
                             if (collectPromise) {
                                 collectionPromises.push(collectPromise);
                             }
@@ -505,32 +495,29 @@
                     }
                 }
             }
-        };
-        JSONCompletion.prototype.addSchemaValueCompletions = function (schema, separatorAfter, collector, types) {
-            var _this = this;
+        }
+        addSchemaValueCompletions(schema, separatorAfter, collector, types) {
             if (typeof schema === 'object') {
                 this.addEnumValueCompletions(schema, separatorAfter, collector);
                 this.addDefaultValueCompletions(schema, separatorAfter, collector);
                 this.collectTypes(schema, types);
                 if (Array.isArray(schema.allOf)) {
-                    schema.allOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });
+                    schema.allOf.forEach(s => this.addSchemaValueCompletions(s, separatorAfter, collector, types));
                 }
                 if (Array.isArray(schema.anyOf)) {
-                    schema.anyOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });
+                    schema.anyOf.forEach(s => this.addSchemaValueCompletions(s, separatorAfter, collector, types));
                 }
                 if (Array.isArray(schema.oneOf)) {
-                    schema.oneOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });
+                    schema.oneOf.forEach(s => this.addSchemaValueCompletions(s, separatorAfter, collector, types));
                 }
             }
-        };
-        JSONCompletion.prototype.addDefaultValueCompletions = function (schema, separatorAfter, collector, arrayDepth) {
-            var _this = this;
-            if (arrayDepth === void 0) { arrayDepth = 0; }
-            var hasProposals = false;
+        }
+        addDefaultValueCompletions(schema, separatorAfter, collector, arrayDepth = 0) {
+            let hasProposals = false;
             if ((0, objects_1.isDefined)(schema.default)) {
-                var type = schema.type;
-                var value = schema.default;
-                for (var i = arrayDepth; i > 0; i--) {
+                let type = schema.type;
+                let value = schema.default;
+                for (let i = arrayDepth; i > 0; i--) {
                     value = [value];
                     type = 'array';
                 }
@@ -544,42 +531,42 @@
                 hasProposals = true;
             }
             if (Array.isArray(schema.examples)) {
-                schema.examples.forEach(function (example) {
-                    var type = schema.type;
-                    var value = example;
-                    for (var i = arrayDepth; i > 0; i--) {
+                schema.examples.forEach(example => {
+                    let type = schema.type;
+                    let value = example;
+                    for (let i = arrayDepth; i > 0; i--) {
                         value = [value];
                         type = 'array';
                     }
                     collector.add({
-                        kind: _this.getSuggestionKind(type),
-                        label: _this.getLabelForValue(value),
-                        insertText: _this.getInsertTextForValue(value, separatorAfter),
+                        kind: this.getSuggestionKind(type),
+                        label: this.getLabelForValue(value),
+                        insertText: this.getInsertTextForValue(value, separatorAfter),
                         insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet
                     });
                     hasProposals = true;
                 });
             }
             if (Array.isArray(schema.defaultSnippets)) {
-                schema.defaultSnippets.forEach(function (s) {
-                    var type = schema.type;
-                    var value = s.body;
-                    var label = s.label;
-                    var insertText;
-                    var filterText;
+                schema.defaultSnippets.forEach(s => {
+                    let type = schema.type;
+                    let value = s.body;
+                    let label = s.label;
+                    let insertText;
+                    let filterText;
                     if ((0, objects_1.isDefined)(value)) {
-                        var type_1 = schema.type;
-                        for (var i = arrayDepth; i > 0; i--) {
+                        let type = schema.type;
+                        for (let i = arrayDepth; i > 0; i--) {
                             value = [value];
-                            type_1 = 'array';
+                            type = 'array';
                         }
-                        insertText = _this.getInsertTextForSnippetValue(value, separatorAfter);
-                        filterText = _this.getFilterTextForSnippetValue(value);
-                        label = label || _this.getLabelForSnippetValue(value);
+                        insertText = this.getInsertTextForSnippetValue(value, separatorAfter);
+                        filterText = this.getFilterTextForSnippetValue(value);
+                        label = label || this.getLabelForSnippetValue(value);
                     }
                     else if (typeof s.bodyText === 'string') {
-                        var prefix = '', suffix = '', indent = '';
-                        for (var i = arrayDepth; i > 0; i--) {
+                        let prefix = '', suffix = '', indent = '';
+                        for (let i = arrayDepth; i > 0; i--) {
                             prefix = prefix + indent + '[\n';
                             suffix = suffix + '\n' + indent + ']';
                             indent += '\t';
@@ -593,12 +580,12 @@
                         return;
                     }
                     collector.add({
-                        kind: _this.getSuggestionKind(type),
-                        label: label,
-                        documentation: _this.fromMarkup(s.markdownDescription) || s.description,
-                        insertText: insertText,
+                        kind: this.getSuggestionKind(type),
+                        label,
+                        documentation: this.fromMarkup(s.markdownDescription) || s.description,
+                        insertText,
                         insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
-                        filterText: filterText
+                        filterText
                     });
                     hasProposals = true;
                 });
@@ -606,8 +593,8 @@
             if (!hasProposals && typeof schema.items === 'object' && !Array.isArray(schema.items) && arrayDepth < 5 /* beware of recursion */) {
                 this.addDefaultValueCompletions(schema.items, separatorAfter, collector, arrayDepth + 1);
             }
-        };
-        JSONCompletion.prototype.addEnumValueCompletions = function (schema, separatorAfter, collector) {
+        }
+        addEnumValueCompletions(schema, separatorAfter, collector) {
             if ((0, objects_1.isDefined)(schema.const)) {
                 collector.add({
                     kind: this.getSuggestionKind(schema.type),
@@ -618,9 +605,9 @@
                 });
             }
             if (Array.isArray(schema.enum)) {
-                for (var i = 0, length = schema.enum.length; i < length; i++) {
-                    var enm = schema.enum[i];
-                    var documentation = this.fromMarkup(schema.markdownDescription) || schema.description;
+                for (let i = 0, length = schema.enum.length; i < length; i++) {
+                    const enm = schema.enum[i];
+                    let documentation = this.fromMarkup(schema.markdownDescription) || schema.description;
                     if (schema.markdownEnumDescriptions && i < schema.markdownEnumDescriptions.length && this.doesSupportMarkdown()) {
                         documentation = this.fromMarkup(schema.markdownEnumDescriptions[i]);
                     }
@@ -632,24 +619,24 @@
                         label: this.getLabelForValue(enm),
                         insertText: this.getInsertTextForValue(enm, separatorAfter),
                         insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
-                        documentation: documentation
+                        documentation
                     });
                 }
             }
-        };
-        JSONCompletion.prototype.collectTypes = function (schema, types) {
+        }
+        collectTypes(schema, types) {
             if (Array.isArray(schema.enum) || (0, objects_1.isDefined)(schema.const)) {
                 return;
             }
-            var type = schema.type;
+            const type = schema.type;
             if (Array.isArray(type)) {
-                type.forEach(function (t) { return types[t] = true; });
+                type.forEach(t => types[t] = true);
             }
             else if (type) {
                 types[type] = true;
             }
-        };
-        JSONCompletion.prototype.addFillerValueCompletions = function (types, separatorAfter, collector) {
+        }
+        addFillerValueCompletions(types, separatorAfter, collector) {
             if (types['object']) {
                 collector.add({
                     kind: this.getSuggestionKind('object'),
@@ -670,8 +657,8 @@
                     documentation: ''
                 });
             }
-        };
-        JSONCompletion.prototype.addBooleanValueCompletion = function (value, separatorAfter, collector) {
+        }
+        addBooleanValueCompletion(value, separatorAfter, collector) {
             collector.add({
                 kind: this.getSuggestionKind('boolean'),
                 label: value ? 'true' : 'false',
@@ -679,8 +666,8 @@
                 insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
                 documentation: ''
             });
-        };
-        JSONCompletion.prototype.addNullValueCompletion = function (separatorAfter, collector) {
+        }
+        addNullValueCompletion(separatorAfter, collector) {
             collector.add({
                 kind: this.getSuggestionKind('null'),
                 label: 'null',
@@ -688,35 +675,34 @@
                 insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet,
                 documentation: ''
             });
-        };
-        JSONCompletion.prototype.addDollarSchemaCompletions = function (separatorAfter, collector) {
-            var _this = this;
-            var schemaIds = this.schemaService.getRegisteredSchemaIds(function (schema) { return schema === 'http' || schema === 'https'; });
-            schemaIds.forEach(function (schemaId) { return collector.add({
+        }
+        addDollarSchemaCompletions(separatorAfter, collector) {
+            const schemaIds = this.schemaService.getRegisteredSchemaIds(schema => schema === 'http' || schema === 'https');
+            schemaIds.forEach(schemaId => collector.add({
                 kind: jsonLanguageTypes_1.CompletionItemKind.Module,
-                label: _this.getLabelForValue(schemaId),
-                filterText: _this.getFilterTextForValue(schemaId),
-                insertText: _this.getInsertTextForValue(schemaId, separatorAfter),
+                label: this.getLabelForValue(schemaId),
+                filterText: this.getFilterTextForValue(schemaId),
+                insertText: this.getInsertTextForValue(schemaId, separatorAfter),
                 insertTextFormat: jsonLanguageTypes_1.InsertTextFormat.Snippet, documentation: ''
-            }); });
-        };
-        JSONCompletion.prototype.getLabelForValue = function (value) {
+            }));
+        }
+        getLabelForValue(value) {
             return JSON.stringify(value);
-        };
-        JSONCompletion.prototype.getFilterTextForValue = function (value) {
+        }
+        getFilterTextForValue(value) {
             return JSON.stringify(value);
-        };
-        JSONCompletion.prototype.getFilterTextForSnippetValue = function (value) {
+        }
+        getFilterTextForSnippetValue(value) {
             return JSON.stringify(value).replace(/\$\{\d+:([^}]+)\}|\$\d+/g, '$1');
-        };
-        JSONCompletion.prototype.getLabelForSnippetValue = function (value) {
-            var label = JSON.stringify(value);
+        }
+        getLabelForSnippetValue(value) {
+            const label = JSON.stringify(value);
             return label.replace(/\$\{\d+:([^}]+)\}|\$\d+/g, '$1');
-        };
-        JSONCompletion.prototype.getInsertTextForPlainText = function (text) {
+        }
+        getInsertTextForPlainText(text) {
             return text.replace(/[\\\$\}]/g, '\\$&'); // escape $, \ and } 
-        };
-        JSONCompletion.prototype.getInsertTextForValue = function (value, separatorAfter) {
+        }
+        getInsertTextForValue(value, separatorAfter) {
             var text = JSON.stringify(value, null, '\t');
             if (text === '{}') {
                 return '{$1}' + separatorAfter;
@@ -725,9 +711,9 @@
                 return '[$1]' + separatorAfter;
             }
             return this.getInsertTextForPlainText(text + separatorAfter);
-        };
-        JSONCompletion.prototype.getInsertTextForSnippetValue = function (value, separatorAfter) {
-            var replacer = function (value) {
+        }
+        getInsertTextForSnippetValue(value, separatorAfter) {
+            const replacer = (value) => {
                 if (typeof value === 'string') {
                     if (value[0] === '^') {
                         return value.substr(1);
@@ -736,8 +722,8 @@
                 return JSON.stringify(value);
             };
             return (0, json_1.stringifyObject)(value, '', replacer) + separatorAfter;
-        };
-        JSONCompletion.prototype.getInsertTextForGuessedValue = function (value, separatorAfter) {
+        }
+        getInsertTextForGuessedValue(value, separatorAfter) {
             switch (typeof value) {
                 case 'object':
                     if (value === null) {
@@ -745,7 +731,7 @@
                     }
                     return this.getInsertTextForValue(value, separatorAfter);
                 case 'string':
-                    var snippetValue = JSON.stringify(value);
+                    let snippetValue = JSON.stringify(value);
                     snippetValue = snippetValue.substr(1, snippetValue.length - 2); // remove quotes
                     snippetValue = this.getInsertTextForPlainText(snippetValue); // escape \ and }
                     return '"${1:' + snippetValue + '}"' + separatorAfter;
@@ -754,10 +740,10 @@
                     return '${1:' + JSON.stringify(value) + '}' + separatorAfter;
             }
             return this.getInsertTextForValue(value, separatorAfter);
-        };
-        JSONCompletion.prototype.getSuggestionKind = function (type) {
+        }
+        getSuggestionKind(type) {
             if (Array.isArray(type)) {
-                var array = type;
+                const array = type;
                 type = array.length > 0 ? array[0] : undefined;
             }
             if (!type) {
@@ -769,41 +755,41 @@
                 case 'property': return jsonLanguageTypes_1.CompletionItemKind.Property;
                 default: return jsonLanguageTypes_1.CompletionItemKind.Value;
             }
-        };
-        JSONCompletion.prototype.getLabelTextForMatchingNode = function (node, document) {
+        }
+        getLabelTextForMatchingNode(node, document) {
             switch (node.type) {
                 case 'array':
                     return '[]';
                 case 'object':
                     return '{}';
                 default:
-                    var content = document.getText().substr(node.offset, node.length);
+                    const content = document.getText().substr(node.offset, node.length);
                     return content;
             }
-        };
-        JSONCompletion.prototype.getInsertTextForMatchingNode = function (node, document, separatorAfter) {
+        }
+        getInsertTextForMatchingNode(node, document, separatorAfter) {
             switch (node.type) {
                 case 'array':
                     return this.getInsertTextForValue([], separatorAfter);
                 case 'object':
                     return this.getInsertTextForValue({}, separatorAfter);
                 default:
-                    var content = document.getText().substr(node.offset, node.length) + separatorAfter;
+                    const content = document.getText().substr(node.offset, node.length) + separatorAfter;
                     return this.getInsertTextForPlainText(content);
             }
-        };
-        JSONCompletion.prototype.getInsertTextForProperty = function (key, propertySchema, addValue, separatorAfter) {
-            var propertyText = this.getInsertTextForValue(key, '');
+        }
+        getInsertTextForProperty(key, propertySchema, addValue, separatorAfter) {
+            const propertyText = this.getInsertTextForValue(key, '');
             if (!addValue) {
                 return propertyText;
             }
-            var resultText = propertyText + ': ';
-            var value;
-            var nValueProposals = 0;
+            const resultText = propertyText + ': ';
+            let value;
+            let nValueProposals = 0;
             if (propertySchema) {
                 if (Array.isArray(propertySchema.defaultSnippets)) {
                     if (propertySchema.defaultSnippets.length === 1) {
-                        var body = propertySchema.defaultSnippets[0].body;
+                        const body = propertySchema.defaultSnippets[0].body;
                         if ((0, objects_1.isDefined)(body)) {
                             value = this.getInsertTextForSnippetValue(body, '');
                         }
@@ -816,6 +802,12 @@
                     }
                     nValueProposals += propertySchema.enum.length;
                 }
+                if ((0, objects_1.isDefined)(propertySchema.const)) {
+                    if (!value) {
+                        value = this.getInsertTextForGuessedValue(propertySchema.const, '');
+                    }
+                    nValueProposals++;
+                }
                 if ((0, objects_1.isDefined)(propertySchema.default)) {
                     if (!value) {
                         value = this.getInsertTextForGuessedValue(propertySchema.default, '');
@@ -867,38 +859,38 @@
                 value = '$1';
             }
             return resultText + value + separatorAfter;
-        };
-        JSONCompletion.prototype.getCurrentWord = function (document, offset) {
+        }
+        getCurrentWord(document, offset) {
             var i = offset - 1;
             var text = document.getText();
             while (i >= 0 && ' \t\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1) {
                 i--;
             }
             return text.substring(i + 1, offset);
-        };
-        JSONCompletion.prototype.evaluateSeparatorAfter = function (document, offset) {
-            var scanner = Json.createScanner(document.getText(), true);
+        }
+        evaluateSeparatorAfter(document, offset) {
+            const scanner = Json.createScanner(document.getText(), true);
             scanner.setPosition(offset);
-            var token = scanner.scan();
+            const token = scanner.scan();
             switch (token) {
-                case 5 /* CommaToken */:
-                case 2 /* CloseBraceToken */:
-                case 4 /* CloseBracketToken */:
-                case 17 /* EOF */:
+                case 5 /* Json.SyntaxKind.CommaToken */:
+                case 2 /* Json.SyntaxKind.CloseBraceToken */:
+                case 4 /* Json.SyntaxKind.CloseBracketToken */:
+                case 17 /* Json.SyntaxKind.EOF */:
                     return '';
                 default:
                     return ',';
             }
-        };
-        JSONCompletion.prototype.findItemAtOffset = function (node, document, offset) {
-            var scanner = Json.createScanner(document.getText(), true);
-            var children = node.items;
-            for (var i = children.length - 1; i >= 0; i--) {
-                var child = children[i];
+        }
+        findItemAtOffset(node, document, offset) {
+            const scanner = Json.createScanner(document.getText(), true);
+            const children = node.items;
+            for (let i = children.length - 1; i >= 0; i--) {
+                const child = children[i];
                 if (offset > child.offset + child.length) {
                     scanner.setPosition(child.offset + child.length);
-                    var token = scanner.scan();
-                    if (token === 5 /* CommaToken */ && offset >= scanner.getTokenOffset() + scanner.getTokenLength()) {
+                    const token = scanner.scan();
+                    if (token === 5 /* Json.SyntaxKind.CommaToken */ && offset >= scanner.getTokenOffset() + scanner.getTokenLength()) {
                         return i + 1;
                     }
                     return i;
@@ -908,17 +900,17 @@
                 }
             }
             return 0;
-        };
-        JSONCompletion.prototype.isInComment = function (document, start, offset) {
-            var scanner = Json.createScanner(document.getText(), false);
+        }
+        isInComment(document, start, offset) {
+            const scanner = Json.createScanner(document.getText(), false);
             scanner.setPosition(start);
-            var token = scanner.scan();
-            while (token !== 17 /* EOF */ && (scanner.getTokenOffset() + scanner.getTokenLength() < offset)) {
+            let token = scanner.scan();
+            while (token !== 17 /* Json.SyntaxKind.EOF */ && (scanner.getTokenOffset() + scanner.getTokenLength() < offset)) {
                 token = scanner.scan();
             }
-            return (token === 12 /* LineCommentTrivia */ || token === 13 /* BlockCommentTrivia */) && scanner.getTokenOffset() <= offset;
-        };
-        JSONCompletion.prototype.fromMarkup = function (markupString) {
+            return (token === 12 /* Json.SyntaxKind.LineCommentTrivia */ || token === 13 /* Json.SyntaxKind.BlockCommentTrivia */) && scanner.getTokenOffset() <= offset;
+        }
+        fromMarkup(markupString) {
             if (markupString && this.doesSupportMarkdown()) {
                 return {
                     kind: jsonLanguageTypes_1.MarkupKind.Markdown,
@@ -926,22 +918,21 @@
                 };
             }
             return undefined;
-        };
-        JSONCompletion.prototype.doesSupportMarkdown = function () {
+        }
+        doesSupportMarkdown() {
             if (!(0, objects_1.isDefined)(this.supportsMarkdown)) {
-                var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
+                const completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
                 this.supportsMarkdown = completion && completion.completionItem && Array.isArray(completion.completionItem.documentationFormat) && completion.completionItem.documentationFormat.indexOf(jsonLanguageTypes_1.MarkupKind.Markdown) !== -1;
             }
             return this.supportsMarkdown;
-        };
-        JSONCompletion.prototype.doesSupportsCommitCharacters = function () {
+        }
+        doesSupportsCommitCharacters() {
             if (!(0, objects_1.isDefined)(this.supportsCommitCharacters)) {
-                var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
+                const completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
                 this.supportsCommitCharacters = completion && completion.completionItem && !!completion.completionItem.commitCharactersSupport;
             }
             return this.supportsCommitCharacters;
-        };
-        return JSONCompletion;
-    }());
+        }
+    }
     exports.JSONCompletion = JSONCompletion;
 });