@serum-enterprises/schema 3.0.0-beta.1 → 3.1.0-beta.0

package/build/index.js

@@ -181,6 +181,28 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/Validator.ts
+var Validator = class {
+  validate(data, path = "data") {
+    this.assert(data, path);
+    return data;
+  }
+  is(data, path = "data") {
+    try {
+      this.assert(data, path);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+
+// src/lib/fromJSON.ts
+var import_json7 = __toESM(require_build());
+
+// src/validators/JSON.ts
+var import_json = __toESM(require_build());
+
 // src/lib/util.ts
 var AssertError = class extends Error {
 };
@@ -188,7 +210,6 @@ var DefinitionError = class extends Error {
 };
 
 // src/validators/JSON.ts
-var import_json = __toESM(require_build());
 var JSONValidator = class _JSONValidator extends Validator {
   static fromJSON(_definition, _path = "definition") {
     return new _JSONValidator();
@@ -200,6 +221,9 @@ var JSONValidator = class _JSONValidator extends Validator {
   isSubset(other) {
     return other instanceof _JSONValidator;
   }
+  isEquals(other) {
+    return other instanceof _JSONValidator;
+  }
   toJSON() {
     return {
       type: "json"
@@ -260,6 +284,17 @@ var BooleanValidator = class _BooleanValidator extends Validator {
     }
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _BooleanValidator))
+      return false;
+    if (this._nullable.isSome() !== other._nullable.isSome())
+      return false;
+    if (this._equals.isSome() !== other._equals.isSome())
+      return false;
+    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
+      return false;
+    return true;
+  }
   toJSON() {
     const definition = {
       type: "boolean"
@@ -390,6 +425,27 @@ var NumberValidator = class _NumberValidator extends Validator {
       return false;
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _NumberValidator))
+      return false;
+    if (this._nullable.isSome() !== other._nullable.isSome())
+      return false;
+    if (this._integer.isSome() !== other._integer.isSome())
+      return false;
+    if (this._equals.isSome() !== other._equals.isSome())
+      return false;
+    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
+      return false;
+    if (this._min.isSome() !== other._min.isSome())
+      return false;
+    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
+      return false;
+    if (this._max.isSome() !== other._max.isSome())
+      return false;
+    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
+      return false;
+    return true;
+  }
   toJSON() {
     const definition = {
       type: "number"
@@ -510,6 +566,25 @@ var StringValidator = class _StringValidator extends Validator {
       return false;
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _StringValidator))
+      return false;
+    if (this._nullable.isSome() !== other._nullable.isSome())
+      return false;
+    if (this._equals.isSome() !== other._equals.isSome())
+      return false;
+    if (this._equals.isSome() && other._equals.isSome() && this._equals.value !== other._equals.value)
+      return false;
+    if (this._min.isSome() !== other._min.isSome())
+      return false;
+    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
+      return false;
+    if (this._max.isSome() !== other._max.isSome())
+      return false;
+    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
+      return false;
+    return true;
+  }
   toJSON() {
     const definition = {
       type: "string"
@@ -527,230 +602,46 @@ var StringValidator = class _StringValidator extends Validator {
 };
 
 // src/validators/Array.ts
-var import_json5 = __toESM(require_build());
-var import_option4 = __toESM(require_Option());
-var ArrayValidator = class _ArrayValidator extends Validator {
-  static fromJSON(definition, path = "definition") {
-    const validatorInstance = new _ArrayValidator();
-    if ("nullable" in definition) {
-      if (!import_json5.JSON.isBoolean(definition["nullable"]))
-        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
-      validatorInstance.nullable(definition["nullable"]);
-    }
-    if ("min" in definition) {
-      if (!import_json5.JSON.isNumber(definition["min"]))
-        throw new DefinitionError(`Expected ${path}.min to be a Number`);
-      validatorInstance.min(definition["min"], `${path}.min`);
-    }
-    if ("max" in definition) {
-      if (!import_json5.JSON.isNumber(definition["max"]))
-        throw new DefinitionError(`Expected ${path}.max to be a Number`);
-      validatorInstance.max(definition["max"], `${path}.max`);
-    }
-    if ("every" in definition) {
-      if (!import_json5.JSON.isObject(definition["every"]))
-        throw new DefinitionError(`Expected ${path}.every to be an Object`);
-      validatorInstance.every(
-        super.fromJSON(definition["every"], `${path}.every`)
-      );
-    }
-    if ("tuple" in definition) {
-      if (!import_json5.JSON.isShallowArray(definition["tuple"]))
-        throw new DefinitionError(`Expected ${path}.tuple to be an Array`);
-      const tupleSchemas = [];
-      const errors = [];
-      definition["tuple"].forEach((tupleDef, index) => {
-        try {
-          tupleSchemas.push(super.fromJSON(tupleDef, `${path}.tuple[${index}]`));
-        } catch (e) {
-          if (!(e instanceof DefinitionError))
-            throw new DefinitionError(`Fatal Error: Undefined Error thrown by Domain.fromJSON at ${path}`);
-          errors.push(e);
-        }
-      });
-      if (errors.length > 0)
-        throw new DefinitionError(`Multiple Definition Errors detected at ${path} (see cause)`, { cause: errors });
-      validatorInstance.tuple(tupleSchemas, `${path}.tuple`);
-    }
-    return validatorInstance;
-  }
-  _nullable = import_option4.Option.None();
-  _every = import_option4.Option.None();
-  _tuple = import_option4.Option.None();
-  _min = import_option4.Option.None();
-  _max = import_option4.Option.None();
-  nullable(flag) {
-    this._nullable = flag ?? true ? import_option4.Option.Some(null) : import_option4.Option.None();
-    return this;
-  }
-  min(value, path = "min") {
-    if (this._max.isSome() && this._max.value < value)
-      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
-    if (this._tuple.isSome() && value < this._tuple.value.length)
-      throw new DefinitionError(`Expected Minimum Rule to be larger than or equal to Tuple Length at Path ${path}`);
-    this._min = import_option4.Option.Some(value);
-    return this;
-  }
-  max(value, path = "max") {
-    if (this._min.isSome() && this._min.value > value)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
-    if (this._tuple.isSome() && value < this._tuple.value.length)
-      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Tuple Length at Path ${path}`);
-    this._max = import_option4.Option.Some(value);
-    return this;
-  }
-  every(validator) {
-    this._every = import_option4.Option.Some(validator);
-    return this;
-  }
-  /**
-   * Applies ONLY to prefix indices [0..validators.length - 1]
-   * If every() is set, prefix elements are effectively `T[i] & E`.
-   */
-  tuple(validators, path = "tuple") {
-    if (this._min.isSome() && this._min.value < validators.length)
-      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Minimum Rule at Path ${path}`);
-    if (this._max.isSome() && this._max.value < validators.length)
-      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Maximum Rule at Path ${path}`);
-    this._tuple = import_option4.Option.Some(validators);
-    return this;
-  }
-  assert(data, path = "data") {
-    if (import_json5.JSON.isShallowArray(data)) {
-      if (this._min.isSome() && this._min.value > data.length)
-        throw new AssertError(`Expected ${path} to be at least ${this._min.value} Elements long`);
-      if (this._max.isSome() && this._max.value < data.length)
-        throw new AssertError(`Expected ${path} to be at most ${this._max.value} Elements long`);
-      const errors = [];
-      if (this._every.isSome()) {
-        const validator = this._every.value;
-        data.forEach((value, index) => {
-          try {
-            validator.assert(value, `${path}[${index}]`);
-          } catch (e) {
-            if (!(e instanceof AssertError))
-              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
-            errors.push(e);
-          }
-        });
-      }
-      if (this._tuple.isSome()) {
-        if (data.length < this._tuple.value.length)
-          throw new AssertError(`Expected ${path} to be at least ${this._tuple.value.length} Elements long (Tuple Constraint)`);
-        this._tuple.value.forEach((validator, index) => {
-          try {
-            validator.assert(data[index], `${path}[${index}]`);
-          } catch (e) {
-            if (!(e instanceof AssertError))
-              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
-            errors.push(e);
-          }
-        });
-      }
-      if (errors.length > 0)
-        throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
-    } else if (import_json5.JSON.isNull(data)) {
-      if (!this._nullable.isSome())
-        throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
-    } else
-      throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
-  }
-  isSubset(other) {
-    if (other instanceof JSONValidator)
-      return true;
-    if (!(other instanceof _ArrayValidator))
-      return false;
-    if (this._nullable.isSome() && !other._nullable.isSome())
-      return false;
-    const thisTupleLen = this._tuple.isSome() ? this._tuple.value.length : 0;
-    const otherTupleLen = other._tuple.isSome() ? other._tuple.value.length : 0;
-    const thisMin = this._min.isSome() ? this._min.value : 0;
-    const otherMin = other._min.isSome() ? other._min.value : 0;
-    const thisMax = this._max.isSome() ? this._max.value : Infinity;
-    const otherMax = other._max.isSome() ? other._max.value : Infinity;
-    const thisEffectiveMin = Math.max(thisMin, thisTupleLen);
-    const otherEffectiveMin = Math.max(otherMin, otherTupleLen);
-    if (thisEffectiveMin < otherEffectiveMin)
-      return false;
-    if (thisMax > otherMax)
-      return false;
-    const indexConjuncts = (i) => {
-      const conjuncts = [];
-      if (this._every.isSome())
-        conjuncts.push(this._every.value);
-      if (this._tuple.isSome() && i < this._tuple.value.length)
-        conjuncts.push(this._tuple.value[i]);
-      return conjuncts;
-    };
-    const conjunctsSubset = (conjuncts, target) => {
-      if (conjuncts.length === 0)
-        return false;
-      return conjuncts.some((c) => c.isSubset(target));
-    };
-    if (other._tuple.isSome()) {
-      for (let i = 0; i < other._tuple.value.length; i++) {
-        const aConj = indexConjuncts(i);
-        if (!conjunctsSubset(aConj, other._tuple.value[i]))
-          return false;
-        if (other._every.isSome() && !conjunctsSubset(aConj, other._every.value))
-          return false;
-      }
-    }
-    return !(other._every.isSome() && (thisMax === Infinity ? true : thisMax > Math.max(thisTupleLen, otherTupleLen)) && (!this._every.isSome() || !this._every.value.isSubset(other._every.value)));
-  }
-  toJSON() {
-    const definition = { type: "array" };
-    if (this._nullable.isSome())
-      definition.nullable = true;
-    if (this._min.isSome())
-      definition.min = this._min.value;
-    if (this._max.isSome())
-      definition.max = this._max.value;
-    if (this._every.isSome())
-      definition.every = this._every.value.toJSON();
-    if (this._tuple.isSome())
-      definition.tuple = this._tuple.value.map((validator) => validator.toJSON());
-    return definition;
-  }
-};
-
-// src/validators/Object.ts
 var import_json6 = __toESM(require_build());
 var import_option5 = __toESM(require_Option());
+
+// src/validators/Object.ts
+var import_json5 = __toESM(require_build());
+var import_option4 = __toESM(require_Option());
 var ObjectValidator = class _ObjectValidator extends Validator {
   static fromJSON(definition, path = "definition") {
     const validatorInstance = new _ObjectValidator();
     if ("nullable" in definition) {
-      if (!import_json6.JSON.isBoolean(definition["nullable"]))
+      if (!import_json5.JSON.isBoolean(definition["nullable"]))
         throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
       validatorInstance.nullable(definition["nullable"]);
     }
     if ("exact" in definition) {
-      if (!import_json6.JSON.isBoolean(definition["exact"]))
+      if (!import_json5.JSON.isBoolean(definition["exact"]))
         throw new DefinitionError(`Expected ${path}.exact to be a Boolean`);
       validatorInstance.exact(definition["exact"], `${path}.exact`);
     }
     if ("min" in definition) {
-      if (!import_json6.JSON.isNumber(definition["min"]))
+      if (!import_json5.JSON.isNumber(definition["min"]))
         throw new DefinitionError(`Expected ${path}.min to be a Number`);
       validatorInstance.min(definition["min"], `${path}.min`);
     }
     if ("max" in definition) {
-      if (!import_json6.JSON.isNumber(definition["max"]))
+      if (!import_json5.JSON.isNumber(definition["max"]))
         throw new DefinitionError(`Expected ${path}.max to be a Number`);
       validatorInstance.max(definition["max"], `${path}.max`);
     }
     if ("every" in definition) {
-      validatorInstance.every(super.fromJSON(definition["every"], `${path}.every`));
+      validatorInstance.every(fromJSON(definition["every"], `${path}.every`));
     }
     if ("shape" in definition) {
-      if (!import_json6.JSON.isShallowObject(definition["shape"]))
+      if (!import_json5.JSON.isShallowObject(definition["shape"]))
         throw new DefinitionError(`Expected ${path}.shape to be an Object`);
       const shape = {};
       const errors = [];
       for (const [key, value] of Object.entries(definition["shape"])) {
         try {
-          shape[key] = super.fromJSON(value, `${path}.shape.${key}`);
+          shape[key] = fromJSON(value, `${path}.shape.${key}`);
         } catch (e) {
           if (!(e instanceof DefinitionError))
             throw new DefinitionError(`Fatal Error: Undefined Error thrown by Domain.fromJSON at ${path}.shape.${key}`);
@@ -764,14 +655,14 @@ var ObjectValidator = class _ObjectValidator extends Validator {
     }
     return validatorInstance;
   }
-  _nullable = import_option5.Option.None();
-  _min = import_option5.Option.None();
-  _max = import_option5.Option.None();
-  _every = import_option5.Option.None();
-  _shape = import_option5.Option.None();
-  _exact = import_option5.Option.None();
+  _nullable = import_option4.Option.None();
+  _min = import_option4.Option.None();
+  _max = import_option4.Option.None();
+  _every = import_option4.Option.None();
+  _shape = import_option4.Option.None();
+  _exact = import_option4.Option.None();
   nullable(flag) {
-    this._nullable = flag ?? true ? import_option5.Option.Some(null) : import_option5.Option.None();
+    this._nullable = flag ?? true ? import_option4.Option.Some(null) : import_option4.Option.None();
     return this;
   }
   min(value, path = "min") {
@@ -781,7 +672,7 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       throw new DefinitionError(`Expected Minimum Rule to be larger than or equal to Shape Key Count at Path ${path}`);
     if (this._exact.isSome() && this._shape.isSome() && value > Object.keys(this._shape.value).length)
       throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Shape Key Count due to Exact Rule at Path ${path}`);
-    this._min = import_option5.Option.Some(value);
+    this._min = import_option4.Option.Some(value);
     return this;
   }
   max(value, path = "max") {
@@ -789,11 +680,11 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
     if (this._shape.isSome() && value < Object.keys(this._shape.value).length)
       throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Shape Key Count at Path ${path}`);
-    this._max = import_option5.Option.Some(value);
+    this._max = import_option4.Option.Some(value);
     return this;
   }
   every(validator) {
-    this._every = import_option5.Option.Some(validator);
+    this._every = import_option4.Option.Some(validator);
     return this;
   }
   shape(value, path = "shape") {
@@ -806,7 +697,7 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       throw new DefinitionError(`Expected Shape Key Count to be larger than or equal to Minimum Rule due to Exact Rule at Path ${path}`);
     if (this._exact.isSome() && this._max.isSome() && this._max.value < shapeKeyCount)
       throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Maximum Rule due to Exact Rule at Path ${path}`);
-    this._shape = import_option5.Option.Some(value);
+    this._shape = import_option4.Option.Some(value);
     return this;
   }
   exact(flag, path = "exact") {
@@ -817,11 +708,11 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       if (this._max.isSome() && this._max.value < shapeKeyCount)
         throw new DefinitionError(`Expected Exact Rule to be false due to Maximum Rule allowing fewer Properties than Shape defines at Path ${path}`);
     }
-    this._exact = flag ?? true ? import_option5.Option.Some(null) : import_option5.Option.None();
+    this._exact = flag ?? true ? import_option4.Option.Some(null) : import_option4.Option.None();
     return this;
   }
   assert(data, path = "data") {
-    if (import_json6.JSON.isShallowObject(data)) {
+    if (import_json5.JSON.isShallowObject(data)) {
       const keys = Object.keys(data);
       if (this._min.isSome() && keys.length < this._min.value)
         throw new AssertError(`Expected ${path} to have at least ${this._min.value} Properties`);
@@ -861,7 +752,7 @@ var ObjectValidator = class _ObjectValidator extends Validator {
       }
       if (errors.length > 0)
         throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
-    } else if (import_json6.JSON.isNull(data)) {
+    } else if (import_json5.JSON.isNull(data)) {
       if (!this._nullable.isSome())
         throw new AssertError(`Expected ${path} to be an Object${this._nullable.isSome() ? " or Null" : ""}`);
     } else
@@ -933,6 +824,39 @@ var ObjectValidator = class _ObjectValidator extends Validator {
     }
     return true;
   }
+  isEquals(other) {
+    if (!(other instanceof _ObjectValidator))
+      return false;
+    if (this._nullable.isSome() !== other._nullable.isSome())
+      return false;
+    if (this._min.isSome() !== other._min.isSome())
+      return false;
+    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
+      return false;
+    if (this._max.isSome() !== other._max.isSome())
+      return false;
+    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
+      return false;
+    if (this._every.isSome() !== other._every.isSome())
+      return false;
+    if (this._every.isSome() && other._every.isSome())
+      return isEquals(this._every.value, other._every.value);
+    if (this._shape.isSome() !== other._shape.isSome())
+      return false;
+    if (this._shape.isSome() && other._shape.isSome()) {
+      if (Object.keys(this._shape.value).length !== Object.keys(other._shape.value).length)
+        return false;
+      for (const [k, v] of Object.entries(this._shape.value)) {
+        if (!(other._shape.value[k] instanceof Validator))
+          return false;
+        if (!isEquals(v, other._shape.value[k]))
+          return false;
+      }
+    }
+    if (this._exact.isSome() !== other._exact.isSome())
+      return false;
+    return true;
+  }
   toJSON() {
     const schema = { type: "object" };
     if (this._nullable.isSome())
@@ -954,45 +878,262 @@ var ObjectValidator = class _ObjectValidator extends Validator {
   }
 };
 
-// src/Validator.ts
-var import_json7 = __toESM(require_build());
-var Validator = class {
-  static fromJSON(definition, path) {
-    if (!import_json7.JSON.isShallowObject(definition))
-      throw new DefinitionError(`Expected ${path} to be an Object`);
-    if (!import_json7.JSON.isString(definition["type"]))
-      throw new DefinitionError(`Expected ${path}.type to be a String`);
-    switch (definition["type"]) {
-      case "json":
-        return JSONValidator.fromJSON(definition, path);
-      case "boolean":
-        return BooleanValidator.fromJSON(definition, path);
-      case "number":
-        return NumberValidator.fromJSON(definition, path);
-      case "string":
-        return StringValidator.fromJSON(definition, path);
-      case "array":
-        return ArrayValidator.fromJSON(definition, path);
-      case "object":
-        return ObjectValidator.fromJSON(definition, path);
-      default:
-        throw new DefinitionError(`Expected ${path}.type to be a registered Validator`);
+// src/lib/isEquals.ts
+function isEquals(a, b) {
+  if (a instanceof JSONValidator)
+    return a.isEquals(b);
+  if (a instanceof BooleanValidator)
+    return a.isEquals(b);
+  if (a instanceof NumberValidator)
+    return a.isEquals(b);
+  if (a instanceof StringValidator)
+    return a.isEquals(b);
+  if (a instanceof ArrayValidator)
+    return a.isEquals(b);
+  if (a instanceof ObjectValidator)
+    return a.isEquals(b);
+  return false;
+}
+
+// src/validators/Array.ts
+var ArrayValidator = class _ArrayValidator extends Validator {
+  static fromJSON(definition, path = "definition") {
+    const validatorInstance = new _ArrayValidator();
+    if ("nullable" in definition) {
+      if (!import_json6.JSON.isBoolean(definition["nullable"]))
+        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
+      validatorInstance.nullable(definition["nullable"]);
+    }
+    if ("min" in definition) {
+      if (!import_json6.JSON.isNumber(definition["min"]))
+        throw new DefinitionError(`Expected ${path}.min to be a Number`);
+      validatorInstance.min(definition["min"], `${path}.min`);
+    }
+    if ("max" in definition) {
+      if (!import_json6.JSON.isNumber(definition["max"]))
+        throw new DefinitionError(`Expected ${path}.max to be a Number`);
+      validatorInstance.max(definition["max"], `${path}.max`);
     }
+    if ("every" in definition) {
+      if (!import_json6.JSON.isObject(definition["every"]))
+        throw new DefinitionError(`Expected ${path}.every to be an Object`);
+      validatorInstance.every(
+        fromJSON(definition["every"], `${path}.every`)
+      );
+    }
+    if ("tuple" in definition) {
+      if (!import_json6.JSON.isShallowArray(definition["tuple"]))
+        throw new DefinitionError(`Expected ${path}.tuple to be an Array`);
+      const tupleSchemas = [];
+      const errors = [];
+      definition["tuple"].forEach((tupleDef, index) => {
+        try {
+          tupleSchemas.push(fromJSON(tupleDef, `${path}.tuple[${index}]`));
+        } catch (e) {
+          if (!(e instanceof DefinitionError))
+            throw new DefinitionError(`Fatal Error: Undefined Error thrown by Domain.fromJSON at ${path}`);
+          errors.push(e);
+        }
+      });
+      if (errors.length > 0)
+        throw new DefinitionError(`Multiple Definition Errors detected at ${path} (see cause)`, { cause: errors });
+      validatorInstance.tuple(tupleSchemas, `${path}.tuple`);
+    }
+    return validatorInstance;
   }
-  validate(data, path = "data") {
-    this.assert(data, path);
-    return data;
+  _nullable = import_option5.Option.None();
+  _every = import_option5.Option.None();
+  _tuple = import_option5.Option.None();
+  _min = import_option5.Option.None();
+  _max = import_option5.Option.None();
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option5.Option.Some(null) : import_option5.Option.None();
+    return this;
   }
-  is(data, path = "data") {
-    try {
-      this.assert(data, path);
+  min(value, path = "min") {
+    if (this._max.isSome() && this._max.value < value)
+      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to Maximum Rule at Path ${path}`);
+    if (this._tuple.isSome() && value < this._tuple.value.length)
+      throw new DefinitionError(`Expected Minimum Rule to be larger than or equal to Tuple Length at Path ${path}`);
+    this._min = import_option5.Option.Some(value);
+    return this;
+  }
+  max(value, path = "max") {
+    if (this._min.isSome() && this._min.value > value)
+      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Minimum Rule at Path ${path}`);
+    if (this._tuple.isSome() && value < this._tuple.value.length)
+      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to Tuple Length at Path ${path}`);
+    this._max = import_option5.Option.Some(value);
+    return this;
+  }
+  every(validator) {
+    this._every = import_option5.Option.Some(validator);
+    return this;
+  }
+  /**
+   * Applies ONLY to prefix indices [0..validators.length - 1]
+   * If every() is set, prefix elements are effectively `T[i] & E`.
+   */
+  tuple(validators, path = "tuple") {
+    if (this._min.isSome() && this._min.value < validators.length)
+      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Minimum Rule at Path ${path}`);
+    if (this._max.isSome() && this._max.value < validators.length)
+      throw new DefinitionError(`Expected Tuple Length to be smaller than or equal to Maximum Rule at Path ${path}`);
+    this._tuple = import_option5.Option.Some(validators);
+    return this;
+  }
+  assert(data, path = "data") {
+    if (import_json6.JSON.isShallowArray(data)) {
+      if (this._min.isSome() && this._min.value > data.length)
+        throw new AssertError(`Expected ${path} to be at least ${this._min.value} Elements long`);
+      if (this._max.isSome() && this._max.value < data.length)
+        throw new AssertError(`Expected ${path} to be at most ${this._max.value} Elements long`);
+      const errors = [];
+      if (this._every.isSome()) {
+        const validator = this._every.value;
+        data.forEach((value, index) => {
+          try {
+            validator.assert(value, `${path}[${index}]`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
+            errors.push(e);
+          }
+        });
+      }
+      if (this._tuple.isSome()) {
+        if (data.length < this._tuple.value.length)
+          throw new AssertError(`Expected ${path} to be at least ${this._tuple.value.length} Elements long (Tuple Constraint)`);
+        this._tuple.value.forEach((validator, index) => {
+          try {
+            validator.assert(data[index], `${path}[${index}]`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}[${index}]`);
+            errors.push(e);
+          }
+        });
+      }
+      if (errors.length > 0)
+        throw new AssertError(`Multiple Errors while asserting ${path} (see cause)`, { cause: errors });
+    } else if (import_json6.JSON.isNull(data)) {
+      if (!this._nullable.isSome())
+        throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be an Array${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
       return true;
-    } catch (e) {
+    if (!(other instanceof _ArrayValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    const thisTupleLen = this._tuple.isSome() ? this._tuple.value.length : 0;
+    const otherTupleLen = other._tuple.isSome() ? other._tuple.value.length : 0;
+    const thisMin = this._min.isSome() ? this._min.value : 0;
+    const otherMin = other._min.isSome() ? other._min.value : 0;
+    const thisMax = this._max.isSome() ? this._max.value : Infinity;
+    const otherMax = other._max.isSome() ? other._max.value : Infinity;
+    const thisEffectiveMin = Math.max(thisMin, thisTupleLen);
+    const otherEffectiveMin = Math.max(otherMin, otherTupleLen);
+    if (thisEffectiveMin < otherEffectiveMin)
+      return false;
+    if (thisMax > otherMax)
+      return false;
+    const indexConjuncts = (i) => {
+      const conjuncts = [];
+      if (this._every.isSome())
+        conjuncts.push(this._every.value);
+      if (this._tuple.isSome() && i < this._tuple.value.length)
+        conjuncts.push(this._tuple.value[i]);
+      return conjuncts;
+    };
+    const conjunctsSubset = (conjuncts, target) => {
+      if (conjuncts.length === 0)
+        return false;
+      return conjuncts.some((c) => c.isSubset(target));
+    };
+    if (other._tuple.isSome()) {
+      for (let i = 0; i < other._tuple.value.length; i++) {
+        const aConj = indexConjuncts(i);
+        if (!conjunctsSubset(aConj, other._tuple.value[i]))
+          return false;
+        if (other._every.isSome() && !conjunctsSubset(aConj, other._every.value))
+          return false;
+      }
+    }
+    return !(other._every.isSome() && (thisMax === Infinity ? true : thisMax > Math.max(thisTupleLen, otherTupleLen)) && (!this._every.isSome() || !this._every.value.isSubset(other._every.value)));
+  }
+  isEquals(other) {
+    if (!(other instanceof _ArrayValidator))
+      return false;
+    if (this._nullable.isSome() !== other._nullable.isSome())
       return false;
+    if (this._min.isSome() !== other._min.isSome())
+      return false;
+    if (this._min.isSome() && other._min.isSome() && this._min.value !== other._min.value)
+      return false;
+    if (this._max.isSome() !== other._max.isSome())
+      return false;
+    if (this._max.isSome() && other._max.isSome() && this._max.value !== other._max.value)
+      return false;
+    if (this._every.isSome() !== other._every.isSome())
+      return false;
+    if (this._every.isSome() && other._every.isSome() && !isEquals(this._every.value, other._every.value))
+      return false;
+    if (this._tuple.isSome() !== other._tuple.isSome())
+      return false;
+    if (this._tuple.isSome() && other._tuple.isSome()) {
+      if (this._tuple.value.length !== other._tuple.value.length)
+        return false;
+      for (let i = 0; i < this._tuple.value.length; i++) {
+        if (!isEquals(this._tuple.value[i], other._tuple.value[i]))
+          return false;
+      }
     }
+    return true;
+  }
+  toJSON() {
+    const definition = { type: "array" };
+    if (this._nullable.isSome())
+      definition.nullable = true;
+    if (this._min.isSome())
+      definition.min = this._min.value;
+    if (this._max.isSome())
+      definition.max = this._max.value;
+    if (this._every.isSome())
+      definition.every = this._every.value.toJSON();
+    if (this._tuple.isSome())
+      definition.tuple = this._tuple.value.map((validator) => validator.toJSON());
+    return definition;
   }
 };
 
+// src/lib/fromJSON.ts
+function fromJSON(definition, path) {
+  if (!import_json7.JSON.isShallowObject(definition))
+    throw new DefinitionError(`Expected ${path} to be an Object`);
+  if (!import_json7.JSON.isString(definition["type"]))
+    throw new DefinitionError(`Expected ${path}.type to be a String`);
+  switch (definition["type"]) {
+    case "json":
+      return JSONValidator.fromJSON(definition, path);
+    case "boolean":
+      return BooleanValidator.fromJSON(definition, path);
+    case "number":
+      return NumberValidator.fromJSON(definition, path);
+    case "string":
+      return StringValidator.fromJSON(definition, path);
+    case "array":
+      return ArrayValidator.fromJSON(definition, path);
+    case "object":
+      return ObjectValidator.fromJSON(definition, path);
+    default:
+      throw new DefinitionError(`Expected ${path}.type to be a registered Validator`);
+  }
+}
+
 // src/index.ts
 var Schema = class {
   static get JSON() {
@@ -1013,6 +1154,12 @@ var Schema = class {
   static get Object() {
     return new ObjectValidator();
   }
+  static fromJSON(definition, path = "definition") {
+    return fromJSON(definition, path);
+  }
+  static isEquals(a, b) {
+    return isEquals(a, b);
+  }
 };
 var Validators = {
   JSON: JSONValidator,