schema-shield 0.0.2 → 0.0.4

package/dist/index.js

@@ -25,24 +25,41 @@ module.exports = __toCommonJS(lib_exports);
 
 // lib/utils.ts
 var ValidationError = class extends Error {
-  name;
-  pointer;
   message;
-  value;
-  code;
-  constructor(message, options = {
-    pointer: "",
-    value: null,
-    code: ""
-  }) {
-    super(message);
-    this.name = "ValidationError";
-    this.pointer = options.pointer;
-    this.message = message;
-    this.value = options.value;
-    this.code = options.code;
+  item;
+  keyword;
+  cause;
+  path = "";
+  data;
+  schema;
+  _getCause(pointer = "#") {
+    const path = pointer + "/" + this.keyword + (typeof this.item !== "undefined" ? "/" + this.item : "");
+    if (!this.cause) {
+      this.path = path;
+      return this;
+    }
+    return this.cause._getCause(path);
+  }
+  getCause() {
+    return this._getCause();
   }
 };
+function getDefinedErrorFunctionForKey(key, schema) {
+  const KeywordError = new ValidationError(`Invalid ${key}`);
+  KeywordError.keyword = key;
+  KeywordError.schema = schema;
+  const defineError = (message, options = {}) => {
+    KeywordError.message = message;
+    KeywordError.item = options.item;
+    KeywordError.cause = options.cause;
+    KeywordError.data = options.data;
+    return KeywordError;
+  };
+  return getNamedFunction(
+    `defineError_${key}`,
+    defineError
+  );
+}
 function deepEqual(obj, other) {
   if (Array.isArray(obj) && Array.isArray(other)) {
     if (obj.length !== other.length) {
@@ -75,571 +92,595 @@ function deepEqual(obj, other) {
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
+function areCloseEnough(a, b, epsilon = 1e-15) {
+  return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
+}
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    const result = [];
+    for (let i = 0; i < obj.length; i++) {
+      result[i] = deepClone(obj[i]);
+    }
+    return result;
+  }
+  if (obj && obj.constructor && obj.constructor.name !== "Object") {
+    return obj;
+  }
+  if (isObject(obj)) {
+    const result = {
+      ...obj
+    };
+    for (const key in obj) {
+      result[key] = deepClone(obj[key]);
+    }
+    return result;
+  }
+  return obj;
+}
+function isCompiledSchema(subSchema) {
+  return isObject(subSchema) && "$validate" in subSchema;
+}
+function getNamedFunction(name, fn) {
+  return Object.defineProperty(fn, "name", { value: name });
+}
 
 // lib/formats.ts
-var RegExps = {
-  "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
-  uri: /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/,
-  email: /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
-  ipv6: /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?=(?:[0-9a-fA-F]{0,4}:){0,7}[0-9a-fA-F]{0,4}(?![:.\w]))(([0-9a-fA-F]{1,4}:){1,7}|:)((:[0-9a-fA-F]{1,4}){1,7}|:))$/,
-  hostname: /^[a-zA-Z0-9][a-zA-Z0-9-]{0,62}(\.[a-zA-Z0-9][a-zA-Z0-9-]{0,62})*$/
-};
-function notImplementedFormat(data) {
-  throw new ValidationError(
-    `Format "${data}" is not implemented yet. Please open an issue on GitHub.`
-  );
-  return false;
-}
 var Formats = {
   ["date-time"](data) {
-    return RegExps["date-time"].test(data);
+    const match = data.match(
+      /^(\d{4})-(0[0-9]|1[0-2])-(\d{2})T(0[0-9]|1\d|2[0-3]):([0-5]\d):((?:[0-5]\d|60))(?:.\d+)?(?:([+-])(0[0-9]|1\d|2[0-3]):([0-5]\d)|Z)?$/i
+    );
+    if (!match) {
+      return false;
+    }
+    let day = Number(match[3]);
+    if (match[2] === "02" && day > 29) {
+      return false;
+    }
+    const [
+      ,
+      yearStr,
+      monthStr,
+      ,
+      hourStr,
+      minuteStr,
+      secondStr,
+      timezoneSign,
+      timezoneHourStr,
+      timezoneMinuteStr
+    ] = match;
+    let year = Number(yearStr);
+    let month = Number(monthStr);
+    let hour = Number(hourStr);
+    let minute = Number(minuteStr);
+    let second = Number(secondStr);
+    if (timezoneSign === "-" || timezoneSign === "+") {
+      const timezoneHour = Number(timezoneHourStr);
+      const timezoneMinute = Number(timezoneMinuteStr);
+      if (timezoneSign === "-") {
+        hour += timezoneHour;
+        minute += timezoneMinute;
+      } else if (timezoneSign === "+") {
+        hour -= timezoneHour;
+        minute -= timezoneMinute;
+      }
+      if (minute > 59) {
+        hour += 1;
+        minute -= 60;
+      } else if (minute < 0) {
+        hour -= 1;
+        minute += 60;
+      }
+      if (hour > 23) {
+        day += 1;
+        hour -= 24;
+      } else if (hour < 0) {
+        day -= 1;
+        hour += 24;
+      }
+      if (day > 31) {
+        month += 1;
+        day -= 31;
+      } else if (day < 1) {
+        month -= 1;
+        day += 31;
+      }
+      if (month > 12) {
+        year += 1;
+        month -= 12;
+      } else if (month < 1) {
+        year -= 1;
+        month += 12;
+      }
+      if (year < 0) {
+        return false;
+      }
+    }
+    const daysInMonth = [31, , 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    const maxDays = month === 2 ? year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28 : daysInMonth[month - 1];
+    if (day > maxDays) {
+      return false;
+    }
+    if (second === 60 && (minute !== 59 || hour !== 23)) {
+      return false;
+    }
+    return true;
   },
   uri(data) {
-    return RegExps.uri.test(data);
+    return /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/.test(data);
   },
   email(data) {
-    return RegExps.email.test(data);
+    return /^(?!\.)(?!.*\.$)[a-z0-9!#$%&'*+/=?^_`{|}~-]{1,20}(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]{1,21}){0,2}@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,60}[a-z0-9])?){0,3}$/i.test(
+      data
+    );
   },
   ipv4(data) {
-    return RegExps.ipv4.test(data);
+    return /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])$/.test(
+      data
+    );
   },
+  // ipv6: isMyIpValid({ version: 6 }),
   ipv6(data) {
-    return RegExps.ipv6.test(data);
+    if (data === "::") {
+      return true;
+    }
+    if (data.indexOf(":") === -1 || /(?:\s+|:::+|^\w{5,}|\w{5}$|^:{1}\w|\w:{1}$)/.test(data)) {
+      return false;
+    }
+    const hasIpv4 = data.indexOf(".") !== -1;
+    let addressParts = data;
+    if (hasIpv4) {
+      addressParts = data.split(":");
+      const ipv4Part = addressParts.pop();
+      if (!/^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])$/.test(
+        ipv4Part
+      )) {
+        return false;
+      }
+    }
+    const isShortened = data.indexOf("::") !== -1;
+    const ipv6Part = hasIpv4 ? addressParts.join(":") : data;
+    if (isShortened) {
+      if (ipv6Part.split("::").length - 1 > 1) {
+        return false;
+      }
+      if (!/^[0-9a-fA-F:.]*$/.test(ipv6Part)) {
+        return false;
+      }
+      return /^(?:(?:(?:[0-9a-fA-F]{1,4}(?::|$)){1,6}))|(?:::(?:[0-9a-fA-F]{1,4})){0,5}$/.test(
+        ipv6Part
+      );
+    }
+    const isIpv6Valid = /^(?:(?:[0-9a-fA-F]{1,4}:){7}(?:[0-9a-fA-F]{1,4}|:))$/.test(ipv6Part);
+    const hasInvalidChar = /(?:[0-9a-fA-F]{5,}|\D[0-9a-fA-F]{3}:)/.test(
+      ipv6Part
+    );
+    if (hasIpv4) {
+      return isIpv6Valid || !hasInvalidChar;
+    }
+    return isIpv6Valid && !hasInvalidChar;
   },
   hostname(data) {
-    return RegExps.hostname.test(data);
-  },
-  // Not supported yet
-  time: notImplementedFormat,
-  date: notImplementedFormat,
-  duration: notImplementedFormat,
-  "idn-email": notImplementedFormat,
-  "idn-hostname": notImplementedFormat,
-  uuid: notImplementedFormat,
-  "uri-reference": notImplementedFormat,
-  iri: notImplementedFormat,
-  "iri-reference": notImplementedFormat,
-  "uri-template": notImplementedFormat,
-  "json-pointer": notImplementedFormat,
-  "relative-json-pointer": notImplementedFormat,
-  regex: notImplementedFormat
-};
-
-// lib/types.ts
-var Types = {
-  object(schema, data, pointer) {
-    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an object", {
-          pointer,
-          value: data,
-          code: "NOT_AN_OBJECT"
-        })
-      ],
+    return /^[a-z0-9][a-z0-9-]{0,62}(?:\.[a-z0-9][a-z0-9-]{0,62})*[a-z0-9]$/i.test(
       data
-    };
+    );
   },
-  array(schema, data, pointer) {
-    if (Array.isArray(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+  date(data) {
+    if (/^(\d{4})-(\d{2})-(\d{2})$/.test(data) === false) {
+      return false;
     }
-    if (typeof data === "object" && data !== null && "length" in data) {
-      const keys = Object.keys(data);
-      if (keys.length > 0 && (keys[0] !== "0" || keys.length !== data.length)) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Data is not an array", {
-              pointer,
-              value: data,
-              code: "NOT_AN_ARRAY"
-            })
-          ],
-          data
-        };
-      }
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+    return !isNaN(new Date(data).getTime());
+  },
+  regex(data) {
+    try {
+      new RegExp(data);
+      return true;
+    } catch (e) {
+      return false;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an array", {
-          pointer,
-          value: data,
-          code: "NOT_AN_ARRAY"
-        })
-      ],
-      data
-    };
   },
-  string(schema, data, pointer) {
-    if (typeof data === "string") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+  "json-pointer"(data) {
+    if (data === "") {
+      return true;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a string", {
-          pointer,
-          value: data,
-          code: "NOT_A_STRING"
-        })
-      ],
-      data
-    };
+    return /^\/(?:[^~]|~0|~1)*$/.test(data);
   },
-  number(schema, data, pointer) {
-    if (typeof data === "number") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+  "relative-json-pointer"(data) {
+    if (data === "") {
+      return true;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a number", {
-          pointer,
-          value: data,
-          code: "NOT_A_NUMBER"
-        })
-      ],
+    return /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/.test(data);
+  },
+  time(data) {
+    return /^(\d{2}):(\d{2}):(\d{2})(\.\d+)?(Z|([+-])(\d{2}):(\d{2}))$/.test(
       data
-    };
+    );
   },
-  integer(schema, data, pointer) {
-    if (typeof data === "number" && Number.isInteger(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+  "uri-reference"(data) {
+    if (/\\/.test(data)) {
+      return false;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an integer", {
-          pointer,
-          value: data,
-          code: "NOT_AN_INTEGER"
-        })
-      ],
+    return /^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#((?![^#]*\\)[^#]*))?/i.test(
       data
-    };
+    );
   },
-  boolean(schema, data, pointer) {
-    if (typeof data === "boolean") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a boolean", {
-          pointer,
-          value: data,
-          code: "NOT_A_BOOLEAN"
-        })
-      ],
+  "uri-template"(data) {
+    return /^(?:(?:https?:\/\/[\w.-]+)?\/?)?[\w- ;,.\/?%&=]*(?:\{[\w-]+(?::\d+)?\}[\w- ;,.\/?%&=]*)*\/?$/.test(
       data
-    };
+    );
   },
-  null(schema, data, pointer) {
-    if (data === null) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+  // Not supported yet
+  duration: false,
+  uuid: false,
+  "idn-email": false,
+  "idn-hostname": false,
+  iri: false,
+  "iri-reference": false
+};
+
+// lib/types.ts
+var Types = {
+  object(data) {
+    return isObject(data);
+  },
+  array(data) {
+    if (Array.isArray(data)) {
+      return true;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not null", {
-          pointer,
-          value: data,
-          code: "NOT_NULL"
-        })
-      ],
-      data
-    };
-  }
+    return typeof data === "object" && data !== null && "length" in data && "0" in data && Object.keys(data).length - 1 === data.length;
+  },
+  string(data) {
+    return typeof data === "string";
+  },
+  number(data) {
+    return typeof data === "number";
+  },
+  integer(data) {
+    return typeof data === "number" && data % 1 === 0;
+  },
+  boolean(data) {
+    return typeof data === "boolean";
+  },
+  null(data) {
+    return data === null;
+  },
+  // Not implemented yet
+  timestamp: false,
+  int8: false,
+  unit8: false,
+  int16: false,
+  unit16: false,
+  int32: false,
+  unit32: false,
+  float32: false,
+  float64: false
 };
 
 // lib/keywords/array-keywords.ts
 var ArrayKeywords = {
-  items(schema, data, pointer, schemaShieldInstance) {
+  items(schema, data, defineError) {
     if (!Array.isArray(data)) {
-      return { valid: true, errors: [], data };
-    }
-    const errors = [];
-    let finalData = [...data];
-    if (Array.isArray(schema.items)) {
-      for (let i = 0; i < schema.items.length; i++) {
-        if (typeof schema.items[i] === "boolean") {
-          if (schema.items[i] === false && typeof data[i] !== "undefined") {
-            errors.push(
-              new ValidationError("Array item is not allowed", {
-                pointer: `${pointer}/${i}`,
-                value: data[i],
-                code: "ARRAY_ITEM_NOT_ALLOWED"
-              })
-            );
+      return;
+    }
+    const schemaItems = schema.items;
+    const dataLength = data.length;
+    if (typeof schemaItems === "boolean") {
+      if (schemaItems === false && dataLength > 0) {
+        return defineError("Array items are not allowed", { data });
+      }
+      return;
+    }
+    if (Array.isArray(schemaItems)) {
+      const schemaItemsLength = schemaItems.length;
+      const itemsLength = Math.min(schemaItemsLength, dataLength);
+      for (let i = 0; i < itemsLength; i++) {
+        const schemaItem = schemaItems[i];
+        if (typeof schemaItem === "boolean") {
+          if (schemaItem === false && typeof data[i] !== "undefined") {
+            return defineError("Array item is not allowed", {
+              item: i,
+              data: data[i]
+            });
           }
           continue;
         }
-        const { validator } = schema.items[i];
-        if (!validator) {
-          continue;
-        }
-        const validatorResult = validator(
-          schema.items[i],
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
-        finalData[i] = validatorResult.data;
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
+        if (isCompiledSchema(schemaItem)) {
+          const error = schemaItem.$validate(data[i]);
+          if (error) {
+            return defineError("Array item is invalid", {
+              item: i,
+              cause: error,
+              data: data[i]
+            });
+          }
         }
       }
-    } else if (typeof schema.items === "boolean") {
-      if (schema.items === false && data.length > 0) {
-        errors.push(
-          new ValidationError("Array is not allowed", {
-            pointer,
-            value: data,
-            code: "ARRAY_NOT_ALLOWED"
-          })
-        );
-      }
-    } else {
-      const { validator } = schema.items;
-      if (!validator) {
-        return { valid: true, errors: [], data };
-      }
-      for (let i = 0; i < finalData.length; i++) {
-        const validatorErrors = validator(
-          schema.items,
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
-        finalData[i] = validatorErrors.data;
-        if (!validatorErrors.valid) {
-          errors.push(...validatorErrors.errors);
+      return;
+    }
+    if (isCompiledSchema(schemaItems)) {
+      for (let i = 0; i < dataLength; i++) {
+        const error = schemaItems.$validate(data[i]);
+        if (error) {
+          return defineError("Array item is invalid", {
+            item: i,
+            cause: error,
+            data: data[i]
+          });
         }
       }
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
-  minItems(schema, data, pointer) {
+  elements(schema, data, defineError) {
+    if (!Array.isArray(data) || !isCompiledSchema(schema.elements)) {
+      return;
+    }
+    for (let i = 0; i < data.length; i++) {
+      const error = schema.elements.$validate(data[i]);
+      if (error) {
+        return defineError("Array item is invalid", {
+          item: i,
+          cause: error,
+          data: data[i]
+        });
+      }
+    }
+    return;
+  },
+  minItems(schema, data, defineError) {
     if (!Array.isArray(data) || data.length >= schema.minItems) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Array is too short", {
-          pointer,
-          value: data,
-          code: "ARRAY_TOO_SHORT"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Array is too short", { data });
   },
-  maxItems(schema, data, pointer) {
+  maxItems(schema, data, defineError) {
     if (!Array.isArray(data) || data.length <= schema.maxItems) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Array is too long", {
-          pointer,
-          value: data,
-          code: "ARRAY_TOO_LONG"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Array is too long", { data });
   },
-  additionalItems(schema, data, pointer, schemaShieldInstance) {
-    if (!Array.isArray(data) || !schema.items || !Array.isArray(schema.items)) {
-      return { valid: true, errors: [], data };
+  additionalItems(schema, data, defineError) {
+    if (!schema.items || isObject(schema.items)) {
+      return;
     }
     if (schema.additionalItems === false) {
       if (data.length > schema.items.length) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Array has too many items", {
-              pointer,
-              value: data,
-              code: "ARRAY_TOO_MANY_ITEMS"
-            })
-          ],
-          data
-        };
+        return defineError("Array is too long", { data });
       }
-      return { valid: true, errors: [], data };
-    }
-    const errors = [];
-    let finalData = [...data];
-    if (typeof schema.additionalItems === "object") {
-      for (let i = schema.items.length; i < finalData.length; i++) {
-        const { validator } = schema.additionalItems;
-        const validatorResult = validator(
-          schema.additionalItems,
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
+      return;
+    }
+    if (isObject(schema.additionalItems)) {
+      if (isCompiledSchema(schema.additionalItems)) {
+        for (let i = schema.items.length; i < data.length; i++) {
+          const error = schema.additionalItems.$validate(data[i]);
+          if (error) {
+            return defineError("Array item is invalid", {
+              item: i,
+              cause: error,
+              data: data[i]
+            });
+          }
         }
-        finalData[i] = validatorResult.data;
+        return;
       }
+      return;
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
-  uniqueItems(schema, data, pointer) {
+  uniqueItems(schema, data, defineError) {
     if (!Array.isArray(data) || !schema.uniqueItems) {
-      return { valid: true, errors: [], data };
+      return;
     }
     const unique = /* @__PURE__ */ new Set();
     for (const item of data) {
-      let itemStr = item;
+      let itemStr;
       if (typeof item === "string") {
-        itemStr = `"${item}"`;
+        itemStr = `s:${item}`;
       } else if (isObject(item)) {
-        const keys = Object.keys(item).sort();
-        const sorted = {};
-        for (let i = 0; i < keys.length; i++) {
-          sorted[keys[i]] = item[keys[i]];
-        }
-        itemStr = JSON.stringify(sorted);
+        itemStr = `o:${JSON.stringify(
+          Object.fromEntries(
+            Object.entries(item).sort(([a], [b]) => a.localeCompare(b))
+          )
+        )}`;
       } else if (Array.isArray(item)) {
         itemStr = JSON.stringify(item);
+      } else {
+        itemStr = String(item);
       }
       if (unique.has(itemStr)) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Array items are not unique", {
-              pointer,
-              value: data,
-              code: "ARRAY_ITEMS_NOT_UNIQUE"
-            })
-          ],
-          data
-        };
-      } else {
-        unique.add(itemStr);
+        return defineError("Array items are not unique", { data: item });
       }
+      unique.add(itemStr);
+    }
+    return;
+  },
+  contains(schema, data, defineError) {
+    if (!Array.isArray(data)) {
+      return;
     }
-    return { valid: true, errors: [], data };
+    if (typeof schema.contains === "boolean") {
+      if (schema.contains) {
+        if (data.length === 0) {
+          return defineError("Array must contain at least one item", { data });
+        }
+        return;
+      }
+      return defineError("Array must not contain any items", { data });
+    }
+    for (let i = 0; i < data.length; i++) {
+      const error = schema.contains.$validate(data[i]);
+      if (!error) {
+        return;
+      }
+      continue;
+    }
+    return defineError("Array must contain at least one item", { data });
   }
 };
 
 // lib/keywords/number-keywords.ts
 var NumberKeywords = {
-  minimum(schema, data, pointer) {
+  minimum(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
-    }
-    const min = schema.exclusiveMinimum ? schema.minimum + 1e-15 : schema.minimum;
-    const valid = data >= min;
-    return {
-      valid,
-      errors: valid ? [] : [
-        new ValidationError("Number is too small", {
-          pointer,
-          value: data,
-          code: "NUMBER_TOO_SMALL"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    let min = schema.minimum;
+    if (typeof schema.exclusiveMinimum === "number") {
+      min = schema.exclusiveMinimum + 1e-15;
+    } else if (schema.exclusiveMinimum === true) {
+      min += 1e-15;
+    }
+    if (data < min) {
+      return defineError("Value is less than the minimum", { data });
+    }
+    return;
   },
-  maximum(schema, data, pointer) {
+  maximum(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
-    }
-    const max = schema.exclusiveMaximum ? schema.maximum - 1e-15 : schema.maximum;
-    const valid = data <= max;
-    return {
-      valid,
-      errors: valid ? [] : [
-        new ValidationError("Number is too large", {
-          pointer,
-          value: data,
-          code: "NUMBER_TOO_LARGE"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    let max = schema.maximum;
+    if (typeof schema.exclusiveMaximum === "number") {
+      max = schema.exclusiveMaximum - 1e-15;
+    } else if (schema.exclusiveMaximum === true) {
+      max -= 1e-15;
+    }
+    if (data > max) {
+      return defineError("Value is greater than the maximum", { data });
+    }
+    return;
   },
-  multipleOf(schema, data, pointer) {
+  multipleOf(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
+      return;
     }
     const quotient = data / schema.multipleOf;
-    const areMultiples = Math.abs(quotient - Math.round(quotient)) < 1e-15;
-    return {
-      valid: areMultiples,
-      errors: areMultiples ? [] : [
-        new ValidationError("Number is not a multiple of", {
-          pointer,
-          value: data,
-          code: "NUMBER_NOT_MULTIPLE_OF"
-        })
-      ],
-      data
-    };
+    if (!isFinite(quotient)) {
+      return;
+    }
+    if (!areCloseEnough(quotient, Math.round(quotient))) {
+      return defineError("Value is not a multiple of the multipleOf", { data });
+    }
+    return;
+  },
+  exclusiveMinimum(schema, data, defineError, instance) {
+    if (typeof data !== "number" || typeof schema.exclusiveMinimum !== "number" || "minimum" in schema) {
+      return;
+    }
+    if (data <= schema.exclusiveMinimum + 1e-15) {
+      return defineError("Value is less than or equal to the exclusiveMinimum");
+    }
+    return;
+  },
+  exclusiveMaximum(schema, data, defineError, instance) {
+    if (typeof data !== "number" || typeof schema.exclusiveMaximum !== "number" || "maximum" in schema) {
+      return;
+    }
+    if (data >= schema.exclusiveMaximum) {
+      return defineError(
+        "Value is greater than or equal to the exclusiveMaximum",
+        { data }
+      );
+    }
+    return;
   }
 };
 
 // lib/keywords/object-keywords.ts
 var ObjectKeywords = {
   // Object
-  required(schema, data, pointer) {
+  required(schema, data, defineError) {
     if (!isObject(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+      return;
     }
-    const errors = [];
     for (let i = 0; i < schema.required.length; i++) {
       const key = schema.required[i];
       if (!data.hasOwnProperty(key)) {
-        errors.push(
-          new ValidationError("Missing required property", {
-            pointer: `${pointer}/${key}`,
-            value: data,
-            code: "MISSING_REQUIRED_PROPERTY"
-          })
-        );
+        return defineError("Required property is missing", {
+          item: key,
+          data: data[key]
+        });
       }
     }
-    return { valid: errors.length === 0, errors, data };
+    return;
   },
-  properties(schema, data, pointer, schemaShieldInstance) {
+  properties(schema, data, defineError) {
     if (!isObject(data)) {
-      return { valid: true, errors: [], data };
-    }
-    const errors = [];
-    let finalData = { ...data };
-    for (let key in schema.properties) {
-      if (!data.hasOwnProperty(key) || typeof data[key] === "undefined") {
-        if (isObject(schema.properties[key]) && "default" in schema.properties[key]) {
-          finalData[key] = schema.properties[key].default;
+      return;
+    }
+    for (const key of Object.keys(schema.properties)) {
+      if (!data.hasOwnProperty(key)) {
+        const schemaProp = schema.properties[key];
+        if (isObject(schemaProp) && "default" in schemaProp) {
+          data[key] = schemaProp.default;
         }
         continue;
       }
       if (typeof schema.properties[key] === "boolean") {
         if (schema.properties[key] === false) {
-          errors.push(
-            new ValidationError("Property is not allowed", {
-              pointer: `${pointer}/${key}`,
-              value: data[key],
-              code: "PROPERTY_NOT_ALLOWED"
-            })
-          );
+          return defineError("Property is not allowed", {
+            item: key,
+            data: data[key]
+          });
         }
         continue;
       }
-      const { validator } = schema.properties[key];
-      if (!validator) {
-        continue;
+      if ("$validate" in schema.properties[key]) {
+        const error = schema.properties[key].$validate(data[key]);
+        if (error) {
+          return defineError("Property is invalid", {
+            item: key,
+            cause: error,
+            data: data[key]
+          });
+        }
       }
-      const validatorResult = validator(
-        schema.properties[key],
-        finalData[key],
-        `${pointer}/${key}`,
-        schemaShieldInstance
-      );
-      finalData[key] = validatorResult.data;
-      if (!validatorResult.valid) {
-        errors.push(...validatorResult.errors);
+    }
+    return;
+  },
+  values(schema, data, defineError) {
+    if (!isObject(data) || !isCompiledSchema(schema.values)) {
+      return;
+    }
+    const keys = Object.keys(data);
+    for (const key of keys) {
+      const error = schema.values.$validate(data[key]);
+      if (error) {
+        return defineError("Property is invalid", {
+          item: key,
+          cause: error,
+          data: data[key]
+        });
       }
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
-  maxProperties(schema, data, pointer) {
+  maxProperties(schema, data, defineError) {
     if (!isObject(data) || Object.keys(data).length <= schema.maxProperties) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Object has too many properties", {
-          pointer,
-          value: data,
-          code: "OBJECT_TOO_MANY_PROPERTIES"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Too many properties", { data });
   },
-  minProperties(schema, data, pointer) {
+  minProperties(schema, data, defineError) {
     if (!isObject(data) || Object.keys(data).length >= schema.minProperties) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Object has too few properties", {
-          pointer,
-          value: data,
-          code: "OBJECT_TOO_FEW_PROPERTIES"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Too few properties", { data });
   },
-  additionalProperties(schema, data, pointer, schemaShieldInstance) {
+  additionalProperties(schema, data, defineError) {
     if (!isObject(data)) {
-      return { valid: true, errors: [], data };
+      return;
     }
-    const errors = [];
-    let finalData = { ...data };
-    for (let key in data) {
+    const keys = Object.keys(data);
+    const isCompiled = isCompiledSchema(schema.additionalProperties);
+    for (const key of keys) {
       if (schema.properties && schema.properties.hasOwnProperty(key)) {
         continue;
       }
       if (schema.patternProperties) {
         let match = false;
-        for (let pattern in schema.patternProperties) {
-          if (new RegExp(pattern).test(key)) {
+        for (const pattern in schema.patternProperties) {
+          if (new RegExp(pattern, "u").test(key)) {
             match = true;
             break;
           }
@@ -649,436 +690,340 @@ var ObjectKeywords = {
         }
       }
       if (schema.additionalProperties === false) {
-        errors.push(
-          new ValidationError("Additional property not allowed", {
-            pointer: `${pointer}/${key}`,
-            value: data,
-            code: "ADDITIONAL_PROPERTY_NOT_ALLOWED"
-          })
-        );
-        continue;
+        return defineError("Additional properties are not allowed", {
+          item: key,
+          data: data[key]
+        });
       }
-      const { validator } = schema.additionalProperties;
-      if (!validator) {
-        continue;
-      }
-      const validatorResult = validator(
-        schema.additionalProperties,
-        finalData[key],
-        `${pointer}/${key}`,
-        schemaShieldInstance
-      );
-      finalData[key] = validatorResult.data;
-      if (!validatorResult.valid) {
-        errors.push(...validatorResult.errors);
+      if (isCompiled) {
+        const error = schema.additionalProperties.$validate(data[key]);
+        if (error) {
+          return defineError("Additional properties are invalid", {
+            item: key,
+            cause: error,
+            data: data[key]
+          });
+        }
       }
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
-  patternProperties(schema, data, pointer, schemaShieldInstance) {
+  patternProperties(schema, data, defineError) {
     if (!isObject(data)) {
-      return { valid: true, errors: [], data };
+      return;
     }
-    const errors = [];
-    let finalData = { ...data };
-    for (let pattern in schema.patternProperties) {
+    const patterns = Object.keys(schema.patternProperties);
+    for (const pattern of patterns) {
+      const regex = new RegExp(pattern, "u");
       if (typeof schema.patternProperties[pattern] === "boolean") {
         if (schema.patternProperties[pattern] === false) {
-          for (let key in finalData) {
-            if (new RegExp(pattern).test(key)) {
-              errors.push(
-                new ValidationError("Property is not allowed", {
-                  pointer: `${pointer}/${key}`,
-                  value: data[key],
-                  code: "PROPERTY_NOT_ALLOWED"
-                })
-              );
+          for (const key in data) {
+            if (regex.test(key)) {
+              return defineError("Property is not allowed", {
+                item: key,
+                data: data[key]
+              });
             }
           }
         }
         continue;
       }
-      const { validator } = schema.patternProperties[pattern];
-      if (!validator) {
-        continue;
-      }
-      for (let key in finalData) {
-        if (new RegExp(pattern).test(key)) {
-          const validatorResult = validator(
-            schema.patternProperties[pattern],
-            finalData[key],
-            `${pointer}/${key}`,
-            schemaShieldInstance
-          );
-          finalData[key] = validatorResult.data;
-          if (!validatorResult.valid) {
-            errors.push(...validatorResult.errors);
+      const keys = Object.keys(data);
+      for (const key of keys) {
+        if (regex.test(key)) {
+          if ("$validate" in schema.patternProperties[pattern]) {
+            const error = schema.patternProperties[pattern].$validate(
+              data[key]
+            );
+            if (error) {
+              return defineError("Property is invalid", {
+                item: key,
+                cause: error,
+                data: data[key]
+              });
+            }
           }
         }
       }
     }
-    return { valid: errors.length === 0, errors, data: finalData };
-  }
-};
-
-// lib/keywords/other-keywords.ts
-var OtherKeywords = {
-  nullable(schema, data, pointer) {
-    if (schema.nullable && data !== null) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError("Value must be null to be empty", {
-            pointer,
-            value: data,
-            code: "VALUE_NOT_NULL"
-          })
-        ],
-        data
-      };
+    return;
+  },
+  propertyNames(schema, data, defineError) {
+    if (!isObject(data)) {
+      return;
+    }
+    if (typeof schema.propertyNames === "boolean") {
+      if (schema.propertyNames === false && Object.keys(data).length > 0) {
+        return defineError("Properties are not allowed", { data });
+      }
+    }
+    if (isCompiledSchema(schema.propertyNames)) {
+      for (let key in data) {
+        const error = schema.propertyNames.$validate(key);
+        if (error) {
+          return defineError("Property name is invalid", {
+            item: key,
+            cause: error,
+            data: data[key]
+          });
+        }
+      }
     }
-    return { valid: true, errors: [], data };
+    return;
   },
-  oneOf(schema, data, pointer, schemaShieldInstance) {
-    const errors = [];
-    let validCount = 0;
-    let finalData = data;
-    for (let i = 0; i < schema.oneOf.length; i++) {
-      if (isObject(schema.oneOf[i])) {
-        const { validator } = schema.oneOf[i];
-        if (!validator) {
-          validCount++;
-          continue;
+  dependencies(schema, data, defineError) {
+    if (!isObject(data)) {
+      return;
+    }
+    for (const key in schema.dependencies) {
+      if (key in data === false) {
+        continue;
+      }
+      const dependency = schema.dependencies[key];
+      if (Array.isArray(dependency)) {
+        for (let i = 0; i < dependency.length; i++) {
+          if (!(dependency[i] in data)) {
+            return defineError("Dependency is not satisfied", {
+              item: i,
+              data: dependency[i]
+            });
+          }
         }
-        const validationResult = validator(
-          schema.oneOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-        if (validationResult.valid) {
-          validCount++;
-        } else {
-          errors.push(...validationResult.errors);
+        continue;
+      }
+      if (typeof dependency === "boolean") {
+        if (dependency) {
+          continue;
         }
-        finalData = validationResult.data;
-      } else {
-        if (typeof schema.oneOf[i] === "boolean") {
-          if (Boolean(data) === schema.oneOf[i]) {
-            validCount++;
-          }
+        return defineError("Dependency is not satisfied", { data: dependency });
+      }
+      if (typeof dependency === "string") {
+        if (dependency in data) {
           continue;
         }
-        if (data === schema.oneOf[i]) {
-          validCount++;
+        return defineError("Dependency is not satisfied", { data: dependency });
+      }
+      const error = dependency.$validate(data);
+      if (error) {
+        return defineError("Dependency is not satisfied", {
+          cause: error,
+          data
+        });
+      }
+    }
+    return;
+  },
+  // Required by other keywords but not used as a function itself
+  then: false,
+  else: false,
+  default: false,
+  // Not implemented yet
+  $ref: false,
+  definitions: false,
+  $id: false,
+  $schema: false,
+  // Metadata keywords (not used as a function)
+  title: false,
+  description: false,
+  $comment: false,
+  examples: false,
+  contentMediaType: false,
+  contentEncoding: false,
+  // Not supported Open API keywords
+  discriminator: false,
+  nullable: false
+};
+
+// lib/keywords/other-keywords.ts
+var OtherKeywords = {
+  enum(schema, data, defineError) {
+    const isArray = Array.isArray(data);
+    const isObject2 = typeof data === "object" && data !== null;
+    for (let i = 0; i < schema.enum.length; i++) {
+      const enumItem = schema.enum[i];
+      if (enumItem === data) {
+        return;
+      }
+      if (isArray && Array.isArray(enumItem) || isObject2 && typeof enumItem === "object" && enumItem !== null) {
+        if (deepEqual(enumItem, data)) {
+          return;
         }
       }
     }
-    if (validCount === 1) {
-      return { valid: true, errors: [], data: finalData };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must match exactly one schema in oneOf`, {
-          pointer,
-          value: data,
-          code: "VALUE_DOES_NOT_MATCH_ONE_OF"
-        })
-      ],
-      data: finalData
-    };
+    return defineError("Value is not one of the allowed values", { data });
   },
-  allOf(schema, data, pointer, schemaShieldInstance) {
-    const errors = [];
-    let finalData = data;
+  allOf(schema, data, defineError) {
     for (let i = 0; i < schema.allOf.length; i++) {
       if (isObject(schema.allOf[i])) {
-        const { validator } = schema.allOf[i];
-        if (!validator) {
-          continue;
-        }
-        const validatorResult = validator(
-          schema.allOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
-        }
-        finalData = validatorResult.data;
-      } else {
-        if (typeof schema.allOf[i] === "boolean") {
-          if (Boolean(data) !== schema.allOf[i]) {
-            errors.push(
-              new ValidationError(`Value must match all schemas in allOf`, {
-                pointer,
-                value: data,
-                code: "VALUE_DOES_NOT_MATCH_ALL_OF"
-              })
-            );
+        if ("$validate" in schema.allOf[i]) {
+          const error = schema.allOf[i].$validate(data);
+          if (error) {
+            return defineError("Value is not valid", { cause: error, data });
           }
-          continue;
         }
-        if (data !== schema.allOf[i]) {
-          errors.push(
-            new ValidationError(`Value must match all schemas in allOf`, {
-              pointer,
-              value: data,
-              code: "VALUE_DOES_NOT_MATCH_ALL_OF"
-            })
-          );
+        continue;
+      }
+      if (typeof schema.allOf[i] === "boolean") {
+        if (Boolean(data) !== schema.allOf[i]) {
+          return defineError("Value is not valid", { data });
         }
+        continue;
+      }
+      if (data !== schema.allOf[i]) {
+        return defineError("Value is not valid", { data });
       }
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
-  anyOf(schema, data, pointer, schemaShieldInstance) {
-    let finalData = data;
+  anyOf(schema, data, defineError) {
     for (let i = 0; i < schema.anyOf.length; i++) {
       if (isObject(schema.anyOf[i])) {
-        const { validator } = schema.anyOf[i];
-        if (!validator) {
-          return { valid: true, errors: [], data };
-        }
-        const validationResult = validator(
-          schema.anyOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-        finalData = validationResult.data;
-        if (validationResult.valid) {
-          return { valid: true, errors: [], data: finalData };
+        if ("$validate" in schema.anyOf[i]) {
+          const error = schema.anyOf[i].$validate(data);
+          if (!error) {
+            return;
+          }
+          continue;
         }
+        return;
       } else {
         if (typeof schema.anyOf[i] === "boolean") {
           if (Boolean(data) === schema.anyOf[i]) {
-            return { valid: true, errors: [], data: finalData };
+            return;
           }
         }
         if (data === schema.anyOf[i]) {
-          return { valid: true, errors: [], data: finalData };
+          return;
         }
       }
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must match at least one schema in anyOf`, {
-          pointer,
-          value: data,
-          code: "VALUE_DOES_NOT_MATCH_ANY_OF"
-        })
-      ],
-      data
-    };
+    return defineError("Value is not valid", { data });
   },
-  dependencies(schema, data, pointer, schemaShieldInstance) {
-    if (!isObject(data)) {
-      return { valid: true, errors: [], data };
-    }
-    const errors = [];
-    let finalData = data;
-    for (const key in schema.dependencies) {
-      if (key in data === false) {
-        continue;
-      }
-      const dependency = schema.dependencies[key];
-      if (Array.isArray(dependency)) {
-        for (let i = 0; i < dependency.length; i++) {
-          if (!(dependency[i] in data)) {
-            errors.push(
-              new ValidationError(`Dependency ${dependency[i]} is missing`, {
-                pointer,
-                value: data,
-                code: "DEPENDENCY_MISSING"
-              })
-            );
+  oneOf(schema, data, defineError) {
+    let validCount = 0;
+    for (let i = 0; i < schema.oneOf.length; i++) {
+      if (isObject(schema.oneOf[i])) {
+        if ("$validate" in schema.oneOf[i]) {
+          const error = schema.oneOf[i].$validate(data);
+          if (!error) {
+            validCount++;
           }
+          continue;
         }
+        validCount++;
         continue;
-      }
-      if (typeof dependency === "boolean") {
-        if (dependency) {
+      } else {
+        if (typeof schema.oneOf[i] === "boolean") {
+          if (Boolean(data) === schema.oneOf[i]) {
+            validCount++;
+          }
           continue;
         }
-        errors.push(
-          new ValidationError(`Dependency ${key} is missing`, {
-            pointer,
-            value: data,
-            code: "DEPENDENCY_MISSING"
-          })
-        );
-        continue;
+        if (data === schema.oneOf[i]) {
+          validCount++;
+        }
       }
-      if (typeof dependency === "string") {
-        if (dependency in data) {
-          continue;
+    }
+    if (validCount === 1) {
+      return;
+    }
+    return defineError("Value is not valid", { data });
+  },
+  const(schema, data, defineError) {
+    if (data === schema.const || isObject(data) && isObject(schema.const) && deepEqual(data, schema.const) || Array.isArray(data) && Array.isArray(schema.const) && deepEqual(data, schema.const)) {
+      return;
+    }
+    return defineError("Value is not valid", { data });
+  },
+  if(schema, data, defineError) {
+    if ("then" in schema === false && "else" in schema === false) {
+      return;
+    }
+    if (typeof schema.if === "boolean") {
+      if (schema.if) {
+        if (isCompiledSchema(schema.then)) {
+          return schema.then.$validate(data);
         }
-        errors.push(
-          new ValidationError(`Dependency ${dependency} is missing`, {
-            pointer,
-            value: data,
-            code: "DEPENDENCY_MISSING"
-          })
-        );
-        continue;
+      } else if (isCompiledSchema(schema.else)) {
+        return schema.else.$validate(data);
       }
-      const { validator } = dependency;
-      if (!validator) {
-        continue;
+      return;
+    }
+    if (!isCompiledSchema(schema.if)) {
+      return;
+    }
+    const error = schema.if.$validate(data);
+    if (!error) {
+      if (isCompiledSchema(schema.then)) {
+        return schema.then.$validate(data);
       }
-      const validatorResult = validator(
-        dependency,
-        finalData,
-        pointer,
-        schemaShieldInstance
-      );
-      if (!validatorResult.valid) {
-        errors.push(...validatorResult.errors);
+      return;
+    } else {
+      if (isCompiledSchema(schema.else)) {
+        return schema.else.$validate(data);
       }
-      finalData = validatorResult.data;
+      return;
     }
-    return { valid: errors.length === 0, errors, data: finalData };
+  },
+  not(schema, data, defineError) {
+    if (typeof schema.not === "boolean") {
+      if (schema.not) {
+        return defineError("Value is not valid", { data });
+      }
+      return;
+    }
+    if (isObject(schema.not)) {
+      if ("$validate" in schema.not) {
+        const error = schema.not.$validate(data);
+        if (!error) {
+          return defineError("Value is not valid", { cause: error, data });
+        }
+        return;
+      }
+      return defineError("Value is not valid", { data });
+    }
+    return defineError("Value is not valid", { data });
   }
 };
 
 // lib/keywords/string-keywords.ts
 var StringKeywords = {
-  minLength(schema, data, pointer) {
+  minLength(schema, data, defineError) {
     if (typeof data !== "string" || data.length >= schema.minLength) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("String is too short", {
-          pointer,
-          value: data,
-          code: "STRING_TOO_SHORT"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Value is shorter than the minimum length", { data });
   },
-  maxLength(schema, data, pointer) {
+  maxLength(schema, data, defineError) {
     if (typeof data !== "string" || data.length <= schema.maxLength) {
-      return { valid: true, errors: [], data };
-    }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("String is too long", {
-          pointer,
-          value: data,
-          code: "STRING_TOO_LONG"
-        })
-      ],
-      data
-    };
+      return;
+    }
+    return defineError("Value is longer than the maximum length", { data });
   },
-  pattern(schema, data, pointer) {
+  pattern(schema, data, defineError) {
     if (typeof data !== "string") {
-      return { valid: true, errors: [], data };
+      return;
     }
-    const patternRegexp = typeof schema.pattern === "string" ? new RegExp(schema.pattern) : schema.pattern;
+    const patternRegexp = new RegExp(schema.pattern, "u");
     if (patternRegexp instanceof RegExp === false) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError("Pattern is not a valid regular expression", {
-            pointer,
-            value: data,
-            code: "PATTERN_IS_NOT_REGEXP"
-          })
-        ],
-        data
-      };
-    }
-    const valid = patternRegexp.test(data);
-    return {
-      valid,
-      errors: valid ? [] : [
-        new ValidationError("String does not match pattern", {
-          pointer,
-          value: data,
-          code: "STRING_DOES_NOT_MATCH_PATTERN"
-        })
-      ],
-      data
-    };
-  },
-  format(schema, data, pointer, formatInstance) {
-    if (typeof data !== "string") {
-      return { valid: true, errors: [], data };
+      return defineError("Invalid regular expression", { data });
     }
-    const formatValidate = formatInstance.formats.get(schema.format);
-    if (!formatValidate) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError(`Unknown format ${schema.format}`, {
-            pointer,
-            value: data,
-            code: "UNKNOWN_FORMAT"
-          })
-        ],
-        data
-      };
+    if (patternRegexp.test(data)) {
+      return;
     }
-    const valid = formatValidate(data);
-    return {
-      valid,
-      errors: valid ? [] : [
-        new ValidationError(
-          `String does not match format ${schema.format}`,
-          {
-            pointer,
-            value: data,
-            code: "STRING_DOES_NOT_MATCH_FORMAT"
-          }
-        )
-      ],
-      data
-    };
+    return defineError("Value does not match the pattern", { data });
   },
-  enum(schema, data, pointer) {
-    for (let i = 0; i < schema.enum.length; i++) {
-      if (schema.enum[i] === data) {
-        return { valid: true, errors: [], data };
-      }
-    }
-    if (Array.isArray(data)) {
-      for (let i = 0; i < schema.enum.length; i++) {
-        if (Array.isArray(schema.enum[i])) {
-          if (deepEqual(schema.enum[i], data)) {
-            return { valid: true, errors: [], data };
-          }
-        }
-      }
+  // Take into account that if we receive a format that is not defined, we
+  // will not throw an error, we just ignore it.
+  format(schema, data, defineError, instance) {
+    if (typeof data !== "string") {
+      return;
     }
-    if (typeof data === "object" && data !== null) {
-      for (let i = 0; i < schema.enum.length; i++) {
-        if (typeof schema.enum[i] === "object" && schema.enum[i] !== null) {
-          if (deepEqual(schema.enum[i], data)) {
-            return { valid: true, errors: [], data };
-          }
-        }
-      }
+    const formatValidate = instance.getFormat(schema.format);
+    if (!formatValidate || formatValidate(data)) {
+      return;
     }
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must be one of ${schema.enum.join(", ")}`, {
-          pointer,
-          value: data,
-          code: "VALUE_NOT_IN_ENUM"
-        })
-      ],
-      data
-    };
+    return defineError("Value does not match the format", { data });
   }
 };
 
@@ -1093,197 +1038,200 @@ var keywords = {
 
 // lib/index.ts
 var SchemaShield = class {
-  types = /* @__PURE__ */ new Map();
-  formats = /* @__PURE__ */ new Map();
-  keywords = /* @__PURE__ */ new Map();
-  constructor() {
-    for (const type in Types) {
-      this.addType(type, Types[type]);
+  types = {};
+  formats = {};
+  keywords = {};
+  immutable = false;
+  constructor({
+    immutable = false
+  } = {}) {
+    this.immutable = immutable;
+    for (const [type, validator] of Object.entries(Types)) {
+      if (validator) {
+        this.addType(type, validator);
+      }
     }
-    for (const keyword in keywords) {
-      this.addKeyword(keyword, keywords[keyword]);
+    for (const [keyword, validator] of Object.entries(keywords)) {
+      this.addKeyword(keyword, validator);
     }
-    for (const format in Formats) {
-      this.addFormat(format, Formats[format]);
+    for (const [format, validator] of Object.entries(Formats)) {
+      if (validator) {
+        this.addFormat(format, validator);
+      }
+    }
+  }
+  addType(name, validator, overwrite = false) {
+    if (this.types[name] && !overwrite) {
+      throw new ValidationError(`Type "${name}" already exists`);
     }
+    this.types[name] = validator;
   }
-  addType(name, validator) {
-    this.types.set(name, validator);
+  getType(type) {
+    return this.types[type];
   }
-  addFormat(name, validator) {
-    this.formats.set(name, validator);
+  addFormat(name, validator, overwrite = false) {
+    if (this.formats[name] && !overwrite) {
+      throw new ValidationError(`Format "${name}" already exists`);
+    }
+    this.formats[name] = validator;
+  }
+  getFormat(format) {
+    return this.formats[format];
+  }
+  addKeyword(name, validator, overwrite = false) {
+    if (this.keywords[name] && !overwrite) {
+      throw new ValidationError(`Keyword "${name}" already exists`);
+    }
+    this.keywords[name] = validator;
   }
-  addKeyword(name, validator) {
-    this.keywords.set(name, validator);
+  getKeyword(keyword) {
+    return this.keywords[keyword];
   }
   compile(schema) {
-    const compiledSchema = this.compileSchema(schema, "#");
-    const schemaShield = this;
-    function validate(data) {
-      return compiledSchema.validator(compiledSchema, data, "#", schemaShield);
+    const compiledSchema = this.compileSchema(schema);
+    if (!compiledSchema.$validate) {
+      if (this.isSchemaLike(schema) === false) {
+        throw new ValidationError("Invalid schema");
+      }
+      compiledSchema.$validate = getNamedFunction(
+        "any",
+        () => {
+        }
+      );
     }
+    const validate = (data) => {
+      const clonedData = this.immutable ? deepClone(data) : data;
+      const error = compiledSchema.$validate(clonedData);
+      return {
+        data: clonedData,
+        error: error ? error : null,
+        valid: !error
+      };
+    };
     validate.compiledSchema = compiledSchema;
     return validate;
   }
-  compileSchema(schema, pointer) {
-    if (typeof schema !== "object" || schema === null) {
-      throw new ValidationError("Schema is not an object", {
-        pointer,
-        value: schema,
-        code: "SCHEMA_NOT_OBJECT"
-      });
-    }
-    const compiledSchema = {
-      ...schema,
-      pointer
-    };
-    if ("type" in compiledSchema) {
-      const types = Array.isArray(compiledSchema.type) ? compiledSchema.type : compiledSchema.type.split(",").map((t) => t.trim());
-      compiledSchema.validators = types.filter((type) => this.types.has(type)).map((type) => this.types.get(type));
-    }
-    const validator = (schema2, data, pointer2) => {
-      if (typeof data === "undefined") {
-        if (pointer2 === "#") {
-          return {
-            valid: false,
-            errors: [
-              new ValidationError("Data is undefined", {
-                pointer: pointer2,
-                value: data,
-                code: "DATA_UNDEFINED"
-              })
-            ],
-            data
-          };
+  compileSchema(schema) {
+    if (!isObject(schema)) {
+      if (schema === true) {
+        schema = {
+          anyOf: [{}]
+        };
+      } else if (schema === false) {
+        schema = {
+          oneOf: []
+        };
+      } else {
+        schema = {
+          oneOf: [schema]
+        };
+      }
+    }
+    const compiledSchema = { ...schema };
+    const defineTypeError = getDefinedErrorFunctionForKey("type", schema);
+    const typeValidations = [];
+    let methodName = "";
+    if ("type" in schema) {
+      const types = Array.isArray(schema.type) ? schema.type : schema.type.split(",").map((t) => t.trim());
+      for (const type of types) {
+        const validator = this.getType(type);
+        if (validator) {
+          typeValidations.push(validator);
+          methodName += (methodName ? "_OR_" : "") + validator.name;
         }
       }
-      let finalData = data;
-      const typeErrorsResult = this.validateTypes(schema2, finalData, pointer2);
-      if (typeErrorsResult.valid === false) {
-        return typeErrorsResult;
+      const typeValidationsLength = typeValidations.length;
+      if (typeValidationsLength === 0) {
+        throw defineTypeError("Invalid type for schema", { data: schema.type });
       }
-      finalData = typeErrorsResult.data;
-      return this.validateKeywords(schema2, finalData, pointer2);
-    };
-    compiledSchema.validator = validator;
-    for (let key in schema) {
+      if (typeValidationsLength === 1) {
+        const typeValidation = typeValidations[0];
+        compiledSchema.$validate = getNamedFunction(
+          methodName,
+          (data) => {
+            if (!typeValidation(data)) {
+              return defineTypeError("Invalid type", { data });
+            }
+          }
+        );
+      } else if (typeValidationsLength > 1) {
+        compiledSchema.$validate = getNamedFunction(
+          methodName,
+          (data) => {
+            for (let i = 0; i < typeValidationsLength; i++) {
+              if (typeValidations[i](data)) {
+                return;
+              }
+            }
+            return defineTypeError("Invalid type", { data });
+          }
+        );
+      }
+    }
+    for (const key of Object.keys(schema)) {
       if (key === "type") {
+        compiledSchema.type = schema.type;
         continue;
       }
-      if (this.keywords.has(key)) {
-        const validator2 = this.keywords.get(key);
-        compiledSchema.keywords = compiledSchema.keywords || {};
-        compiledSchema.keywords[key] = validator2;
-      }
-      if (Array.isArray(schema[key])) {
-        this.handleArraySchema(key, schema, pointer, compiledSchema);
-        continue;
+      const keywordValidator = this.getKeyword(key);
+      if (keywordValidator) {
+        const defineError = getDefinedErrorFunctionForKey(key, schema[key]);
+        if (compiledSchema.$validate) {
+          const prevValidator = compiledSchema.$validate;
+          methodName += `_AND_${keywordValidator.name}`;
+          compiledSchema.$validate = getNamedFunction(
+            methodName,
+            (data) => {
+              const error = prevValidator(data);
+              if (error) {
+                return error;
+              }
+              return keywordValidator(
+                compiledSchema,
+                data,
+                defineError,
+                this
+              );
+            }
+          );
+        } else {
+          methodName = keywordValidator.name;
+          compiledSchema.$validate = getNamedFunction(
+            methodName,
+            (data) => keywordValidator(
+              compiledSchema,
+              data,
+              defineError,
+              this
+            )
+          );
+        }
       }
       if (isObject(schema[key])) {
-        this.handleObjectSchema(key, schema, pointer, compiledSchema);
+        compiledSchema[key] = this.compileSchema(schema[key]);
         continue;
       }
-    }
-    return compiledSchema;
-  }
-  handleArraySchema(key, schema, pointer, compiledSchema) {
-    compiledSchema[key] = schema[key].map((subSchema, index) => {
-      if (typeof subSchema === "object" && subSchema !== null) {
-        if ("type" in subSchema) {
-          return this.compileSchema(subSchema, `${pointer}/${key}/${index}`);
-        }
-        for (let subKey in subSchema) {
-          if (this.keywords.has(subKey)) {
-            return this.compileSchema(subSchema, `${pointer}/${key}/${index}`);
-          }
-        }
-      }
-      return subSchema;
-    });
-  }
-  handleObjectSchema(key, schema, pointer, compiledSchema) {
-    if ("type" in schema[key]) {
-      compiledSchema[key] = this.compileSchema(
-        schema[key],
-        `${pointer}/${key}`
-      );
-      return;
-    }
-    for (let subKey in schema[key]) {
-      compiledSchema[key] = compiledSchema[key] || {};
-      if (this.keywords.has(subKey)) {
-        compiledSchema[key][subKey] = this.compileSchema(
-          schema[key][subKey],
-          `${pointer}/${subKey}`
+      if (Array.isArray(schema[key])) {
+        compiledSchema[key] = schema[key].map(
+          (subSchema, index) => this.isSchemaLike(subSchema) ? this.compileSchema(subSchema) : subSchema
         );
         continue;
       }
-      if (typeof schema[key][subKey] === "object") {
-        if ("type" in schema[key][subKey]) {
-          compiledSchema[key][subKey] = this.compileSchema(
-            schema[key][subKey],
-            `${pointer}/${key}/${subKey}`
-          );
-          continue;
-        }
-        for (let subSubKey in schema[key][subKey]) {
-          if (this.keywords.has(subSubKey)) {
-            compiledSchema[key][subKey] = this.compileSchema(
-              schema[key][subKey],
-              `${pointer}/${key}/${subKey}`
-            );
-            continue;
-          }
-        }
-      }
+      compiledSchema[key] = schema[key];
     }
+    return compiledSchema;
   }
-  validateTypes(schema, data, pointer) {
-    if (typeof data === "undefined" || !Array.isArray(schema.validators) || schema.validators.length === 0) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-    let errors = [];
-    let finalData = data;
-    for (let schemaValidator of schema.validators) {
-      const schemaResult = schemaValidator(schema, data, pointer, this);
-      finalData = schemaResult.data;
-      if (schemaResult.valid) {
-        return schemaResult;
+  isSchemaLike(subSchema) {
+    if (isObject(subSchema)) {
+      if ("type" in subSchema) {
+        return true;
       }
-      errors = schemaResult.errors;
-    }
-    return {
-      valid: errors.length === 0,
-      errors,
-      data: finalData
-    };
-  }
-  validateKeywords(schema, data, pointer) {
-    const errors = [];
-    let finalData = data;
-    if ("keywords" in schema) {
-      for (let keyword in schema.keywords) {
-        const keywordValidator = schema.keywords[keyword];
-        const keywordResult = keywordValidator(
-          schema,
-          finalData,
-          pointer,
-          this
-        );
-        finalData = keywordResult.data;
-        if (!keywordResult.valid) {
-          errors.push(...keywordResult.errors);
+      for (let subKey in subSchema) {
+        if (subKey in this.keywords) {
+          return true;
         }
       }
     }
-    return {
-      valid: errors.length === 0,
-      errors,
-      data: finalData
-    };
+    return false;
   }
 };