z-schema 7.0.5 → 7.0.7

package/cjs/index.js

@@ -997,38 +997,8 @@ const Errors = {
     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';
         }
@@ -1037,7 +1007,7 @@ function whatIs(what) {
         }
         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';
@@ -1051,242 +1021,45 @@ function whatIs(what) {
         }
         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) {
@@ -1317,17 +1090,15 @@ class Report {
                 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();
@@ -1347,9 +1118,6 @@ class Report {
         }, validationTimeout);
     }
     getPath(returnPathAsString) {
-        /**
-         * @type {string[]|string}
-         */
         let path = [];
         if (this.parentReport) {
             path = path.concat(this.parentReport.path);
@@ -1372,7 +1140,7 @@ class Report {
     }
     getSchemaId() {
         if (!this.rootSchema) {
-            return null;
+            return undefined;
         }
         // get the error path as an array
         let path = [];
@@ -1391,16 +1159,16 @@ class Report {
         // 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;
                     }
                 }
@@ -1412,12 +1180,13 @@ class Report {
         }
         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;
@@ -1428,7 +1197,7 @@ class Report {
         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) {
@@ -1437,9 +1206,9 @@ class Report {
         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,
@@ -1448,6 +1217,7 @@ class Report {
             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') {
@@ -1979,7 +1749,7 @@ function requireMatches () {
 	return matches.exports;
 }
 
-var isEmail = {exports: {}};
+var isEmail$1 = {exports: {}};
 
 var checkHost = {exports: {}};
 
@@ -2137,12 +1907,12 @@ function requireIsFQDN () {
 	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) {
 
@@ -2211,14 +1981,14 @@ function requireIsIP () {
 		}
 		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) {
 
@@ -2394,11 +2164,11 @@ function requireIsEmail () {
 		}
 		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: {}};
 
@@ -2426,7 +2196,7 @@ function requireIncludesString () {
 var hasRequiredIsURL;
 
 function requireIsURL () {
-	if (hasRequiredIsURL) return isURL.exports;
+	if (hasRequiredIsURL) return isURL$1.exports;
 	hasRequiredIsURL = 1;
 	(function (module, exports$1) {
 
@@ -2677,8 +2447,8 @@ function requireIsURL () {
 		}
 		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: {}};
@@ -9379,140 +9149,359 @@ function requireValidator () {
 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) {
@@ -9524,6 +9513,12 @@ const shouldSkipValidate = function (options, errors) {
         }));
 };
 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'])) {
@@ -9535,7 +9530,7 @@ const JsonValidators = {
         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) {
@@ -9548,12 +9543,12 @@ const JsonValidators = {
         }
         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);
             }
         }
     },
@@ -9570,12 +9565,12 @@ const JsonValidators = {
         }
         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);
             }
         }
     },
@@ -9591,7 +9586,7 @@ const JsonValidators = {
             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) {
@@ -9603,7 +9598,7 @@ const JsonValidators = {
             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) {
@@ -9615,7 +9610,7 @@ const JsonValidators = {
             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) {
@@ -9630,12 +9625,12 @@ const JsonValidators = {
         // 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) {
@@ -9647,7 +9642,7 @@ const JsonValidators = {
             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) {
@@ -9659,7 +9654,7 @@ const JsonValidators = {
             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) {
@@ -9673,7 +9668,7 @@ const JsonValidators = {
         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);
             }
         }
     },
@@ -9682,12 +9677,12 @@ const JsonValidators = {
         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) {
@@ -9695,12 +9690,12 @@ const JsonValidators = {
         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) {
@@ -9708,14 +9703,14 @@ const JsonValidators = {
         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);
             }
         }
     },
@@ -9736,7 +9731,7 @@ const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
             return;
         }
-        if (whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const properties = schema.properties !== undefined ? schema.properties : {};
@@ -9764,19 +9759,21 @@ const JsonValidators = {
             // 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);
                     }
                 }
             }
@@ -9787,7 +9784,7 @@ const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
             return;
         }
-        if (whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const keys = Object.keys(schema.dependencies);
@@ -9797,21 +9794,21 @@ const JsonValidators = {
             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);
+                }
             }
         }
     },
@@ -9832,7 +9829,7 @@ const JsonValidators = {
         }
         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) {
@@ -9843,12 +9840,12 @@ const JsonValidators = {
         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);
             }
         }
     },
@@ -9892,24 +9889,25 @@ const JsonValidators = {
             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;
@@ -9919,12 +9917,12 @@ const JsonValidators = {
             }
             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;
                     }
                 });
@@ -9932,12 +9930,12 @@ const JsonValidators = {
             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);
         }
     },
 };
@@ -10023,18 +10021,12 @@ const recurseObject = function (report, schema, json) {
         }
     }
 };
-/**
- *
- * @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
@@ -10054,7 +10046,7 @@ function validate(report, schema, json) {
         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) {
@@ -10071,7 +10063,6 @@ function validate(report, schema, json) {
         }
     }
     // type checking first
-    const jsonType = whatIs(json);
     if (schema.type) {
         keys.splice(keys.indexOf('type'), 1);
         JsonValidators.type.call(this, report, schema, json);
@@ -10090,10 +10081,10 @@ function validate(report, schema, json) {
         }
     }
     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);
         }
     }
@@ -11972,33 +11963,425 @@ function requireLodash_isequal () {
 var lodash_isequalExports = requireLodash_isequal();
 var isequal = /*@__PURE__*/getDefaultExportFromCjs(lodash_isequalExports);
 
-const SchemaValidators = {
-    $ref: function (report, schema) {
-        // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
-        // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
-        if (typeof schema.$ref !== 'string') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['$ref', 'string']);
-        }
-    },
-    $schema: function (report, schema) {
-        // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
-        if (typeof schema.$schema !== 'string') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['$schema', 'string']);
-        }
-    },
-    multipleOf: function (report, schema) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
-        if (typeof schema.multipleOf !== 'number') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['multipleOf', 'number']);
-        }
-        else if (schema.multipleOf <= 0) {
-            report.addError('KEYWORD_MUST_BE', ['multipleOf', 'strictly greater than 0']);
+const 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;
         }
-    },
-    maximum: function (report, schema) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
-        if (typeof schema.maximum !== 'number') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['maximum', 'number']);
+    }
+    let idx, result;
+    if (Array.isArray(schema)) {
+        idx = schema.length;
+        while (idx--) {
+            result = findId(schema[idx], id);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    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);
+    }
+    if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
+        results.push({
+            ref: mergeReference(scope, obj.$ref),
+            key: '$ref',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
+    if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
+        results.push({
+            ref: mergeReference(scope, obj.$schema),
+            key: '$schema',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
+    let idx;
+    if (Array.isArray(obj)) {
+        idx = obj.length;
+        while (idx--) {
+            path.push(idx);
+            collectReferences(obj[idx], results, scope, path);
+            path.pop();
+        }
+    }
+    else {
+        const keys = Object.keys(obj);
+        idx = keys.length;
+        while (idx--) {
+            // do not recurse through resolved references and other z-schema props
+            if (keys[idx].indexOf('__$') === 0) {
+                continue;
+            }
+            path.push(keys[idx]);
+            collectReferences(obj[keys[idx]], results, scope, path);
+            path.pop();
+        }
+    }
+    if (typeof obj.id === 'string') {
+        scope.pop();
+    }
+    return results;
+};
+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);
+        }
+    }
+    else if (isScopeRelative && isRefRelative) {
+        joinedScope = '';
+    }
+    else {
+        toRemove = joinedScope.match(/[^#/]+$/);
+        if (toRemove) {
+            joinedScope = joinedScope.slice(0, toRemove.index);
+        }
+    }
+    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;
+        }
+        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--) {
+            // 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 (!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;
+        }
+        const isValid = report.isValid();
+        if (isValid) {
+            schema.__$compiled = true;
+        }
+        else {
+            if (schema.id && typeof schema.id === 'string') {
+                // remove this schema from schemaCache because it failed to compile
+                this.validator.scache.removeFromCacheByUri(schema.id);
+            }
+        }
+        // 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);
+                }
+            }
+            // 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;
+                    }
+                }
+            }
+            // 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();
+    }
+    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;
+    }
+}
+
+const SchemaValidators = {
+    $ref: function (report, schema) {
+        // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
+        // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
+        if (typeof schema.$ref !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['$ref', 'string']);
+        }
+    },
+    $schema: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
+        if (typeof schema.$schema !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['$schema', 'string']);
+        }
+    },
+    multipleOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
+        if (typeof schema.multipleOf !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['multipleOf', 'number']);
+        }
+        else if (schema.multipleOf <= 0) {
+            report.addError('KEYWORD_MUST_BE', ['multipleOf', 'strictly greater than 0']);
+        }
+    },
+    maximum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
+        if (typeof schema.maximum !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['maximum', 'number']);
         }
     },
     exclusiveMaximum: function (report, schema) {
@@ -12063,9 +12446,9 @@ const SchemaValidators = {
         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();
         }
     },
@@ -12074,15 +12457,15 @@ const SchemaValidators = {
         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();
             }
@@ -12167,9 +12550,9 @@ const SchemaValidators = {
         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();
         }
     },
@@ -12182,10 +12565,11 @@ const SchemaValidators = {
         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();
         }
@@ -12219,8 +12603,8 @@ const SchemaValidators = {
                 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();
         }
@@ -12238,11 +12622,13 @@ const SchemaValidators = {
             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();
                 }
@@ -12280,8 +12666,10 @@ const SchemaValidators = {
     },
     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) {
@@ -12375,8 +12763,8 @@ const SchemaValidators = {
             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();
             }
@@ -12394,8 +12782,8 @@ const SchemaValidators = {
             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();
             }
@@ -12413,8 +12801,8 @@ const SchemaValidators = {
             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();
             }
@@ -12427,7 +12815,7 @@ const SchemaValidators = {
         }
         else {
             report.path.push('not');
-            validateSchema.call(this, report, schema.not);
+            this.validateSchema(report, schema.not);
             report.path.pop();
         }
     },
@@ -12443,7 +12831,7 @@ const SchemaValidators = {
                 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();
             }
@@ -12454,7 +12842,7 @@ const SchemaValidators = {
             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]);
             }
         }
@@ -12477,547 +12865,124 @@ const SchemaValidators = {
             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]);
+class SchemaValidator {
+    validator;
+    constructor(validator) {
+        this.validator = validator;
     }
-    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);
+    get options() {
+        return this.validator.options;
     }
-    // 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, 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]);
-            }
-        }
-    }
-    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);
-            }
-            schemas.forEach(function (sch) {
-                if (!sch.type) {
-                    sch.type = schema.type;
-                }
-            });
-        }
-        // 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();
-            }
-            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$1(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;
+    validateArrayOfSchemas(report, arr) {
+        let idx = arr.length;
         while (idx--) {
-            result = findId$1(schema[idx], id);
-            if (result) {
-                return result;
-            }
+            this.validateSchema(report, arr[idx]);
         }
+        return report.isValid();
     }
-    else {
-        const keys = Object.keys(schema);
-        idx = keys.length;
-        while (idx--) {
-            const k = keys[idx];
-            if (k.indexOf('__$') === 0) {
-                continue;
-            }
-            result = findId$1(schema[k], id);
-            if (result) {
-                return result;
-            }
-        }
-    }
-}
-/**
- *
- * @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];
+    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;
         }
-    }
-    // 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;
+        // 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);
+                }
             }
             else {
-                remoteReport = new Report(report);
-                if (this._compileSchema(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;
-                    }
+                if (this.validator.options.ignoreUnresolvableReferences !== true) {
+                    report.addError('REF_UNRESOLVED', [schema.$schema]);
                 }
             }
-            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$1(result, key);
+        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;
+                    }
+                });
             }
-            else {
-                // it's a path behind id
-                result = result[key];
+            // 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']);
             }
         }
-    }
-    return result;
-}
-
-function 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);
-        }
-    }
-    else if (isScopeRelative && isRefRelative) {
-        joinedScope = '';
-    }
-    else {
-        toRemove = joinedScope.match(/[^#/]+$/);
-        if (toRemove) {
-            joinedScope = joinedScope.slice(0, toRemove.index);
-        }
-    }
-    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 (typeof obj.id === 'string') {
-        scope.push(obj.id);
-    }
-    if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$ref),
-            key: '$ref',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$schema),
-            key: '$schema',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    let idx;
-    if (Array.isArray(obj)) {
-        idx = obj.length;
-        while (idx--) {
-            path.push(idx.toString());
-            collectReferences(obj[idx], results, scope, path);
-            path.pop();
-        }
-    }
-    else {
-        const keys = Object.keys(obj);
-        idx = keys.length;
+        const keys = Object.keys(schema);
+        let idx = keys.length;
         while (idx--) {
-            // do not recurse through resolved references and other z-schema props
-            if (keys[idx].indexOf('__$') === 0) {
+            const key = keys[idx];
+            if (key.indexOf('__') === 0) {
                 continue;
             }
-            path.push(keys[idx]);
-            collectReferences(obj[keys[idx]], results, scope, path);
-            path.pop();
-        }
-    }
-    if (typeof obj.id === 'string') {
-        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++;
-        }
-        // copy errors to report
-        mainReport.errors = mainReport.errors.concat(report.errors);
-    }
-    return compiledCount;
-};
-function findId(arr, id) {
-    let idx = arr.length;
-    while (idx--) {
-        if (arr[idx].id === id) {
-            return arr[idx];
-        }
-    }
-    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);
+            if (Object.prototype.hasOwnProperty.call(SchemaValidators, key)) {
+                SchemaValidators[key].call(this, report, schema);
             }
-        }
-        // 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;
-        while (idx--) {
-            const sch = arr[idx];
-            if (sch.__$missingReferences) {
-                let idx2 = sch.__$missingReferences.length;
-                while (idx2--) {
-                    const refObj = sch.__$missingReferences[idx2];
-                    const response = findId(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);
-                    }
-                }
-                if (sch.__$missingReferences.length === 0) {
-                    delete sch.__$missingReferences;
+            else if (!hasParentSchema) {
+                if (this.validator.options.noExtraKeywords === true) {
+                    report.addError('KEYWORD_UNEXPECTED', [key]);
                 }
             }
         }
-        // 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;
-        }
-        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);
-                    }
+        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();
             }
-        }
-        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);
-            }
-            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);
-                }
+            if (schema.default) {
+                report.path.push('default');
+                validate.call(this.validator, report, schema, schema.default);
+                report.path.pop();
             }
         }
-        // this might create circular references
-        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-    }
-    const isValid = report.isValid();
-    if (isValid) {
-        schema.__$compiled = true;
-    }
-    else {
-        if (schema.id && typeof schema.id === 'string') {
-            // remove this schema from schemaCache because it failed to compile
-            removeFromCacheByUri.call(this, schema.id);
+        const isValid = report.isValid();
+        if (isValid) {
+            schema.__$validated = true;
         }
+        return isValid;
     }
-    // we don't need the root pointer anymore
-    if (isRoot) {
-        report.rootSchema = undefined;
-    }
-    return isValid;
 }
 
 var id$1 = "http://json-schema.org/draft-04/schema#";
@@ -13248,7 +13213,7 @@ var dependencies = {
 		"minimum"
 	]
 };
-var Draft4Schema = {
+var _Draft4Schema = {
 	id: id$1,
 	$schema: $schema$1,
 	description: description,
@@ -13417,7 +13382,7 @@ var definitions = {
 		}
 	}
 };
-var Draft4HyperSchema = {
+var _Draft4HyperSchema = {
 	$schema: $schema,
 	id: id,
 	title: title,
@@ -13426,6 +13391,8 @@ var Draft4HyperSchema = {
 	definitions: definitions
 };
 
+const Draft4Schema = _Draft4Schema;
+const Draft4HyperSchema = _Draft4HyperSchema;
 /**
  * default options
  */
@@ -13475,11 +13442,13 @@ const defaultOptions = {
     // 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];
@@ -13493,13 +13462,13 @@ function normalizeOptions(options) {
         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;
@@ -13512,72 +13481,45 @@ function normalizeOptions(options) {
         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);
     }
-    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
-    _compileSchema(report, schema) {
-        return compileSchema.call(this, report, schema);
-    }
-    /**
-     * @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 +13533,9 @@ class ZSchema {
             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);
@@ -13605,19 +13547,20 @@ class ZSchema {
         let foundError = false;
         const report = new Report(this.options);
         report.json = json;
+        let _schema;
         if (typeof schema === 'string') {
             const schemaName = schema;
-            schema = getSchema.call(this, report, schemaName);
-            if (!schema) {
+            _schema = this.scache.getSchema(report, schemaName);
+            if (!_schema) {
                 throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
             }
         }
         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,21 +13568,21 @@ class ZSchema {
         }
         let validated = false;
         if (!foundError) {
-            validated = validateSchema.call(this, report, schema);
+            validated = this.sv.validateSchema(report, _schema);
         }
         if (!validated) {
             this.lastReport = report;
             foundError = true;
         }
         if (options.schemaPath) {
-            report.rootSchema = schema;
-            schema = get(schema, options.schemaPath);
-            if (!schema) {
+            report.rootSchema = _schema;
+            _schema = get(_schema, options.schemaPath);
+            if (!_schema) {
                 throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
             }
         }
         if (!foundError) {
-            validate.call(this, report, schema, json);
+            validate.call(this, report, _schema, json);
         }
         if (callback) {
             report.processAsyncTasks(this.options.asyncTimeout, callback);
@@ -13656,6 +13599,9 @@ class ZSchema {
      * 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 +13619,29 @@ class ZSchema {
         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 +13670,10 @@ class ZSchema {
     }
     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);