z-schema 7.0.0 → 7.0.6

package/umd/ZSchema.js

@@ -1001,38 +1001,8 @@
 	    REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
 	};
 
-	const jsonSymbol = Symbol.for('z-schema/json');
-	const schemaSymbol = Symbol.for('z-schema/schema');
-	/**
-	 * @param {object} obj
-	 *
-	 * @returns {string[]}
-	 */
-	function sortedKeys(obj) {
-	    return Object.keys(obj).sort();
-	}
-	/**
-	 *
-	 * @param {string} uri
-	 *
-	 * @returns {boolean}
-	 */
-	function isAbsoluteUri(uri) {
-	    return /^https?:\/\//.test(uri);
-	}
-	/**
-	 *
-	 * @param {string} uri
-	 *
-	 * @returns {boolean}
-	 */
-	function isRelativeUri(uri) {
-	    // relative URIs that end with a hash sign, issue #56
-	    return /.+#/.test(uri);
-	}
-	function whatIs(what) {
-	    const to = typeof what;
-	    if (to === 'object') {
+	const whatIs = (what) => {
+	    if (typeof what === 'object') {
 	        if (what === null) {
 	            return 'null';
 	        }
@@ -1041,7 +1011,7 @@
 	        }
 	        return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
 	    }
-	    if (to === 'number') {
+	    if (typeof what === 'number') {
 	        if (Number.isFinite(what)) {
 	            if (what % 1 === 0) {
 	                return 'integer';
@@ -1055,242 +1025,45 @@
 	        }
 	        return 'unknown-number';
 	    }
-	    return to; // undefined, boolean, string, function
-	}
-	/**
-	 *
-	 * @param {*} json1
-	 * @param {*} json2
-	 * @param {*} [options]
-	 *
-	 * @returns {boolean}
-	 */
-	function areEqual(json1, json2, options) {
-	    options = options || {};
-	    const caseInsensitiveComparison = options.caseInsensitiveComparison || false;
-	    // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
-	    // Two JSON values are said to be equal if and only if:
-	    // both are nulls; or
-	    // both are booleans, and have the same value; or
-	    // both are strings, and have the same value; or
-	    // both are numbers, and have the same mathematical value; or
-	    if (json1 === json2) {
-	        return true;
-	    }
-	    if (caseInsensitiveComparison === true &&
-	        typeof json1 === 'string' &&
-	        typeof json2 === 'string' &&
-	        json1.toUpperCase() === json2.toUpperCase()) {
-	        return true;
-	    }
-	    let i, len;
-	    // both are arrays, and:
-	    if (Array.isArray(json1) && Array.isArray(json2)) {
-	        // have the same number of items; and
-	        if (json1.length !== json2.length) {
-	            return false;
-	        }
-	        // items at the same index are equal according to this definition; or
-	        len = json1.length;
-	        for (i = 0; i < len; i++) {
-	            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-	                return false;
-	            }
-	        }
-	        return true;
-	    }
-	    // both are objects, and:
-	    if (whatIs(json1) === 'object' && whatIs(json2) === 'object') {
-	        // have the same set of property names; and
-	        const keys1 = sortedKeys(json1);
-	        const keys2 = sortedKeys(json2);
-	        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
-	            return false;
-	        }
-	        // values for a same property name are equal according to this definition.
-	        len = keys1.length;
-	        for (i = 0; i < len; i++) {
-	            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-	                return false;
-	            }
-	        }
-	        return true;
-	    }
-	    return false;
-	}
-	/**
-	 *
-	 * @param {*[]} arr
-	 * @param {number[]} [indexes]
-	 *
-	 * @returns {boolean}
-	 */
-	function isUniqueArray(arr, indexes) {
-	    let i;
-	    let j;
-	    const l = arr.length;
-	    for (i = 0; i < l; i++) {
-	        for (j = i + 1; j < l; j++) {
-	            if (areEqual(arr[i], arr[j])) {
-	                if (indexes) {
-	                    indexes.push(i, j);
-	                }
-	                return false;
-	            }
-	        }
-	    }
-	    return true;
-	}
-	/**
-	 *
-	 * @param {*} bigSet
-	 * @param {*} subSet
-	 *
-	 * @returns {*[]}
-	 */
-	function difference(bigSet, subSet) {
-	    const arr = [];
-	    let idx = bigSet.length;
-	    while (idx--) {
-	        if (subSet.indexOf(bigSet[idx]) === -1) {
-	            arr.push(bigSet[idx]);
-	        }
-	    }
-	    return arr;
+	    return typeof what; // undefined, boolean, string, function
+	};
+	function isObject(value) {
+	    return whatIs(value) === 'object';
 	}
-	// NOT a deep version of clone
-	function clone(src) {
-	    if (typeof src === 'undefined') {
-	        return void 0;
-	    }
-	    if (typeof src !== 'object' || src === null) {
-	        return src;
-	    }
-	    let res, idx;
-	    if (Array.isArray(src)) {
-	        res = [];
-	        idx = src.length;
-	        while (idx--) {
-	            res[idx] = src[idx];
-	        }
-	    }
-	    else {
-	        res = {};
-	        const keys = Object.keys(src);
-	        idx = keys.length;
-	        while (idx--) {
-	            const key = keys[idx];
-	            res[key] = src[key];
-	        }
-	    }
+
+	const jsonSymbol = Symbol.for('z-schema/json');
+	const schemaSymbol = Symbol.for('z-schema/schema');
+
+	const getQueryPath = (uri) => {
+	    const io = uri.indexOf('#');
+	    const res = io === -1 ? undefined : uri.slice(io + 1);
+	    // WARN: do not slice slash, #/ means take root and go down from it
+	    // if (res && res[0] === "/") { res = res.slice(1); }
 	    return res;
-	}
-	function cloneDeep(src) {
-	    let vidx = 0;
-	    const visited = new Map();
-	    const cloned = [];
-	    function cloneDeepInner(src) {
-	        if (typeof src !== 'object' || src === null) {
-	            return src;
-	        }
-	        let res;
-	        let idx;
-	        const cidx = visited.get(src);
-	        if (cidx !== undefined) {
-	            return cloned[cidx];
-	        }
-	        visited.set(src, vidx++);
-	        if (Array.isArray(src)) {
-	            res = [];
-	            cloned.push(res);
-	            idx = src.length;
-	            while (idx--) {
-	                res[idx] = cloneDeepInner(src[idx]);
-	            }
-	        }
-	        else {
-	            res = {};
-	            cloned.push(res);
-	            const keys = Object.keys(src);
-	            idx = keys.length;
-	            while (idx--) {
-	                const key = keys[idx];
-	                res[key] = cloneDeepInner(src[key]);
-	            }
-	        }
-	        return res;
-	    }
-	    return cloneDeepInner(src);
-	}
-	/*
-	  following function comes from punycode.js library
-	  see: https://github.com/bestiejs/punycode.js
-	*/
-	/**
-	 * Creates an array containing the numeric code points of each Unicode
-	 * character in the string. While JavaScript uses UCS-2 internally,
-	 * this function will convert a pair of surrogate halves (each of which
-	 * UCS-2 exposes as separate characters) into a single code point,
-	 * matching UTF-16.
-	 * @see `punycode.ucs2.encode`
-	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-	 * @memberOf punycode.ucs2
-	 * @name decode
-	 * @param {String} string The Unicode input string (UCS-2).
-	 * @returns {Array} The new array of code points.
-	 */
-	function ucs2decode(string) {
-	    const output = [];
-	    let counter = 0;
-	    const length = string.length;
-	    let value;
-	    let extra;
-	    while (counter < length) {
-	        value = string.charCodeAt(counter++);
-	        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
-	            // high surrogate, and there is a next character
-	            extra = string.charCodeAt(counter++);
-	            if ((extra & 0xfc00) == 0xdc00) {
-	                // low surrogate
-	                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-	            }
-	            else {
-	                // unmatched surrogate; only append this code unit, in case the next
-	                // code unit is the high surrogate of a surrogate pair
-	                output.push(value);
-	                counter--;
-	            }
-	        }
-	        else {
-	            output.push(value);
-	        }
-	    }
-	    return output;
-	}
+	};
+	const getRemotePath = (uri) => {
+	    const io = uri.indexOf('#');
+	    return io === -1 ? uri : uri.slice(0, io);
+	};
+	const isAbsoluteUri = (uri) => /^https?:\/\//.test(uri);
+	const isRelativeUri = (uri) => 
+	// relative URIs that end with a hash sign, issue #56
+	/.+#/.test(uri);
 
 	class Report {
-	    errors;
+	    asyncTasks = [];
+	    commonErrorMessage;
+	    errors = [];
+	    json;
+	    path = [];
+	    rootSchema;
 	    parentReport;
 	    options;
 	    reportOptions;
-	    path;
-	    asyncTasks;
-	    rootSchema;
-	    commonErrorMessage;
-	    json;
 	    constructor(parentOrOptions, reportOptions) {
 	        this.parentReport = parentOrOptions instanceof Report ? parentOrOptions : undefined;
 	        this.options = parentOrOptions instanceof Report ? parentOrOptions.options : parentOrOptions || {};
 	        this.reportOptions = reportOptions || {};
-	        this.errors = [];
-	        /**
-	         * @type {string[]}
-	         */
-	        this.path = [];
-	        this.asyncTasks = [];
-	        this.rootSchema = undefined;
-	        this.commonErrorMessage = undefined;
-	        this.json = undefined;
 	    }
 	    isValid() {
 	        if (this.asyncTasks.length > 0) {
@@ -1321,17 +1094,15 @@
 	                callback(err, valid);
 	            }, 0);
 	        };
-	        function respond(asyncTaskResultProcessFn) {
-	            return function (asyncTaskResult) {
-	                if (timedOut) {
-	                    return;
-	                }
-	                asyncTaskResultProcessFn(asyncTaskResult);
-	                if (--tasksCount === 0) {
-	                    finish();
-	                }
-	            };
-	        }
+	        const respond = (asyncTaskResultProcessFn) => (asyncTaskResult) => {
+	            if (timedOut) {
+	                return;
+	            }
+	            asyncTaskResultProcessFn(asyncTaskResult);
+	            if (--tasksCount === 0) {
+	                finish();
+	            }
+	        };
 	        // finish if tasks are completed or there are any errors and breaking on first error was requested
 	        if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
 	            finish();
@@ -1351,9 +1122,6 @@
 	        }, validationTimeout);
 	    }
 	    getPath(returnPathAsString) {
-	        /**
-	         * @type {string[]|string}
-	         */
 	        let path = [];
 	        if (this.parentReport) {
 	            path = path.concat(this.parentReport.path);
@@ -1376,7 +1144,7 @@
 	    }
 	    getSchemaId() {
 	        if (!this.rootSchema) {
-	            return null;
+	            return undefined;
 	        }
 	        // get the error path as an array
 	        let path = [];
@@ -1395,16 +1163,16 @@
 	        // return id of the root
 	        return this.rootSchema.id;
 	    }
-	    hasError(errorCode, params) {
+	    hasError(errCode, errParams) {
 	        let idx = this.errors.length;
 	        while (idx--) {
-	            if (this.errors[idx].code === errorCode) {
+	            if (this.errors[idx].code === errCode) {
 	                // assume match
 	                let match = true;
 	                // check the params too
 	                let idx2 = this.errors[idx].params.length;
 	                while (idx2--) {
-	                    if (this.errors[idx].params[idx2] !== params[idx2]) {
+	                    if (this.errors[idx].params[idx2] !== errParams[idx2]) {
 	                        match = false;
 	                    }
 	                }
@@ -1416,12 +1184,13 @@
 	        }
 	        return false;
 	    }
-	    addError(errorCode, params, subReports, schema) {
-	        if (!errorCode) {
+	    addError(errCode, errParams, subReports, schema) {
+	        if (!errCode) {
 	            throw new Error('No errorCode passed into addError()');
 	        }
-	        this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
+	        this.addCustomError(errCode, Errors[errCode], errParams, subReports, schema);
 	    }
+	    // this returns the root object being validated (the one passed into validator.validate)
 	    getJson() {
 	        if (this.json) {
 	            return this.json;
@@ -1432,7 +1201,7 @@
 	        return undefined;
 	    }
 	    addCustomError(errorCode, errorMessage, params, subReports, schema) {
-	        if (this.errors.length >= this.reportOptions.maxErrors) {
+	        if (typeof this.reportOptions.maxErrors === 'number' && this.errors.length >= this.reportOptions.maxErrors) {
 	            return;
 	        }
 	        if (!errorMessage) {
@@ -1441,9 +1210,9 @@
 	        params = params || [];
 	        let idx = params.length;
 	        while (idx--) {
-	            const whatIs$1 = whatIs(params[idx]);
-	            const param = whatIs$1 === 'object' || whatIs$1 === 'null' ? JSON.stringify(params[idx]) : params[idx];
-	            errorMessage = errorMessage.replace('{' + idx + '}', param);
+	            const paramType = whatIs(params[idx]);
+	            const param = paramType === 'object' || paramType === 'null' ? JSON.stringify(params[idx]) : params[idx];
+	            errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
 	        }
 	        const err = {
 	            code: errorCode,
@@ -1452,6 +1221,7 @@
 	            path: this.getPath(this.options.reportPathAsArray),
 	            schemaId: this.getSchemaId(),
 	        };
+	        // TODO v8: remove Symbol usage
 	        err[schemaSymbol] = schema;
 	        err[jsonSymbol] = this.getJson();
 	        if (schema && typeof schema === 'string') {
@@ -1983,7 +1753,7 @@
 		return matches.exports;
 	}
 
-	var isEmail = {exports: {}};
+	var isEmail$1 = {exports: {}};
 
 	var checkHost = {exports: {}};
 
@@ -2141,12 +1911,12 @@
 		return isFQDN.exports;
 	}
 
-	var isIP = {exports: {}};
+	var isIP$1 = {exports: {}};
 
 	var hasRequiredIsIP;
 
 	function requireIsIP () {
-		if (hasRequiredIsIP) return isIP.exports;
+		if (hasRequiredIsIP) return isIP$1.exports;
 		hasRequiredIsIP = 1;
 		(function (module, exports$1) {
 
@@ -2215,14 +1985,14 @@
 			}
 			module.exports = exports$1.default;
 			module.exports.default = exports$1.default; 
-		} (isIP, isIP.exports));
-		return isIP.exports;
+		} (isIP$1, isIP$1.exports));
+		return isIP$1.exports;
 	}
 
 	var hasRequiredIsEmail;
 
 	function requireIsEmail () {
-		if (hasRequiredIsEmail) return isEmail.exports;
+		if (hasRequiredIsEmail) return isEmail$1.exports;
 		hasRequiredIsEmail = 1;
 		(function (module, exports$1) {
 
@@ -2398,11 +2168,11 @@
 			}
 			module.exports = exports$1.default;
 			module.exports.default = exports$1.default; 
-		} (isEmail, isEmail.exports));
-		return isEmail.exports;
+		} (isEmail$1, isEmail$1.exports));
+		return isEmail$1.exports;
 	}
 
-	var isURL = {exports: {}};
+	var isURL$1 = {exports: {}};
 
 	var includesString = {exports: {}};
 
@@ -2430,7 +2200,7 @@
 	var hasRequiredIsURL;
 
 	function requireIsURL () {
-		if (hasRequiredIsURL) return isURL.exports;
+		if (hasRequiredIsURL) return isURL$1.exports;
 		hasRequiredIsURL = 1;
 		(function (module, exports$1) {
 
@@ -2681,8 +2451,8 @@
 			}
 			module.exports = exports$1.default;
 			module.exports.default = exports$1.default; 
-		} (isURL, isURL.exports));
-		return isURL.exports;
+		} (isURL$1, isURL$1.exports));
+		return isURL$1.exports;
 	}
 
 	var isMACAddress = {exports: {}};
@@ -9383,140 +9153,359 @@
 	var validatorExports = /*@__PURE__*/ requireValidator();
 	var validator = /*@__PURE__*/getDefaultExportFromCjs(validatorExports);
 
-	const FormatValidators = {
-	    date: function (date) {
-	        if (typeof date !== 'string') {
-	            return true;
-	        }
-	        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
-	        const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
-	        if (matches === null) {
+	const areEqual = (json1, json2, options) => {
+	    options = options || {};
+	    const caseInsensitiveComparison = options.caseInsensitiveComparison || false;
+	    // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
+	    // Two JSON values are said to be equal if and only if:
+	    // both are nulls; or
+	    // both are booleans, and have the same value; or
+	    // both are strings, and have the same value; or
+	    // both are numbers, and have the same mathematical value; or
+	    if (json1 === json2) {
+	        return true;
+	    }
+	    if (caseInsensitiveComparison === true &&
+	        typeof json1 === 'string' &&
+	        typeof json2 === 'string' &&
+	        json1.toUpperCase() === json2.toUpperCase()) {
+	        return true;
+	    }
+	    let i, len;
+	    // both are arrays, and:
+	    if (Array.isArray(json1) && Array.isArray(json2)) {
+	        // have the same number of items; and
+	        if (json1.length !== json2.length) {
 	            return false;
 	        }
-	        // var year = matches[1];
-	        // var month = matches[2];
-	        // var day = matches[3];
-	        if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
-	            return false;
+	        // items at the same index are equal according to this definition; or
+	        len = json1.length;
+	        for (i = 0; i < len; i++) {
+	            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+	                return false;
+	            }
 	        }
 	        return true;
-	    },
-	    'date-time': function (dateTime) {
-	        if (typeof dateTime !== 'string') {
-	            return true;
-	        }
-	        // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
-	        const s = dateTime.toLowerCase().split('t');
-	        if (!FormatValidators.date(s[0])) {
-	            return false;
-	        }
-	        const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
-	        if (matches === null) {
+	    }
+	    // both are objects, and:
+	    if (isObject(json1) && isObject(json2)) {
+	        // have the same set of property names; and
+	        const keys1 = sortedKeys(json1);
+	        const keys2 = sortedKeys(json2);
+	        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
 	            return false;
 	        }
-	        // var hour = matches[1];
-	        // var minute = matches[2];
-	        // var second = matches[3];
-	        // var fraction = matches[4];
-	        // var timezone = matches[5];
-	        if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
-	            return false;
+	        // values for a same property name are equal according to this definition.
+	        len = keys1.length;
+	        for (i = 0; i < len; i++) {
+	            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+	                return false;
+	            }
 	        }
 	        return true;
-	    },
-	    email: function (email) {
-	        if (typeof email !== 'string') {
-	            return true;
-	        }
-	        return validator.isEmail(email, { require_tld: true });
-	    },
-	    hostname: function (hostname) {
-	        if (typeof hostname !== 'string') {
-	            return true;
+	    }
+	    return false;
+	};
+	const decodeJSONPointer = (str) => {
+	    // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
+	    return decodeURIComponent(str).replace(/~[0-1]/g, (x) => (x === '~1' ? '/' : '~'));
+	};
+	const sortedKeys = (obj) => Object.keys(obj).sort();
+
+	const { isEmail, isIP, isURL } = validator;
+	const dateValidator = (date) => {
+	    if (typeof date !== 'string') {
+	        return true;
+	    }
+	    // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+	    const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
+	    if (matches === null) {
+	        return false;
+	    }
+	    // var year = matches[1];
+	    // var month = matches[2];
+	    // var day = matches[3];
+	    if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
+	        return false;
+	    }
+	    return true;
+	};
+	const dateTimeValidator = (dateTime) => {
+	    if (typeof dateTime !== 'string') {
+	        return true;
+	    }
+	    // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
+	    const s = dateTime.toLowerCase().split('t');
+	    if (!dateValidator(s[0])) {
+	        return false;
+	    }
+	    const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
+	    if (matches === null) {
+	        return false;
+	    }
+	    // var hour = matches[1];
+	    // var minute = matches[2];
+	    // var second = matches[3];
+	    // var fraction = matches[4];
+	    // var timezone = matches[5];
+	    if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
+	        return false;
+	    }
+	    return true;
+	};
+	const emailValidator = (email) => {
+	    if (typeof email !== 'string') {
+	        return true;
+	    }
+	    return isEmail(email, { require_tld: true });
+	};
+	const hostnameValidator = (hostname) => {
+	    if (typeof hostname !== 'string') {
+	        return true;
+	    }
+	    /*
+	            http://json-schema.org/latest/json-schema-validation.html#anchor114
+	            A string instance is valid against this attribute if it is a valid
+	            representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+	  
+	            http://tools.ietf.org/html/rfc1034#section-3.5
+	  
+	            <digit> ::= any one of the ten digits 0 through 9
+	            var digit = /[0-9]/;
+	  
+	            <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+	            var letter = /[a-zA-Z]/;
+	  
+	            <let-dig> ::= <letter> | <digit>
+	            var letDig = /[0-9a-zA-Z]/;
+	  
+	            <let-dig-hyp> ::= <let-dig> | "-"
+	            var letDigHyp = /[-0-9a-zA-Z]/;
+	  
+	            <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+	            var ldhStr = /[-0-9a-zA-Z]+/;
+	  
+	            <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+	            var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+	  
+	            <subdomain> ::= <label> | <subdomain> "." <label>
+	            var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+	  
+	            <domain> ::= <subdomain> | " "
+	            var domain = null;
+	        */
+	    const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
+	    if (valid) {
+	        // the sum of all label octets and label lengths is limited to 255.
+	        if (hostname.length > 255) {
+	            return false;
 	        }
-	        /*
-	                http://json-schema.org/latest/json-schema-validation.html#anchor114
-	                A string instance is valid against this attribute if it is a valid
-	                representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
-	    
-	                http://tools.ietf.org/html/rfc1034#section-3.5
-	    
-	                <digit> ::= any one of the ten digits 0 through 9
-	                var digit = /[0-9]/;
-	    
-	                <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
-	                var letter = /[a-zA-Z]/;
-	    
-	                <let-dig> ::= <letter> | <digit>
-	                var letDig = /[0-9a-zA-Z]/;
-	    
-	                <let-dig-hyp> ::= <let-dig> | "-"
-	                var letDigHyp = /[-0-9a-zA-Z]/;
-	    
-	                <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
-	                var ldhStr = /[-0-9a-zA-Z]+/;
-	    
-	                <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
-	                var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
-	    
-	                <subdomain> ::= <label> | <subdomain> "." <label>
-	                var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
-	    
-	                <domain> ::= <subdomain> | " "
-	                var domain = null;
-	            */
-	        const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
-	        if (valid) {
-	            // the sum of all label octets and label lengths is limited to 255.
-	            if (hostname.length > 255) {
+	        // Each node has a label, which is zero to 63 octets in length
+	        const labels = hostname.split('.');
+	        for (let i = 0; i < labels.length; i++) {
+	            if (labels[i].length > 63) {
 	                return false;
 	            }
-	            // Each node has a label, which is zero to 63 octets in length
-	            const labels = hostname.split('.');
-	            for (let i = 0; i < labels.length; i++) {
-	                if (labels[i].length > 63) {
-	                    return false;
+	        }
+	    }
+	    return valid;
+	};
+	const ipv4Validator = (ipv4) => {
+	    if (typeof ipv4 !== 'string') {
+	        return true;
+	    }
+	    return isIP(ipv4, 4);
+	};
+	const ipv6Validator = (ipv6) => {
+	    if (typeof ipv6 !== 'string') {
+	        return true;
+	    }
+	    return isIP(ipv6, 6);
+	};
+	const regexValidator = (input) => {
+	    if (typeof input !== 'string') {
+	        return false;
+	    }
+	    try {
+	        RegExp(input);
+	        return true;
+	    }
+	    catch (_e) {
+	        return false;
+	    }
+	};
+	const strictUriValidator = (uri) => typeof uri !== 'string' || isURL(uri);
+	const uriValidator = function (uri) {
+	    // https://github.com/zaggino/z-schema/issues/18
+	    // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
+	    return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
+	};
+	const inbuiltValidators = {
+	    date: dateValidator,
+	    'date-time': dateTimeValidator,
+	    email: emailValidator,
+	    hostname: hostnameValidator,
+	    'host-name': hostnameValidator,
+	    ipv4: ipv4Validator,
+	    ipv6: ipv6Validator,
+	    regex: regexValidator,
+	    uri: uriValidator,
+	    'strict-uri': strictUriValidator,
+	};
+	const customValidators = {};
+	function getFormatValidators(options) {
+	    return {
+	        ...inbuiltValidators,
+	        ...(options?.strictUris ? { uri: strictUriValidator } : {}),
+	        ...customValidators,
+	    };
+	}
+	function registerFormat(name, validatorFunction) {
+	    customValidators[name] = validatorFunction;
+	}
+	function unregisterFormat(name) {
+	    delete customValidators[name];
+	}
+	function isFormatSupported(name) {
+	    return inbuiltValidators[name] != null || customValidators[name] != null;
+	}
+	function getRegisteredFormats() {
+	    return sortedKeys(customValidators);
+	}
+
+	/*
+	  following function comes from punycode.js library
+	  see: https://github.com/bestiejs/punycode.js
+	*/
+	/**
+	 * Creates an array containing the numeric code points of each Unicode
+	 * character in the string. While JavaScript uses UCS-2 internally,
+	 * this function will convert a pair of surrogate halves (each of which
+	 * UCS-2 exposes as separate characters) into a single code point,
+	 * matching UTF-16.
+	 * @see `punycode.ucs2.encode`
+	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode.ucs2
+	 * @name decode
+	 * @param {String} string The Unicode input string (UCS-2).
+	 * @returns {Array} The new array of code points.
+	 */
+	function ucs2decode(string) {
+	    const output = [];
+	    let counter = 0;
+	    const length = string.length;
+	    let value;
+	    let extra;
+	    while (counter < length) {
+	        value = string.charCodeAt(counter++);
+	        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
+	            // high surrogate, and there is a next character
+	            extra = string.charCodeAt(counter++);
+	            if ((extra & 0xfc00) == 0xdc00) {
+	                // low surrogate
+	                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
+	            }
+	            else {
+	                // unmatched surrogate; only append this code unit, in case the next
+	                // code unit is the high surrogate of a surrogate pair
+	                output.push(value);
+	                counter--;
+	            }
+	        }
+	        else {
+	            output.push(value);
+	        }
+	    }
+	    return output;
+	}
+
+	const isUniqueArray = (arr, indexes) => {
+	    let i;
+	    let j;
+	    const l = arr.length;
+	    for (i = 0; i < l; i++) {
+	        for (j = i + 1; j < l; j++) {
+	            if (areEqual(arr[i], arr[j])) {
+	                if (indexes) {
+	                    indexes.push(i, j);
 	                }
+	                return false;
 	            }
 	        }
-	        return valid;
-	    },
-	    'host-name': function (hostname) {
-	        return FormatValidators.hostname.call(this, hostname);
-	    },
-	    ipv4: function (ipv4) {
-	        if (typeof ipv4 !== 'string') {
-	            return true;
+	    }
+	    return true;
+	};
+	const difference = (bigSet, subSet) => {
+	    const arr = [];
+	    let idx = bigSet.length;
+	    while (idx--) {
+	        if (subSet.indexOf(bigSet[idx]) === -1) {
+	            arr.push(bigSet[idx]);
 	        }
-	        return validator.isIP(ipv4, 4);
-	    },
-	    ipv6: function (ipv6) {
-	        if (typeof ipv6 !== 'string') {
-	            return true;
+	    }
+	    return arr;
+	};
+
+	const shallowClone = (src) => {
+	    if (src == null || typeof src !== 'object') {
+	        return src;
+	    }
+	    let res;
+	    let idx;
+	    if (Array.isArray(src)) {
+	        res = [];
+	        idx = src.length;
+	        while (idx--) {
+	            res[idx] = src[idx];
 	        }
-	        return validator.isIP(ipv6, 6);
-	    },
-	    regex: function (str) {
-	        try {
-	            RegExp(str);
-	            return true;
+	    }
+	    else {
+	        res = {};
+	        const keys = Object.keys(src);
+	        idx = keys.length;
+	        while (idx--) {
+	            const key = keys[idx];
+	            res[key] = src[key];
 	        }
-	        catch (_e) {
-	            return false;
+	    }
+	    return res;
+	};
+	const deepClone = (src) => {
+	    let vidx = 0;
+	    const visited = new Map();
+	    const cloned = [];
+	    const cloneDeepInner = (src) => {
+	        if (typeof src !== 'object' || src === null) {
+	            return src;
 	        }
-	    },
-	    uri: function (...args) {
-	        if (this.options.strictUris) {
-	            return FormatValidators['strict-uri'].apply(this, args);
-	        }
-	        const [uri] = args;
-	        // https://github.com/zaggino/z-schema/issues/18
-	        // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
-	        return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
-	    },
-	    'strict-uri': function (uri) {
-	        return typeof uri !== 'string' || validator.isURL(uri);
-	    },
+	        let res;
+	        let idx;
+	        const cidx = visited.get(src);
+	        if (cidx !== undefined) {
+	            return cloned[cidx];
+	        }
+	        visited.set(src, vidx++);
+	        if (Array.isArray(src)) {
+	            res = [];
+	            cloned.push(res);
+	            idx = src.length;
+	            while (idx--) {
+	                res[idx] = cloneDeepInner(src[idx]);
+	            }
+	        }
+	        else {
+	            res = {};
+	            cloned.push(res);
+	            const keys = Object.keys(src);
+	            idx = keys.length;
+	            while (idx--) {
+	                const key = keys[idx];
+	                res[key] = cloneDeepInner(src[key]);
+	            }
+	        }
+	        return res;
+	    };
+	    return cloneDeepInner(src);
 	};
 
 	const shouldSkipValidate = function (options, errors) {
@@ -9528,6 +9517,12 @@
 	        }));
 	};
 	const JsonValidators = {
+	    id: () => { },
+	    $ref: () => { },
+	    $schema: () => { },
+	    title: () => { },
+	    description: () => { },
+	    default: () => { },
 	    multipleOf: function (report, schema, json) {
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
 	        if (shouldSkipValidate(this.validateOptions, ['MULTIPLE_OF'])) {
@@ -9539,7 +9534,7 @@
 	        const stringMultipleOf = String(schema.multipleOf);
 	        const scale = Math.pow(10, stringMultipleOf.length - stringMultipleOf.indexOf('.') - 1);
 	        if (whatIs((json * scale) / (schema.multipleOf * scale)) !== 'integer') {
-	            report.addError('MULTIPLE_OF', [json, schema.multipleOf], null, schema);
+	            report.addError('MULTIPLE_OF', [json, schema.multipleOf], undefined, schema);
 	        }
 	    },
 	    maximum: function (report, schema, json) {
@@ -9552,12 +9547,12 @@
 	        }
 	        if (schema.exclusiveMaximum !== true) {
 	            if (json > schema.maximum) {
-	                report.addError('MAXIMUM', [json, schema.maximum], null, schema);
+	                report.addError('MAXIMUM', [json, schema.maximum], undefined, schema);
 	            }
 	        }
 	        else {
 	            if (json >= schema.maximum) {
-	                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], null, schema);
+	                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], undefined, schema);
 	            }
 	        }
 	    },
@@ -9574,12 +9569,12 @@
 	        }
 	        if (schema.exclusiveMinimum !== true) {
 	            if (json < schema.minimum) {
-	                report.addError('MINIMUM', [json, schema.minimum], null, schema);
+	                report.addError('MINIMUM', [json, schema.minimum], undefined, schema);
 	            }
 	        }
 	        else {
 	            if (json <= schema.minimum) {
-	                report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], null, schema);
+	                report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], undefined, schema);
 	            }
 	        }
 	    },
@@ -9595,7 +9590,7 @@
 	            return;
 	        }
 	        if (ucs2decode(json).length > schema.maxLength) {
-	            report.addError('MAX_LENGTH', [json.length, schema.maxLength], null, schema);
+	            report.addError('MAX_LENGTH', [json.length, schema.maxLength], undefined, schema);
 	        }
 	    },
 	    minLength: function (report, schema, json) {
@@ -9607,7 +9602,7 @@
 	            return;
 	        }
 	        if (ucs2decode(json).length < schema.minLength) {
-	            report.addError('MIN_LENGTH', [json.length, schema.minLength], null, schema);
+	            report.addError('MIN_LENGTH', [json.length, schema.minLength], undefined, schema);
 	        }
 	    },
 	    pattern: function (report, schema, json) {
@@ -9619,7 +9614,7 @@
 	            return;
 	        }
 	        if (RegExp(schema.pattern).test(json) === false) {
-	            report.addError('PATTERN', [schema.pattern, json], null, schema);
+	            report.addError('PATTERN', [schema.pattern, json], undefined, schema);
 	        }
 	    },
 	    additionalItems: function (report, schema, json) {
@@ -9634,12 +9629,12 @@
 	        // the json is valid if its size is less than, or equal to, the size of "items".
 	        if (schema.additionalItems === false && Array.isArray(schema.items)) {
 	            if (json.length > schema.items.length) {
-	                report.addError('ARRAY_ADDITIONAL_ITEMS', null, null, schema);
+	                report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema);
 	            }
 	        }
 	    },
 	    items: function () {
-	        /*report, schema, json*/
+	        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
 	        // covered in additionalItems
 	    },
 	    maxItems: function (report, schema, json) {
@@ -9651,7 +9646,7 @@
 	            return;
 	        }
 	        if (json.length > schema.maxItems) {
-	            report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], null, schema);
+	            report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], undefined, schema);
 	        }
 	    },
 	    minItems: function (report, schema, json) {
@@ -9663,7 +9658,7 @@
 	            return;
 	        }
 	        if (json.length < schema.minItems) {
-	            report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], null, schema);
+	            report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], undefined, schema);
 	        }
 	    },
 	    uniqueItems: function (report, schema, json) {
@@ -9677,7 +9672,7 @@
 	        if (schema.uniqueItems === true) {
 	            const matches = [];
 	            if (isUniqueArray(json, matches) === false) {
-	                report.addError('ARRAY_UNIQUE', matches, null, schema);
+	                report.addError('ARRAY_UNIQUE', matches, undefined, schema);
 	            }
 	        }
 	    },
@@ -9686,12 +9681,12 @@
 	        if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
 	            return;
 	        }
-	        if (whatIs(json) !== 'object') {
+	        if (!isObject(json)) {
 	            return;
 	        }
 	        const keysCount = Object.keys(json).length;
 	        if (keysCount > schema.maxProperties) {
-	            report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], null, schema);
+	            report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], undefined, schema);
 	        }
 	    },
 	    minProperties: function (report, schema, json) {
@@ -9699,12 +9694,12 @@
 	        if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
 	            return;
 	        }
-	        if (whatIs(json) !== 'object') {
+	        if (!isObject(json)) {
 	            return;
 	        }
 	        const keysCount = Object.keys(json).length;
 	        if (keysCount < schema.minProperties) {
-	            report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], null, schema);
+	            report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], undefined, schema);
 	        }
 	    },
 	    required: function (report, schema, json) {
@@ -9712,14 +9707,14 @@
 	        if (shouldSkipValidate(this.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
 	            return;
 	        }
-	        if (whatIs(json) !== 'object') {
+	        if (!isObject(json)) {
 	            return;
 	        }
 	        let idx = schema.required.length;
 	        while (idx--) {
 	            const requiredPropertyName = schema.required[idx];
 	            if (json[requiredPropertyName] === undefined) {
-	                report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], null, schema);
+	                report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], undefined, schema);
 	            }
 	        }
 	    },
@@ -9740,7 +9735,7 @@
 	        if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
 	            return;
 	        }
-	        if (whatIs(json) !== 'object') {
+	        if (!isObject(json)) {
 	            return;
 	        }
 	        const properties = schema.properties !== undefined ? schema.properties : {};
@@ -9768,19 +9763,21 @@
 	            // Validation of the json succeeds if, after these two steps, set "s" is empty.
 	            if (s.length > 0) {
 	                // assumeAdditional can be an array of allowed properties
-	                let idx3 = this.options.assumeAdditional.length;
-	                if (idx3) {
-	                    while (idx3--) {
-	                        const io = s.indexOf(this.options.assumeAdditional[idx3]);
-	                        if (io !== -1) {
-	                            s.splice(io, 1);
+	                if (Array.isArray(this.options.assumeAdditional)) {
+	                    let idx3 = this.options.assumeAdditional.length;
+	                    if (idx3) {
+	                        while (idx3--) {
+	                            const io = s.indexOf(this.options.assumeAdditional[idx3]);
+	                            if (io !== -1) {
+	                                s.splice(io, 1);
+	                            }
 	                        }
 	                    }
 	                }
 	                let idx4 = s.length;
 	                if (idx4) {
 	                    while (idx4--) {
-	                        report.addError('OBJECT_ADDITIONAL_PROPERTIES', [s[idx4]], null, schema);
+	                        report.addError('OBJECT_ADDITIONAL_PROPERTIES', [s[idx4]], undefined, schema);
 	                    }
 	                }
 	            }
@@ -9791,7 +9788,7 @@
 	        if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
 	            return;
 	        }
-	        if (whatIs(json) !== 'object') {
+	        if (!isObject(json)) {
 	            return;
 	        }
 	        const keys = Object.keys(schema.dependencies);
@@ -9801,21 +9798,21 @@
 	            const dependencyName = keys[idx];
 	            if (json[dependencyName]) {
 	                const dependencyDefinition = schema.dependencies[dependencyName];
-	                if (whatIs(dependencyDefinition) === 'object') {
-	                    // if dependency is a schema, validate against this schema
-	                    validate.call(this, report, dependencyDefinition, json);
-	                }
-	                else {
+	                if (Array.isArray(dependencyDefinition)) {
 	                    // Array
 	                    // if dependency is an array, object needs to have all properties in this array
 	                    let idx2 = dependencyDefinition.length;
 	                    while (idx2--) {
 	                        const requiredPropertyName = dependencyDefinition[idx2];
 	                        if (json[requiredPropertyName] === undefined) {
-	                            report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], null, schema);
+	                            report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], undefined, schema);
 	                        }
 	                    }
 	                }
+	                else {
+	                    // if dependency is a schema, validate against this schema
+	                    validate.call(this, report, dependencyDefinition, json);
+	                }
 	            }
 	        }
 	    },
@@ -9836,7 +9833,7 @@
 	        }
 	        if (match === false) {
 	            const error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
-	            report.addError(error, [json], null, schema);
+	            report.addError(error, [JSON.stringify(json)], undefined, schema);
 	        }
 	    },
 	    type: function (report, schema, json) {
@@ -9847,12 +9844,12 @@
 	        const jsonType = whatIs(json);
 	        if (typeof schema.type === 'string') {
 	            if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
-	                report.addError('INVALID_TYPE', [schema.type, jsonType], null, schema);
+	                report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema);
 	            }
 	        }
 	        else {
 	            if (schema.type.indexOf(jsonType) === -1 && (jsonType !== 'integer' || schema.type.indexOf('number') === -1)) {
-	                report.addError('INVALID_TYPE', [schema.type, jsonType], null, schema);
+	                report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema);
 	            }
 	        }
 	    },
@@ -9896,24 +9893,25 @@
 	            report.addError('ONE_OF_MISSING', undefined, subReports, schema);
 	        }
 	        else if (passes > 1) {
-	            report.addError('ONE_OF_MULTIPLE', null, null, schema);
+	            report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema);
 	        }
 	    },
 	    not: function (report, schema, json) {
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
 	        const subReport = new Report(report);
 	        if (validate.call(this, subReport, schema.not, json) === true) {
-	            report.addError('NOT_PASSED', null, null, schema);
+	            report.addError('NOT_PASSED', undefined, undefined, schema);
 	        }
 	    },
 	    definitions: function () {
-	        /*report, schema, json*/
+	        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.2
 	        // nothing to do here
 	    },
 	    format: function (report, schema, json) {
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-	        const formatValidatorFn = FormatValidators[schema.format];
+	        const formatValidators = getFormatValidators(this.options);
+	        const formatValidatorFn = formatValidators[schema.format];
 	        if (typeof formatValidatorFn === 'function') {
 	            if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
 	                return;
@@ -9923,12 +9921,12 @@
 	            }
 	            if (formatValidatorFn.length === 2) {
 	                // async - need to clone the path here, because it will change by the time async function reports back
-	                const pathBeforeAsync = clone(report.path);
+	                const pathBeforeAsync = shallowClone(report.path);
 	                report.addAsyncTask(formatValidatorFn, [json], function (result) {
 	                    if (result !== true) {
 	                        const backup = report.path;
 	                        report.path = pathBeforeAsync;
-	                        report.addError('INVALID_FORMAT', [schema.format, json], null, schema);
+	                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema);
 	                        report.path = backup;
 	                    }
 	                });
@@ -9936,12 +9934,12 @@
 	            else {
 	                // sync
 	                if (formatValidatorFn.call(this, json) !== true) {
-	                    report.addError('INVALID_FORMAT', [schema.format, json], null, schema);
+	                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema);
 	                }
 	            }
 	        }
 	        else if (this.options.ignoreUnknownFormats !== true) {
-	            report.addError('UNKNOWN_FORMAT', [schema.format], null, schema);
+	            report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema);
 	        }
 	    },
 	};
@@ -10027,18 +10025,12 @@
 	        }
 	    }
 	};
-	/**
-	 *
-	 * @param {Report} report
-	 * @param {*} schema
-	 * @param {*} json
-	 */
 	function validate(report, schema, json) {
 	    report.commonErrorMessage = 'JSON_OBJECT_VALIDATION_FAILED';
 	    // check if schema is an object
 	    const to = whatIs(schema);
 	    if (to !== 'object') {
-	        report.addError('SCHEMA_NOT_AN_OBJECT', [to], null, schema);
+	        report.addError('SCHEMA_NOT_AN_OBJECT', [to], undefined, schema);
 	        return false;
 	    }
 	    // check if schema is empty, everything is valid against empty schema
@@ -10058,7 +10050,7 @@
 	        let maxRefs = 99;
 	        while (schema.$ref && maxRefs > 0) {
 	            if (!schema.__$refResolved) {
-	                report.addError('REF_UNRESOLVED', [schema.$ref], null, schema);
+	                report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
 	                break;
 	            }
 	            else if (schema.__$refResolved === schema) {
@@ -10075,7 +10067,6 @@
 	        }
 	    }
 	    // type checking first
-	    const jsonType = whatIs(json);
 	    if (schema.type) {
 	        keys.splice(keys.indexOf('type'), 1);
 	        JsonValidators.type.call(this, report, schema, json);
@@ -10094,10 +10085,10 @@
 	        }
 	    }
 	    if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
-	        if (jsonType === 'array') {
+	        if (Array.isArray(json)) {
 	            recurseArray.call(this, report, schema, json);
 	        }
-	        else if (jsonType === 'object') {
+	        else if (isObject(json)) {
 	            recurseObject.call(this, report, schema, json);
 	        }
 	    }
@@ -11976,40 +11967,156 @@
 	var lodash_isequalExports = requireLodash_isequal();
 	var isequal = /*@__PURE__*/getDefaultExportFromCjs(lodash_isequalExports);
 
-	function mergeReference(scope, ref) {
-	    if (isAbsoluteUri(ref)) {
-	        return ref;
+	const findId = (schema, id) => {
+	    // process only arrays and objects
+	    if (typeof schema !== 'object' || schema === null) {
+	        return;
 	    }
-	    let joinedScope = scope.join('');
-	    const isScopeAbsolute = isAbsoluteUri(joinedScope);
-	    const isScopeRelative = isRelativeUri(joinedScope);
-	    const isRefRelative = isRelativeUri(ref);
-	    let toRemove;
-	    if (isScopeAbsolute && isRefRelative) {
-	        toRemove = joinedScope.match(/\/[^/]*$/);
-	        if (toRemove) {
-	            joinedScope = joinedScope.slice(0, toRemove.index + 1);
-	        }
+	    // no id means root so return itself
+	    if (!id) {
+	        return schema;
 	    }
-	    else if (isScopeRelative && isRefRelative) {
-	        joinedScope = '';
+	    if (schema.id) {
+	        if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+	            return schema;
+	        }
 	    }
-	    else {
-	        toRemove = joinedScope.match(/[^#/]+$/);
-	        if (toRemove) {
-	            joinedScope = joinedScope.slice(0, toRemove.index);
+	    let idx, result;
+	    if (Array.isArray(schema)) {
+	        idx = schema.length;
+	        while (idx--) {
+	            result = findId(schema[idx], id);
+	            if (result) {
+	                return result;
+	            }
 	        }
 	    }
-	    let res = joinedScope + ref;
-	    res = res.replace(/##/, '#');
-	    return res;
-	}
-	function collectReferences(obj, results, scope, path) {
-	    results = results || [];
-	    scope = scope || [];
-	    path = path || [];
-	    if (typeof obj !== 'object' || obj === null) {
-	        return results;
+	    if (isObject(schema)) {
+	        const keys = Object.keys(schema);
+	        idx = keys.length;
+	        while (idx--) {
+	            const k = keys[idx];
+	            if (k.indexOf('__$') === 0) {
+	                continue;
+	            }
+	            result = findId(schema[k], id);
+	            if (result) {
+	                return result;
+	            }
+	        }
+	    }
+	};
+
+	class SchemaCache {
+	    validator;
+	    cache = {};
+	    referenceCache = [];
+	    constructor(validator) {
+	        this.validator = validator;
+	    }
+	    cacheSchemaByUri(uri, schema) {
+	        const remotePath = getRemotePath(uri);
+	        if (remotePath) {
+	            this.cache[remotePath] = schema;
+	        }
+	    }
+	    removeFromCacheByUri(uri) {
+	        const remotePath = getRemotePath(uri);
+	        if (remotePath) {
+	            delete this.cache[remotePath];
+	        }
+	    }
+	    checkCacheForUri(uri) {
+	        const remotePath = getRemotePath(uri);
+	        return remotePath ? this.cache[remotePath] != null : false;
+	    }
+	    getSchema(report, refOrSchema) {
+	        if (typeof refOrSchema === 'string') {
+	            // ref input
+	            return this.getSchemaByUri(report, refOrSchema);
+	        }
+	        if (typeof refOrSchema === 'object') {
+	            // schema obj input
+	            return this.getSchemaByReference(report, refOrSchema);
+	        }
+	        throw new Error(`unexpected code reached`);
+	    }
+	    getSchemaByUri(report, uri, root) {
+	        const remotePath = getRemotePath(uri);
+	        const queryPath = getQueryPath(uri);
+	        let result = remotePath ? this.cache[remotePath] : root;
+	        if (result && remotePath) {
+	            // we need to avoid compiling schemas in a recursive loop
+	            const compileRemote = result !== root;
+	            // now we need to compile and validate resolved schema (in case it's not already)
+	            if (compileRemote) {
+	                report.path.push(remotePath);
+	                let remoteReport;
+	                const anscestorReport = result.id ? report.getAncestor(result.id) : undefined;
+	                if (anscestorReport) {
+	                    remoteReport = anscestorReport;
+	                }
+	                else {
+	                    remoteReport = new Report(report);
+	                    if (this.validator.sc.compileSchema(remoteReport, result)) {
+	                        const savedOptions = this.validator.options;
+	                        try {
+	                            // If custom validationOptions were provided to setRemoteReference(),
+	                            // use them instead of the default options
+	                            this.validator.options = result.__$validationOptions || this.validator.options;
+	                            this.validator.sv.validateSchema(remoteReport, result);
+	                        }
+	                        finally {
+	                            this.validator.options = savedOptions;
+	                        }
+	                    }
+	                }
+	                const remoteReportIsValid = remoteReport.isValid();
+	                if (!remoteReportIsValid) {
+	                    report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
+	                }
+	                report.path.pop();
+	                if (!remoteReportIsValid) {
+	                    return undefined;
+	                }
+	            }
+	        }
+	        if (result && queryPath) {
+	            const parts = queryPath.split('/');
+	            for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
+	                const key = decodeJSONPointer(parts[idx]);
+	                if (idx === 0) {
+	                    // it's an id
+	                    result = findId(result, key);
+	                }
+	                else {
+	                    // it's a path behind id
+	                    result = result[key];
+	                }
+	            }
+	        }
+	        return result;
+	    }
+	    getSchemaByReference(report, schema) {
+	        let i = this.referenceCache.length;
+	        while (i--) {
+	            if (isequal(this.referenceCache[i][0], schema)) {
+	                return this.referenceCache[i][1];
+	            }
+	        }
+	        // not found
+	        const schemaClone = deepClone(schema);
+	        this.referenceCache.push([schema, schemaClone]);
+	        return schemaClone;
+	    }
+	}
+
+	const collectReferences = (obj, results, scope, path) => {
+	    results = results || [];
+	    scope = scope || [];
+	    path = path || [];
+	    if (typeof obj !== 'object' || obj === null) {
+	        return results;
 	    }
 	    if (typeof obj.id === 'string') {
 	        scope.push(obj.id);
@@ -12034,7 +12141,7 @@
 	    if (Array.isArray(obj)) {
 	        idx = obj.length;
 	        while (idx--) {
-	            path.push(idx.toString());
+	            path.push(idx);
 	            collectReferences(obj[idx], results, scope, path);
 	            path.pop();
 	        }
@@ -12056,175 +12163,200 @@
 	        scope.pop();
 	    }
 	    return results;
-	}
-	const compileArrayOfSchemasLoop = function (mainReport, arr) {
-	    let idx = arr.length, compiledCount = 0;
-	    while (idx--) {
-	        // try to compile each schema separately
-	        const report = new Report(mainReport);
-	        const isValid = compileSchema.call(this, report, arr[idx]);
-	        if (isValid) {
-	            compiledCount++;
+	};
+	const mergeReference = (scope, ref) => {
+	    if (isAbsoluteUri(ref)) {
+	        return ref;
+	    }
+	    let joinedScope = scope.join('');
+	    const isScopeAbsolute = isAbsoluteUri(joinedScope);
+	    const isScopeRelative = isRelativeUri(joinedScope);
+	    const isRefRelative = isRelativeUri(ref);
+	    let toRemove;
+	    if (isScopeAbsolute && isRefRelative) {
+	        toRemove = joinedScope.match(/\/[^/]*$/);
+	        if (toRemove) {
+	            joinedScope = joinedScope.slice(0, toRemove.index + 1);
 	        }
-	        // copy errors to report
-	        mainReport.errors = mainReport.errors.concat(report.errors);
 	    }
-	    return compiledCount;
-	};
-	function findId$1(arr, id) {
-	    let idx = arr.length;
-	    while (idx--) {
-	        if (arr[idx].id === id) {
-	            return arr[idx];
+	    else if (isScopeRelative && isRefRelative) {
+	        joinedScope = '';
+	    }
+	    else {
+	        toRemove = joinedScope.match(/[^#/]+$/);
+	        if (toRemove) {
+	            joinedScope = joinedScope.slice(0, toRemove.index);
 	        }
 	    }
-	    return null;
-	}
-	const compileArrayOfSchemas = function (report, arr) {
-	    let compiled = 0, lastLoopCompiled;
-	    do {
-	        // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-	        let idx = report.errors.length;
-	        while (idx--) {
-	            if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
-	                report.errors.splice(idx, 1);
+	    let res = joinedScope + ref;
+	    res = res.replace(/##/, '#');
+	    return res;
+	};
+	class SchemaCompiler {
+	    validator;
+	    constructor(validator) {
+	        this.validator = validator;
+	    }
+	    compileSchema(report, schema) {
+	        report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
+	        // if schema is a string, assume it's a uri
+	        if (typeof schema === 'string') {
+	            const loadedSchema = this.validator.scache.getSchemaByUri(report, schema);
+	            if (!loadedSchema) {
+	                report.addError('SCHEMA_NOT_REACHABLE', [schema]);
+	                return false;
 	            }
+	            schema = loadedSchema;
+	        }
+	        // if schema is an array, assume it's an array of schemas
+	        if (Array.isArray(schema)) {
+	            return this.compileArrayOfSchemas(report, schema);
+	        }
+	        // if we have an id than it should be cached already (if this instance has compiled it)
+	        if (schema.__$compiled && schema.id && this.validator.scache.checkCacheForUri(schema.id) === false) {
+	            schema.__$compiled = undefined;
+	        }
+	        // do not re-compile schemas
+	        if (schema.__$compiled) {
+	            return true;
 	        }
-	        // remember how many were compiled in the last loop
-	        lastLoopCompiled = compiled;
-	        // count how many are compiled now
-	        compiled = compileArrayOfSchemasLoop.call(this, report, arr);
-	        // fix __$missingReferences if possible
-	        idx = arr.length;
+	        if (schema.id && typeof schema.id === 'string') {
+	            // add this to our schemaCache (before compilation in case we have references including id)
+	            this.validator.scache.cacheSchemaByUri(schema.id, schema);
+	        }
+	        // this method can be called recursively, so we need to remember our root
+	        let isRoot = false;
+	        if (!report.rootSchema) {
+	            report.rootSchema = schema;
+	            isRoot = true;
+	        }
+	        // delete all __$missingReferences from previous compilation attempts
+	        const isValidExceptReferences = report.isValid();
+	        delete schema.__$missingReferences;
+	        // collect all references that need to be resolved - $ref and $schema
+	        const refs = collectReferences(schema);
+	        let idx = refs.length;
 	        while (idx--) {
-	            const sch = arr[idx];
-	            if (sch.__$missingReferences) {
-	                let idx2 = sch.__$missingReferences.length;
-	                while (idx2--) {
-	                    const refObj = sch.__$missingReferences[idx2];
-	                    const response = findId$1(arr, refObj.ref);
-	                    if (response) {
-	                        // this might create circular references
-	                        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-	                        // it's resolved now so delete it
-	                        sch.__$missingReferences.splice(idx2, 1);
+	            // resolve all the collected references into __xxxResolved pointer
+	            const refObj = refs[idx];
+	            let response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+	            // we can try to use custom schemaReader if available
+	            if (!response) {
+	                const schemaReader = this.validator.getSchemaReader();
+	                if (schemaReader) {
+	                    // it's supposed to return a valid schema
+	                    const s = schemaReader(refObj.ref);
+	                    if (s) {
+	                        // it needs to have the id
+	                        s.id = refObj.ref;
+	                        // try to compile the schema
+	                        const subreport = new Report(report);
+	                        if (!this.compileSchema(subreport, s)) {
+	                            // copy errors to report
+	                            report.errors = report.errors.concat(subreport.errors);
+	                        }
+	                        else {
+	                            response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+	                        }
 	                    }
 	                }
-	                if (sch.__$missingReferences.length === 0) {
-	                    delete sch.__$missingReferences;
+	            }
+	            if (!response) {
+	                const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
+	                const isAbsolute = isAbsoluteUri(refObj.ref);
+	                let isDownloaded = false;
+	                const ignoreUnresolvableRemotes = this.validator.options.ignoreUnresolvableReferences === true;
+	                if (isAbsolute) {
+	                    // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
+	                    // and set through setRemoteReference method
+	                    isDownloaded = this.validator.scache.checkCacheForUri(refObj.ref);
+	                }
+	                if (hasNotValid) ;
+	                else if (ignoreUnresolvableRemotes && isAbsolute) ;
+	                else if (isDownloaded) ;
+	                else {
+	                    report.path.push(...refObj.path);
+	                    report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
+	                    report.path = report.path.slice(0, -refObj.path.length);
+	                    // pusblish unresolved references out
+	                    if (isValidExceptReferences) {
+	                        schema.__$missingReferences = schema.__$missingReferences || [];
+	                        schema.__$missingReferences.push(refObj);
+	                    }
 	                }
 	            }
+	            // this might create circular references
+	            refObj.obj[`__${refObj.key}Resolved`] = response;
 	        }
-	        // keep repeating if not all compiled and at least one more was compiled in the last loop
-	    } while (compiled !== arr.length && compiled !== lastLoopCompiled);
-	    return report.isValid();
-	};
-	function compileSchema(report, schema) {
-	    report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
-	    // if schema is a string, assume it's a uri
-	    if (typeof schema === 'string') {
-	        const loadedSchema = getSchemaByUri.call(this, report, schema);
-	        if (!loadedSchema) {
-	            report.addError('SCHEMA_NOT_REACHABLE', [schema]);
-	            return false;
+	        const isValid = report.isValid();
+	        if (isValid) {
+	            schema.__$compiled = true;
 	        }
-	        schema = loadedSchema;
-	    }
-	    // if schema is an array, assume it's an array of schemas
-	    if (Array.isArray(schema)) {
-	        return compileArrayOfSchemas.call(this, report, schema);
-	    }
-	    // if we have an id than it should be cached already (if this instance has compiled it)
-	    if (schema.__$compiled && schema.id && checkCacheForUri.call(this, schema.id) === false) {
-	        schema.__$compiled = undefined;
-	    }
-	    // do not re-compile schemas
-	    if (schema.__$compiled) {
-	        return true;
-	    }
-	    if (schema.id && typeof schema.id === 'string') {
-	        // add this to our schemaCache (before compilation in case we have references including id)
-	        cacheSchemaByUri.call(this, schema.id, schema);
-	    }
-	    // this method can be called recursively, so we need to remember our root
-	    let isRoot = false;
-	    if (!report.rootSchema) {
-	        report.rootSchema = schema;
-	        isRoot = true;
-	    }
-	    // delete all __$missingReferences from previous compilation attempts
-	    const isValidExceptReferences = report.isValid();
-	    delete schema.__$missingReferences;
-	    // collect all references that need to be resolved - $ref and $schema
-	    const refs = collectReferences.call(this, schema);
-	    let idx = refs.length;
-	    while (idx--) {
-	        // resolve all the collected references into __xxxResolved pointer
-	        const refObj = refs[idx];
-	        let response = getSchemaByUri.call(this, report, refObj.ref, schema);
-	        // we can try to use custom schemaReader if available
-	        if (!response) {
-	            const schemaReader = this.getSchemaReader();
-	            if (schemaReader) {
-	                // it's supposed to return a valid schema
-	                const s = schemaReader(refObj.ref);
-	                if (s) {
-	                    // it needs to have the id
-	                    s.id = refObj.ref;
-	                    // try to compile the schema
-	                    const subreport = new Report(report);
-	                    if (!compileSchema.call(this, subreport, s)) {
-	                        // copy errors to report
-	                        report.errors = report.errors.concat(subreport.errors);
-	                    }
-	                    else {
-	                        response = getSchemaByUri.call(this, report, refObj.ref, schema);
-	                    }
-	                }
+	        else {
+	            if (schema.id && typeof schema.id === 'string') {
+	                // remove this schema from schemaCache because it failed to compile
+	                this.validator.scache.removeFromCacheByUri(schema.id);
 	            }
 	        }
-	        if (!response) {
-	            const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
-	            const isAbsolute = isAbsoluteUri(refObj.ref);
-	            let isDownloaded = false;
-	            const ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
-	            if (isAbsolute) {
-	                // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
-	                // and set through setRemoteReference method
-	                isDownloaded = checkCacheForUri.call(this, refObj.ref);
+	        // we don't need the root pointer anymore
+	        if (isRoot) {
+	            report.rootSchema = undefined;
+	        }
+	        return isValid;
+	    }
+	    compileArrayOfSchemas(report, arr) {
+	        let compiled = 0, lastLoopCompiled;
+	        do {
+	            // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
+	            let idx = report.errors.length;
+	            while (idx--) {
+	                if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
+	                    report.errors.splice(idx, 1);
+	                }
 	            }
-	            if (hasNotValid) ;
-	            else if (ignoreUnresolvableRemotes && isAbsolute) ;
-	            else if (isDownloaded) ;
-	            else {
-	                Array.prototype.push.apply(report.path, refObj.path);
-	                report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
-	                report.path = report.path.slice(0, -refObj.path.length);
-	                // pusblish unresolved references out
-	                if (isValidExceptReferences) {
-	                    schema.__$missingReferences = schema.__$missingReferences || [];
-	                    schema.__$missingReferences.push(refObj);
+	            // remember how many were compiled in the last loop
+	            lastLoopCompiled = compiled;
+	            // count how many are compiled now
+	            compiled = this.compileArrayOfSchemasLoop(report, arr);
+	            // fix __$missingReferences if possible
+	            idx = arr.length;
+	            while (idx--) {
+	                const sch = arr[idx];
+	                if (sch.__$missingReferences) {
+	                    let idx2 = sch.__$missingReferences.length;
+	                    while (idx2--) {
+	                        const refObj = sch.__$missingReferences[idx2];
+	                        const response = arr.find((x) => x.id === refObj.ref);
+	                        if (response) {
+	                            // this might create circular references
+	                            refObj.obj[`__${refObj.key}Resolved`] = response;
+	                            // it's resolved now so delete it
+	                            sch.__$missingReferences.splice(idx2, 1);
+	                        }
+	                    }
+	                    if (sch.__$missingReferences.length === 0) {
+	                        delete sch.__$missingReferences;
+	                    }
 	                }
 	            }
-	        }
-	        // this might create circular references
-	        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-	    }
-	    const isValid = report.isValid();
-	    if (isValid) {
-	        schema.__$compiled = true;
+	            // keep repeating if not all compiled and at least one more was compiled in the last loop
+	        } while (compiled !== arr.length && compiled !== lastLoopCompiled);
+	        return report.isValid();
 	    }
-	    else {
-	        if (schema.id && typeof schema.id === 'string') {
-	            // remove this schema from schemaCache because it failed to compile
-	            removeFromCacheByUri.call(this, schema.id);
+	    compileArrayOfSchemasLoop(mainReport, arr) {
+	        let idx = arr.length, compiledCount = 0;
+	        while (idx--) {
+	            // try to compile each schema separately
+	            const report = new Report(mainReport);
+	            const isValid = this.compileSchema(report, arr[idx]);
+	            if (isValid) {
+	                compiledCount++;
+	            }
+	            // copy errors to report
+	            mainReport.errors = mainReport.errors.concat(report.errors);
 	        }
+	        return compiledCount;
 	    }
-	    // we don't need the root pointer anymore
-	    if (isRoot) {
-	        report.rootSchema = undefined;
-	    }
-	    return isValid;
 	}
 
 	const SchemaValidators = {
@@ -12318,9 +12450,9 @@
 	        if (type !== 'boolean' && type !== 'object') {
 	            report.addError('KEYWORD_TYPE_EXPECTED', ['additionalItems', ['boolean', 'object']]);
 	        }
-	        else if (type === 'object') {
+	        else if (isObject(schema.additionalItems)) {
 	            report.path.push('additionalItems');
-	            validateSchema.call(this, report, schema.additionalItems);
+	            this.validateSchema(report, schema.additionalItems);
 	            report.path.pop();
 	        }
 	    },
@@ -12329,15 +12461,15 @@
 	        const type = whatIs(schema.items);
 	        if (type === 'object') {
 	            report.path.push('items');
-	            validateSchema.call(this, report, schema.items);
+	            this.validateSchema(report, schema.items);
 	            report.path.pop();
 	        }
-	        else if (type === 'array') {
+	        else if (Array.isArray(schema.items)) {
 	            let idx = schema.items.length;
 	            while (idx--) {
 	                report.path.push('items');
-	                report.path.push(idx.toString());
-	                validateSchema.call(this, report, schema.items[idx]);
+	                report.path.push(idx);
+	                this.validateSchema(report, schema.items[idx]);
 	                report.path.pop();
 	                report.path.pop();
 	            }
@@ -12422,9 +12554,9 @@
 	        if (type !== 'boolean' && type !== 'object') {
 	            report.addError('KEYWORD_TYPE_EXPECTED', ['additionalProperties', ['boolean', 'object']]);
 	        }
-	        else if (type === 'object') {
+	        else if (isObject(schema.additionalProperties)) {
 	            report.path.push('additionalProperties');
-	            validateSchema.call(this, report, schema.additionalProperties);
+	            this.validateSchema(report, schema.additionalProperties);
 	            report.path.pop();
 	        }
 	    },
@@ -12437,10 +12569,11 @@
 	        const keys = Object.keys(schema.properties);
 	        let idx = keys.length;
 	        while (idx--) {
-	            const key = keys[idx], val = schema.properties[key];
+	            const key = keys[idx];
+	            const val = schema.properties[key];
 	            report.path.push('properties');
 	            report.path.push(key);
-	            validateSchema.call(this, report, val);
+	            this.validateSchema(report, val);
 	            report.path.pop();
 	            report.path.pop();
 	        }
@@ -12474,8 +12607,8 @@
 	                report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
 	            }
 	            report.path.push('patternProperties');
-	            report.path.push(key.toString());
-	            validateSchema.call(this, report, val);
+	            report.path.push(key);
+	            this.validateSchema(report, val);
 	            report.path.pop();
 	            report.path.pop();
 	        }
@@ -12493,11 +12626,13 @@
 	            const keys = Object.keys(schema.dependencies);
 	            let idx = keys.length;
 	            while (idx--) {
-	                const schemaKey = keys[idx], schemaDependency = schema.dependencies[schemaKey], type = whatIs(schemaDependency);
+	                const schemaKey = keys[idx];
+	                const schemaDependency = schema.dependencies[schemaKey];
+	                const type = whatIs(schemaDependency);
 	                if (type === 'object') {
 	                    report.path.push('dependencies');
 	                    report.path.push(schemaKey);
-	                    validateSchema.call(this, report, schemaDependency);
+	                    this.validateSchema(report, schemaDependency);
 	                    report.path.pop();
 	                    report.path.pop();
 	                }
@@ -12535,8 +12670,10 @@
 	    },
 	    type: function (report, schema) {
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.1
-	        const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'], primitiveTypeStr = primitiveTypes.join(','), isArray = Array.isArray(schema.type);
-	        if (isArray) {
+	        const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'];
+	        const primitiveTypeStr = primitiveTypes.join(',');
+	        const isArray = Array.isArray(schema.type);
+	        if (Array.isArray(schema.type)) {
 	            let idx = schema.type.length;
 	            while (idx--) {
 	                if (primitiveTypes.indexOf(schema.type[idx]) === -1) {
@@ -12630,8 +12767,8 @@
 	            let idx = schema.allOf.length;
 	            while (idx--) {
 	                report.path.push('allOf');
-	                report.path.push(idx.toString());
-	                validateSchema.call(this, report, schema.allOf[idx]);
+	                report.path.push(idx);
+	                this.validateSchema(report, schema.allOf[idx]);
 	                report.path.pop();
 	                report.path.pop();
 	            }
@@ -12649,8 +12786,8 @@
 	            let idx = schema.anyOf.length;
 	            while (idx--) {
 	                report.path.push('anyOf');
-	                report.path.push(idx.toString());
-	                validateSchema.call(this, report, schema.anyOf[idx]);
+	                report.path.push(idx);
+	                this.validateSchema(report, schema.anyOf[idx]);
 	                report.path.pop();
 	                report.path.pop();
 	            }
@@ -12668,8 +12805,8 @@
 	            let idx = schema.oneOf.length;
 	            while (idx--) {
 	                report.path.push('oneOf');
-	                report.path.push(idx.toString());
-	                validateSchema.call(this, report, schema.oneOf[idx]);
+	                report.path.push(idx);
+	                this.validateSchema(report, schema.oneOf[idx]);
 	                report.path.pop();
 	                report.path.pop();
 	            }
@@ -12682,7 +12819,7 @@
 	        }
 	        else {
 	            report.path.push('not');
-	            validateSchema.call(this, report, schema.not);
+	            this.validateSchema(report, schema.not);
 	            report.path.pop();
 	        }
 	    },
@@ -12698,7 +12835,7 @@
 	                const key = keys[idx], val = schema.definitions[key];
 	                report.path.push('definitions');
 	                report.path.push(key);
-	                validateSchema.call(this, report, val);
+	                this.validateSchema(report, val);
 	                report.path.pop();
 	                report.path.pop();
 	            }
@@ -12709,7 +12846,7 @@
 	            report.addError('KEYWORD_TYPE_EXPECTED', ['format', 'string']);
 	        }
 	        else {
-	            if (FormatValidators[schema.format] === undefined && this.options.ignoreUnknownFormats !== true) {
+	            if (!isFormatSupported(schema.format) && this.options.ignoreUnknownFormats !== true) {
 	                report.addError('UNKNOWN_FORMAT', [schema.format]);
 	            }
 	        }
@@ -12732,296 +12869,124 @@
 	            report.addError('KEYWORD_TYPE_EXPECTED', ['description', 'string']);
 	        }
 	    },
-	    default: function ( /* report, schema */) {
+	    default: function () {
 	        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.2
 	        // There are no restrictions placed on the value of this keyword.
 	    },
 	};
-	/**
-	 *
-	 * @param {Report} report
-	 * @param {*[]} arr
-	 *
-	 * @returns {boolean}
-	 */
-	const validateArrayOfSchemas = function (report, arr) {
-	    let idx = arr.length;
-	    while (idx--) {
-	        validateSchema.call(this, report, arr[idx]);
-	    }
-	    return report.isValid();
-	};
-	/**
-	 *
-	 * @param {Report} report
-	 * @param {*} schema
-	 */
-	function validateSchema(report, schema) {
-	    report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
-	    // if schema is an array, assume it's an array of schemas
-	    if (Array.isArray(schema)) {
-	        return validateArrayOfSchemas.call(this, report, schema);
+	class SchemaValidator {
+	    validator;
+	    constructor(validator) {
+	        this.validator = validator;
 	    }
-	    // do not revalidate schema that has already been validated once
-	    if (schema.__$validated) {
-	        return true;
+	    get options() {
+	        return this.validator.options;
 	    }
-	    // if $schema is present, this schema should validate against that $schema
-	    const hasParentSchema = schema.$schema && schema.id !== schema.$schema;
-	    if (hasParentSchema) {
-	        if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
-	            const subReport = new Report(report);
-	            const valid = validate.call(this, subReport, schema.__$schemaResolved, schema);
-	            if (valid === false) {
-	                report.addError('PARENT_SCHEMA_VALIDATION_FAILED', null, subReport);
-	            }
-	        }
-	        else {
-	            if (this.options.ignoreUnresolvableReferences !== true) {
-	                report.addError('REF_UNRESOLVED', [schema.$schema]);
-	            }
+	    validateArrayOfSchemas(report, arr) {
+	        let idx = arr.length;
+	        while (idx--) {
+	            this.validateSchema(report, arr[idx]);
 	        }
+	        return report.isValid();
 	    }
-	    if (this.options.noTypeless === true) {
-	        // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
-	        if (schema.type !== undefined) {
-	            let schemas = [];
-	            if (Array.isArray(schema.anyOf)) {
-	                schemas = schemas.concat(schema.anyOf);
-	            }
-	            if (Array.isArray(schema.oneOf)) {
-	                schemas = schemas.concat(schema.oneOf);
-	            }
-	            if (Array.isArray(schema.allOf)) {
-	                schemas = schemas.concat(schema.allOf);
+	    validateSchema(report, schema) {
+	        report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
+	        // if schema is an array, assume it's an array of schemas
+	        if (Array.isArray(schema)) {
+	            return this.validateArrayOfSchemas(report, schema);
+	        }
+	        // do not revalidate schema that has already been validated once
+	        if (schema.__$validated) {
+	            return true;
+	        }
+	        // if $schema is present, this schema should validate against that $schema
+	        const hasParentSchema = schema.$schema && schema.id !== schema.$schema;
+	        if (hasParentSchema) {
+	            if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
+	                const subReport = new Report(report);
+	                const valid = validate.call(this.validator, subReport, schema.__$schemaResolved, schema);
+	                if (valid === false) {
+	                    report.addError('PARENT_SCHEMA_VALIDATION_FAILED', undefined, subReport);
+	                }
 	            }
-	            schemas.forEach(function (sch) {
-	                if (!sch.type) {
-	                    sch.type = schema.type;
+	            else {
+	                if (this.validator.options.ignoreUnresolvableReferences !== true) {
+	                    report.addError('REF_UNRESOLVED', [schema.$schema]);
 	                }
-	            });
-	        }
-	        // end issue #36
-	        if (schema.enum === undefined &&
-	            schema.type === undefined &&
-	            schema.anyOf === undefined &&
-	            schema.oneOf === undefined &&
-	            schema.not === undefined &&
-	            schema.$ref === undefined) {
-	            report.addError('KEYWORD_UNDEFINED_STRICT', ['type']);
-	        }
-	    }
-	    const keys = Object.keys(schema);
-	    let idx = keys.length;
-	    while (idx--) {
-	        const key = keys[idx];
-	        if (key.indexOf('__') === 0) {
-	            continue;
-	        }
-	        if (SchemaValidators[key] !== undefined) {
-	            SchemaValidators[key].call(this, report, schema);
-	        }
-	        else if (!hasParentSchema) {
-	            if (this.options.noExtraKeywords === true) {
-	                report.addError('KEYWORD_UNEXPECTED', [key]);
 	            }
 	        }
-	    }
-	    if (this.options.pedanticCheck === true) {
-	        if (schema.enum) {
-	            // break recursion
-	            const tmpSchema = clone(schema);
-	            delete tmpSchema.enum;
-	            delete tmpSchema.default;
-	            report.path.push('enum');
-	            idx = schema.enum.length;
-	            while (idx--) {
-	                report.path.push(idx.toString());
-	                validate.call(this, report, tmpSchema, schema.enum[idx]);
-	                report.path.pop();
+	        if (this.validator.options.noTypeless === true) {
+	            // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
+	            if (schema.type !== undefined) {
+	                let schemas = [];
+	                if (Array.isArray(schema.anyOf)) {
+	                    schemas = schemas.concat(schema.anyOf);
+	                }
+	                if (Array.isArray(schema.oneOf)) {
+	                    schemas = schemas.concat(schema.oneOf);
+	                }
+	                if (Array.isArray(schema.allOf)) {
+	                    schemas = schemas.concat(schema.allOf);
+	                }
+	                schemas.forEach(function (sch) {
+	                    if (!sch.type) {
+	                        sch.type = schema.type;
+	                    }
+	                });
 	            }
-	            report.path.pop();
-	        }
-	        if (schema.default) {
-	            report.path.push('default');
-	            validate.call(this, report, schema, schema.default);
-	            report.path.pop();
-	        }
-	    }
-	    const isValid = report.isValid();
-	    if (isValid) {
-	        schema.__$validated = true;
-	    }
-	    return isValid;
-	}
-
-	function decodeJSONPointer(str) {
-	    // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
-	    return decodeURIComponent(str).replace(/~[0-1]/g, function (x) {
-	        return x === '~1' ? '/' : '~';
-	    });
-	}
-	function getRemotePath(uri) {
-	    const io = uri.indexOf('#');
-	    return io === -1 ? uri : uri.slice(0, io);
-	}
-	function getQueryPath(uri) {
-	    const io = uri.indexOf('#');
-	    const res = io === -1 ? undefined : uri.slice(io + 1);
-	    // WARN: do not slice slash, #/ means take root and go down from it
-	    // if (res && res[0] === "/") { res = res.slice(1); }
-	    return res;
-	}
-	function findId(schema, id) {
-	    // process only arrays and objects
-	    if (typeof schema !== 'object' || schema === null) {
-	        return;
-	    }
-	    // no id means root so return itself
-	    if (!id) {
-	        return schema;
-	    }
-	    if (schema.id) {
-	        if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
-	            return schema;
-	        }
-	    }
-	    let idx, result;
-	    if (Array.isArray(schema)) {
-	        idx = schema.length;
-	        while (idx--) {
-	            result = findId(schema[idx], id);
-	            if (result) {
-	                return result;
+	            // end issue #36
+	            if (schema.enum === undefined &&
+	                schema.type === undefined &&
+	                schema.anyOf === undefined &&
+	                schema.oneOf === undefined &&
+	                schema.not === undefined &&
+	                schema.$ref === undefined) {
+	                report.addError('KEYWORD_UNDEFINED_STRICT', ['type']);
 	            }
 	        }
-	    }
-	    else {
 	        const keys = Object.keys(schema);
-	        idx = keys.length;
+	        let idx = keys.length;
 	        while (idx--) {
-	            const k = keys[idx];
-	            if (k.indexOf('__$') === 0) {
+	            const key = keys[idx];
+	            if (key.indexOf('__') === 0) {
 	                continue;
 	            }
-	            result = findId(schema[k], id);
-	            if (result) {
-	                return result;
+	            if (Object.prototype.hasOwnProperty.call(SchemaValidators, key)) {
+	                SchemaValidators[key].call(this, report, schema);
 	            }
-	        }
-	    }
-	}
-	/**
-	 *
-	 * @param {*} uri
-	 * @param {*} schema
-	 *
-	 * @returns {void}
-	 */
-	function cacheSchemaByUri(uri, schema) {
-	    const remotePath = getRemotePath(uri);
-	    if (remotePath) {
-	        this.cache[remotePath] = schema;
-	    }
-	}
-	/**
-	 *
-	 * @param {*} uri
-	 *
-	 * @returns {void}
-	 */
-	function removeFromCacheByUri(uri) {
-	    const remotePath = getRemotePath(uri);
-	    if (remotePath) {
-	        delete this.cache[remotePath];
-	    }
-	}
-	/**
-	 *
-	 * @param {*} uri
-	 *
-	 * @returns {boolean}
-	 */
-	function checkCacheForUri(uri) {
-	    const remotePath = getRemotePath(uri);
-	    return remotePath ? this.cache[remotePath] != null : false;
-	}
-	function getSchema(report, schema) {
-	    if (typeof schema === 'object') {
-	        schema = getSchemaByReference.call(this, report, schema);
-	    }
-	    if (typeof schema === 'string') {
-	        schema = getSchemaByUri.call(this, report, schema);
-	    }
-	    return schema;
-	}
-	function getSchemaByReference(report, key) {
-	    let i = this.referenceCache.length;
-	    while (i--) {
-	        if (isequal(this.referenceCache[i][0], key)) {
-	            return this.referenceCache[i][1];
-	        }
-	    }
-	    // not found
-	    const schema = cloneDeep(key);
-	    this.referenceCache.push([key, schema]);
-	    return schema;
-	}
-	function getSchemaByUri(report, uri, root) {
-	    const remotePath = getRemotePath(uri);
-	    const queryPath = getQueryPath(uri);
-	    let result = remotePath ? this.cache[remotePath] : root;
-	    if (result && remotePath) {
-	        // we need to avoid compiling schemas in a recursive loop
-	        const compileRemote = result !== root;
-	        // now we need to compile and validate resolved schema (in case it's not already)
-	        if (compileRemote) {
-	            report.path.push(remotePath);
-	            let remoteReport;
-	            const anscestorReport = report.getAncestor(result.id);
-	            if (anscestorReport) {
-	                remoteReport = anscestorReport;
-	            }
-	            else {
-	                remoteReport = new Report(report);
-	                if (compileSchema.call(this, remoteReport, result)) {
-	                    const savedOptions = this.options;
-	                    try {
-	                        // If custom validationOptions were provided to setRemoteReference(),
-	                        // use them instead of the default options
-	                        this.options = result.__$validationOptions || this.options;
-	                        validateSchema.call(this, remoteReport, result);
-	                    }
-	                    finally {
-	                        this.options = savedOptions;
-	                    }
+	            else if (!hasParentSchema) {
+	                if (this.validator.options.noExtraKeywords === true) {
+	                    report.addError('KEYWORD_UNEXPECTED', [key]);
 	                }
 	            }
-	            const remoteReportIsValid = remoteReport.isValid();
-	            if (!remoteReportIsValid) {
-	                report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
-	            }
-	            report.path.pop();
-	            if (!remoteReportIsValid) {
-	                return undefined;
-	            }
 	        }
-	    }
-	    if (result && queryPath) {
-	        const parts = queryPath.split('/');
-	        for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
-	            const key = decodeJSONPointer(parts[idx]);
-	            if (idx === 0) {
-	                // it's an id
-	                result = findId(result, key);
+	        if (this.validator.options.pedanticCheck === true) {
+	            if (schema.enum) {
+	                // break recursion
+	                const tmpSchema = shallowClone(schema);
+	                delete tmpSchema.enum;
+	                delete tmpSchema.default;
+	                report.path.push('enum');
+	                idx = schema.enum.length;
+	                while (idx--) {
+	                    report.path.push(idx);
+	                    validate.call(this.validator, report, tmpSchema, schema.enum[idx]);
+	                    report.path.pop();
+	                }
+	                report.path.pop();
 	            }
-	            else {
-	                // it's a path behind id
-	                result = result[key];
+	            if (schema.default) {
+	                report.path.push('default');
+	                validate.call(this.validator, report, schema, schema.default);
+	                report.path.pop();
 	            }
 	        }
+	        const isValid = report.isValid();
+	        if (isValid) {
+	            schema.__$validated = true;
+	        }
+	        return isValid;
 	    }
-	    return result;
 	}
 
 	var id$1 = "http://json-schema.org/draft-04/schema#";
@@ -13252,7 +13217,7 @@
 			"minimum"
 		]
 	};
-	var Draft4Schema = {
+	var _Draft4Schema = {
 		id: id$1,
 		$schema: $schema$1,
 		description: description,
@@ -13421,7 +13386,7 @@
 			}
 		}
 	};
-	var Draft4HyperSchema = {
+	var _Draft4HyperSchema = {
 		$schema: $schema,
 		id: id,
 		title: title,
@@ -13430,6 +13395,8 @@
 		definitions: definitions
 	};
 
+	const Draft4Schema = _Draft4Schema;
+	const Draft4HyperSchema = _Draft4HyperSchema;
 	/**
 	 * default options
 	 */
@@ -13479,11 +13446,13 @@
 	    // function to be called on every schema
 	    customValidator: null,
 	};
-	function normalizeOptions(options) {
+	const normalizeOptions = (options) => {
 	    let normalized;
 	    // options
 	    if (typeof options === 'object') {
-	        let keys = Object.keys(options), idx = keys.length, key;
+	        let keys = Object.keys(options);
+	        let idx = keys.length;
+	        let key;
 	        // check that the options are correctly configured
 	        while (idx--) {
 	            key = keys[idx];
@@ -13497,13 +13466,13 @@
 	        while (idx--) {
 	            key = keys[idx];
 	            if (options[key] === undefined) {
-	                options[key] = clone(defaultOptions[key]);
+	                options[key] = shallowClone(defaultOptions[key]);
 	            }
 	        }
 	        normalized = options;
 	    }
 	    else {
-	        normalized = clone(defaultOptions);
+	        normalized = shallowClone(defaultOptions);
 	    }
 	    if (normalized.strictMode === true) {
 	        normalized.forceAdditional = true;
@@ -13516,68 +13485,45 @@
 	        normalized.noEmptyArrays = true;
 	    }
 	    return normalized;
-	}
+	};
 	class ZSchema {
-	    lastReport;
-	    /**
-	     * Register a custom format.
-	     *
-	     * @param name - name of the custom format
-	     * @param validatorFunction - custom format validator function.
-	     *   Returns `true` if `value` matches the custom format.
-	     */
-	    static registerFormat(formatName, validatorFunction) {
-	        FormatValidators[formatName] = validatorFunction;
+	    static registerFormat(name, validatorFunction) {
+	        return registerFormat(name, validatorFunction);
 	    }
-	    /**
-	     * Unregister a format.
-	     *
-	     * @param name - name of the custom format
-	     */
 	    static unregisterFormat(name) {
-	        delete FormatValidators[name];
+	        return unregisterFormat(name);
 	    }
-	    /**
-	     * Get the list of all registered formats.
-	     *
-	     * Both the names of the burned-in formats and the custom format names are
-	     * returned by this function.
-	     *
-	     * @returns {string[]} the list of all registered format names.
-	     */
 	    static getRegisteredFormats() {
-	        return Object.keys(FormatValidators);
+	        return getRegisteredFormats();
 	    }
 	    static getDefaultOptions() {
-	        return cloneDeep(defaultOptions);
+	        return deepClone(defaultOptions);
 	    }
-	    cache;
-	    referenceCache;
-	    validateOptions;
+	    lastReport;
+	    scache;
+	    sc;
+	    sv;
+	    validateOptions = {};
 	    options;
 	    constructor(options) {
-	        this.cache = {};
-	        this.referenceCache = [];
-	        this.validateOptions = {};
+	        this.scache = new SchemaCache(this);
+	        this.sc = new SchemaCompiler(this);
+	        this.sv = new SchemaValidator(this);
 	        this.options = normalizeOptions(options);
 	        // Disable strict validation for the built-in schemas
 	        const metaschemaOptions = normalizeOptions({});
 	        this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
 	        this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
 	    }
-	    /**
-	     * @param schema - JSON object representing schema
-	     * @returns {boolean} true if schema is valid.
-	     */
 	    validateSchema(schema) {
 	        if (Array.isArray(schema) && schema.length === 0) {
 	            throw new Error('.validateSchema was called with an empty array');
 	        }
 	        const report = new Report(this.options);
-	        schema = getSchema.call(this, report, schema);
-	        const compiled = compileSchema.call(this, report, schema);
+	        schema = this.scache.getSchema(report, schema);
+	        const compiled = this.sc.compileSchema(report, schema);
 	        if (compiled) {
-	            validateSchema.call(this, report, schema);
+	            this.sv.validateSchema(report, schema);
 	        }
 	        this.lastReport = report;
 	        return report.isValid();
@@ -13591,9 +13537,9 @@
 	            options = {};
 	        }
 	        this.validateOptions = options;
-	        const whatIs$1 = whatIs(schema);
-	        if (whatIs$1 !== 'string' && whatIs$1 !== 'object') {
-	            const e = new Error('Invalid .validate call - schema must be a string or object but ' + whatIs$1 + ' was passed!');
+	        const schemaType = whatIs(schema);
+	        if (schemaType !== 'string' && schemaType !== 'object') {
+	            const e = new Error('Invalid .validate call - schema must be a string or object but ' + schemaType + ' was passed!');
 	            if (callback) {
 	                setTimeout(function () {
 	                    callback(e, false);
@@ -13607,17 +13553,18 @@
 	        report.json = json;
 	        if (typeof schema === 'string') {
 	            const schemaName = schema;
-	            schema = getSchema.call(this, report, schemaName);
-	            if (!schema) {
+	            const _schema = this.scache.getSchema(report, schemaName);
+	            if (!_schema) {
 	                throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
 	            }
+	            schema = _schema;
 	        }
 	        else {
-	            schema = getSchema.call(this, report, schema);
+	            schema = this.scache.getSchema(report, schema);
 	        }
 	        let compiled = false;
 	        if (!foundError) {
-	            compiled = compileSchema.call(this, report, schema);
+	            compiled = this.sc.compileSchema(report, schema);
 	        }
 	        if (!compiled) {
 	            this.lastReport = report;
@@ -13625,7 +13572,7 @@
 	        }
 	        let validated = false;
 	        if (!foundError) {
-	            validated = validateSchema.call(this, report, schema);
+	            validated = this.sv.validateSchema(report, schema);
 	        }
 	        if (!validated) {
 	            this.lastReport = report;
@@ -13656,6 +13603,9 @@
 	     * Returns an Error object for the most recent failed validation, or null if the validation was successful.
 	     */
 	    getLastError() {
+	        if (!this.lastReport) {
+	            throw new Error(`getLastError() called before doing any validation!`);
+	        }
 	        if (this.lastReport.errors.length === 0) {
 	            return null;
 	        }
@@ -13673,27 +13623,29 @@
 	        return this.lastReport && this.lastReport.errors.length > 0 ? this.lastReport.errors : null;
 	    }
 	    setRemoteReference(uri, schema, validationOptions) {
+	        let _schema;
 	        if (typeof schema === 'string') {
-	            schema = JSON.parse(schema);
+	            _schema = JSON.parse(schema);
 	        }
 	        else {
-	            schema = cloneDeep(schema);
+	            _schema = deepClone(schema);
 	        }
 	        if (validationOptions) {
-	            schema.__$validationOptions = normalizeOptions(validationOptions);
+	            _schema.__$validationOptions = normalizeOptions(validationOptions);
 	        }
-	        cacheSchemaByUri.call(this, uri, schema);
+	        this.scache.cacheSchemaByUri(uri, _schema);
 	    }
 	    compileSchema(schema) {
 	        const report = new Report(this.options);
-	        schema = getSchema.call(this, report, schema);
-	        compileSchema.call(this, report, schema);
+	        schema = this.scache.getSchema(report, schema);
+	        this.sc.compileSchema(report, schema);
 	        this.lastReport = report;
 	        return report.isValid();
 	    }
 	    getMissingReferences(arr) {
-	        arr = arr || this.lastReport.errors;
-	        let res = [], idx = arr.length;
+	        arr = arr || this.lastReport?.errors || [];
+	        let res = [];
+	        let idx = arr.length;
 	        while (idx--) {
 	            const error = arr[idx];
 	            if (error.code === 'UNRESOLVABLE_REFERENCE') {
@@ -13722,11 +13674,10 @@
 	    }
 	    getResolvedSchema(schema) {
 	        const report = new Report(this.options);
-	        schema = getSchema.call(this, report, schema);
+	        schema = this.scache.getSchema(report, schema);
 	        // clone before making any modifications
-	        schema = cloneDeep(schema);
+	        schema = deepClone(schema);
 	        const visited = [];
-	        // clean-up the schema and resolve references
 	        const cleanup = function (schema) {
 	            let key;
 	            const typeOf = whatIs(schema);