vscode-json-languageservice 4.2.0 → 5.1.0

package/lib/umd/services/jsonSchemaService.js

@@ -8,28 +8,28 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "jsonc-parser", "vscode-uri", "../utils/strings", "../parser/jsonParser", "vscode-nls", "../utils/glob"], factory);
+        define(["require", "exports", "jsonc-parser", "vscode-uri", "../utils/strings", "../parser/jsonParser", "vscode-nls", "../utils/glob", "../utils/objects"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JSONSchemaService = exports.ResolvedSchema = exports.UnresolvedSchema = void 0;
-    var Json = require("jsonc-parser");
-    var vscode_uri_1 = require("vscode-uri");
-    var Strings = require("../utils/strings");
-    var Parser = require("../parser/jsonParser");
-    var nls = require("vscode-nls");
-    var glob_1 = require("../utils/glob");
-    var localize = nls.loadMessageBundle();
-    var BANG = '!';
-    var PATH_SEP = '/';
-    var FilePatternAssociation = /** @class */ (function () {
-        function FilePatternAssociation(pattern, uris) {
+    const Json = require("jsonc-parser");
+    const vscode_uri_1 = require("vscode-uri");
+    const Strings = require("../utils/strings");
+    const Parser = require("../parser/jsonParser");
+    const nls = require("vscode-nls");
+    const glob_1 = require("../utils/glob");
+    const objects_1 = require("../utils/objects");
+    const localize = nls.loadMessageBundle();
+    const BANG = '!';
+    const PATH_SEP = '/';
+    class FilePatternAssociation {
+        constructor(pattern, uris) {
             this.globWrappers = [];
             try {
-                for (var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++) {
-                    var patternString = pattern_1[_i];
-                    var include = patternString[0] !== BANG;
+                for (let patternString of pattern) {
+                    const include = patternString[0] !== BANG;
                     if (!include) {
                         patternString = patternString.substring(1);
                     }
@@ -51,23 +51,21 @@
                 this.uris = [];
             }
         }
-        FilePatternAssociation.prototype.matchesPattern = function (fileName) {
-            var match = false;
-            for (var _i = 0, _a = this.globWrappers; _i < _a.length; _i++) {
-                var _b = _a[_i], regexp = _b.regexp, include = _b.include;
+        matchesPattern(fileName) {
+            let match = false;
+            for (const { regexp, include } of this.globWrappers) {
                 if (regexp.test(fileName)) {
                     match = include;
                 }
             }
             return match;
-        };
-        FilePatternAssociation.prototype.getURIs = function () {
+        }
+        getURIs() {
             return this.uris;
-        };
-        return FilePatternAssociation;
-    }());
-    var SchemaHandle = /** @class */ (function () {
-        function SchemaHandle(service, uri, unresolvedSchemaContent) {
+        }
+    }
+    class SchemaHandle {
+        constructor(service, uri, unresolvedSchemaContent) {
             this.service = service;
             this.uri = uri;
             this.dependencies = new Set();
@@ -76,66 +74,62 @@
                 this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));
             }
         }
-        SchemaHandle.prototype.getUnresolvedSchema = function () {
+        getUnresolvedSchema() {
             if (!this.unresolvedSchema) {
                 this.unresolvedSchema = this.service.loadSchema(this.uri);
             }
             return this.unresolvedSchema;
-        };
-        SchemaHandle.prototype.getResolvedSchema = function () {
-            var _this = this;
+        }
+        getResolvedSchema() {
             if (!this.resolvedSchema) {
-                this.resolvedSchema = this.getUnresolvedSchema().then(function (unresolved) {
-                    return _this.service.resolveSchemaContent(unresolved, _this);
+                this.resolvedSchema = this.getUnresolvedSchema().then(unresolved => {
+                    return this.service.resolveSchemaContent(unresolved, this);
                 });
             }
             return this.resolvedSchema;
-        };
-        SchemaHandle.prototype.clearSchema = function () {
-            var hasChanges = !!this.unresolvedSchema;
+        }
+        clearSchema() {
+            const hasChanges = !!this.unresolvedSchema;
             this.resolvedSchema = undefined;
             this.unresolvedSchema = undefined;
             this.dependencies.clear();
             this.anchors = undefined;
             return hasChanges;
-        };
-        return SchemaHandle;
-    }());
-    var UnresolvedSchema = /** @class */ (function () {
-        function UnresolvedSchema(schema, errors) {
-            if (errors === void 0) { errors = []; }
+        }
+    }
+    class UnresolvedSchema {
+        constructor(schema, errors = []) {
             this.schema = schema;
             this.errors = errors;
         }
-        return UnresolvedSchema;
-    }());
+    }
     exports.UnresolvedSchema = UnresolvedSchema;
-    var ResolvedSchema = /** @class */ (function () {
-        function ResolvedSchema(schema, errors) {
-            if (errors === void 0) { errors = []; }
+    class ResolvedSchema {
+        constructor(schema, errors = [], warnings = [], schemaDraft) {
             this.schema = schema;
             this.errors = errors;
+            this.warnings = warnings;
+            this.schemaDraft = schemaDraft;
         }
-        ResolvedSchema.prototype.getSection = function (path) {
-            var schemaRef = this.getSectionRecursive(path, this.schema);
+        getSection(path) {
+            const schemaRef = this.getSectionRecursive(path, this.schema);
             if (schemaRef) {
                 return Parser.asSchema(schemaRef);
             }
             return undefined;
-        };
-        ResolvedSchema.prototype.getSectionRecursive = function (path, schema) {
+        }
+        getSectionRecursive(path, schema) {
             if (!schema || typeof schema === 'boolean' || path.length === 0) {
                 return schema;
             }
-            var next = path.shift();
+            const next = path.shift();
             if (schema.properties && typeof schema.properties[next]) {
                 return this.getSectionRecursive(path, schema.properties[next]);
             }
             else if (schema.patternProperties) {
-                for (var _i = 0, _a = Object.keys(schema.patternProperties); _i < _a.length; _i++) {
-                    var pattern = _a[_i];
-                    var regex = Strings.extendedRegExp(pattern);
-                    if (regex === null || regex === void 0 ? void 0 : regex.test(next)) {
+                for (const pattern of Object.keys(schema.patternProperties)) {
+                    const regex = Strings.extendedRegExp(pattern);
+                    if (regex?.test(next)) {
                         return this.getSectionRecursive(path, schema.patternProperties[pattern]);
                     }
                 }
@@ -145,7 +139,7 @@
             }
             else if (next.match('[0-9]+')) {
                 if (Array.isArray(schema.items)) {
-                    var index = parseInt(next, 10);
+                    const index = parseInt(next, 10);
                     if (!isNaN(index) && schema.items[index]) {
                         return this.getSectionRecursive(path, schema.items[index]);
                     }
@@ -155,12 +149,11 @@
                 }
             }
             return undefined;
-        };
-        return ResolvedSchema;
-    }());
+        }
+    }
     exports.ResolvedSchema = ResolvedSchema;
-    var JSONSchemaService = /** @class */ (function () {
-        function JSONSchemaService(requestService, contextService, promiseConstructor) {
+    class JSONSchemaService {
+        constructor(requestService, contextService, promiseConstructor) {
             this.contextService = contextService;
             this.requestService = requestService;
             this.promiseConstructor = promiseConstructor || Promise;
@@ -171,36 +164,31 @@
             this.filePatternAssociations = [];
             this.registeredSchemasIds = {};
         }
-        JSONSchemaService.prototype.getRegisteredSchemaIds = function (filter) {
-            return Object.keys(this.registeredSchemasIds).filter(function (id) {
-                var scheme = vscode_uri_1.URI.parse(id).scheme;
+        getRegisteredSchemaIds(filter) {
+            return Object.keys(this.registeredSchemasIds).filter(id => {
+                const scheme = vscode_uri_1.URI.parse(id).scheme;
                 return scheme !== 'schemaservice' && (!filter || filter(scheme));
             });
-        };
-        Object.defineProperty(JSONSchemaService.prototype, "promise", {
-            get: function () {
-                return this.promiseConstructor;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        JSONSchemaService.prototype.dispose = function () {
+        }
+        get promise() {
+            return this.promiseConstructor;
+        }
+        dispose() {
             while (this.callOnDispose.length > 0) {
                 this.callOnDispose.pop()();
             }
-        };
-        JSONSchemaService.prototype.onResourceChange = function (uri) {
-            var _this = this;
+        }
+        onResourceChange(uri) {
             // always clear this local cache when a resource changes
             this.cachedSchemaForResource = undefined;
-            var hasChanges = false;
+            let hasChanges = false;
             uri = normalizeId(uri);
-            var toWalk = [uri];
-            var all = Object.keys(this.schemasById).map(function (key) { return _this.schemasById[key]; });
+            const toWalk = [uri];
+            const all = Object.keys(this.schemasById).map(key => this.schemasById[key]);
             while (toWalk.length) {
-                var curr = toWalk.pop();
-                for (var i = 0; i < all.length; i++) {
-                    var handle = all[i];
+                const curr = toWalk.pop();
+                for (let i = 0; i < all.length; i++) {
+                    const handle = all[i];
                     if (handle && (handle.uri === curr || handle.dependencies.has(curr))) {
                         if (handle.uri !== curr) {
                             toWalk.push(handle.uri);
@@ -213,87 +201,85 @@
                 }
             }
             return hasChanges;
-        };
-        JSONSchemaService.prototype.setSchemaContributions = function (schemaContributions) {
+        }
+        setSchemaContributions(schemaContributions) {
             if (schemaContributions.schemas) {
-                var schemas = schemaContributions.schemas;
-                for (var id in schemas) {
-                    var normalizedId = normalizeId(id);
+                const schemas = schemaContributions.schemas;
+                for (const id in schemas) {
+                    const normalizedId = normalizeId(id);
                     this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas[id]);
                 }
             }
             if (Array.isArray(schemaContributions.schemaAssociations)) {
-                var schemaAssociations = schemaContributions.schemaAssociations;
-                for (var _i = 0, schemaAssociations_1 = schemaAssociations; _i < schemaAssociations_1.length; _i++) {
-                    var schemaAssociation = schemaAssociations_1[_i];
-                    var uris = schemaAssociation.uris.map(normalizeId);
-                    var association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
+                const schemaAssociations = schemaContributions.schemaAssociations;
+                for (let schemaAssociation of schemaAssociations) {
+                    const uris = schemaAssociation.uris.map(normalizeId);
+                    const association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
                     this.contributionAssociations.push(association);
                 }
             }
-        };
-        JSONSchemaService.prototype.addSchemaHandle = function (id, unresolvedSchemaContent) {
-            var schemaHandle = new SchemaHandle(this, id, unresolvedSchemaContent);
+        }
+        addSchemaHandle(id, unresolvedSchemaContent) {
+            const schemaHandle = new SchemaHandle(this, id, unresolvedSchemaContent);
             this.schemasById[id] = schemaHandle;
             return schemaHandle;
-        };
-        JSONSchemaService.prototype.getOrAddSchemaHandle = function (id, unresolvedSchemaContent) {
+        }
+        getOrAddSchemaHandle(id, unresolvedSchemaContent) {
             return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);
-        };
-        JSONSchemaService.prototype.addFilePatternAssociation = function (pattern, uris) {
-            var fpa = new FilePatternAssociation(pattern, uris);
+        }
+        addFilePatternAssociation(pattern, uris) {
+            const fpa = new FilePatternAssociation(pattern, uris);
             this.filePatternAssociations.push(fpa);
             return fpa;
-        };
-        JSONSchemaService.prototype.registerExternalSchema = function (uri, filePatterns, unresolvedSchemaContent) {
-            var id = normalizeId(uri);
+        }
+        registerExternalSchema(uri, filePatterns, unresolvedSchemaContent) {
+            const id = normalizeId(uri);
             this.registeredSchemasIds[id] = true;
             this.cachedSchemaForResource = undefined;
             if (filePatterns) {
                 this.addFilePatternAssociation(filePatterns, [id]);
             }
             return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);
-        };
-        JSONSchemaService.prototype.clearExternalSchemas = function () {
+        }
+        clearExternalSchemas() {
             this.schemasById = {};
             this.filePatternAssociations = [];
             this.registeredSchemasIds = {};
             this.cachedSchemaForResource = undefined;
-            for (var id in this.contributionSchemas) {
+            for (const id in this.contributionSchemas) {
                 this.schemasById[id] = this.contributionSchemas[id];
                 this.registeredSchemasIds[id] = true;
             }
-            for (var _i = 0, _a = this.contributionAssociations; _i < _a.length; _i++) {
-                var contributionAssociation = _a[_i];
+            for (const contributionAssociation of this.contributionAssociations) {
                 this.filePatternAssociations.push(contributionAssociation);
             }
-        };
-        JSONSchemaService.prototype.getResolvedSchema = function (schemaId) {
-            var id = normalizeId(schemaId);
-            var schemaHandle = this.schemasById[id];
+        }
+        getResolvedSchema(schemaId) {
+            const id = normalizeId(schemaId);
+            const schemaHandle = this.schemasById[id];
             if (schemaHandle) {
                 return schemaHandle.getResolvedSchema();
             }
             return this.promise.resolve(undefined);
-        };
-        JSONSchemaService.prototype.loadSchema = function (url) {
+        }
+        loadSchema(url) {
             if (!this.requestService) {
-                var errorMessage = localize('json.schema.norequestservice', 'Unable to load schema from \'{0}\'. No schema request service available', toDisplayString(url));
+                const errorMessage = localize('json.schema.norequestservice', 'Unable to load schema from \'{0}\'. No schema request service available', toDisplayString(url));
                 return this.promise.resolve(new UnresolvedSchema({}, [errorMessage]));
             }
-            return this.requestService(url).then(function (content) {
+            return this.requestService(url).then(content => {
                 if (!content) {
-                    var errorMessage = localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': No content.', toDisplayString(url));
+                    const errorMessage = localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': No content.', toDisplayString(url));
                     return new UnresolvedSchema({}, [errorMessage]);
                 }
-                var schemaContent = {};
-                var jsonErrors = [];
+                let schemaContent = {};
+                const jsonErrors = [];
                 schemaContent = Json.parse(content, jsonErrors);
-                var errors = jsonErrors.length ? [localize('json.schema.invalidFormat', 'Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset)] : [];
+                const errors = jsonErrors.length ? [localize('json.schema.invalidFormat', 'Unable to parse content from \'{0}\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset)] : [];
                 return new UnresolvedSchema(schemaContent, errors);
-            }, function (error) {
-                var errorMessage = error.toString();
-                var errorSplit = error.toString().split('Error: ');
+            }, (error) => {
+                let errorMessage = error.toString();
+                const errorSplit = error.toString().split('Error: ');
                 if (errorSplit.length > 1) {
                     // more concise error message, URL and context are attached by caller anyways
                     errorMessage = errorSplit[1];
@@ -303,52 +289,44 @@
                 }
                 return new UnresolvedSchema({}, [localize('json.schema.nocontent', 'Unable to load schema from \'{0}\': {1}.', toDisplayString(url), errorMessage)]);
             });
-        };
-        JSONSchemaService.prototype.resolveSchemaContent = function (schemaToResolve, handle) {
-            var _this = this;
-            var resolveErrors = schemaToResolve.errors.slice(0);
-            var schema = schemaToResolve.schema;
-            if (schema.$schema) {
-                var id = normalizeId(schema.$schema);
-                if (id === 'http://json-schema.org/draft-03/schema') {
-                    return this.promise.resolve(new ResolvedSchema({}, [localize('json.schema.draft03.notsupported', "Draft-03 schemas are not supported.")]));
-                }
-                else if (id === 'https://json-schema.org/draft/2019-09/schema') {
-                    resolveErrors.push(localize('json.schema.draft201909.notsupported', "Draft 2019-09 schemas are not yet fully supported."));
-                }
-                else if (id === 'https://json-schema.org/draft/2020-12/schema') {
-                    resolveErrors.push(localize('json.schema.draft202012.notsupported', "Draft 2020-12 schemas are not yet fully supported."));
-                }
-            }
-            var contextService = this.contextService;
-            var findSectionByJSONPointer = function (schema, path) {
+        }
+        resolveSchemaContent(schemaToResolve, handle) {
+            const resolveErrors = schemaToResolve.errors.slice(0);
+            const schema = schemaToResolve.schema;
+            let schemaDraft = schema.$schema ? normalizeId(schema.$schema) : undefined;
+            if (schemaDraft === 'http://json-schema.org/draft-03/schema') {
+                return this.promise.resolve(new ResolvedSchema({}, [localize('json.schema.draft03.notsupported', "Draft-03 schemas are not supported.")], [], schemaDraft));
+            }
+            let usesUnsupportedFeatures = new Set();
+            const contextService = this.contextService;
+            const findSectionByJSONPointer = (schema, path) => {
                 path = decodeURIComponent(path);
-                var current = schema;
+                let current = schema;
                 if (path[0] === '/') {
                     path = path.substring(1);
                 }
-                path.split('/').some(function (part) {
+                path.split('/').some((part) => {
                     part = part.replace(/~1/g, '/').replace(/~0/g, '~');
                     current = current[part];
                     return !current;
                 });
                 return current;
             };
-            var findSchemaById = function (schema, handle, id) {
+            const findSchemaById = (schema, handle, id) => {
                 if (!handle.anchors) {
                     handle.anchors = collectAnchors(schema);
                 }
                 return handle.anchors.get(id);
             };
-            var merge = function (target, section) {
-                for (var key in section) {
+            const merge = (target, section) => {
+                for (const key in section) {
                     if (section.hasOwnProperty(key) && !target.hasOwnProperty(key) && key !== 'id' && key !== '$id') {
                         target[key] = section[key];
                     }
                 }
             };
-            var mergeRef = function (target, sourceRoot, sourceHandle, refSegment) {
-                var section;
+            const mergeRef = (target, sourceRoot, sourceHandle, refSegment) => {
+                let section;
                 if (refSegment === undefined || refSegment.length === 0) {
                     section = sourceRoot;
                 }
@@ -367,29 +345,29 @@
                     resolveErrors.push(localize('json.schema.invalidid', '$ref \'{0}\' in \'{1}\' can not be resolved.', refSegment, sourceHandle.uri));
                 }
             };
-            var resolveExternalLink = function (node, uri, refSegment, parentHandle) {
+            const resolveExternalLink = (node, uri, refSegment, parentHandle) => {
                 if (contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/\/.*/.test(uri)) {
                     uri = contextService.resolveRelativePath(uri, parentHandle.uri);
                 }
                 uri = normalizeId(uri);
-                var referencedHandle = _this.getOrAddSchemaHandle(uri);
-                return referencedHandle.getUnresolvedSchema().then(function (unresolvedSchema) {
+                const referencedHandle = this.getOrAddSchemaHandle(uri);
+                return referencedHandle.getUnresolvedSchema().then(unresolvedSchema => {
                     parentHandle.dependencies.add(uri);
                     if (unresolvedSchema.errors.length) {
-                        var loc = refSegment ? uri + '#' + refSegment : uri;
+                        const loc = refSegment ? uri + '#' + refSegment : uri;
                         resolveErrors.push(localize('json.schema.problemloadingref', 'Problems loading reference \'{0}\': {1}', loc, unresolvedSchema.errors[0]));
                     }
                     mergeRef(node, unresolvedSchema.schema, referencedHandle, refSegment);
                     return resolveRefs(node, unresolvedSchema.schema, referencedHandle);
                 });
             };
-            var resolveRefs = function (node, parentSchema, parentHandle) {
-                var openPromises = [];
-                _this.traverseNodes(node, function (next) {
-                    var seenRefs = new Set();
+            const resolveRefs = (node, parentSchema, parentHandle) => {
+                const openPromises = [];
+                this.traverseNodes(node, next => {
+                    const seenRefs = new Set();
                     while (next.$ref) {
-                        var ref = next.$ref;
-                        var segments = ref.split('#', 2);
+                        const ref = next.$ref;
+                        const segments = ref.split('#', 2);
                         delete next.$ref;
                         if (segments[0].length > 0) {
                             // This is a reference to an external schema
@@ -399,110 +377,119 @@
                         else {
                             // This is a reference inside the current schema
                             if (!seenRefs.has(ref)) {
-                                var id = segments[1];
+                                const id = segments[1];
                                 mergeRef(next, parentSchema, parentHandle, id);
                                 seenRefs.add(ref);
                             }
                         }
                     }
+                    if (next.$recursiveRef) {
+                        usesUnsupportedFeatures.add('$recursiveRef');
+                    }
+                    if (next.$dynamicRef) {
+                        usesUnsupportedFeatures.add('$dynamicRef');
+                    }
                 });
-                return _this.promise.all(openPromises);
+                return this.promise.all(openPromises);
             };
-            var collectAnchors = function (root) {
-                var result = new Map();
-                _this.traverseNodes(root, function (next) {
-                    var id = next.$id || next.id;
-                    if (typeof id === 'string' && id.charAt(0) === '#') {
-                        // delete next.$id;
-                        // delete next.id;
-                        var anchor = id.substring(1);
+            const collectAnchors = (root) => {
+                const result = new Map();
+                this.traverseNodes(root, next => {
+                    const id = next.$id || next.id;
+                    const anchor = (0, objects_1.isString)(id) && id.charAt(0) === '#' ? id.substring(1) : next.$anchor;
+                    if (anchor) {
                         if (result.has(anchor)) {
-                            resolveErrors.push(localize('json.schema.duplicateid', 'Duplicate id declaration: \'{0}\'', id));
+                            resolveErrors.push(localize('json.schema.duplicateid', 'Duplicate anchor declaration: \'{0}\'', anchor));
                         }
                         else {
                             result.set(anchor, next);
                         }
                     }
+                    if (next.$recursiveAnchor) {
+                        usesUnsupportedFeatures.add('$recursiveAnchor');
+                    }
+                    if (next.$dynamicAnchor) {
+                        usesUnsupportedFeatures.add('$dynamicAnchor');
+                    }
                 });
                 return result;
             };
-            return resolveRefs(schema, schema, handle).then(function (_) {
-                return new ResolvedSchema(schema, resolveErrors);
+            return resolveRefs(schema, schema, handle).then(_ => {
+                let resolveWarnings = [];
+                if (usesUnsupportedFeatures.size) {
+                    resolveWarnings.push(localize('json.schema.warnings', 'The schema uses meta-schema features ({0}) that are not yet supported by the validator.', Array.from(usesUnsupportedFeatures.keys()).join(', ')));
+                }
+                return new ResolvedSchema(schema, resolveErrors, resolveWarnings, schemaDraft);
             });
-        };
-        JSONSchemaService.prototype.traverseNodes = function (root, handle) {
+        }
+        traverseNodes(root, handle) {
             if (!root || typeof root !== 'object') {
                 return Promise.resolve(null);
             }
-            var seen = new Set();
-            var collectEntries = function () {
-                var entries = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    entries[_i] = arguments[_i];
-                }
-                for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {
-                    var entry = entries_1[_a];
-                    if (typeof entry === 'object') {
+            const seen = new Set();
+            const collectEntries = (...entries) => {
+                for (const entry of entries) {
+                    if ((0, objects_1.isObject)(entry)) {
                         toWalk.push(entry);
                     }
                 }
             };
-            var collectMapEntries = function () {
-                var maps = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    maps[_i] = arguments[_i];
-                }
-                for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {
-                    var map = maps_1[_a];
-                    if (typeof map === 'object') {
-                        for (var k in map) {
-                            var key = k;
-                            var entry = map[key];
-                            if (typeof entry === 'object') {
+            const collectMapEntries = (...maps) => {
+                for (const map of maps) {
+                    if ((0, objects_1.isObject)(map)) {
+                        for (const k in map) {
+                            const key = k;
+                            const entry = map[key];
+                            if ((0, objects_1.isObject)(entry)) {
                                 toWalk.push(entry);
                             }
                         }
                     }
                 }
             };
-            var collectArrayEntries = function () {
-                var arrays = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    arrays[_i] = arguments[_i];
-                }
-                for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {
-                    var array = arrays_1[_a];
+            const collectArrayEntries = (...arrays) => {
+                for (const array of arrays) {
                     if (Array.isArray(array)) {
-                        for (var _b = 0, array_1 = array; _b < array_1.length; _b++) {
-                            var entry = array_1[_b];
-                            if (typeof entry === 'object') {
+                        for (const entry of array) {
+                            if ((0, objects_1.isObject)(entry)) {
                                 toWalk.push(entry);
                             }
                         }
                     }
                 }
             };
-            var toWalk = [root];
-            var next = toWalk.pop();
+            const collectEntryOrArrayEntries = (items) => {
+                if (Array.isArray(items)) {
+                    for (const entry of items) {
+                        if ((0, objects_1.isObject)(entry)) {
+                            toWalk.push(entry);
+                        }
+                    }
+                }
+                else if ((0, objects_1.isObject)(items)) {
+                    toWalk.push(items);
+                }
+            };
+            const toWalk = [root];
+            let next = toWalk.pop();
             while (next) {
                 if (!seen.has(next)) {
                     seen.add(next);
                     handle(next);
-                    collectEntries(next.items, next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else);
-                    collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);
-                    collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items);
+                    collectEntries(next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else, next.unevaluatedItems, next.unevaluatedProperties);
+                    collectMapEntries(next.definitions, next.$defs, next.properties, next.patternProperties, next.dependencies, next.dependentSchemas);
+                    collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.prefixItems);
+                    collectEntryOrArrayEntries(next.items);
                 }
                 next = toWalk.pop();
             }
-        };
+        }
         ;
-        JSONSchemaService.prototype.getSchemaFromProperty = function (resource, document) {
-            var _a, _b;
-            if (((_a = document.root) === null || _a === void 0 ? void 0 : _a.type) === 'object') {
-                for (var _i = 0, _c = document.root.properties; _i < _c.length; _i++) {
-                    var p = _c[_i];
-                    if (p.keyNode.value === '$schema' && ((_b = p.valueNode) === null || _b === void 0 ? void 0 : _b.type) === 'string') {
-                        var schemaId = p.valueNode.value;
+        getSchemaFromProperty(resource, document) {
+            if (document.root?.type === 'object') {
+                for (const p of document.root.properties) {
+                    if (p.keyNode.value === '$schema' && p.valueNode?.type === 'string') {
+                        let schemaId = p.valueNode.value;
                         if (this.contextService && !/^\w[\w\d+.-]*:/.test(schemaId)) { // has scheme
                             schemaId = this.contextService.resolveRelativePath(schemaId, resource);
                         }
@@ -511,16 +498,14 @@
                 }
             }
             return undefined;
-        };
-        JSONSchemaService.prototype.getAssociatedSchemas = function (resource) {
-            var seen = Object.create(null);
-            var schemas = [];
-            var normalizedResource = normalizeResourceForMatching(resource);
-            for (var _i = 0, _a = this.filePatternAssociations; _i < _a.length; _i++) {
-                var entry = _a[_i];
+        }
+        getAssociatedSchemas(resource) {
+            const seen = Object.create(null);
+            const schemas = [];
+            const normalizedResource = normalizeResourceForMatching(resource);
+            for (const entry of this.filePatternAssociations) {
                 if (entry.matchesPattern(normalizedResource)) {
-                    for (var _b = 0, _c = entry.getURIs(); _b < _c.length; _b++) {
-                        var schemaId = _c[_b];
+                    for (const schemaId of entry.getURIs()) {
                         if (!seen[schemaId]) {
                             schemas.push(schemaId);
                             seen[schemaId] = true;
@@ -529,66 +514,65 @@
                 }
             }
             return schemas;
-        };
-        JSONSchemaService.prototype.getSchemaURIsForResource = function (resource, document) {
-            var schemeId = document && this.getSchemaFromProperty(resource, document);
+        }
+        getSchemaURIsForResource(resource, document) {
+            let schemeId = document && this.getSchemaFromProperty(resource, document);
             if (schemeId) {
                 return [schemeId];
             }
             return this.getAssociatedSchemas(resource);
-        };
-        JSONSchemaService.prototype.getSchemaForResource = function (resource, document) {
+        }
+        getSchemaForResource(resource, document) {
             if (document) {
                 // first use $schema if present
-                var schemeId = this.getSchemaFromProperty(resource, document);
+                let schemeId = this.getSchemaFromProperty(resource, document);
                 if (schemeId) {
-                    var id = normalizeId(schemeId);
+                    const id = normalizeId(schemeId);
                     return this.getOrAddSchemaHandle(id).getResolvedSchema();
                 }
             }
             if (this.cachedSchemaForResource && this.cachedSchemaForResource.resource === resource) {
                 return this.cachedSchemaForResource.resolvedSchema;
             }
-            var schemas = this.getAssociatedSchemas(resource);
-            var resolvedSchema = schemas.length > 0 ? this.createCombinedSchema(resource, schemas).getResolvedSchema() : this.promise.resolve(undefined);
-            this.cachedSchemaForResource = { resource: resource, resolvedSchema: resolvedSchema };
+            const schemas = this.getAssociatedSchemas(resource);
+            const resolvedSchema = schemas.length > 0 ? this.createCombinedSchema(resource, schemas).getResolvedSchema() : this.promise.resolve(undefined);
+            this.cachedSchemaForResource = { resource, resolvedSchema };
             return resolvedSchema;
-        };
-        JSONSchemaService.prototype.createCombinedSchema = function (resource, schemaIds) {
+        }
+        createCombinedSchema(resource, schemaIds) {
             if (schemaIds.length === 1) {
                 return this.getOrAddSchemaHandle(schemaIds[0]);
             }
             else {
-                var combinedSchemaId = 'schemaservice://combinedSchema/' + encodeURIComponent(resource);
-                var combinedSchema = {
-                    allOf: schemaIds.map(function (schemaId) { return ({ $ref: schemaId }); })
+                const combinedSchemaId = 'schemaservice://combinedSchema/' + encodeURIComponent(resource);
+                const combinedSchema = {
+                    allOf: schemaIds.map(schemaId => ({ $ref: schemaId }))
                 };
                 return this.addSchemaHandle(combinedSchemaId, combinedSchema);
             }
-        };
-        JSONSchemaService.prototype.getMatchingSchemas = function (document, jsonDocument, schema) {
+        }
+        getMatchingSchemas(document, jsonDocument, schema) {
             if (schema) {
-                var id = schema.id || ('schemaservice://untitled/matchingSchemas/' + idCounter++);
-                var handle = this.addSchemaHandle(id, schema);
-                return handle.getResolvedSchema().then(function (resolvedSchema) {
-                    return jsonDocument.getMatchingSchemas(resolvedSchema.schema).filter(function (s) { return !s.inverted; });
+                const id = schema.id || ('schemaservice://untitled/matchingSchemas/' + idCounter++);
+                const handle = this.addSchemaHandle(id, schema);
+                return handle.getResolvedSchema().then(resolvedSchema => {
+                    return jsonDocument.getMatchingSchemas(resolvedSchema.schema).filter(s => !s.inverted);
                 });
             }
-            return this.getSchemaForResource(document.uri, jsonDocument).then(function (schema) {
+            return this.getSchemaForResource(document.uri, jsonDocument).then(schema => {
                 if (schema) {
-                    return jsonDocument.getMatchingSchemas(schema.schema).filter(function (s) { return !s.inverted; });
+                    return jsonDocument.getMatchingSchemas(schema.schema).filter(s => !s.inverted);
                 }
                 return [];
             });
-        };
-        return JSONSchemaService;
-    }());
+        }
+    }
     exports.JSONSchemaService = JSONSchemaService;
-    var idCounter = 0;
+    let idCounter = 0;
     function normalizeId(id) {
         // remove trailing '#', normalize drive capitalization
         try {
-            return vscode_uri_1.URI.parse(id).toString();
+            return vscode_uri_1.URI.parse(id).toString(true);
         }
         catch (e) {
             return id;
@@ -597,7 +581,7 @@
     function normalizeResourceForMatching(resource) {
         // remove queries and fragments, normalize drive capitalization
         try {
-            return vscode_uri_1.URI.parse(resource).with({ fragment: null, query: null }).toString();
+            return vscode_uri_1.URI.parse(resource).with({ fragment: null, query: null }).toString(true);
         }
         catch (e) {
             return resource;
@@ -605,7 +589,7 @@
     }
     function toDisplayString(url) {
         try {
-            var uri = vscode_uri_1.URI.parse(url);
+            const uri = vscode_uri_1.URI.parse(url);
             if (uri.scheme === 'file') {
                 return uri.fsPath;
             }