@serum-enterprises/schema 2.0.1-beta.2 → 3.0.0-beta.2

package/build/index.js

@@ -0,0 +1,1040 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/@serum-enterprises/json/build/index.js
+var require_build = __commonJS({
+  "node_modules/@serum-enterprises/json/build/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JSON = void 0;
+    var JSON8;
+    (function(JSON9) {
+      function isNull(value) {
+        return value === null;
+      }
+      JSON9.isNull = isNull;
+      function isBoolean(value) {
+        return typeof value === "boolean";
+      }
+      JSON9.isBoolean = isBoolean;
+      function isNumber(value) {
+        return Number.isFinite(value);
+      }
+      JSON9.isNumber = isNumber;
+      function isInteger(value) {
+        return Number.isSafeInteger(value);
+      }
+      JSON9.isInteger = isInteger;
+      function isString(value) {
+        return typeof value === "string";
+      }
+      JSON9.isString = isString;
+      function isShallowArray(value) {
+        return Array.isArray(value);
+      }
+      JSON9.isShallowArray = isShallowArray;
+      function isArray(value) {
+        return isShallowArray(value) && value.every((v) => isJSON(v));
+      }
+      JSON9.isArray = isArray;
+      function isShallowObject(value) {
+        return Object.prototype.toString.call(value) === "[object Object]";
+      }
+      JSON9.isShallowObject = isShallowObject;
+      function isObject(value) {
+        return isShallowObject(value) && Object.values(value).every((v) => isJSON(v));
+      }
+      JSON9.isObject = isObject;
+      function isPrimitive(value) {
+        return isBoolean(value) || isNumber(value) || isString(value);
+      }
+      JSON9.isPrimitive = isPrimitive;
+      function isShallowContainer(value) {
+        return isShallowArray(value) || isShallowObject(value);
+      }
+      JSON9.isShallowContainer = isShallowContainer;
+      function isContainer(value) {
+        return isArray(value) || isObject(value);
+      }
+      JSON9.isContainer = isContainer;
+      function isShallowJSON(value) {
+        return isNull(value) || isPrimitive(value) || isShallowArray(value) || isShallowObject(value);
+      }
+      JSON9.isShallowJSON = isShallowJSON;
+      function isJSON(value) {
+        return isNull(value) || isPrimitive(value) || isContainer(value);
+      }
+      JSON9.isJSON = isJSON;
+      function clone(value) {
+        if (isShallowObject(value))
+          return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, clone(v)]));
+        else if (isShallowArray(value))
+          return value.map((v) => clone(v));
+        else
+          return value;
+      }
+      JSON9.clone = clone;
+      function parse(value) {
+        return globalThis.JSON.parse(value);
+      }
+      JSON9.parse = parse;
+      function stringify(value) {
+        return globalThis.JSON.stringify(value);
+      }
+      JSON9.stringify = stringify;
+    })(JSON8 || (exports2.JSON = JSON8 = {}));
+  }
+});
+
+// node_modules/@serum-enterprises/option/build/Option.js
+var require_Option = __commonJS({
+  "node_modules/@serum-enterprises/option/build/Option.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.None = exports2.Some = exports2.Option = void 0;
+    var Option6 = class _Option {
+      static Some(value) {
+        return new Some(value);
+      }
+      static None() {
+        return new None();
+      }
+      isSome() {
+        return this instanceof Some;
+      }
+      isNone() {
+        return this instanceof None;
+      }
+      onSome(fn) {
+        if (this.isSome())
+          fn(this.value);
+        return this;
+      }
+      onNone(fn) {
+        if (this.isNone())
+          fn();
+        return this;
+      }
+      map(fn) {
+        return this.match((value) => _Option.Some(fn(value)), () => _Option.None());
+      }
+      match(onSome, onNone) {
+        if (this.isSome())
+          return onSome(this.value);
+        else
+          return onNone();
+      }
+    };
+    exports2.Option = Option6;
+    var Some = class extends Option6 {
+      _value;
+      constructor(value) {
+        super();
+        this._value = value;
+      }
+      get value() {
+        return this._value;
+      }
+    };
+    exports2.Some = Some;
+    var None = class extends Option6 {
+    };
+    exports2.None = None;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Schema: () => Schema,
+  Validator: () => Validator,
+  Validators: () => Validators
+});
+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 {
+};
+var DefinitionError = class extends Error {
+};
+
+// src/validators/JSON.ts
+var JSONValidator = class _JSONValidator extends Validator {
+  static fromJSON(_definition, _path = "definition") {
+    return new _JSONValidator();
+  }
+  assert(data, path = "data") {
+    if (!import_json.JSON.isJSON(data))
+      throw new AssertError(`Expected ${path} to be valid JSON`);
+  }
+  isSubset(other) {
+    return other instanceof _JSONValidator;
+  }
+  toJSON() {
+    return {
+      type: "json"
+    };
+  }
+};
+
+// src/validators/Boolean.ts
+var import_json2 = __toESM(require_build());
+var import_option = __toESM(require_Option());
+var BooleanValidator = class _BooleanValidator extends Validator {
+  static fromJSON(definition, path = "definition") {
+    const validatorInstance = new _BooleanValidator();
+    if ("nullable" in definition) {
+      if (!import_json2.JSON.isBoolean(definition["nullable"]))
+        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
+      validatorInstance.nullable(definition["nullable"]);
+    }
+    if ("equals" in definition) {
+      if (!import_json2.JSON.isBoolean(definition["equals"]))
+        throw new DefinitionError(`Expected ${path}.equals to be a Boolean`);
+      validatorInstance.equals(definition["equals"]);
+    }
+    return validatorInstance;
+  }
+  _nullable = import_option.Option.None();
+  _equals = import_option.Option.None();
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option.Option.Some(null) : import_option.Option.None();
+    return this;
+  }
+  equals(value) {
+    this._equals = import_option.Option.Some(value);
+    return this;
+  }
+  assert(data, path = "data") {
+    if (import_json2.JSON.isBoolean(data)) {
+      if (this._equals.isSome() && this._equals.value !== data)
+        throw new AssertError(`Expected ${path} to be ${this._equals.value}${this._nullable.isSome() ? "" : " or Null"}`);
+    } else if (import_json2.JSON.isNull(data)) {
+      if (!this._nullable.isSome())
+        throw new AssertError(`Expected ${path} to be a Boolean${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be a Boolean${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
+      return true;
+    if (!(other instanceof _BooleanValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    if (other._equals.isSome()) {
+      if (this._equals.isSome())
+        return this._equals.value === other._equals.value;
+      else
+        return false;
+    }
+    return true;
+  }
+  toJSON() {
+    const definition = {
+      type: "boolean"
+    };
+    if (this._nullable.isSome())
+      definition["nullable"] = true;
+    if (this._equals.isSome())
+      definition["equals"] = this._equals.value;
+    return definition;
+  }
+};
+
+// src/validators/Number.ts
+var import_json3 = __toESM(require_build());
+var import_option2 = __toESM(require_Option());
+var NumberValidator = class _NumberValidator extends Validator {
+  static fromJSON(definition, path = "definition") {
+    const validatorInstance = new _NumberValidator();
+    if ("nullable" in definition) {
+      if (!import_json3.JSON.isBoolean(definition["nullable"]))
+        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
+      validatorInstance.nullable(definition["nullable"]);
+    }
+    if ("equals" in definition) {
+      if (!import_json3.JSON.isNumber(definition["equals"]))
+        throw new DefinitionError(`Expected ${path}.equals to be a Number`);
+      validatorInstance.equals(definition["equals"], `${path}.equals`);
+    }
+    if ("integer" in definition) {
+      if (!import_json3.JSON.isBoolean(definition["integer"]))
+        throw new DefinitionError(`Expected ${path}.integer to be a Boolean`);
+      validatorInstance.integer(definition["integer"], `${path}.integer`);
+    }
+    if ("min" in definition) {
+      if (!import_json3.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_json3.JSON.isNumber(definition["max"]))
+        throw new DefinitionError(`Expected ${path}.max to be a Number`);
+      validatorInstance.max(definition["max"], `${path}.max`);
+    }
+    return validatorInstance;
+  }
+  _nullable = import_option2.Option.None();
+  _equals = import_option2.Option.None();
+  _integer = import_option2.Option.None();
+  _min = import_option2.Option.None();
+  _max = import_option2.Option.None();
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option2.Option.Some(null) : import_option2.Option.None();
+    return this;
+  }
+  equals(value, path = "equals") {
+    if (this._integer.isSome() && !Number.isSafeInteger(value))
+      throw new DefinitionError(`Expected Equals Rule to be an Integer according to the Integer Rule at Path ${path}`);
+    if (this._min.isSome() && this._min.value > value)
+      throw new DefinitionError(`Expected Equals Rule to be larger than or equal to the Minimum Rule at Path ${path}`);
+    if (this._max.isSome() && this._max.value < value)
+      throw new DefinitionError(`Expected Equals Rule to be smaller than or equal to the Maximum Rule at Path ${path}`);
+    this._equals = import_option2.Option.Some(value);
+    return this;
+  }
+  integer(flag = true, path = "integer") {
+    if (flag && this._equals.isSome() && !Number.isSafeInteger(this._equals.value))
+      throw new DefinitionError(`Expected Integer Rule to be a false due to the Equals Rule being a Float at Path ${path}`);
+    this._integer = flag ? import_option2.Option.Some(null) : import_option2.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._equals.isSome() && this._equals.value < value)
+      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to the Equals Rule at Path ${path}`);
+    this._min = import_option2.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._equals.isSome() && this._equals.value > value)
+      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to the Equals Rule at Path ${path}`);
+    this._max = import_option2.Option.Some(value);
+    return this;
+  }
+  assert(data, path = "data") {
+    if (import_json3.JSON.isNumber(data)) {
+      if (this._equals.isSome() && this._equals.value !== data)
+        throw new AssertError(`Expected ${path} to be ${this._equals.value}`);
+      if (this._integer.isSome() && !Number.isInteger(data))
+        throw new AssertError(`Expected ${path} to be an Integer`);
+      if (this._min.isSome() && this._min.value > data)
+        throw new AssertError(`Expected ${path} to be at least ${this._min.value}`);
+      if (this._max.isSome() && this._max.value < data)
+        throw new AssertError(`Expected ${path} to be at most ${this._max.value}`);
+    } else if (import_json3.JSON.isNull(data)) {
+      if (!this._nullable.isSome())
+        throw new AssertError(`Expected ${path} to be a Number${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be a Number${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
+      return true;
+    if (!(other instanceof _NumberValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    if (this._equals.isSome()) {
+      if (other._equals.isSome() && other._equals.value !== this._equals.value)
+        return false;
+      if (other._integer.isSome() && !Number.isInteger(this._equals.value))
+        return false;
+      if (other._min.isSome() && other._min.value > this._equals.value)
+        return false;
+      if (other._max.isSome() && other._max.value < this._equals.value)
+        return false;
+      return true;
+    }
+    if (other._equals.isSome())
+      return false;
+    if (!this._integer.isSome() && other._integer.isSome())
+      return false;
+    if (other._min.isSome() && (!this._min.isSome() || this._min.value < other._min.value))
+      return false;
+    if (other._max.isSome() && (!this._max.isSome() || this._max.value > other._max.value))
+      return false;
+    return true;
+  }
+  toJSON() {
+    const definition = {
+      type: "number"
+    };
+    if (this._nullable.isSome())
+      definition["nullable"] = true;
+    if (this._equals.isSome())
+      definition["equals"] = this._equals.value;
+    if (this._integer.isSome())
+      definition["integer"] = true;
+    if (this._min.isSome())
+      definition["min"] = this._min.value;
+    if (this._max.isSome())
+      definition["max"] = this._max.value;
+    return definition;
+  }
+};
+
+// src/validators/String.ts
+var import_json4 = __toESM(require_build());
+var import_option3 = __toESM(require_Option());
+var StringValidator = class _StringValidator extends Validator {
+  static fromJSON(definition, path = "schema") {
+    const validatorInstance = new _StringValidator();
+    if ("nullable" in definition) {
+      if (!import_json4.JSON.isBoolean(definition["nullable"]))
+        throw new DefinitionError(`Expected ${path}.nullable to be a Boolean`);
+      validatorInstance.nullable(definition["nullable"]);
+    }
+    if ("equals" in definition) {
+      if (!import_json4.JSON.isString(definition["equals"]))
+        throw new DefinitionError(`Expected ${path}.equals to be a String`);
+      validatorInstance.equals(definition["equals"], `${path}.equals`);
+    }
+    if ("min" in definition) {
+      if (!import_json4.JSON.isNumber(definition["min"]))
+        throw new DefinitionError(`Expected ${path}.min to be a positive Integer`);
+      validatorInstance.min(definition["min"], `${path}.min`);
+    }
+    if ("max" in definition) {
+      if (!import_json4.JSON.isNumber(definition["max"]))
+        throw new DefinitionError(`Expected ${path}.max to be a positive Integer`);
+      validatorInstance.max(definition["max"], `${path}.max`);
+    }
+    return validatorInstance;
+  }
+  _nullable = import_option3.Option.None();
+  _equals = import_option3.Option.None();
+  _min = import_option3.Option.None();
+  _max = import_option3.Option.None();
+  nullable(flag) {
+    this._nullable = flag ?? true ? import_option3.Option.Some(null) : import_option3.Option.None();
+    return this;
+  }
+  equals(value, path = "equals") {
+    if (this._min.isSome() && this._min.value > value.length)
+      throw new DefinitionError(`Expected the Equals Rules Length to be larger than or equal to the Minimum Rule at Path ${path}`);
+    if (this._max.isSome() && this._max.value < value.length)
+      throw new DefinitionError(`Expected the Equals Rules Length to be smaller than or equal to the Maximum Rule at Path ${path}`);
+    this._equals = import_option3.Option.Some(value);
+    return this;
+  }
+  min(value, path = "min") {
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new DefinitionError(`Expected ${path}.min to be a positive Integer`);
+    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._equals.isSome() && this._equals.value.length < value)
+      throw new DefinitionError(`Expected Minimum Rule to be smaller than or equal to the Equals Rules Length at Path ${path}`);
+    this._min = import_option3.Option.Some(value);
+    return this;
+  }
+  max(value, path = "max") {
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new DefinitionError(`Expected ${path}.max to be a positive Integer`);
+    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._equals.isSome() && this._equals.value.length > value)
+      throw new DefinitionError(`Expected Maximum Rule to be larger than or equal to the Equals Rules Length at Path ${path}`);
+    this._max = import_option3.Option.Some(value);
+    return this;
+  }
+  assert(data, path = "data") {
+    if (import_json4.JSON.isString(data)) {
+      if (this._equals.isSome() && this._equals.value !== data)
+        throw new AssertError(`Expected ${path} to be ${this._equals.value}`);
+      if (this._min.isSome() && this._min.value > data.length)
+        throw new AssertError(`Expected ${path} to be at least ${this._min.value} characters long`);
+      if (this._max.isSome() && this._max.value < data.length)
+        throw new AssertError(`Expected ${path} to be at most ${this._max.value} characters long`);
+    } else if (import_json4.JSON.isNull(data)) {
+      if (!this._nullable.isSome())
+        throw new AssertError(`Expected ${path} to be a String${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be a String${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
+      return true;
+    if (!(other instanceof _StringValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    if (this._equals.isSome()) {
+      if (other._equals.isSome() && other._equals.value !== this._equals.value)
+        return false;
+      if (other._min.isSome() && other._min.value > this._equals.value.length)
+        return false;
+      if (other._max.isSome() && other._max.value < this._equals.value.length)
+        return false;
+      return true;
+    }
+    if (other._equals.isSome())
+      return false;
+    if (other._min.isSome() && (!this._min.isSome() || this._min.value < other._min.value))
+      return false;
+    if (other._max.isSome() && (!this._max.isSome() || this._max.value > other._max.value))
+      return false;
+    return true;
+  }
+  toJSON() {
+    const definition = {
+      type: "string"
+    };
+    if (this._nullable.isSome())
+      definition["nullable"] = true;
+    if (this._equals.isSome())
+      definition["equals"] = this._equals.value;
+    if (this._min.isSome())
+      definition["min"] = this._min.value;
+    if (this._max.isSome())
+      definition["max"] = this._max.value;
+    return definition;
+  }
+};
+
+// 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(
+        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(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());
+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"]))
+        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"]))
+        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"]))
+        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) {
+      validatorInstance.every(fromJSON(definition["every"], `${path}.every`));
+    }
+    if ("shape" in definition) {
+      if (!import_json6.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] = 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}`);
+          errors.push(e);
+        }
+      }
+      if (errors.length > 0) {
+        throw new DefinitionError(`Multiple Definition Errors detected at ${path}.shape (see cause)`, { cause: errors });
+      }
+      validatorInstance.shape(shape, `${path}.shape`);
+    }
+    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(flag) {
+    this._nullable = flag ?? true ? import_option5.Option.Some(null) : import_option5.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._shape.isSome() && value < Object.keys(this._shape.value).length)
+      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);
+    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._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);
+    return this;
+  }
+  every(validator) {
+    this._every = import_option5.Option.Some(validator);
+    return this;
+  }
+  shape(value, path = "shape") {
+    const shapeKeyCount = Object.keys(value).length;
+    if (this._min.isSome() && this._min.value < shapeKeyCount)
+      throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Minimum Rule at Path ${path}`);
+    if (this._max.isSome() && this._max.value < shapeKeyCount)
+      throw new DefinitionError(`Expected Shape Key Count to be smaller than or equal to Maximum Rule at Path ${path}`);
+    if (this._exact.isSome() && this._min.isSome() && this._min.value > shapeKeyCount)
+      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);
+    return this;
+  }
+  exact(flag, path = "exact") {
+    if ((flag ?? true) && this._shape.isSome()) {
+      const shapeKeyCount = Object.keys(this._shape.value).length;
+      if (this._min.isSome() && this._min.value > shapeKeyCount)
+        throw new DefinitionError(`Expected Exact Rule to be false due to Minimum Rule requiring more Properties than Shape defines at Path ${path}`);
+      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();
+    return this;
+  }
+  assert(data, path = "data") {
+    if (import_json6.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`);
+      if (this._max.isSome() && keys.length > this._max.value)
+        throw new AssertError(`Expected ${path} to have at most ${this._max.value} Properties`);
+      const errors = [];
+      if (this._shape.isSome()) {
+        for (const key of Object.keys(this._shape.value)) {
+          try {
+            const validator = this._shape.value[key];
+            validator.assert(data[key], `${path}.${key}`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}.${key}`);
+            errors.push(e);
+          }
+        }
+        if (this._exact.isSome()) {
+          for (const key of keys) {
+            if (!(key in this._shape.value)) {
+              errors.push(new AssertError(`Unexpected property ${path}.${key}`));
+            }
+          }
+        }
+      }
+      if (this._every.isSome()) {
+        const validator = this._every.value;
+        for (const key of keys) {
+          try {
+            validator.assert(data[key], `${path}.${key}`);
+          } catch (e) {
+            if (!(e instanceof AssertError))
+              throw new AssertError(`Fatal Error: Undefined Error thrown by an Assert Method at ${path}.${key}`);
+            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 Object${this._nullable.isSome() ? " or Null" : ""}`);
+    } else
+      throw new AssertError(`Expected ${path} to be an Object${this._nullable.isSome() ? " or Null" : ""}`);
+  }
+  isSubset(other) {
+    if (other instanceof JSONValidator)
+      return true;
+    if (!(other instanceof _ObjectValidator))
+      return false;
+    if (this._nullable.isSome() && !other._nullable.isSome())
+      return false;
+    const thisMin = this._min.isSome() ? this._min.value : 0;
+    const otherMin = other._min.isSome() ? other._min.value : 0;
+    if (thisMin < otherMin)
+      return false;
+    const thisMax = this._max.isSome() ? this._max.value : Number.POSITIVE_INFINITY;
+    const otherMax = other._max.isSome() ? other._max.value : Number.POSITIVE_INFINITY;
+    if (thisMax > otherMax)
+      return false;
+    if (other._shape.isSome()) {
+      if (!this._shape.isSome())
+        return false;
+      const thisShape = this._shape.value;
+      const otherShape = other._shape.value;
+      for (const key of Object.keys(otherShape)) {
+        if (!(key in thisShape))
+          return false;
+        const a = thisShape[key];
+        const b = otherShape[key];
+        if (!a.isSubset(b))
+          return false;
+      }
+    }
+    if (other._exact.isSome()) {
+      if (!this._exact.isSome())
+        return false;
+      if (!other._shape.isSome() || !this._shape.isSome())
+        return false;
+      const aKeys = Object.keys(this._shape.value).sort();
+      const bKeys = Object.keys(other._shape.value).sort();
+      if (aKeys.length !== bKeys.length)
+        return false;
+      for (let i = 0; i < aKeys.length; i++) {
+        if (aKeys[i] !== bKeys[i])
+          return false;
+      }
+    }
+    if (other._every.isSome()) {
+      const bEvery = other._every.value;
+      if (!this._exact.isSome()) {
+        if (!this._every.isSome())
+          return false;
+        if (!this._every.value.isSubset(bEvery))
+          return false;
+      }
+      if (this._shape.isSome()) {
+        for (const [_, v] of Object.entries(this._shape.value)) {
+          if (!v.isSubset(bEvery))
+            return false;
+        }
+      }
+      if (this._exact.isSome() && !this._shape.isSome()) {
+        if (!this._every.isSome())
+          return false;
+        if (!this._every.value.isSubset(bEvery))
+          return false;
+      }
+    }
+    return true;
+  }
+  toJSON() {
+    const schema = { type: "object" };
+    if (this._nullable.isSome())
+      schema.nullable = true;
+    if (this._exact.isSome())
+      schema.exact = true;
+    if (this._min.isSome())
+      schema.min = this._min.value;
+    if (this._max.isSome())
+      schema.max = this._max.value;
+    if (this._every.isSome())
+      schema.every = this._every.value.toJSON();
+    if (this._shape.isSome()) {
+      schema.shape = Object.fromEntries(
+        Object.entries(this._shape.value).map(([k, s]) => [k, s.toJSON()])
+      );
+    }
+    return schema;
+  }
+};
+
+// 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() {
+    return new JSONValidator();
+  }
+  static get Boolean() {
+    return new BooleanValidator();
+  }
+  static get Number() {
+    return new NumberValidator();
+  }
+  static get String() {
+    return new StringValidator();
+  }
+  static get Array() {
+    return new ArrayValidator();
+  }
+  static get Object() {
+    return new ObjectValidator();
+  }
+  static fromJSON(definition, path = "definition") {
+    return fromJSON(definition, path);
+  }
+};
+var Validators = {
+  JSON: JSONValidator,
+  Boolean: BooleanValidator,
+  Number: NumberValidator,
+  String: StringValidator,
+  Array: ArrayValidator,
+  Object: ObjectValidator
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Schema,
+  Validator,
+  Validators
+});
+//# sourceMappingURL=index.js.map