justus 0.1.6 → 0.2.1

package/dist/index.mjs

@@ -1,802 +1,28 @@
-// src/errors.ts
-function pathToString(path) {
-  return path.reduce((string2, key, index) => {
-    if (typeof key === "number")
-      return `${string2}[${key}]`;
-    return index === 0 ? key : `${string2}.${key}`;
-  }, "");
-}
-var ValidationError = class extends Error {
-  /** An `Array` of validation errors encountered while validating */
-  errors;
-  /** Our stack, always present as we enforce it in the constructor */
-  stack;
-  constructor(builderOrCause, constructorOrPath, maybeConstructor) {
-    let constructor;
-    let errors;
-    if (builderOrCause instanceof ValidationErrorBuilder) {
-      errors = builderOrCause.errors;
-      constructor = builderOrCause.assert;
-    } else {
-      const path = Array.isArray(constructorOrPath) ? constructorOrPath : [];
-      if (builderOrCause instanceof ValidationError) {
-        errors = builderOrCause.errors.map(({ path: subpath, message: message2 }) => ({ path: [...path, ...subpath], message: message2 }));
-      } else {
-        errors = [{ path, message: `${builderOrCause}` }];
-      }
-      constructor = typeof maybeConstructor === "function" ? maybeConstructor : typeof constructorOrPath === "function" ? constructorOrPath : ValidationError;
-    }
-    const details = errors.map(({ path, message: message2 }) => ({ key: pathToString(path), message: message2 })).map(({ key, message: message2 }) => key ? `${key}: ${message2}` : message2).join("\n  ");
-    const message = errors.length !== 1 ? `Found ${errors.length} validation errors` : "Found 1 validation error";
-    super(`${message}
-  ${details}`);
-    Error.captureStackTrace(this, constructor);
-    Object.defineProperty(this, "errors", { value: errors });
-  }
-};
-var ValidationErrorBuilder = class {
-  /** The current list of validation errors */
-  errors = [];
-  /**
-   * Record a validation error associated with the specified key.
-   *
-   * @param error - The error (normally a `string` or a `ValidationError`)
-   *                to record and associate with the given key
-   * @param key - The key in an object, or index in an array where the
-   *              vaildation error was encountered
-   */
-  record(error, ...key) {
-    const path = [...key];
-    if (error instanceof ValidationError) {
-      error.errors.forEach(({ path: subpath, message }) => {
-        this.errors.push({ path: [...path, ...subpath], message });
-      });
-    } else {
-      this.errors.push({ path, message: `${error}` });
-    }
-    return this;
-  }
-  /**
-   * Assert there are no validation errors and return the specified value, or
-   * throw a `ValidationError` combining all errors
-   *
-   * @param value - The value to return if no errors have been recorded
-   */
-  assert(value) {
-    if (this.errors.length > 0)
-      throw new ValidationError(this);
-    return value;
-  }
-};
-function assertValidation(what, message) {
-  if (!what)
-    throw new ValidationError(message, assertValidation);
-}
-function assertSchema(what, message) {
-  if (!what)
-    throw new TypeError(message);
-}
-
-// src/types.ts
-var isValidator = Symbol.for("justus.isValidator");
-var restValidator = Symbol.for("justus.restValidator");
-var schemaValidator = Symbol.for("justus.schemaValidator");
-var additionalValidator = Symbol.for("justus.additionalValidator");
-function makeValidatorFactory(validator, factory) {
-  return Object.assign(factory, {
-    optional: validator.optional,
-    validate: validator.validate.bind(validator),
-    [Symbol.iterator]: validator[Symbol.iterator].bind(validator),
-    [isValidator]: true
-  });
-}
-var AbstractValidator = class {
-  [isValidator] = true;
-  optional = void 0;
-  /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
-  *[Symbol.iterator]() {
-    yield { [restValidator]: this };
-  }
-};
-
-// src/validators/any.ts
-var AnyValidator = class extends AbstractValidator {
-  validate(value) {
-    return value;
-  }
-};
-var any = new AnyValidator();
-
-// src/validators/constant.ts
-var ConstantValidator = class extends AbstractValidator {
-  constant;
-  constructor(constant2) {
-    super();
-    this.constant = constant2;
-  }
-  validate(value) {
-    assertValidation(value === this.constant, `Value does not match constant "${this.constant}"`);
-    return value;
-  }
-};
-function constant(constant2) {
-  return new ConstantValidator(constant2);
-}
-var nullValidator = new ConstantValidator(null);
-
-// src/validators/tuple.ts
-var TupleValidator = class extends AbstractValidator {
-  members;
-  tuple;
-  constructor(tuple2) {
-    super();
-    const members = [];
-    for (const item of tuple2) {
-      if (item === null) {
-        members.push({ single: true, validator: nullValidator });
-      } else if (typeof item === "object" && restValidator in item) {
-        members.push({ single: false, validator: item[restValidator] });
-      } else {
-        members.push({ single: true, validator: getValidator(item) });
-      }
-    }
-    this.members = members;
-    this.tuple = tuple2;
-  }
-  validate(value, options) {
-    assertValidation(Array.isArray(value), 'Value is not an "array"');
-    if (this.members.length === 0) {
-      const size = value.length;
-      assertValidation(size === 0, `Found ${size} element${size === 1 ? "" : "s"} validating empty tuple`);
-      return value;
-    }
-    const clone = new Array(value.length);
-    let needle = 0;
-    let haystack = 0;
-    let { single, validator } = this.members[needle];
-    while (needle < this.members.length && haystack < value.length) {
-      try {
-        clone[haystack] = validator.validate(value[haystack], options);
-        if (single)
-          ({ single, validator } = this.members[++needle] || {});
-        haystack++;
-      } catch (error) {
-        if (single)
-          throw new ValidationError(error, [haystack]);
-        else
-          ({ single, validator } = this.members[++needle] || {});
-      }
-    }
-    while (needle < this.members.length && this.members[needle].single === false) {
-      needle++;
-    }
-    const missing = this.members.length - needle;
-    if (missing === 1 && single) {
-      throw new ValidationError("Tuple defines 1 missing validation");
-    } else if (missing > 1) {
-      throw new ValidationError(`Tuple defines ${missing} missing validations`);
-    }
-    const extra = value.length - haystack;
-    assertValidation(extra === 0, `Found ${extra} extra element${extra === 1 ? "" : "s"} in tuple`);
-    return clone;
-  }
-};
-function tuple(tuple2) {
-  return new TupleValidator(tuple2);
-}
-
-// src/validators/object.ts
-var AnyObjectValidator = class extends AbstractValidator {
-  validate(value) {
-    assertValidation(typeof value == "object", 'Value is not an "object"');
-    assertValidation(value !== null, 'Value is "null"');
-    return value;
-  }
-};
-var ObjectValidator = class extends AbstractValidator {
-  schema;
-  validators = /* @__PURE__ */ new Map();
-  additionalProperties;
-  constructor(schema) {
-    super();
-    const { [additionalValidator]: additional, ...properties } = schema;
-    if (additional)
-      this.additionalProperties = getValidator(additional);
-    for (const key of Object.keys(properties)) {
-      this.validators.set(key, getValidator(properties[key]));
-    }
-    this.schema = schema;
-  }
-  validate(value, options) {
-    assertValidation(typeof value === "object", 'Value is not an "object"');
-    assertValidation(value !== null, 'Value is "null"');
-    const { stripAdditionalProperties, stripOptionalNulls } = options;
-    const record = value;
-    const builder = new ValidationErrorBuilder();
-    const clone = {};
-    for (const [key, validator] of this.validators.entries()) {
-      const optional2 = !!validator.optional;
-      const original = record[key];
-      if (stripOptionalNulls && optional2 && original === null) {
-        continue;
-      }
-      if (original === void 0) {
-        try {
-          const validated = validator.validate(original, options);
-          if (!(optional2 && validated == void 0))
-            clone[key] = validated;
-        } catch (error) {
-          if (optional2)
-            continue;
-          builder.record("Required property missing", key);
-        }
-        continue;
-      }
-      try {
-        const validated = validator.validate(original, options);
-        if (!(optional2 && validated == void 0))
-          clone[key] = validated;
-      } catch (error) {
-        builder.record(error, key);
-      }
-    }
-    const additionalKeys = Object.keys(record).filter((k) => !this.validators.has(k));
-    const additional = this.additionalProperties;
-    if (additional) {
-      additionalKeys.forEach((key) => {
-        if (record[key] === void 0)
-          return;
-        try {
-          clone[key] = additional.validate(record[key], options);
-        } catch (error) {
-          builder.record(error, key);
-        }
-      });
-    } else if (!stripAdditionalProperties) {
-      additionalKeys.forEach((key) => {
-        if (record[key] !== void 0)
-          builder.record("Unknown property", key);
-      });
-    }
-    return builder.assert(clone);
-  }
-};
-function _object(schema) {
-  const validator = new ObjectValidator(schema);
-  function* iterator() {
-    yield { [restValidator]: validator };
-  }
-  return Object.defineProperties(schema, {
-    [schemaValidator]: { value: validator, enumerable: false },
-    [Symbol.iterator]: { value: iterator, enumerable: false }
-  });
-}
-var object = makeValidatorFactory(new AnyObjectValidator(), _object);
-function objectOf(validation) {
-  return new ObjectValidator({ ...allowAdditionalProperties(validation) });
-}
-
-// src/utilities.ts
-function getValidator(validation) {
-  if (validation === null)
-    return nullValidator;
-  if (validation[isValidator] === true)
-    return validation;
-  switch (typeof validation) {
-    case "boolean":
-    case "string":
-    case "number":
-      return new ConstantValidator(validation);
-    case "object":
-      if (schemaValidator in validation)
-        return validation[schemaValidator];
-      if (Array.isArray(validation))
-        return new TupleValidator(validation);
-      return new ObjectValidator(validation);
-    default:
-      throw new TypeError(`Invalid validation (type=${typeof validation})`);
-  }
-}
-
-// src/schema.ts
-function _allowAdditionalProperties(options) {
-  if (options === false)
-    return { [additionalValidator]: false };
-  if (options === true)
-    return { [additionalValidator]: any };
-  return { [additionalValidator]: options ? getValidator(options) : any };
-}
-var allowAdditionalProperties = _allowAdditionalProperties;
-allowAdditionalProperties[additionalValidator] = any;
-
-// src/validators/union.ts
-var OneOfValidator = class extends AbstractValidator {
-  validators;
-  constructor(args) {
-    super();
-    this.validators = args.map((validation) => getValidator(validation));
-    assertSchema(this.validators.length > 0, 'At least one validation required in "oneOf"');
-  }
-  validate(value, options) {
-    const builder = new ValidationErrorBuilder();
-    for (const validator of this.validators) {
-      try {
-        return validator.validate(value, options);
-      } catch (error) {
-        builder.record(error);
-      }
-    }
-    return builder.assert(value);
-  }
-};
-function oneOf(...args) {
-  return new OneOfValidator(args);
-}
-var AllOfValidator = class extends AbstractValidator {
-  validators;
-  constructor(args) {
-    super();
-    this.validators = args.map((validation) => getValidator(validation));
-    assertSchema(this.validators.length > 0, 'At least one validation required in "allOf"');
-  }
-  validate(value, options) {
-    for (const validator of this.validators) {
-      value = validator.validate(value, options);
-    }
-    return value;
-  }
-};
-function allOf(...args) {
-  return new AllOfValidator(args);
-}
-
-// src/validators/array.ts
-var AnyArrayValidator = class extends AbstractValidator {
-  validate(value, options) {
-    assertValidation(Array.isArray(value), 'Value is not an "array"');
-    return [...value];
-  }
-};
-var ArrayValidator = class extends AbstractValidator {
-  maxItems;
-  minItems;
-  uniqueItems;
-  items;
-  constructor(options = {}) {
-    super();
-    const {
-      items = any,
-      maxItems = Number.POSITIVE_INFINITY,
-      minItems = 0,
-      uniqueItems = false
-    } = options;
-    assertSchema(minItems >= 0, `Constraint "minItems" (${minItems}) must be non-negative`);
-    assertSchema(maxItems >= 0, `Constraint "maxItems" (${maxItems}) must be non-negative`);
-    assertSchema(minItems <= maxItems, `Constraint "minItems" (${minItems}) is greater than "maxItems" (${maxItems})`);
-    this.items = items;
-    this.maxItems = maxItems;
-    this.minItems = minItems;
-    this.uniqueItems = uniqueItems;
-  }
-  validate(value, options) {
-    assertValidation(Array.isArray(value), 'Value is not an "array"');
-    assertValidation(
-      value.length >= this.minItems,
-      `Array must have a minimum length of ${this.minItems}`
-    );
-    assertValidation(
-      value.length <= this.maxItems,
-      `Array must have a maximum length of ${this.maxItems}`
-    );
-    const builder = new ValidationErrorBuilder();
-    const clone = new Array(value.length);
-    value.forEach((item, i) => {
-      try {
-        const position = value.indexOf(value[i]);
-        if (position === i) {
-          clone[i] = this.items.validate(item, options);
-        } else if (this.uniqueItems) {
-          builder.record(`Duplicate of item at index ${position}`, i);
-        } else {
-          clone[i] = clone[position];
-        }
-      } catch (error) {
-        builder.record(error, i);
-      }
-    });
-    return builder.assert(clone);
-  }
-};
-function _array(constraints) {
-  const items = constraints.items ? getValidator(constraints.items) : any;
-  return new ArrayValidator({ ...constraints, items });
-}
-var array = makeValidatorFactory(new AnyArrayValidator(), _array);
-function arrayOf(validation) {
-  return new ArrayValidator({ items: getValidator(validation) });
-}
-
-// src/validators/boolean.ts
-var BooleanValidator = class extends AbstractValidator {
-  fromString;
-  constructor(constraints = {}) {
-    super();
-    const { fromString = false } = constraints;
-    this.fromString = fromString;
-  }
-  validate(value) {
-    if (typeof value == "string" && this.fromString) {
-      const string2 = value.toLowerCase();
-      const parsed = string2 === "true" ? true : string2 === "false" ? false : void 0;
-      assertValidation(parsed !== void 0, "Boolean can not be parsed from string");
-      value = parsed;
-    }
-    assertValidation(typeof value === "boolean", 'Value is not a "boolean"');
-    return value;
-  }
-};
-function _boolean(constraints) {
-  return new BooleanValidator(constraints);
-}
-var boolean = makeValidatorFactory(new BooleanValidator(), _boolean);
-
-// src/validators/date.ts
-var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
-var DateValidator = class extends AbstractValidator {
-  format;
-  from;
-  until;
-  constructor(constraints = {}) {
-    super();
-    const { format, from, until } = constraints;
-    if (from != void 0 && until !== void 0) {
-      assertSchema(
-        until.getTime() >= from.getTime(),
-        `Constraint "until" (${until.toISOString()}) must not be before "from" (${from.toISOString()})`
-      );
-    }
-    this.format = format;
-    this.from = from;
-    this.until = until;
-  }
-  validate(value) {
-    let date2;
-    try {
-      date2 = new Date(value);
-    } catch (error) {
-      throw new ValidationError('Value could not be converted to a "Date"');
-    }
-    if (isNaN(date2.getTime()))
-      throw new ValidationError("Invalid date");
-    if (this.format === "iso") {
-      assertValidation(typeof value === "string", 'ISO Date is not a "string"');
-      assertValidation(ISO_8601_REGEX.test(value), "Invalid format for ISO Date");
-    } else if (this.format === "timestamp") {
-      assertValidation(typeof value === "number", 'Timestamp is not a "number"');
-    }
-    if (this.from) {
-      assertValidation(this.from.getTime() <= date2.getTime(), `Date is before ${this.from.toISOString()}`);
-    }
-    if (this.until) {
-      assertValidation(this.until.getTime() >= date2.getTime(), `Date is after ${this.until.toISOString()}`);
-    }
-    return date2;
-  }
-};
-function _date(constraints) {
-  return new DateValidator(constraints);
-}
-var date = makeValidatorFactory(new DateValidator(), _date);
-
-// src/validators/never.ts
-var NeverValidator = class extends AbstractValidator {
-  optional = true;
-  validate(value, options) {
-    const { stripForbiddenProperties } = options;
-    if (stripForbiddenProperties || value === void 0)
-      return;
-    throw new ValidationError("Forbidden property");
-  }
-};
-var never = new NeverValidator();
-
-// src/validators/number.ts
-var PRECISION = 6;
-var MULTIPLIER = Math.pow(10, PRECISION);
-function countDecimals(n) {
-  const match = n.toExponential().match(/^\d+(\.\d+)?e([+-]\d+)$/);
-  if (!match)
-    throw new RangeError(`Can't calculate digits for number "${n}"`);
-  const digits = (match[1] || ".").length - 1 - parseInt(match[2]);
-  return digits < 0 ? 0 : digits;
-}
-var AnyNumberValidator = class extends AbstractValidator {
-  validate(value) {
-    assertValidation(typeof value == "number", 'Value is not a "number"');
-    assertValidation(!isNaN(value), 'Number is "NaN"');
-    return value;
-  }
-};
-var NumberValidator = class extends AbstractValidator {
-  #isMultipleOf;
-  allowNaN;
-  exclusiveMaximum;
-  exclusiveMinimum;
-  fromString;
-  maximum;
-  minimum;
-  multipleOf;
-  brand;
-  constructor(constraints = {}) {
-    super();
-    const {
-      allowNaN = false,
-      exclusiveMaximum,
-      exclusiveMinimum,
-      fromString = false,
-      maximum = Number.POSITIVE_INFINITY,
-      minimum = Number.NEGATIVE_INFINITY,
-      multipleOf
-    } = constraints;
-    if ("brand" in constraints)
-      this.brand = constraints.brand;
-    assertSchema(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`);
-    if (exclusiveMaximum !== void 0) {
-      assertSchema(
-        exclusiveMaximum > minimum,
-        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "minimum" (${minimum})`
-      );
-    }
-    if (exclusiveMinimum !== void 0) {
-      assertSchema(
-        maximum > exclusiveMinimum,
-        `Constraint "maximum" (${maximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
-      );
-    }
-    if (exclusiveMinimum != void 0 && exclusiveMaximum !== void 0) {
-      assertSchema(
-        exclusiveMaximum > exclusiveMinimum,
-        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
-      );
-    }
-    if (multipleOf !== void 0) {
-      assertSchema(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`);
-      const decimals = countDecimals(multipleOf);
-      if (decimals === 0) {
-        this.#isMultipleOf = (value) => !(value % multipleOf);
-      } else if (decimals <= PRECISION) {
-        this.#isMultipleOf = (value) => {
-          try {
-            if (countDecimals(value) > PRECISION)
-              return false;
-            return !(value * MULTIPLIER % (multipleOf * MULTIPLIER));
-          } catch (error) {
-            throw new ValidationError(error.message);
-          }
-        };
-      } else {
-        assertSchema(false, `Constraint "multipleOf" (${multipleOf}) requires too much precision`);
-      }
-    }
-    this.allowNaN = allowNaN;
-    this.exclusiveMaximum = exclusiveMaximum;
-    this.exclusiveMinimum = exclusiveMinimum;
-    this.fromString = fromString;
-    this.maximum = maximum;
-    this.minimum = minimum;
-    this.multipleOf = multipleOf;
-  }
-  validate(value) {
-    if (typeof value == "string" && this.fromString) {
-      const parsed = +`${value}`;
-      assertValidation(!isNaN(parsed), "Number can not be parsed from string");
-      value = parsed;
-    }
-    assertValidation(typeof value == "number", 'Value is not a "number"');
-    if (isNaN(value)) {
-      assertValidation(this.allowNaN, 'Number is "NaN"');
-      return value;
-    }
-    assertValidation(value >= this.minimum, `Number is less than ${this.minimum}`);
-    assertValidation(value <= this.maximum, `Number is greater than ${this.maximum}`);
-    assertValidation(
-      this.exclusiveMinimum == void 0 || value > this.exclusiveMinimum,
-      `Number is less than or equal to ${this.exclusiveMinimum}`
-    );
-    assertValidation(
-      this.exclusiveMaximum == void 0 || value < this.exclusiveMaximum,
-      `Number is greater than or equal to ${this.exclusiveMaximum}`
-    );
-    assertValidation(
-      this.#isMultipleOf ? this.#isMultipleOf(value) : true,
-      `Number is not a multiple of ${this.multipleOf}`
-    );
-    return value;
-  }
-};
-function _number(constraints) {
-  return new NumberValidator(constraints);
-}
-var number = makeValidatorFactory(new AnyNumberValidator(), _number);
-
-// src/validators/optional.ts
-var OptionalValidator = class extends AbstractValidator {
-  validator;
-  defaultValue;
-  constructor(validator, defaultValue) {
-    super();
-    this.validator = validator;
-    this.optional = defaultValue === void 0;
-    if (this.optional) {
-      this.defaultValue = void 0;
-      return;
-    }
-    try {
-      this.defaultValue = validator.validate(defaultValue, {
-        stripAdditionalProperties: false,
-        stripForbiddenProperties: false,
-        stripOptionalNulls: false
-      });
-    } catch (cause) {
-      throw new TypeError("Default value does not match validator", { cause });
-    }
-  }
-  validate(value, options) {
-    if (value === void 0)
-      return this.defaultValue;
-    return this.validator.validate(value, options);
-  }
-};
-function optional(validation, defaultValue) {
-  const validator = getValidator(validation);
-  return new OptionalValidator(validator, defaultValue);
-}
-
-// src/validators/string.ts
-var AnyStringValidator = class extends AbstractValidator {
-  validate(value) {
-    assertValidation(typeof value == "string", 'Value is not a "string"');
-    return value;
-  }
-};
-var StringValidator = class extends AbstractValidator {
-  maxLength;
-  minLength;
-  pattern;
-  brand;
-  constructor(constraints = {}) {
-    super();
-    const {
-      minLength = 0,
-      maxLength = Number.MAX_SAFE_INTEGER,
-      pattern
-    } = constraints;
-    if ("brand" in constraints)
-      this.brand = constraints.brand;
-    assertSchema(minLength >= 0, `Constraint "minLength" (${minLength}) must be non-negative`);
-    assertSchema(maxLength >= 0, `Constraint "maxLength" (${maxLength}) must be non-negative`);
-    assertSchema(minLength <= maxLength, `Constraint "minLength" (${minLength}) is greater than "maxLength" (${maxLength})`);
-    this.maxLength = maxLength;
-    this.minLength = minLength;
-    this.pattern = pattern;
-  }
-  validate(value) {
-    assertValidation(typeof value == "string", 'Value is not a "string"');
-    assertValidation(
-      value.length >= this.minLength,
-      `String must have a minimum length of ${this.minLength}`
-    );
-    assertValidation(
-      value.length <= this.maxLength,
-      `String must have a maximum length of ${this.maxLength}`
-    );
-    assertValidation(
-      this.pattern ? this.pattern.test(value) : true,
-      `String does not match required pattern ${this.pattern}`
-    );
-    return value;
-  }
-};
-function _string(constraints) {
-  return new StringValidator(constraints);
-}
-var string = makeValidatorFactory(new AnyStringValidator(), _string);
-
-// src/validators/url.ts
-var KEYS = [
-  "href",
-  "origin",
-  "protocol",
-  "username",
-  "password",
-  "host",
-  "hostname",
-  "port",
-  "pathname",
-  "search",
-  "hash"
-];
-var OPTIONS = {
-  stripAdditionalProperties: false,
-  stripForbiddenProperties: false,
-  stripOptionalNulls: false
-};
-var URLValidator = class extends AbstractValidator {
-  href;
-  origin;
-  protocol;
-  username;
-  password;
-  host;
-  hostname;
-  port;
-  pathname;
-  search;
-  hash;
-  searchParams;
-  constructor(constraints = {}) {
-    super();
-    for (const key of KEYS) {
-      const constraint = constraints[key];
-      if (typeof constraint === "string") {
-        this[key] = new ConstantValidator(constraint);
-      } else if (constraint) {
-        this[key] = constraint;
-      }
-    }
-    if (constraints.searchParams) {
-      this.searchParams = new ObjectValidator(constraints.searchParams);
-    }
-  }
-  validate(value) {
-    let url2;
-    try {
-      url2 = value instanceof URL ? value : new URL(value);
-    } catch (error) {
-      throw new ValidationError('Value could not be converted to a "URL"');
-    }
-    const builder = new ValidationErrorBuilder();
-    for (const key of KEYS) {
-      const validator = this[key];
-      if (validator) {
-        try {
-          validator.validate(url2[key], OPTIONS);
-        } catch (error) {
-          builder.record(error, key);
-        }
-      }
-    }
-    if (this.searchParams) {
-      const parameters = {};
-      for (const param of url2.searchParams.keys()) {
-        parameters[param] = url2.searchParams.get(param);
-      }
-      try {
-        this.searchParams.validate(parameters, OPTIONS);
-      } catch (error) {
-        builder.record(error, "searchParams");
-      }
-    }
-    return builder.assert(url2);
-  }
-};
-var anyURLValidator = new URLValidator();
-function _url(constraints) {
-  return new URLValidator(constraints);
-}
-var url = makeValidatorFactory(anyURLValidator, _url);
-
-// src/index.ts
-function validate(validation, value, options = {}) {
-  const opts = {
-    stripAdditionalProperties: false,
-    stripForbiddenProperties: false,
-    stripOptionalNulls: false,
-    ...options
-  };
+// index.ts
+export * from "./errors.mjs";
+export * from "./schema.mjs";
+export * from "./types.mjs";
+export * from "./utilities.mjs";
+import { any, AnyValidator } from "./validators/any.mjs";
+import { array, arrayOf, ArrayValidator, AnyArrayValidator } from "./validators/array.mjs";
+import { boolean, BooleanValidator } from "./validators/boolean.mjs";
+import { constant, ConstantValidator } from "./validators/constant.mjs";
+import { date, DateValidator } from "./validators/date.mjs";
+import { never, NeverValidator } from "./validators/never.mjs";
+import { AnyNumberValidator, number, NumberValidator } from "./validators/number.mjs";
+import { AnyObjectValidator, object, objectOf, ObjectValidator } from "./validators/object.mjs";
+import { optional, OptionalValidator } from "./validators/optional.mjs";
+import { AnyStringValidator, string, StringValidator } from "./validators/string.mjs";
+import { tuple, TupleValidator } from "./validators/tuple.mjs";
+import { allOf, AllOfValidator, oneOf, OneOfValidator } from "./validators/union.mjs";
+import { url, URLValidator } from "./validators/url.mjs";
+import { defaultValidationOptions } from "./types.mjs";
+import { getValidator } from "./utilities.mjs";
+function validate(validation, value, options) {
+  const opts = { ...defaultValidationOptions, ...options };
   return getValidator(validation).validate(value, opts);
 }
-function strip(validation, value, options = {}) {
+function strip(validation, value, options) {
   const opts = {
     stripAdditionalProperties: true,
     stripForbiddenProperties: false,
@@ -806,7 +32,6 @@ function strip(validation, value, options = {}) {
   return getValidator(validation).validate(value, opts);
 }
 export {
-  AbstractValidator,
   AllOfValidator,
   AnyArrayValidator,
   AnyNumberValidator,
@@ -825,38 +50,19 @@ export {
   StringValidator,
   TupleValidator,
   URLValidator,
-  ValidationError,
-  ValidationErrorBuilder,
-  _allowAdditionalProperties,
-  _array,
-  _boolean,
-  _date,
-  _number,
-  _object,
-  _string,
-  _url,
-  additionalValidator,
   allOf,
-  allowAdditionalProperties,
   any,
   array,
   arrayOf,
-  assertSchema,
-  assertValidation,
   boolean,
   constant,
   date,
-  getValidator,
-  isValidator,
-  makeValidatorFactory,
   never,
   number,
   object,
   objectOf,
   oneOf,
   optional,
-  restValidator,
-  schemaValidator,
   string,
   strip,
   tuple,