json-schema-library 5.2.1 → 6.1.0

package/dist/module/lib/resolveAllOf.js

@@ -1,13 +1,12 @@
 import copy from "./utils/copy";
 import merge from "./utils/merge";
-import errors from "./validation/errors";
 export default function resolveAllOf(core, data, schema = core.rootSchema, pointer = "#") {
     let mergedSchema = copy(schema);
     for (let i = 0; i < schema.allOf.length; i += 1) {
         const allOfSchema = core.resolveRef(schema.allOf[i]);
-        if (core.isValid(data, allOfSchema, pointer) === false) {
-            return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
-        }
+        // if (core.isValid(data, allOfSchema, pointer) === false) {
+        //     return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
+        // }
         mergedSchema = merge(mergedSchema, allOfSchema);
     }
     delete mergedSchema.allOf;

package/dist/module/lib/resolveOneOf.fuzzy.js

@@ -2,6 +2,7 @@ import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
 import getTypeOf from "./getTypeOf";
 import settings from "./config/settings";
+import { isJSONError } from "./types";
 const { DECLARATOR_ONEOF } = settings;
 /**
  * Returns a ranking for the data and given schema
@@ -52,7 +53,7 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
         for (let i = 0; i < schema.oneOf.length; i += 1) {
             const one = core.resolveRef(schema.oneOf[i]);
             const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
-            if (oneOfPropertySchema && oneOfPropertySchema.type === "error") {
+            if (isJSONError(oneOfPropertySchema)) {
                 return oneOfPropertySchema;
             }
             let result = flattenArray(core.validate(oneOfValue, oneOfPropertySchema, pointer));
@@ -64,7 +65,12 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
                 return one; // return resolved schema
             }
         }
-        return core.errors.oneOfPropertyError({ property: oneOfProperty, value: oneOfValue, pointer, errors });
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
     }
     // keyword: oneOf
     const matches = [];
@@ -90,7 +96,11 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
             }
         }
         if (schemaOfItem === undefined) {
-            return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf });
+            return core.errors.oneOfError({
+                value: JSON.stringify(data),
+                pointer,
+                oneOf: schema.oneOf
+            });
         }
         return schemaOfItem;
     }

package/dist/module/lib/resolveOneOf.strict.js

@@ -27,7 +27,16 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
         return matches[0];
     }
     if (matches.length > 1) {
-        return core.errors.multipleOneOfError({ value: data, pointer, matches });
+        return core.errors.multipleOneOfError({
+            value: data,
+            pointer,
+            matches,
+        });
     }
-    return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf, errors });
+    return core.errors.oneOfError({
+        value: JSON.stringify(data),
+        pointer,
+        oneOf: schema.oneOf,
+        errors,
+    });
 }

package/dist/module/lib/resolveRef.strict.js

@@ -2,6 +2,14 @@ export default function resolveRef(schema, rootSchema) {
     if (schema == null || schema.$ref == null) {
         return schema;
     }
+    if (schema.getRoot) {
+        // we actually always need to resolve the schema like this, since returned subschemas
+        // must resolve relative from their schema
+        const resolvedSchema = schema.getRoot().getRef(schema);
+        // console.log(schema.$ref, "=>", resolvedSchema);
+        return resolvedSchema;
+    }
+    // tryout - this should never be called, except we missed something
     const resolvedSchema = rootSchema.getRef(schema);
     return resolvedSchema;
 }

package/dist/module/lib/schema/getTypeDefs.js

@@ -14,7 +14,18 @@ export default function getTypeDefs(schema) {
     if (id == null) {
         return defs;
     }
-    const type = types[id];
+    let type;
+    if (Array.isArray(id)) {
+        // since types can also be declared as a set of types, merge the definitions
+        // maybe this will require a more sophisticated approach
+        type = {};
+        for (let i = 0, l = id.length; i < l; i += 1) {
+            Object.assign(type, types[id[i]]);
+        }
+    }
+    else {
+        type = types[id];
+    }
     if (type.definitions == null) {
         return defs;
     }

package/dist/module/lib/schema/getTypeId.js

@@ -15,7 +15,7 @@ export default function getTypeId(schema) {
     if (schema.enum) {
         return "enum";
     }
-    if (types[schema.type]) {
+    if (types[schema.type] || Array.isArray(schema.type)) {
         return schema.type;
     }
     const ids = typeKeywords.filter(type => schema[type]);

package/dist/module/lib/step.js

@@ -2,6 +2,7 @@ import getTypeOf from "./getTypeOf";
 import createSchemaOf from "./createSchemaOf";
 import errors from "./validation/errors";
 import merge from "./utils/merge";
+import { isJSONError } from "./types";
 const stepType = {
     array: (core, key, schema, data, pointer) => {
         const itemsType = getTypeOf(schema.items);
@@ -23,11 +24,27 @@ const stepType = {
             return core.resolveRef(schema.items);
         }
         if (itemsType === "array") {
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === true) {
+                return createSchemaOf(data[key]);
+            }
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === false) {
+                return errors.invalidDataError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
+            }
             if (schema.items[key]) {
                 return core.resolveRef(schema.items[key]);
             }
             if (schema.additionalItems === false) {
-                return errors.additionalItemsError({ key, value: data[key], pointer });
+                return errors.additionalItemsError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
             }
             if (schema.additionalItems === true || schema.additionalItems === undefined) {
                 return createSchemaOf(data[key]);
@@ -50,21 +67,21 @@ const stepType = {
             const oneOfSchema = core.resolveOneOf(data, schema, pointer);
             // resolveOneOf does currently not apply merge with base schema
             schema = merge(schema, oneOfSchema);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
         if (Array.isArray(schema.anyOf)) {
             // update current schema
             schema = core.resolveAnyOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
         if (Array.isArray(schema.allOf)) {
             // update current schema
             schema = core.resolveAllOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -73,7 +90,7 @@ const stepType = {
         if (schema.properties && schema.properties[key] !== undefined) {
             // @todo patternProperties also validate properties
             targetSchema = core.resolveRef(schema.properties[key]);
-            if (targetSchema && targetSchema.type === "error") {
+            if (isJSONError(targetSchema)) {
                 return targetSchema;
             }
             // check if there is a oneOf selection, which must be resolved
@@ -81,8 +98,10 @@ const stepType = {
                 // @special case: this is a mix of a schema and optional definitions
                 // we resolve the schema here and add the original schema to `oneOfSchema`
                 let resolvedSchema = core.resolveOneOf(data[key], targetSchema, `${pointer}/${key}`);
+                const oneOfIndex = targetSchema.oneOf.findIndex((s) => s === resolvedSchema);
                 resolvedSchema = JSON.parse(JSON.stringify(resolvedSchema));
                 resolvedSchema.variableSchema = true;
+                resolvedSchema.oneOfIndex = oneOfIndex;
                 resolvedSchema.oneOfSchema = targetSchema;
                 return resolvedSchema;
             }
@@ -91,6 +110,20 @@ const stepType = {
                 return targetSchema;
             }
         }
+        // @draft <= 07
+        const { dependencies } = schema;
+        if (getTypeOf(dependencies) === "object") {
+            const dependentProperties = Object.keys(dependencies).filter((propertyName) => 
+            // data[propertyName] !== undefined &&
+            getTypeOf(dependencies[propertyName]) === "object");
+            for (let i = 0, l = dependentProperties.length; i < l; i += 1) {
+                const dependentProperty = dependentProperties[i];
+                const schema = step(core, key, dependencies[dependentProperty], data);
+                if (!isJSONError(schema)) {
+                    return schema;
+                }
+            }
+        }
         // find matching property key
         if (getTypeOf(schema.patternProperties) === "object") {
             let regex;
@@ -106,9 +139,14 @@ const stepType = {
             return schema.additionalProperties;
         }
         if (schema.additionalProperties === true) {
-            return createSchemaOf(data);
+            return createSchemaOf(data[key]);
         }
-        return errors.unknownPropertyError({ property: key, value: data, pointer });
+        return errors.unknownPropertyError({
+            property: key,
+            value: data,
+            // pointer: `${pointer}/${key}`,
+            pointer: `${pointer}`
+        });
     }
 };
 /**
@@ -118,14 +156,27 @@ const stepType = {
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
 export default function step(core, key, schema, data, pointer = "#") {
+    // @draft >= 4 ?
+    if (Array.isArray(schema.type)) {
+        const dataType = getTypeOf(data);
+        if (schema.type.includes(dataType)) {
+            return stepType[dataType](core, key, schema, data, pointer);
+        }
+        return core.errors.typeError({
+            value: data,
+            pointer,
+            expected: schema.type,
+            received: dataType
+        });
+    }
     const expectedType = schema.type || getTypeOf(data);
     if (stepType[expectedType]) {
         return stepType[expectedType](core, key, schema, data, pointer);

package/dist/module/lib/types.js

@@ -1 +1,7 @@
-export {};
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export function isJSONError(error) {
+    return (error === null || error === void 0 ? void 0 : error.type) === "error";
+}

package/dist/module/lib/utils/filter.js

@@ -1,12 +1,10 @@
+import { isJSONError } from "../types";
 export function isPromise(obj) {
     return obj instanceof Promise;
 }
-export function isError(obj) {
-    return obj && obj.type === "error";
-}
 export function errorOrPromise(error) {
-    return isError(error) || isPromise(error);
+    return isJSONError(error) || isPromise(error);
 }
 export function errorsOnly(error) {
-    return isError(error);
+    return isJSONError(error);
 }

package/dist/module/lib/utils/merge.js

@@ -1,3 +1,6 @@
 import deepmerge from "deepmerge";
 const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 export default (a, b) => deepmerge(a, b, { arrayMerge: overwriteMerge });

package/dist/module/lib/validate.js

@@ -1,11 +1,14 @@
 import getTypeOf from "./getTypeOf";
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import { isJSONError } from "./types";
+import equal from "fast-deep-equal";
 function getJsonSchemaType(value, expectedType) {
-    let jsType = getTypeOf(value);
-    if (jsType === "number" && (expectedType === "integer" ||
-        (Array.isArray(expectedType) && expectedType.includes("integer")))) {
-        jsType = Number.isInteger(value) ? "integer" : "number";
+    const jsType = getTypeOf(value);
+    if (jsType === "number" &&
+        (expectedType === "integer" ||
+            (Array.isArray(expectedType) && expectedType.includes("integer")))) {
+        return Number.isInteger(value) ? "integer" : "number";
     }
     return jsType;
 }
@@ -19,14 +22,36 @@ function getJsonSchemaType(value, expectedType) {
  * @return list of errors or empty
  */
 export default function validate(core, value, schema = core.rootSchema, pointer = "#") {
-    if (schema.type === "error") {
+    schema = core.resolveRef(schema);
+    // this is a high level v7 schema validation
+    if (getTypeOf(schema) === "boolean") {
+        if (schema) {
+            return [];
+        }
+        return [core.errors.invalidDataError({ value, pointer })];
+    }
+    if (isJSONError(schema)) {
         return [schema];
     }
-    schema = core.resolveRef(schema);
+    // @draft >= 6 const
+    if (schema.const !== undefined) {
+        if (equal(schema.const, value)) {
+            return [];
+        }
+        return [core.errors.constError({ value, expected: schema.const, pointer })];
+    }
     const receivedType = getJsonSchemaType(value, schema.type);
     const expectedType = schema.type || receivedType;
-    if (receivedType !== expectedType && (!Array.isArray(expectedType) || !expectedType.includes(receivedType))) {
-        return [core.errors.typeError({ received: receivedType, expected: expectedType, value, pointer })];
+    if (receivedType !== expectedType &&
+        (!Array.isArray(expectedType) || !expectedType.includes(receivedType))) {
+        return [
+            core.errors.typeError({
+                received: receivedType,
+                expected: expectedType,
+                value,
+                pointer
+            })
+        ];
     }
     if (core.validateType[receivedType] == null) {
         return [core.errors.invalidTypeError({ receivedType, pointer })];

package/dist/module/lib/validateAsync.js

@@ -1,5 +1,6 @@
-import { isError, errorsOnly } from "./utils/filter";
+import { errorsOnly } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import { isJSONError } from "./types";
 function createErrorNotification(onError) {
     return function notifyError(error) {
         if (Array.isArray(error)) {
@@ -7,7 +8,7 @@ function createErrorNotification(onError) {
             error.forEach(notifyError);
             return error;
         }
-        if (isError(error)) {
+        if (isJSONError(error)) {
             onError(error);
         }
         return error;
@@ -35,16 +36,15 @@ export default function validateAsync(core, value, options) {
             if (errors[i] instanceof Promise) {
                 errors[i].then(notifyError);
             }
-            else if (isError(errors[i])) {
+            else if (isJSONError(errors[i])) {
                 onError(errors[i]);
             }
         }
     }
-    return Promise
-        .all(errors)
+    return Promise.all(errors)
         .then(flattenArray)
-        .then(resolvedErrors => resolvedErrors.filter(errorsOnly))
-        .catch(e => {
+        .then((resolvedErrors) => resolvedErrors.filter(errorsOnly))
+        .catch((e) => {
         console.log("Failed resolving promises", e.message);
         console.log(e.stack);
         throw e;

package/dist/module/lib/validation/errors.js

@@ -5,17 +5,30 @@ const errors = {
     additionalPropertiesError: createCustomError("AdditionalPropertiesError"),
     anyOfError: createCustomError("AnyOfError"),
     allOfError: createCustomError("AllOfError"),
+    constError: createCustomError("ConstError"),
+    containsError: createCustomError("ContainsError"),
+    containsArrayError: createCustomError("ContainsArrayError"),
+    containsAnyError: createCustomError("ContainsAnyError"),
     enumError: createCustomError("EnumError"),
-    formatUrlError: createCustomError("FormatUrlError"),
-    formatUriError: createCustomError("FormatUriError"),
+    formatURLError: createCustomError("FormatURLError"),
+    formatURIError: createCustomError("FormatURIError"),
+    formatURIReferenceError: createCustomError("FormatURIReferenceError"),
+    formatURITemplateError: createCustomError("FormatURITemplateError"),
+    formatDateError: createCustomError("FormatDateaError"),
     formatDateTimeError: createCustomError("FormatDateTimeError"),
     formatEmailError: createCustomError("FormatEmailError"),
     formatHostnameError: createCustomError("FormatHostnameError"),
     formatIPV4Error: createCustomError("FormatIPV4Error"),
+    formatIPV4LeadingZeroError: createCustomError("FormatIPV4LeadingZeroError"),
     formatIPV6Error: createCustomError("FormatIPV6Error"),
+    formatIPV6LeadingZeroError: createCustomError("FormatIPV6LeadingZeroError"),
+    formatJSONPointerError: createCustomError("FormatJSONPointerError"),
     formatRegExError: createCustomError("FormatRegExError"),
+    formatTimeError: createCustomError("FormatTimeError"),
     invalidSchemaError: createCustomError("InvalidSchemaError"),
+    invalidDataError: createCustomError("InvalidDataError"),
     invalidTypeError: createCustomError("InvalidTypeError"),
+    invalidPropertyNameError: createCustomError("InvalidPropertyNameError"),
     maximumError: createCustomError("MaximumError"),
     maxItemsError: createCustomError("MaxItemsError"),
     maxLengthError: createCustomError("MaxLengthError"),

package/dist/module/lib/validation/format.js

@@ -1,13 +1,43 @@
-/* eslint-disable max-len */
+/* eslint-disable max-len, no-control-regex */
 import errors from "./errors";
 import validUrl from "valid-url";
+// referenced
+// https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
 // https://gist.github.com/marcelotmelo/b67f58a08bee6c2468f8
 const isValidDateTime = new RegExp("^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])[Tt]([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\\.[0-9]+)?(([Zz])|([\\+|\\-]([01][0-9]|2[0-3]):[0-5][0-9]))$");
 const isValidIPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
 const isValidIPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
 const isValidHostname = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/;
+const matchDate = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const matchTime = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const isValidJSONPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const isValidRelativeJSONPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const isValidURIRef = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+// uri-template: https://tools.ietf.org/html/rfc6570
+const isValidURITemplate = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
 // Default JSON-Schema formats: date-time, email, hostname, ipv4, ipv6, uri, uriref
 export default {
+    date: (core, schema, value, pointer) => {
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+        const matches = value.match(matchDate);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const year = +matches[1];
+        const month = +matches[2];
+        const day = +matches[3];
+        // https://tools.ietf.org/html/rfc3339#appendix-C
+        const isLeapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        if (month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear ? 29 : DAYS[month])) {
+            return undefined;
+        }
+        return errors.formatDateError({ value, pointer });
+    },
     "date-time": (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
@@ -56,6 +86,10 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV4LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 15 && isValidIPV4.test(value)) {
             return undefined;
         }
@@ -65,25 +99,92 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV6LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 45 && isValidIPV6.test(value)) {
             return undefined;
         }
         return errors.formatIPV6Error({ value, pointer });
     },
+    "json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
+    "relative-json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidRelativeJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
     regex: (core, schema, value, pointer) => {
         if (typeof value === "string" && /\\Z$/.test(value) === false) {
+            try {
+                new RegExp(value);
+                return undefined;
+            }
+            catch (e) { } // eslint-disable-line no-empty
+            return errors.formatRegExError({ value, pointer });
+        }
+        // v7 tests, ignore non-regex values
+        if (typeof value === "object" || typeof value === "number" || Array.isArray(value)) {
             return undefined;
         }
         return errors.formatRegExError({ value, pointer });
     },
-    uri: (core, schema, value, pointer) => {
+    time: (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
         }
-        if (value === "" || validUrl.isUri(value)) {
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        const matches = value.match(matchTime);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const hour = +matches[1];
+        const minute = +matches[2];
+        const second = +matches[3];
+        const timeZone = !!matches[5];
+        if (((hour <= 23 && minute <= 59 && second <= 59) || (hour == 23 && minute == 59 && second == 60)) && timeZone) {
+            return undefined;
+        }
+        return errors.formatTimeError({ value, pointer });
+    },
+    uri: (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (validUrl.isUri(value)) {
+            return undefined;
+        }
+        return errors.formatURIError({ value, pointer });
+    },
+    "uri-reference": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURIRef.test(value)) {
+            return undefined;
+        }
+        return errors.formatURIReferenceError({ value, pointer });
+    },
+    "uri-template": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURITemplate.test(value)) {
             return undefined;
         }
-        return errors.formatUriError({ value, pointer });
+        return errors.formatURITemplateError({ value, pointer });
     },
     url: (core, schema, value, pointer) => {
         if (value === "" || validUrl.isWebUri(value)) {