vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/umd/parser/jsonParser.js

@@ -2,21 +2,6 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
@@ -29,13 +14,13 @@ var __extends = (this && this.__extends) || (function () {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.parse = exports.JSONDocument = exports.contains = exports.getNodePath = exports.getNodeValue = exports.newJSONDocument = exports.ValidationResult = exports.EnumMatch = exports.asSchema = exports.ObjectASTNodeImpl = exports.PropertyASTNodeImpl = exports.StringASTNodeImpl = exports.NumberASTNodeImpl = exports.ArrayASTNodeImpl = exports.BooleanASTNodeImpl = exports.NullASTNodeImpl = exports.ASTNodeImpl = void 0;
-    var Json = require("jsonc-parser");
-    var objects_1 = require("../utils/objects");
-    var strings_1 = require("../utils/strings");
-    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    var nls = require("vscode-nls");
-    var localize = nls.loadMessageBundle();
-    var formats = {
+    const Json = require("jsonc-parser");
+    const objects_1 = require("../utils/objects");
+    const strings_1 = require("../utils/strings");
+    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    const nls = require("vscode-nls");
+    const localize = nls.loadMessageBundle();
+    const formats = {
         'color-hex': { errorMessage: localize('colorHexFormatWarning', 'Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA.'), pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/ },
         'date-time': { errorMessage: localize('dateTimeFormatWarning', 'String is not a RFC3339 date-time.'), pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i },
         'date': { errorMessage: localize('dateFormatWarning', 'String is not a RFC3339 date.'), pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/i },
@@ -45,125 +30,86 @@ var __extends = (this && this.__extends) || (function () {
         'ipv4': { errorMessage: localize('ipv4FormatWarning', 'String is not an IPv4 address.'), pattern: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/ },
         'ipv6': { errorMessage: localize('ipv6FormatWarning', 'String is not an IPv6 address.'), pattern: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i },
     };
-    var ASTNodeImpl = /** @class */ (function () {
-        function ASTNodeImpl(parent, offset, length) {
-            if (length === void 0) { length = 0; }
+    class ASTNodeImpl {
+        constructor(parent, offset, length = 0) {
             this.offset = offset;
             this.length = length;
             this.parent = parent;
         }
-        Object.defineProperty(ASTNodeImpl.prototype, "children", {
-            get: function () {
-                return [];
-            },
-            enumerable: false,
-            configurable: true
-        });
-        ASTNodeImpl.prototype.toString = function () {
+        get children() {
+            return [];
+        }
+        toString() {
             return 'type: ' + this.type + ' (' + this.offset + '/' + this.length + ')' + (this.parent ? ' parent: {' + this.parent.toString() + '}' : '');
-        };
-        return ASTNodeImpl;
-    }());
+        }
+    }
     exports.ASTNodeImpl = ASTNodeImpl;
-    var NullASTNodeImpl = /** @class */ (function (_super) {
-        __extends(NullASTNodeImpl, _super);
-        function NullASTNodeImpl(parent, offset) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'null';
-            _this.value = null;
-            return _this;
+    class NullASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset) {
+            super(parent, offset);
+            this.type = 'null';
+            this.value = null;
         }
-        return NullASTNodeImpl;
-    }(ASTNodeImpl));
+    }
     exports.NullASTNodeImpl = NullASTNodeImpl;
-    var BooleanASTNodeImpl = /** @class */ (function (_super) {
-        __extends(BooleanASTNodeImpl, _super);
-        function BooleanASTNodeImpl(parent, boolValue, offset) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'boolean';
-            _this.value = boolValue;
-            return _this;
+    class BooleanASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, boolValue, offset) {
+            super(parent, offset);
+            this.type = 'boolean';
+            this.value = boolValue;
         }
-        return BooleanASTNodeImpl;
-    }(ASTNodeImpl));
+    }
     exports.BooleanASTNodeImpl = BooleanASTNodeImpl;
-    var ArrayASTNodeImpl = /** @class */ (function (_super) {
-        __extends(ArrayASTNodeImpl, _super);
-        function ArrayASTNodeImpl(parent, offset) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'array';
-            _this.items = [];
-            return _this;
+    class ArrayASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset) {
+            super(parent, offset);
+            this.type = 'array';
+            this.items = [];
         }
-        Object.defineProperty(ArrayASTNodeImpl.prototype, "children", {
-            get: function () {
-                return this.items;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return ArrayASTNodeImpl;
-    }(ASTNodeImpl));
+        get children() {
+            return this.items;
+        }
+    }
     exports.ArrayASTNodeImpl = ArrayASTNodeImpl;
-    var NumberASTNodeImpl = /** @class */ (function (_super) {
-        __extends(NumberASTNodeImpl, _super);
-        function NumberASTNodeImpl(parent, offset) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'number';
-            _this.isInteger = true;
-            _this.value = Number.NaN;
-            return _this;
+    class NumberASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset) {
+            super(parent, offset);
+            this.type = 'number';
+            this.isInteger = true;
+            this.value = Number.NaN;
         }
-        return NumberASTNodeImpl;
-    }(ASTNodeImpl));
+    }
     exports.NumberASTNodeImpl = NumberASTNodeImpl;
-    var StringASTNodeImpl = /** @class */ (function (_super) {
-        __extends(StringASTNodeImpl, _super);
-        function StringASTNodeImpl(parent, offset, length) {
-            var _this = _super.call(this, parent, offset, length) || this;
-            _this.type = 'string';
-            _this.value = '';
-            return _this;
+    class StringASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset, length) {
+            super(parent, offset, length);
+            this.type = 'string';
+            this.value = '';
         }
-        return StringASTNodeImpl;
-    }(ASTNodeImpl));
+    }
     exports.StringASTNodeImpl = StringASTNodeImpl;
-    var PropertyASTNodeImpl = /** @class */ (function (_super) {
-        __extends(PropertyASTNodeImpl, _super);
-        function PropertyASTNodeImpl(parent, offset, keyNode) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'property';
-            _this.colonOffset = -1;
-            _this.keyNode = keyNode;
-            return _this;
+    class PropertyASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset, keyNode) {
+            super(parent, offset);
+            this.type = 'property';
+            this.colonOffset = -1;
+            this.keyNode = keyNode;
         }
-        Object.defineProperty(PropertyASTNodeImpl.prototype, "children", {
-            get: function () {
-                return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return PropertyASTNodeImpl;
-    }(ASTNodeImpl));
+        get children() {
+            return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+        }
+    }
     exports.PropertyASTNodeImpl = PropertyASTNodeImpl;
-    var ObjectASTNodeImpl = /** @class */ (function (_super) {
-        __extends(ObjectASTNodeImpl, _super);
-        function ObjectASTNodeImpl(parent, offset) {
-            var _this = _super.call(this, parent, offset) || this;
-            _this.type = 'object';
-            _this.properties = [];
-            return _this;
+    class ObjectASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, offset) {
+            super(parent, offset);
+            this.type = 'object';
+            this.properties = [];
         }
-        Object.defineProperty(ObjectASTNodeImpl.prototype, "children", {
-            get: function () {
-                return this.properties;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return ObjectASTNodeImpl;
-    }(ASTNodeImpl));
+        get children() {
+            return this.properties;
+        }
+    }
     exports.ObjectASTNodeImpl = ObjectASTNodeImpl;
     function asSchema(schema) {
         if ((0, objects_1.isBoolean)(schema)) {
@@ -177,75 +123,66 @@ var __extends = (this && this.__extends) || (function () {
         EnumMatch[EnumMatch["Key"] = 0] = "Key";
         EnumMatch[EnumMatch["Enum"] = 1] = "Enum";
     })(EnumMatch = exports.EnumMatch || (exports.EnumMatch = {}));
-    var SchemaCollector = /** @class */ (function () {
-        function SchemaCollector(focusOffset, exclude) {
-            if (focusOffset === void 0) { focusOffset = -1; }
+    class SchemaCollector {
+        constructor(focusOffset = -1, exclude) {
             this.focusOffset = focusOffset;
             this.exclude = exclude;
             this.schemas = [];
         }
-        SchemaCollector.prototype.add = function (schema) {
+        add(schema) {
             this.schemas.push(schema);
-        };
-        SchemaCollector.prototype.merge = function (other) {
+        }
+        merge(other) {
             Array.prototype.push.apply(this.schemas, other.schemas);
-        };
-        SchemaCollector.prototype.include = function (node) {
+        }
+        include(node) {
             return (this.focusOffset === -1 || contains(node, this.focusOffset)) && (node !== this.exclude);
-        };
-        SchemaCollector.prototype.newSub = function () {
+        }
+        newSub() {
             return new SchemaCollector(-1, this.exclude);
-        };
-        return SchemaCollector;
-    }());
-    var NoOpSchemaCollector = /** @class */ (function () {
-        function NoOpSchemaCollector() {
         }
-        Object.defineProperty(NoOpSchemaCollector.prototype, "schemas", {
-            get: function () { return []; },
-            enumerable: false,
-            configurable: true
-        });
-        NoOpSchemaCollector.prototype.add = function (schema) { };
-        NoOpSchemaCollector.prototype.merge = function (other) { };
-        NoOpSchemaCollector.prototype.include = function (node) { return true; };
-        NoOpSchemaCollector.prototype.newSub = function () { return this; };
-        NoOpSchemaCollector.instance = new NoOpSchemaCollector();
-        return NoOpSchemaCollector;
-    }());
-    var ValidationResult = /** @class */ (function () {
-        function ValidationResult() {
+    }
+    class NoOpSchemaCollector {
+        constructor() { }
+        get schemas() { return []; }
+        add(schema) { }
+        merge(other) { }
+        include(node) { return true; }
+        newSub() { return this; }
+    }
+    NoOpSchemaCollector.instance = new NoOpSchemaCollector();
+    class ValidationResult {
+        constructor() {
             this.problems = [];
             this.propertiesMatches = 0;
+            this.processedProperties = new Set();
             this.propertiesValueMatches = 0;
             this.primaryValueMatches = 0;
             this.enumValueMatch = false;
             this.enumValues = undefined;
         }
-        ValidationResult.prototype.hasProblems = function () {
+        hasProblems() {
             return !!this.problems.length;
-        };
-        ValidationResult.prototype.mergeAll = function (validationResults) {
-            for (var _i = 0, validationResults_1 = validationResults; _i < validationResults_1.length; _i++) {
-                var validationResult = validationResults_1[_i];
+        }
+        mergeAll(validationResults) {
+            for (const validationResult of validationResults) {
                 this.merge(validationResult);
             }
-        };
-        ValidationResult.prototype.merge = function (validationResult) {
+        }
+        merge(validationResult) {
             this.problems = this.problems.concat(validationResult.problems);
-        };
-        ValidationResult.prototype.mergeEnumValues = function (validationResult) {
+        }
+        mergeEnumValues(validationResult) {
             if (!this.enumValueMatch && !validationResult.enumValueMatch && this.enumValues && validationResult.enumValues) {
                 this.enumValues = this.enumValues.concat(validationResult.enumValues);
-                for (var _i = 0, _a = this.problems; _i < _a.length; _i++) {
-                    var error = _a[_i];
+                for (const error of this.problems) {
                     if (error.code === jsonLanguageTypes_1.ErrorCode.EnumValueMismatch) {
-                        error.message = localize('enumWarning', 'Value is not accepted. Valid values: {0}.', this.enumValues.map(function (v) { return JSON.stringify(v); }).join(', '));
+                        error.message = localize('enumWarning', 'Value is not accepted. Valid values: {0}.', this.enumValues.map(v => JSON.stringify(v)).join(', '));
                     }
                 }
             }
-        };
-        ValidationResult.prototype.mergePropertyMatch = function (propertyValidationResult) {
+        }
+        mergePropertyMatch(propertyValidationResult) {
             this.merge(propertyValidationResult);
             this.propertiesMatches++;
             if (propertyValidationResult.enumValueMatch || !propertyValidationResult.hasProblems() && propertyValidationResult.propertiesMatches) {
@@ -254,9 +191,12 @@ var __extends = (this && this.__extends) || (function () {
             if (propertyValidationResult.enumValueMatch && propertyValidationResult.enumValues && propertyValidationResult.enumValues.length === 1) {
                 this.primaryValueMatches++;
             }
-        };
-        ValidationResult.prototype.compare = function (other) {
-            var hasProblems = this.hasProblems();
+        }
+        mergeProcessedProperties(validationResult) {
+            validationResult.processedProperties.forEach(p => this.processedProperties.add(p));
+        }
+        compare(other) {
+            const hasProblems = this.hasProblems();
             if (hasProblems !== other.hasProblems()) {
                 return hasProblems ? -1 : 1;
             }
@@ -270,12 +210,10 @@ var __extends = (this && this.__extends) || (function () {
                 return this.propertiesValueMatches - other.propertiesValueMatches;
             }
             return this.propertiesMatches - other.propertiesMatches;
-        };
-        return ValidationResult;
-    }());
+        }
+    }
     exports.ValidationResult = ValidationResult;
-    function newJSONDocument(root, diagnostics) {
-        if (diagnostics === void 0) { diagnostics = []; }
+    function newJSONDocument(root, diagnostics = []) {
         return new JSONDocument(root, diagnostics, []);
     }
     exports.newJSONDocument = newJSONDocument;
@@ -287,87 +225,80 @@ var __extends = (this && this.__extends) || (function () {
         return Json.getNodePath(node);
     }
     exports.getNodePath = getNodePath;
-    function contains(node, offset, includeRightBound) {
-        if (includeRightBound === void 0) { includeRightBound = false; }
+    function contains(node, offset, includeRightBound = false) {
         return offset >= node.offset && offset < (node.offset + node.length) || includeRightBound && offset === (node.offset + node.length);
     }
     exports.contains = contains;
-    var JSONDocument = /** @class */ (function () {
-        function JSONDocument(root, syntaxErrors, comments) {
-            if (syntaxErrors === void 0) { syntaxErrors = []; }
-            if (comments === void 0) { comments = []; }
+    class JSONDocument {
+        constructor(root, syntaxErrors = [], comments = []) {
             this.root = root;
             this.syntaxErrors = syntaxErrors;
             this.comments = comments;
         }
-        JSONDocument.prototype.getNodeFromOffset = function (offset, includeRightBound) {
-            if (includeRightBound === void 0) { includeRightBound = false; }
+        getNodeFromOffset(offset, includeRightBound = false) {
             if (this.root) {
                 return Json.findNodeAtOffset(this.root, offset, includeRightBound);
             }
             return undefined;
-        };
-        JSONDocument.prototype.visit = function (visitor) {
+        }
+        visit(visitor) {
             if (this.root) {
-                var doVisit_1 = function (node) {
-                    var ctn = visitor(node);
-                    var children = node.children;
+                const doVisit = (node) => {
+                    let ctn = visitor(node);
+                    const children = node.children;
                     if (Array.isArray(children)) {
-                        for (var i = 0; i < children.length && ctn; i++) {
-                            ctn = doVisit_1(children[i]);
+                        for (let i = 0; i < children.length && ctn; i++) {
+                            ctn = doVisit(children[i]);
                         }
                     }
                     return ctn;
                 };
-                doVisit_1(this.root);
+                doVisit(this.root);
             }
-        };
-        JSONDocument.prototype.validate = function (textDocument, schema, severity) {
-            if (severity === void 0) { severity = jsonLanguageTypes_1.DiagnosticSeverity.Warning; }
+        }
+        validate(textDocument, schema, severity = jsonLanguageTypes_1.DiagnosticSeverity.Warning) {
             if (this.root && schema) {
-                var validationResult = new ValidationResult();
+                const validationResult = new ValidationResult();
                 validate(this.root, schema, validationResult, NoOpSchemaCollector.instance);
-                return validationResult.problems.map(function (p) {
-                    var _a;
-                    var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
-                    return jsonLanguageTypes_1.Diagnostic.create(range, p.message, (_a = p.severity) !== null && _a !== void 0 ? _a : severity, p.code);
+                return validationResult.problems.map(p => {
+                    const range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
+                    return jsonLanguageTypes_1.Diagnostic.create(range, p.message, p.severity ?? severity, p.code);
                 });
             }
             return undefined;
-        };
-        JSONDocument.prototype.getMatchingSchemas = function (schema, focusOffset, exclude) {
-            if (focusOffset === void 0) { focusOffset = -1; }
-            var matchingSchemas = new SchemaCollector(focusOffset, exclude);
+        }
+        getMatchingSchemas(schema, focusOffset = -1, exclude) {
+            const matchingSchemas = new SchemaCollector(focusOffset, exclude);
             if (this.root && schema) {
                 validate(this.root, schema, new ValidationResult(), matchingSchemas);
             }
             return matchingSchemas.schemas;
-        };
-        return JSONDocument;
-    }());
+        }
+    }
     exports.JSONDocument = JSONDocument;
     function validate(n, schema, validationResult, matchingSchemas) {
         if (!n || !matchingSchemas.include(n)) {
             return;
         }
-        var node = n;
+        if (n.type === 'property') {
+            return validate(n.valueNode, schema, validationResult, matchingSchemas);
+        }
+        const node = n;
+        _validateNode();
         switch (node.type) {
             case 'object':
-                _validateObjectNode(node, schema, validationResult, matchingSchemas);
+                _validateObjectNode(node);
                 break;
             case 'array':
-                _validateArrayNode(node, schema, validationResult, matchingSchemas);
+                _validateArrayNode(node);
                 break;
             case 'string':
-                _validateStringNode(node, schema, validationResult, matchingSchemas);
+                _validateStringNode(node);
                 break;
             case 'number':
-                _validateNumberNode(node, schema, validationResult, matchingSchemas);
+                _validateNumberNode(node);
                 break;
-            case 'property':
-                return validate(node.valueNode, schema, validationResult, matchingSchemas);
         }
-        _validateNode();
         matchingSchemas.add({ node: node, schema: schema });
         function _validateNode() {
             function matchesType(type) {
@@ -390,15 +321,14 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             if (Array.isArray(schema.allOf)) {
-                for (var _i = 0, _a = schema.allOf; _i < _a.length; _i++) {
-                    var subSchemaRef = _a[_i];
+                for (const subSchemaRef of schema.allOf) {
                     validate(node, asSchema(subSchemaRef), validationResult, matchingSchemas);
                 }
             }
-            var notSchema = asSchema(schema.not);
+            const notSchema = asSchema(schema.not);
             if (notSchema) {
-                var subValidationResult = new ValidationResult();
-                var subMatchingSchemas = matchingSchemas.newSub();
+                const subValidationResult = new ValidationResult();
+                const subMatchingSchemas = matchingSchemas.newSub();
                 validate(node, notSchema, subValidationResult, subMatchingSchemas);
                 if (!subValidationResult.hasProblems()) {
                     validationResult.problems.push({
@@ -406,21 +336,19 @@ var __extends = (this && this.__extends) || (function () {
                         message: localize('notSchemaWarning', "Matches a schema that is not allowed.")
                     });
                 }
-                for (var _b = 0, _c = subMatchingSchemas.schemas; _b < _c.length; _b++) {
-                    var ms = _c[_b];
+                for (const ms of subMatchingSchemas.schemas) {
                     ms.inverted = !ms.inverted;
                     matchingSchemas.add(ms);
                 }
             }
-            var testAlternatives = function (alternatives, maxOneMatch) {
-                var matches = [];
+            const testAlternatives = (alternatives, maxOneMatch) => {
+                const matches = [];
                 // remember the best match that is used for error messages
-                var bestMatch = undefined;
-                for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) {
-                    var subSchemaRef = alternatives_1[_i];
-                    var subSchema = asSchema(subSchemaRef);
-                    var subValidationResult = new ValidationResult();
-                    var subMatchingSchemas = matchingSchemas.newSub();
+                let bestMatch = undefined;
+                for (const subSchemaRef of alternatives) {
+                    const subSchema = asSchema(subSchemaRef);
+                    const subValidationResult = new ValidationResult();
+                    const subMatchingSchemas = matchingSchemas.newSub();
                     validate(node, subSchema, subValidationResult, subMatchingSchemas);
                     if (!subValidationResult.hasProblems()) {
                         matches.push(subSchema);
@@ -434,9 +362,10 @@ var __extends = (this && this.__extends) || (function () {
                             bestMatch.matchingSchemas.merge(subMatchingSchemas);
                             bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;
                             bestMatch.validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
+                            bestMatch.validationResult.mergeProcessedProperties(subValidationResult);
                         }
                         else {
-                            var compareResult = subValidationResult.compare(bestMatch.validationResult);
+                            const compareResult = subValidationResult.compare(bestMatch.validationResult);
                             if (compareResult > 0) {
                                 // our node is the best matching so far
                                 bestMatch = { schema: subSchema, validationResult: subValidationResult, matchingSchemas: subMatchingSchemas };
@@ -459,6 +388,7 @@ var __extends = (this && this.__extends) || (function () {
                     validationResult.merge(bestMatch.validationResult);
                     validationResult.propertiesMatches += bestMatch.validationResult.propertiesMatches;
                     validationResult.propertiesValueMatches += bestMatch.validationResult.propertiesValueMatches;
+                    validationResult.mergeProcessedProperties(bestMatch.validationResult);
                     matchingSchemas.merge(bestMatch.matchingSchemas);
                 }
                 return matches.length;
@@ -469,21 +399,23 @@ var __extends = (this && this.__extends) || (function () {
             if (Array.isArray(schema.oneOf)) {
                 testAlternatives(schema.oneOf, true);
             }
-            var testBranch = function (schema) {
-                var subValidationResult = new ValidationResult();
-                var subMatchingSchemas = matchingSchemas.newSub();
+            const testBranch = (schema) => {
+                const subValidationResult = new ValidationResult();
+                const subMatchingSchemas = matchingSchemas.newSub();
                 validate(node, asSchema(schema), subValidationResult, subMatchingSchemas);
                 validationResult.merge(subValidationResult);
                 validationResult.propertiesMatches += subValidationResult.propertiesMatches;
                 validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
+                validationResult.mergeProcessedProperties(subValidationResult);
                 matchingSchemas.merge(subMatchingSchemas);
             };
-            var testCondition = function (ifSchema, thenSchema, elseSchema) {
-                var subSchema = asSchema(ifSchema);
-                var subValidationResult = new ValidationResult();
-                var subMatchingSchemas = matchingSchemas.newSub();
+            const testCondition = (ifSchema, thenSchema, elseSchema) => {
+                const subSchema = asSchema(ifSchema);
+                const subValidationResult = new ValidationResult();
+                const subMatchingSchemas = matchingSchemas.newSub();
                 validate(node, subSchema, subValidationResult, subMatchingSchemas);
                 matchingSchemas.merge(subMatchingSchemas);
+                validationResult.mergeProcessedProperties(subValidationResult);
                 if (!subValidationResult.hasProblems()) {
                     if (thenSchema) {
                         testBranch(thenSchema);
@@ -493,15 +425,14 @@ var __extends = (this && this.__extends) || (function () {
                     testBranch(elseSchema);
                 }
             };
-            var ifSchema = asSchema(schema.if);
+            const ifSchema = asSchema(schema.if);
             if (ifSchema) {
                 testCondition(ifSchema, asSchema(schema.then), asSchema(schema.else));
             }
             if (Array.isArray(schema.enum)) {
-                var val = getNodeValue(node);
-                var enumValueMatch = false;
-                for (var _d = 0, _e = schema.enum; _d < _e.length; _d++) {
-                    var e = _e[_d];
+                const val = getNodeValue(node);
+                let enumValueMatch = false;
+                for (const e of schema.enum) {
                     if ((0, objects_1.equals)(val, e)) {
                         enumValueMatch = true;
                         break;
@@ -513,12 +444,12 @@ var __extends = (this && this.__extends) || (function () {
                     validationResult.problems.push({
                         location: { offset: node.offset, length: node.length },
                         code: jsonLanguageTypes_1.ErrorCode.EnumValueMismatch,
-                        message: schema.errorMessage || localize('enumWarning', 'Value is not accepted. Valid values: {0}.', schema.enum.map(function (v) { return JSON.stringify(v); }).join(', '))
+                        message: schema.errorMessage || localize('enumWarning', 'Value is not accepted. Valid values: {0}.', schema.enum.map(v => JSON.stringify(v)).join(', '))
                     });
                 }
             }
             if ((0, objects_1.isDefined)(schema.const)) {
-                var val = getNodeValue(node);
+                const val = getNodeValue(node);
                 if (!(0, objects_1.equals)(val, schema.const)) {
                     validationResult.problems.push({
                         location: { offset: node.offset, length: node.length },
@@ -532,36 +463,37 @@ var __extends = (this && this.__extends) || (function () {
                 }
                 validationResult.enumValues = [schema.const];
             }
-            if (schema.deprecationMessage && node.parent) {
+            let deprecationMessage = schema.deprecationMessage;
+            if ((deprecationMessage || schema.deprecated) && node.parent) {
+                deprecationMessage = deprecationMessage || localize('deprecated', 'Value is deprecated');
                 validationResult.problems.push({
                     location: { offset: node.parent.offset, length: node.parent.length },
                     severity: jsonLanguageTypes_1.DiagnosticSeverity.Warning,
-                    message: schema.deprecationMessage,
+                    message: deprecationMessage,
                     code: jsonLanguageTypes_1.ErrorCode.Deprecated
                 });
             }
         }
-        function _validateNumberNode(node, schema, validationResult, matchingSchemas) {
-            var val = node.value;
+        function _validateNumberNode(node) {
+            const val = node.value;
             function normalizeFloats(float) {
-                var _a;
-                var parts = /^(-?\d+)(?:\.(\d+))?(?:e([-+]\d+))?$/.exec(float.toString());
+                const parts = /^(-?\d+)(?:\.(\d+))?(?:e([-+]\d+))?$/.exec(float.toString());
                 return parts && {
                     value: Number(parts[1] + (parts[2] || '')),
-                    multiplier: (((_a = parts[2]) === null || _a === void 0 ? void 0 : _a.length) || 0) - (parseInt(parts[3]) || 0)
+                    multiplier: (parts[2]?.length || 0) - (parseInt(parts[3]) || 0)
                 };
             }
             ;
             if ((0, objects_1.isNumber)(schema.multipleOf)) {
-                var remainder = -1;
+                let remainder = -1;
                 if (Number.isInteger(schema.multipleOf)) {
                     remainder = val % schema.multipleOf;
                 }
                 else {
-                    var normMultipleOf = normalizeFloats(schema.multipleOf);
-                    var normValue = normalizeFloats(val);
+                    let normMultipleOf = normalizeFloats(schema.multipleOf);
+                    let normValue = normalizeFloats(val);
                     if (normMultipleOf && normValue) {
-                        var multiplier = Math.pow(10, Math.abs(normValue.multiplier - normMultipleOf.multiplier));
+                        const multiplier = 10 ** Math.abs(normValue.multiplier - normMultipleOf.multiplier);
                         if (normValue.multiplier < normMultipleOf.multiplier) {
                             normValue.value *= multiplier;
                         }
@@ -593,28 +525,28 @@ var __extends = (this && this.__extends) || (function () {
                 }
                 return undefined;
             }
-            var exclusiveMinimum = getExclusiveLimit(schema.minimum, schema.exclusiveMinimum);
+            const exclusiveMinimum = getExclusiveLimit(schema.minimum, schema.exclusiveMinimum);
             if ((0, objects_1.isNumber)(exclusiveMinimum) && val <= exclusiveMinimum) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
                     message: localize('exclusiveMinimumWarning', 'Value is below the exclusive minimum of {0}.', exclusiveMinimum)
                 });
             }
-            var exclusiveMaximum = getExclusiveLimit(schema.maximum, schema.exclusiveMaximum);
+            const exclusiveMaximum = getExclusiveLimit(schema.maximum, schema.exclusiveMaximum);
             if ((0, objects_1.isNumber)(exclusiveMaximum) && val >= exclusiveMaximum) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
                     message: localize('exclusiveMaximumWarning', 'Value is above the exclusive maximum of {0}.', exclusiveMaximum)
                 });
             }
-            var minimum = getLimit(schema.minimum, schema.exclusiveMinimum);
+            const minimum = getLimit(schema.minimum, schema.exclusiveMinimum);
             if ((0, objects_1.isNumber)(minimum) && val < minimum) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
                     message: localize('minimumWarning', 'Value is below the minimum of {0}.', minimum)
                 });
             }
-            var maximum = getLimit(schema.maximum, schema.exclusiveMaximum);
+            const maximum = getLimit(schema.maximum, schema.exclusiveMaximum);
             if ((0, objects_1.isNumber)(maximum) && val > maximum) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -622,7 +554,7 @@ var __extends = (this && this.__extends) || (function () {
                 });
             }
         }
-        function _validateStringNode(node, schema, validationResult, matchingSchemas) {
+        function _validateStringNode(node) {
             if ((0, objects_1.isNumber)(schema.minLength) && node.value.length < schema.minLength) {
                 validationResult.problems.push({
                     location: { offset: node.offset, length: node.length },
@@ -636,8 +568,8 @@ var __extends = (this && this.__extends) || (function () {
                 });
             }
             if ((0, objects_1.isString)(schema.pattern)) {
-                var regex = (0, strings_1.extendedRegExp)(schema.pattern);
-                if (!(regex === null || regex === void 0 ? void 0 : regex.test(node.value))) {
+                const regex = (0, strings_1.extendedRegExp)(schema.pattern);
+                if (!(regex?.test(node.value))) {
                     validationResult.problems.push({
                         location: { offset: node.offset, length: node.length },
                         message: schema.patternErrorMessage || schema.errorMessage || localize('patternWarning', 'String does not match the pattern of "{0}".', schema.pattern)
@@ -649,12 +581,12 @@ var __extends = (this && this.__extends) || (function () {
                     case 'uri':
                     case 'uri-reference':
                         {
-                            var errorMessage = void 0;
+                            let errorMessage;
                             if (!node.value) {
                                 errorMessage = localize('uriEmpty', 'URI expected.');
                             }
                             else {
-                                var match = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/.exec(node.value);
+                                const match = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/.exec(node.value);
                                 if (!match) {
                                     errorMessage = localize('uriMissing', 'URI is expected.');
                                 }
@@ -678,7 +610,7 @@ var __extends = (this && this.__extends) || (function () {
                     case 'hostname':
                     case 'ipv4':
                     case 'ipv6':
-                        var format = formats[schema.format];
+                        const format = formats[schema.format];
                         if (!node.value || !format.pattern.exec(node.value)) {
                             validationResult.problems.push({
                                 location: { offset: node.offset, length: node.length },
@@ -689,62 +621,107 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
         }
-        function _validateArrayNode(node, schema, validationResult, matchingSchemas) {
-            if (Array.isArray(schema.items)) {
-                var subSchemas = schema.items;
-                for (var index = 0; index < subSchemas.length; index++) {
-                    var subSchemaRef = subSchemas[index];
-                    var subSchema = asSchema(subSchemaRef);
-                    var itemValidationResult = new ValidationResult();
-                    var item = node.items[index];
+        function _validateArrayNode(node) {
+            let prefixItemsSchemas;
+            let additionalItemSchema;
+            let isSchema_2020_12 = Array.isArray(schema.prefixItems) || (schema.items !== undefined && !Array.isArray(schema.items) && schema.additionalItems === undefined);
+            if (isSchema_2020_12) {
+                prefixItemsSchemas = schema.prefixItems;
+                additionalItemSchema = !Array.isArray(schema.items) ? schema.items : undefined;
+            }
+            else {
+                prefixItemsSchemas = Array.isArray(schema.items) ? schema.items : undefined;
+                additionalItemSchema = !Array.isArray(schema.items) ? schema.items : schema.additionalItems;
+            }
+            let index = 0;
+            if (prefixItemsSchemas !== undefined) {
+                const max = Math.min(prefixItemsSchemas.length, node.items.length);
+                for (; index < max; index++) {
+                    const subSchemaRef = prefixItemsSchemas[index];
+                    const subSchema = asSchema(subSchemaRef);
+                    const itemValidationResult = new ValidationResult();
+                    const item = node.items[index];
                     if (item) {
                         validate(item, subSchema, itemValidationResult, matchingSchemas);
                         validationResult.mergePropertyMatch(itemValidationResult);
                     }
-                    else if (node.items.length >= subSchemas.length) {
-                        validationResult.propertiesValueMatches++;
-                    }
+                    validationResult.processedProperties.add(String(index));
                 }
-                if (node.items.length > subSchemas.length) {
-                    if (typeof schema.additionalItems === 'object') {
-                        for (var i = subSchemas.length; i < node.items.length; i++) {
-                            var itemValidationResult = new ValidationResult();
-                            validate(node.items[i], schema.additionalItems, itemValidationResult, matchingSchemas);
-                            validationResult.mergePropertyMatch(itemValidationResult);
-                        }
-                    }
-                    else if (schema.additionalItems === false) {
+            }
+            if (additionalItemSchema !== undefined && index < node.items.length) {
+                if (typeof additionalItemSchema === 'boolean') {
+                    if (additionalItemSchema === false) {
                         validationResult.problems.push({
                             location: { offset: node.offset, length: node.length },
-                            message: localize('additionalItemsWarning', 'Array has too many items according to schema. Expected {0} or fewer.', subSchemas.length)
+                            message: localize('additionalItemsWarning', 'Array has too many items according to schema. Expected {0} or fewer.', index)
                         });
                     }
+                    for (; index < node.items.length; index++) {
+                        validationResult.processedProperties.add(String(index));
+                        validationResult.propertiesValueMatches++;
+                    }
                 }
-            }
-            else {
-                var itemSchema = asSchema(schema.items);
-                if (itemSchema) {
-                    for (var _i = 0, _a = node.items; _i < _a.length; _i++) {
-                        var item = _a[_i];
-                        var itemValidationResult = new ValidationResult();
-                        validate(item, itemSchema, itemValidationResult, matchingSchemas);
+                else {
+                    for (; index < node.items.length; index++) {
+                        const itemValidationResult = new ValidationResult();
+                        validate(node.items[index], additionalItemSchema, itemValidationResult, matchingSchemas);
                         validationResult.mergePropertyMatch(itemValidationResult);
+                        validationResult.processedProperties.add(String(index));
                     }
                 }
             }
-            var containsSchema = asSchema(schema.contains);
+            const containsSchema = asSchema(schema.contains);
             if (containsSchema) {
-                var doesContain = node.items.some(function (item) {
-                    var itemValidationResult = new ValidationResult();
+                let containsCount = 0;
+                for (let index = 0; index < node.items.length; index++) {
+                    const item = node.items[index];
+                    const itemValidationResult = new ValidationResult();
                     validate(item, containsSchema, itemValidationResult, NoOpSchemaCollector.instance);
-                    return !itemValidationResult.hasProblems();
-                });
-                if (!doesContain) {
+                    if (!itemValidationResult.hasProblems()) {
+                        containsCount++;
+                        if (isSchema_2020_12) {
+                            validationResult.processedProperties.add(String(index));
+                        }
+                    }
+                }
+                if (containsCount === 0 && !(0, objects_1.isNumber)(schema.minContains)) {
                     validationResult.problems.push({
                         location: { offset: node.offset, length: node.length },
                         message: schema.errorMessage || localize('requiredItemMissingWarning', 'Array does not contain required item.')
                     });
                 }
+                if ((0, objects_1.isNumber)(schema.minContains) && containsCount < schema.minContains) {
+                    validationResult.problems.push({
+                        location: { offset: node.offset, length: node.length },
+                        message: localize('minContainsWarning', 'Array has too few items that match the contains contraint. Expected {0} or more.', schema.minContains)
+                    });
+                }
+                if ((0, objects_1.isNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+                    validationResult.problems.push({
+                        location: { offset: node.offset, length: node.length },
+                        message: localize('maxContainsWarning', 'Array has too many items that match the contains contraint. Expected {0} or less.', schema.maxContains)
+                    });
+                }
+            }
+            const unevaluatedItems = schema.unevaluatedItems;
+            if (unevaluatedItems !== undefined) {
+                for (let i = 0; i < node.items.length; i++) {
+                    if (!validationResult.processedProperties.has(String(i))) {
+                        if (unevaluatedItems === false) {
+                            validationResult.problems.push({
+                                location: { offset: node.offset, length: node.length },
+                                message: localize('unevaluatedItemsWarning', 'Item does not match any validation rule from the array.')
+                            });
+                        }
+                        else {
+                            const itemValidationResult = new ValidationResult();
+                            validate(node.items[i], schema.additionalItems, itemValidationResult, matchingSchemas);
+                            validationResult.mergePropertyMatch(itemValidationResult);
+                        }
+                    }
+                    validationResult.processedProperties.add(String(i));
+                    validationResult.propertiesValueMatches++;
+                }
             }
             if ((0, objects_1.isNumber)(schema.minItems) && node.items.length < schema.minItems) {
                 validationResult.problems.push({
@@ -759,9 +736,9 @@ var __extends = (this && this.__extends) || (function () {
                 });
             }
             if (schema.uniqueItems === true) {
-                var values_1 = getNodeValue(node);
-                var duplicates = values_1.some(function (value, index) {
-                    return index !== values_1.lastIndexOf(value);
+                const values = getNodeValue(node);
+                const duplicates = values.some((value, index) => {
+                    return index !== values.lastIndexOf(value);
                 });
                 if (duplicates) {
                     validationResult.problems.push({
@@ -771,21 +748,19 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
         }
-        function _validateObjectNode(node, schema, validationResult, matchingSchemas) {
-            var seenKeys = Object.create(null);
-            var unprocessedProperties = [];
-            for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
-                var propertyNode = _a[_i];
-                var key = propertyNode.keyNode.value;
+        function _validateObjectNode(node) {
+            const seenKeys = Object.create(null);
+            const unprocessedProperties = new Set();
+            for (const propertyNode of node.properties) {
+                const key = propertyNode.keyNode.value;
                 seenKeys[key] = propertyNode.valueNode;
-                unprocessedProperties.push(key);
+                unprocessedProperties.add(key);
             }
             if (Array.isArray(schema.required)) {
-                for (var _b = 0, _c = schema.required; _b < _c.length; _b++) {
-                    var propertyName = _c[_b];
+                for (const propertyName of schema.required) {
                     if (!seenKeys[propertyName]) {
-                        var keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;
-                        var location = keyNode ? { offset: keyNode.offset, length: keyNode.length } : { offset: node.offset, length: 1 };
+                        const keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;
+                        const location = keyNode ? { offset: keyNode.offset, length: keyNode.length } : { offset: node.offset, length: 1 };
                         validationResult.problems.push({
                             location: location,
                             message: localize('MissingRequiredPropWarning', 'Missing property "{0}".', propertyName)
@@ -793,23 +768,19 @@ var __extends = (this && this.__extends) || (function () {
                     }
                 }
             }
-            var propertyProcessed = function (prop) {
-                var index = unprocessedProperties.indexOf(prop);
-                while (index >= 0) {
-                    unprocessedProperties.splice(index, 1);
-                    index = unprocessedProperties.indexOf(prop);
-                }
+            const propertyProcessed = (prop) => {
+                unprocessedProperties.delete(prop);
+                validationResult.processedProperties.add(prop);
             };
             if (schema.properties) {
-                for (var _d = 0, _e = Object.keys(schema.properties); _d < _e.length; _d++) {
-                    var propertyName = _e[_d];
+                for (const propertyName of Object.keys(schema.properties)) {
                     propertyProcessed(propertyName);
-                    var propertySchema = schema.properties[propertyName];
-                    var child = seenKeys[propertyName];
+                    const propertySchema = schema.properties[propertyName];
+                    const child = seenKeys[propertyName];
                     if (child) {
                         if ((0, objects_1.isBoolean)(propertySchema)) {
                             if (!propertySchema) {
-                                var propertyNode = child.parent;
+                                const propertyNode = child.parent;
                                 validationResult.problems.push({
                                     location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },
                                     message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
@@ -821,7 +792,7 @@ var __extends = (this && this.__extends) || (function () {
                             }
                         }
                         else {
-                            var propertyValidationResult = new ValidationResult();
+                            const propertyValidationResult = new ValidationResult();
                             validate(child, propertySchema, propertyValidationResult, matchingSchemas);
                             validationResult.mergePropertyMatch(propertyValidationResult);
                         }
@@ -829,64 +800,86 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             if (schema.patternProperties) {
-                for (var _f = 0, _g = Object.keys(schema.patternProperties); _f < _g.length; _f++) {
-                    var propertyPattern = _g[_f];
-                    var regex = (0, strings_1.extendedRegExp)(propertyPattern);
-                    for (var _h = 0, _j = unprocessedProperties.slice(0); _h < _j.length; _h++) {
-                        var propertyName = _j[_h];
-                        if (regex === null || regex === void 0 ? void 0 : regex.test(propertyName)) {
-                            propertyProcessed(propertyName);
-                            var child = seenKeys[propertyName];
-                            if (child) {
-                                var propertySchema = schema.patternProperties[propertyPattern];
-                                if ((0, objects_1.isBoolean)(propertySchema)) {
-                                    if (!propertySchema) {
-                                        var propertyNode = child.parent;
-                                        validationResult.problems.push({
-                                            location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },
-                                            message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
-                                        });
+                for (const propertyPattern of Object.keys(schema.patternProperties)) {
+                    const regex = (0, strings_1.extendedRegExp)(propertyPattern);
+                    if (regex) {
+                        const processed = [];
+                        for (const propertyName of unprocessedProperties) {
+                            if (regex.test(propertyName)) {
+                                processed.push(propertyName);
+                                const child = seenKeys[propertyName];
+                                if (child) {
+                                    const propertySchema = schema.patternProperties[propertyPattern];
+                                    if ((0, objects_1.isBoolean)(propertySchema)) {
+                                        if (!propertySchema) {
+                                            const propertyNode = child.parent;
+                                            validationResult.problems.push({
+                                                location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },
+                                                message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
+                                            });
+                                        }
+                                        else {
+                                            validationResult.propertiesMatches++;
+                                            validationResult.propertiesValueMatches++;
+                                        }
                                     }
                                     else {
-                                        validationResult.propertiesMatches++;
-                                        validationResult.propertiesValueMatches++;
+                                        const propertyValidationResult = new ValidationResult();
+                                        validate(child, propertySchema, propertyValidationResult, matchingSchemas);
+                                        validationResult.mergePropertyMatch(propertyValidationResult);
                                     }
                                 }
-                                else {
-                                    var propertyValidationResult = new ValidationResult();
-                                    validate(child, propertySchema, propertyValidationResult, matchingSchemas);
-                                    validationResult.mergePropertyMatch(propertyValidationResult);
-                                }
                             }
                         }
+                        processed.forEach(propertyProcessed);
                     }
                 }
             }
-            if (typeof schema.additionalProperties === 'object') {
-                for (var _k = 0, unprocessedProperties_1 = unprocessedProperties; _k < unprocessedProperties_1.length; _k++) {
-                    var propertyName = unprocessedProperties_1[_k];
-                    var child = seenKeys[propertyName];
+            const additionalProperties = schema.additionalProperties;
+            if (additionalProperties !== undefined && additionalProperties !== true) {
+                for (const propertyName of unprocessedProperties) {
+                    propertyProcessed(propertyName);
+                    const child = seenKeys[propertyName];
                     if (child) {
-                        var propertyValidationResult = new ValidationResult();
-                        validate(child, schema.additionalProperties, propertyValidationResult, matchingSchemas);
-                        validationResult.mergePropertyMatch(propertyValidationResult);
-                    }
-                }
-            }
-            else if (schema.additionalProperties === false) {
-                if (unprocessedProperties.length > 0) {
-                    for (var _l = 0, unprocessedProperties_2 = unprocessedProperties; _l < unprocessedProperties_2.length; _l++) {
-                        var propertyName = unprocessedProperties_2[_l];
-                        var child = seenKeys[propertyName];
-                        if (child) {
-                            var propertyNode = child.parent;
+                        if (additionalProperties === false) {
+                            const propertyNode = child.parent;
                             validationResult.problems.push({
                                 location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },
                                 message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
                             });
                         }
+                        else {
+                            const propertyValidationResult = new ValidationResult();
+                            validate(child, additionalProperties, propertyValidationResult, matchingSchemas);
+                            validationResult.mergePropertyMatch(propertyValidationResult);
+                        }
+                    }
+                }
+            }
+            const unevaluatedProperties = schema.unevaluatedProperties;
+            if (unevaluatedProperties !== undefined && unevaluatedProperties !== true) {
+                const processed = [];
+                for (const propertyName of unprocessedProperties) {
+                    if (!validationResult.processedProperties.has(propertyName)) {
+                        processed.push(propertyName);
+                        const child = seenKeys[propertyName];
+                        if (child) {
+                            if (unevaluatedProperties === false) {
+                                const propertyNode = child.parent;
+                                validationResult.problems.push({
+                                    location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },
+                                    message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)
+                                });
+                            }
+                            else {
+                                const propertyValidationResult = new ValidationResult();
+                                validate(child, unevaluatedProperties, propertyValidationResult, matchingSchemas);
+                                validationResult.mergePropertyMatch(propertyValidationResult);
+                            }
+                        }
                     }
                 }
+                processed.forEach(propertyProcessed);
             }
             if ((0, objects_1.isNumber)(schema.maxProperties)) {
                 if (node.properties.length > schema.maxProperties) {
@@ -904,71 +897,88 @@ var __extends = (this && this.__extends) || (function () {
                     });
                 }
             }
+            if (schema.dependentRequired) {
+                for (const key in schema.dependentRequired) {
+                    const prop = seenKeys[key];
+                    const propertyDeps = schema.dependentRequired[key];
+                    if (prop && Array.isArray(propertyDeps)) {
+                        _validatePropertyDependencies(key, propertyDeps);
+                    }
+                }
+            }
+            if (schema.dependentSchemas) {
+                for (const key in schema.dependentSchemas) {
+                    const prop = seenKeys[key];
+                    const propertyDeps = schema.dependentSchemas[key];
+                    if (prop && (0, objects_1.isObject)(propertyDeps)) {
+                        _validatePropertyDependencies(key, propertyDeps);
+                    }
+                }
+            }
             if (schema.dependencies) {
-                for (var _m = 0, _o = Object.keys(schema.dependencies); _m < _o.length; _m++) {
-                    var key = _o[_m];
-                    var prop = seenKeys[key];
+                for (const key in schema.dependencies) {
+                    const prop = seenKeys[key];
                     if (prop) {
-                        var propertyDep = schema.dependencies[key];
-                        if (Array.isArray(propertyDep)) {
-                            for (var _p = 0, propertyDep_1 = propertyDep; _p < propertyDep_1.length; _p++) {
-                                var requiredProp = propertyDep_1[_p];
-                                if (!seenKeys[requiredProp]) {
-                                    validationResult.problems.push({
-                                        location: { offset: node.offset, length: node.length },
-                                        message: localize('RequiredDependentPropWarning', 'Object is missing property {0} required by property {1}.', requiredProp, key)
-                                    });
-                                }
-                                else {
-                                    validationResult.propertiesValueMatches++;
-                                }
-                            }
-                        }
-                        else {
-                            var propertySchema = asSchema(propertyDep);
-                            if (propertySchema) {
-                                var propertyValidationResult = new ValidationResult();
-                                validate(node, propertySchema, propertyValidationResult, matchingSchemas);
-                                validationResult.mergePropertyMatch(propertyValidationResult);
-                            }
-                        }
+                        _validatePropertyDependencies(key, schema.dependencies[key]);
                     }
                 }
             }
-            var propertyNames = asSchema(schema.propertyNames);
+            const propertyNames = asSchema(schema.propertyNames);
             if (propertyNames) {
-                for (var _q = 0, _r = node.properties; _q < _r.length; _q++) {
-                    var f = _r[_q];
-                    var key = f.keyNode;
+                for (const f of node.properties) {
+                    const key = f.keyNode;
                     if (key) {
                         validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance);
                     }
                 }
             }
+            function _validatePropertyDependencies(key, propertyDep) {
+                if (Array.isArray(propertyDep)) {
+                    for (const requiredProp of propertyDep) {
+                        if (!seenKeys[requiredProp]) {
+                            validationResult.problems.push({
+                                location: { offset: node.offset, length: node.length },
+                                message: localize('RequiredDependentPropWarning', 'Object is missing property {0} required by property {1}.', requiredProp, key)
+                            });
+                        }
+                        else {
+                            validationResult.propertiesValueMatches++;
+                        }
+                    }
+                }
+                else {
+                    const propertySchema = asSchema(propertyDep);
+                    if (propertySchema) {
+                        const propertyValidationResult = new ValidationResult();
+                        validate(node, propertySchema, propertyValidationResult, matchingSchemas);
+                        validationResult.mergePropertyMatch(propertyValidationResult);
+                    }
+                }
+            }
         }
     }
     function parse(textDocument, config) {
-        var problems = [];
-        var lastProblemOffset = -1;
-        var text = textDocument.getText();
-        var scanner = Json.createScanner(text, false);
-        var commentRanges = config && config.collectComments ? [] : undefined;
+        const problems = [];
+        let lastProblemOffset = -1;
+        const text = textDocument.getText();
+        const scanner = Json.createScanner(text, false);
+        const commentRanges = config && config.collectComments ? [] : undefined;
         function _scanNext() {
             while (true) {
-                var token_1 = scanner.scan();
+                const token = scanner.scan();
                 _checkScanError();
-                switch (token_1) {
-                    case 12 /* LineCommentTrivia */:
-                    case 13 /* BlockCommentTrivia */:
+                switch (token) {
+                    case 12 /* Json.SyntaxKind.LineCommentTrivia */:
+                    case 13 /* Json.SyntaxKind.BlockCommentTrivia */:
                         if (Array.isArray(commentRanges)) {
                             commentRanges.push(jsonLanguageTypes_1.Range.create(textDocument.positionAt(scanner.getTokenOffset()), textDocument.positionAt(scanner.getTokenOffset() + scanner.getTokenLength())));
                         }
                         break;
-                    case 15 /* Trivia */:
-                    case 14 /* LineBreakTrivia */:
+                    case 15 /* Json.SyntaxKind.Trivia */:
+                    case 14 /* Json.SyntaxKind.LineBreakTrivia */:
                         break;
                     default:
-                        return token_1;
+                        return token;
                 }
             }
         }
@@ -979,20 +989,16 @@ var __extends = (this && this.__extends) || (function () {
             }
             return false;
         }
-        function _errorAtRange(message, code, startOffset, endOffset, severity) {
-            if (severity === void 0) { severity = jsonLanguageTypes_1.DiagnosticSeverity.Error; }
+        function _errorAtRange(message, code, startOffset, endOffset, severity = jsonLanguageTypes_1.DiagnosticSeverity.Error) {
             if (problems.length === 0 || startOffset !== lastProblemOffset) {
-                var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(startOffset), textDocument.positionAt(endOffset));
+                const range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(startOffset), textDocument.positionAt(endOffset));
                 problems.push(jsonLanguageTypes_1.Diagnostic.create(range, message, severity, code, textDocument.languageId));
                 lastProblemOffset = startOffset;
             }
         }
-        function _error(message, code, node, skipUntilAfter, skipUntil) {
-            if (node === void 0) { node = undefined; }
-            if (skipUntilAfter === void 0) { skipUntilAfter = []; }
-            if (skipUntil === void 0) { skipUntil = []; }
-            var start = scanner.getTokenOffset();
-            var end = scanner.getTokenOffset() + scanner.getTokenLength();
+        function _error(message, code, node = undefined, skipUntilAfter = [], skipUntil = []) {
+            let start = scanner.getTokenOffset();
+            let end = scanner.getTokenOffset() + scanner.getTokenLength();
             if (start === end && start > 0) {
                 start--;
                 while (start > 0 && /\s/.test(text.charAt(start))) {
@@ -1005,38 +1011,38 @@ var __extends = (this && this.__extends) || (function () {
                 _finalize(node, false);
             }
             if (skipUntilAfter.length + skipUntil.length > 0) {
-                var token_2 = scanner.getToken();
-                while (token_2 !== 17 /* EOF */) {
-                    if (skipUntilAfter.indexOf(token_2) !== -1) {
+                let token = scanner.getToken();
+                while (token !== 17 /* Json.SyntaxKind.EOF */) {
+                    if (skipUntilAfter.indexOf(token) !== -1) {
                         _scanNext();
                         break;
                     }
-                    else if (skipUntil.indexOf(token_2) !== -1) {
+                    else if (skipUntil.indexOf(token) !== -1) {
                         break;
                     }
-                    token_2 = _scanNext();
+                    token = _scanNext();
                 }
             }
             return node;
         }
         function _checkScanError() {
             switch (scanner.getTokenError()) {
-                case 4 /* InvalidUnicode */:
+                case 4 /* Json.ScanError.InvalidUnicode */:
                     _error(localize('InvalidUnicode', 'Invalid unicode sequence in string.'), jsonLanguageTypes_1.ErrorCode.InvalidUnicode);
                     return true;
-                case 5 /* InvalidEscapeCharacter */:
+                case 5 /* Json.ScanError.InvalidEscapeCharacter */:
                     _error(localize('InvalidEscapeCharacter', 'Invalid escape character in string.'), jsonLanguageTypes_1.ErrorCode.InvalidEscapeCharacter);
                     return true;
-                case 3 /* UnexpectedEndOfNumber */:
+                case 3 /* Json.ScanError.UnexpectedEndOfNumber */:
                     _error(localize('UnexpectedEndOfNumber', 'Unexpected end of number.'), jsonLanguageTypes_1.ErrorCode.UnexpectedEndOfNumber);
                     return true;
-                case 1 /* UnexpectedEndOfComment */:
+                case 1 /* Json.ScanError.UnexpectedEndOfComment */:
                     _error(localize('UnexpectedEndOfComment', 'Unexpected end of comment.'), jsonLanguageTypes_1.ErrorCode.UnexpectedEndOfComment);
                     return true;
-                case 2 /* UnexpectedEndOfString */:
+                case 2 /* Json.ScanError.UnexpectedEndOfString */:
                     _error(localize('UnexpectedEndOfString', 'Unexpected end of string.'), jsonLanguageTypes_1.ErrorCode.UnexpectedEndOfString);
                     return true;
-                case 6 /* InvalidCharacter */:
+                case 6 /* Json.ScanError.InvalidCharacter */:
                     _error(localize('InvalidCharacter', 'Invalid characters in string. Control characters must be escaped.'), jsonLanguageTypes_1.ErrorCode.InvalidCharacter);
                     return true;
             }
@@ -1050,21 +1056,21 @@ var __extends = (this && this.__extends) || (function () {
             return node;
         }
         function _parseArray(parent) {
-            if (scanner.getToken() !== 3 /* OpenBracketToken */) {
+            if (scanner.getToken() !== 3 /* Json.SyntaxKind.OpenBracketToken */) {
                 return undefined;
             }
-            var node = new ArrayASTNodeImpl(parent, scanner.getTokenOffset());
+            const node = new ArrayASTNodeImpl(parent, scanner.getTokenOffset());
             _scanNext(); // consume OpenBracketToken
-            var count = 0;
-            var needsComma = false;
-            while (scanner.getToken() !== 4 /* CloseBracketToken */ && scanner.getToken() !== 17 /* EOF */) {
-                if (scanner.getToken() === 5 /* CommaToken */) {
+            const count = 0;
+            let needsComma = false;
+            while (scanner.getToken() !== 4 /* Json.SyntaxKind.CloseBracketToken */ && scanner.getToken() !== 17 /* Json.SyntaxKind.EOF */) {
+                if (scanner.getToken() === 5 /* Json.SyntaxKind.CommaToken */) {
                     if (!needsComma) {
                         _error(localize('ValueExpected', 'Value expected'), jsonLanguageTypes_1.ErrorCode.ValueExpected);
                     }
-                    var commaOffset = scanner.getTokenOffset();
+                    const commaOffset = scanner.getTokenOffset();
                     _scanNext(); // consume comma
-                    if (scanner.getToken() === 4 /* CloseBracketToken */) {
+                    if (scanner.getToken() === 4 /* Json.SyntaxKind.CloseBracketToken */) {
                         if (needsComma) {
                             _errorAtRange(localize('TrailingComma', 'Trailing comma'), jsonLanguageTypes_1.ErrorCode.TrailingComma, commaOffset, commaOffset + 1);
                         }
@@ -1074,29 +1080,29 @@ var __extends = (this && this.__extends) || (function () {
                 else if (needsComma) {
                     _error(localize('ExpectedComma', 'Expected comma'), jsonLanguageTypes_1.ErrorCode.CommaExpected);
                 }
-                var item = _parseValue(node);
+                const item = _parseValue(node);
                 if (!item) {
-                    _error(localize('PropertyExpected', 'Value expected'), jsonLanguageTypes_1.ErrorCode.ValueExpected, undefined, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
+                    _error(localize('PropertyExpected', 'Value expected'), jsonLanguageTypes_1.ErrorCode.ValueExpected, undefined, [], [4 /* Json.SyntaxKind.CloseBracketToken */, 5 /* Json.SyntaxKind.CommaToken */]);
                 }
                 else {
                     node.items.push(item);
                 }
                 needsComma = true;
             }
-            if (scanner.getToken() !== 4 /* CloseBracketToken */) {
+            if (scanner.getToken() !== 4 /* Json.SyntaxKind.CloseBracketToken */) {
                 return _error(localize('ExpectedCloseBracket', 'Expected comma or closing bracket'), jsonLanguageTypes_1.ErrorCode.CommaOrCloseBacketExpected, node);
             }
             return _finalize(node, true);
         }
-        var keyPlaceholder = new StringASTNodeImpl(undefined, 0, 0);
+        const keyPlaceholder = new StringASTNodeImpl(undefined, 0, 0);
         function _parseProperty(parent, keysSeen) {
-            var node = new PropertyASTNodeImpl(parent, scanner.getTokenOffset(), keyPlaceholder);
-            var key = _parseString(node);
+            const node = new PropertyASTNodeImpl(parent, scanner.getTokenOffset(), keyPlaceholder);
+            let key = _parseString(node);
             if (!key) {
-                if (scanner.getToken() === 16 /* Unknown */) {
+                if (scanner.getToken() === 16 /* Json.SyntaxKind.Unknown */) {
                     // give a more helpful error message
                     _error(localize('DoubleQuotesExpected', 'Property keys must be doublequoted'), jsonLanguageTypes_1.ErrorCode.Undefined);
-                    var keyNode = new StringASTNodeImpl(node, scanner.getTokenOffset(), scanner.getTokenLength());
+                    const keyNode = new StringASTNodeImpl(node, scanner.getTokenOffset(), scanner.getTokenLength());
                     keyNode.value = scanner.getTokenValue();
                     key = keyNode;
                     _scanNext(); // consume Unknown
@@ -1106,52 +1112,56 @@ var __extends = (this && this.__extends) || (function () {
                 }
             }
             node.keyNode = key;
-            var seen = keysSeen[key.value];
-            if (seen) {
-                _errorAtRange(localize('DuplicateKeyWarning', "Duplicate object key"), jsonLanguageTypes_1.ErrorCode.DuplicateKey, node.keyNode.offset, node.keyNode.offset + node.keyNode.length, jsonLanguageTypes_1.DiagnosticSeverity.Warning);
-                if (typeof seen === 'object') {
-                    _errorAtRange(localize('DuplicateKeyWarning', "Duplicate object key"), jsonLanguageTypes_1.ErrorCode.DuplicateKey, seen.keyNode.offset, seen.keyNode.offset + seen.keyNode.length, jsonLanguageTypes_1.DiagnosticSeverity.Warning);
+            // For JSON files that forbid code comments, there is a convention to use the key name "//" to add comments.
+            // Multiple instances of "//" are okay.
+            if (key.value !== "//") {
+                const seen = keysSeen[key.value];
+                if (seen) {
+                    _errorAtRange(localize('DuplicateKeyWarning', "Duplicate object key"), jsonLanguageTypes_1.ErrorCode.DuplicateKey, node.keyNode.offset, node.keyNode.offset + node.keyNode.length, jsonLanguageTypes_1.DiagnosticSeverity.Warning);
+                    if ((0, objects_1.isObject)(seen)) {
+                        _errorAtRange(localize('DuplicateKeyWarning', "Duplicate object key"), jsonLanguageTypes_1.ErrorCode.DuplicateKey, seen.keyNode.offset, seen.keyNode.offset + seen.keyNode.length, jsonLanguageTypes_1.DiagnosticSeverity.Warning);
+                    }
+                    keysSeen[key.value] = true; // if the same key is duplicate again, avoid duplicate error reporting
+                }
+                else {
+                    keysSeen[key.value] = node;
                 }
-                keysSeen[key.value] = true; // if the same key is duplicate again, avoid duplicate error reporting
-            }
-            else {
-                keysSeen[key.value] = node;
             }
-            if (scanner.getToken() === 6 /* ColonToken */) {
+            if (scanner.getToken() === 6 /* Json.SyntaxKind.ColonToken */) {
                 node.colonOffset = scanner.getTokenOffset();
                 _scanNext(); // consume ColonToken
             }
             else {
                 _error(localize('ColonExpected', 'Colon expected'), jsonLanguageTypes_1.ErrorCode.ColonExpected);
-                if (scanner.getToken() === 10 /* StringLiteral */ && textDocument.positionAt(key.offset + key.length).line < textDocument.positionAt(scanner.getTokenOffset()).line) {
+                if (scanner.getToken() === 10 /* Json.SyntaxKind.StringLiteral */ && textDocument.positionAt(key.offset + key.length).line < textDocument.positionAt(scanner.getTokenOffset()).line) {
                     node.length = key.length;
                     return node;
                 }
             }
-            var value = _parseValue(node);
+            const value = _parseValue(node);
             if (!value) {
-                return _error(localize('ValueExpected', 'Value expected'), jsonLanguageTypes_1.ErrorCode.ValueExpected, node, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+                return _error(localize('ValueExpected', 'Value expected'), jsonLanguageTypes_1.ErrorCode.ValueExpected, node, [], [2 /* Json.SyntaxKind.CloseBraceToken */, 5 /* Json.SyntaxKind.CommaToken */]);
             }
             node.valueNode = value;
             node.length = value.offset + value.length - node.offset;
             return node;
         }
         function _parseObject(parent) {
-            if (scanner.getToken() !== 1 /* OpenBraceToken */) {
+            if (scanner.getToken() !== 1 /* Json.SyntaxKind.OpenBraceToken */) {
                 return undefined;
             }
-            var node = new ObjectASTNodeImpl(parent, scanner.getTokenOffset());
-            var keysSeen = Object.create(null);
+            const node = new ObjectASTNodeImpl(parent, scanner.getTokenOffset());
+            const keysSeen = Object.create(null);
             _scanNext(); // consume OpenBraceToken
-            var needsComma = false;
-            while (scanner.getToken() !== 2 /* CloseBraceToken */ && scanner.getToken() !== 17 /* EOF */) {
-                if (scanner.getToken() === 5 /* CommaToken */) {
+            let needsComma = false;
+            while (scanner.getToken() !== 2 /* Json.SyntaxKind.CloseBraceToken */ && scanner.getToken() !== 17 /* Json.SyntaxKind.EOF */) {
+                if (scanner.getToken() === 5 /* Json.SyntaxKind.CommaToken */) {
                     if (!needsComma) {
                         _error(localize('PropertyExpected', 'Property expected'), jsonLanguageTypes_1.ErrorCode.PropertyExpected);
                     }
-                    var commaOffset = scanner.getTokenOffset();
+                    const commaOffset = scanner.getTokenOffset();
                     _scanNext(); // consume comma
-                    if (scanner.getToken() === 2 /* CloseBraceToken */) {
+                    if (scanner.getToken() === 2 /* Json.SyntaxKind.CloseBraceToken */) {
                         if (needsComma) {
                             _errorAtRange(localize('TrailingComma', 'Trailing comma'), jsonLanguageTypes_1.ErrorCode.TrailingComma, commaOffset, commaOffset + 1);
                         }
@@ -1161,37 +1171,37 @@ var __extends = (this && this.__extends) || (function () {
                 else if (needsComma) {
                     _error(localize('ExpectedComma', 'Expected comma'), jsonLanguageTypes_1.ErrorCode.CommaExpected);
                 }
-                var property = _parseProperty(node, keysSeen);
+                const property = _parseProperty(node, keysSeen);
                 if (!property) {
-                    _error(localize('PropertyExpected', 'Property expected'), jsonLanguageTypes_1.ErrorCode.PropertyExpected, undefined, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
+                    _error(localize('PropertyExpected', 'Property expected'), jsonLanguageTypes_1.ErrorCode.PropertyExpected, undefined, [], [2 /* Json.SyntaxKind.CloseBraceToken */, 5 /* Json.SyntaxKind.CommaToken */]);
                 }
                 else {
                     node.properties.push(property);
                 }
                 needsComma = true;
             }
-            if (scanner.getToken() !== 2 /* CloseBraceToken */) {
+            if (scanner.getToken() !== 2 /* Json.SyntaxKind.CloseBraceToken */) {
                 return _error(localize('ExpectedCloseBrace', 'Expected comma or closing brace'), jsonLanguageTypes_1.ErrorCode.CommaOrCloseBraceExpected, node);
             }
             return _finalize(node, true);
         }
         function _parseString(parent) {
-            if (scanner.getToken() !== 10 /* StringLiteral */) {
+            if (scanner.getToken() !== 10 /* Json.SyntaxKind.StringLiteral */) {
                 return undefined;
             }
-            var node = new StringASTNodeImpl(parent, scanner.getTokenOffset());
+            const node = new StringASTNodeImpl(parent, scanner.getTokenOffset());
             node.value = scanner.getTokenValue();
             return _finalize(node, true);
         }
         function _parseNumber(parent) {
-            if (scanner.getToken() !== 11 /* NumericLiteral */) {
+            if (scanner.getToken() !== 11 /* Json.SyntaxKind.NumericLiteral */) {
                 return undefined;
             }
-            var node = new NumberASTNodeImpl(parent, scanner.getTokenOffset());
-            if (scanner.getTokenError() === 0 /* None */) {
-                var tokenValue = scanner.getTokenValue();
+            const node = new NumberASTNodeImpl(parent, scanner.getTokenOffset());
+            if (scanner.getTokenError() === 0 /* Json.ScanError.None */) {
+                const tokenValue = scanner.getTokenValue();
                 try {
-                    var numberValue = JSON.parse(tokenValue);
+                    const numberValue = JSON.parse(tokenValue);
                     if (!(0, objects_1.isNumber)(numberValue)) {
                         return _error(localize('InvalidNumberFormat', 'Invalid number format.'), jsonLanguageTypes_1.ErrorCode.Undefined, node);
                     }
@@ -1205,13 +1215,13 @@ var __extends = (this && this.__extends) || (function () {
             return _finalize(node, true);
         }
         function _parseLiteral(parent) {
-            var node;
+            let node;
             switch (scanner.getToken()) {
-                case 7 /* NullKeyword */:
+                case 7 /* Json.SyntaxKind.NullKeyword */:
                     return _finalize(new NullASTNodeImpl(parent, scanner.getTokenOffset()), true);
-                case 8 /* TrueKeyword */:
+                case 8 /* Json.SyntaxKind.TrueKeyword */:
                     return _finalize(new BooleanASTNodeImpl(parent, true, scanner.getTokenOffset()), true);
-                case 9 /* FalseKeyword */:
+                case 9 /* Json.SyntaxKind.FalseKeyword */:
                     return _finalize(new BooleanASTNodeImpl(parent, false, scanner.getTokenOffset()), true);
                 default:
                     return undefined;
@@ -1220,14 +1230,14 @@ var __extends = (this && this.__extends) || (function () {
         function _parseValue(parent) {
             return _parseArray(parent) || _parseObject(parent) || _parseString(parent) || _parseNumber(parent) || _parseLiteral(parent);
         }
-        var _root = undefined;
-        var token = _scanNext();
-        if (token !== 17 /* EOF */) {
+        let _root = undefined;
+        const token = _scanNext();
+        if (token !== 17 /* Json.SyntaxKind.EOF */) {
             _root = _parseValue(_root);
             if (!_root) {
                 _error(localize('Invalid symbol', 'Expected a JSON object, array or literal.'), jsonLanguageTypes_1.ErrorCode.Undefined);
             }
-            else if (scanner.getToken() !== 17 /* EOF */) {
+            else if (scanner.getToken() !== 17 /* Json.SyntaxKind.EOF */) {
                 _error(localize('End of file expected', 'End of file expected.'), jsonLanguageTypes_1.ErrorCode.Undefined);
             }
         }