justus 0.1.5 → 0.2.0

package/dist/validators/object.mjs

@@ -0,0 +1,108 @@
+// validators/object.ts
+import { assertValidation, ValidationErrorBuilder } from "../errors.mjs";
+import { allowAdditionalProperties } from "../schema.mjs";
+import {
+  AbstractValidator,
+  additionalValidator,
+  defaultValidationOptions,
+  makeValidatorFactory,
+  restValidator,
+  schemaValidator
+} from "../types.mjs";
+import { getValidator } from "../utilities.mjs";
+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 = defaultValidationOptions) {
+    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 optional = !!validator.optional;
+      const original = record[key];
+      if (stripOptionalNulls && optional && original === null) {
+        continue;
+      }
+      if (original === void 0) {
+        try {
+          const validated = validator.validate(original, options);
+          if (!(optional && validated == void 0))
+            clone[key] = validated;
+        } catch (error) {
+          if (optional)
+            continue;
+          builder.record("Required property missing", key);
+        }
+        continue;
+      }
+      try {
+        const validated = validator.validate(original, options);
+        if (!(optional && 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) });
+}
+export {
+  AnyObjectValidator,
+  ObjectValidator,
+  object,
+  objectOf
+};
+//# sourceMappingURL=object.mjs.map

package/dist/validators/object.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/object.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/validators/optional.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/optional.ts
+var optional_exports = {};
+__export(optional_exports, {
+  OptionalValidator: () => OptionalValidator,
+  optional: () => optional
+});
+module.exports = __toCommonJS(optional_exports);
+var import_types = require("../types.cjs");
+var import_utilities = require("../utilities.cjs");
+var OptionalValidator = class extends import_types.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, import_types.defaultValidationOptions);
+    } 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 = (0, import_utilities.getValidator)(validation);
+  return new OptionalValidator(validator, defaultValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OptionalValidator,
+  optional
+});
+//# sourceMappingURL=optional.cjs.map

package/dist/validators/optional.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/optional.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA4D;AAC5D,uBAA6B;AAOtB,IAAM,oBAAN,cAGG,+BAA2D;AAAA,EACnE;AAAA,EACA;AAAA,EAKA,YAAY,WAAyB,cAAkB;AACrD,UAAM;AACN,SAAK,YAAY;AACjB,SAAK,WAAY,iBAAiB;AAClC,QAAI,KAAK,UAAU;AACjB,WAAK,eAAe;AACpB;AAAA,IACF;AAEA,QAAI;AACF,WAAK,eAAe,UAAU,SAAS,cAAc,qCAAwB;AAAA,IAC/E,SAAS,OAAP;AACA,YAAM,IAAI,UAAU,0CAA0C,EAAE,MAAM,CAAC;AAAA,IACzE;AAAA,EACF;AAAA,EAEA,SAAS,OAAgB,SAAsE;AAC7F,QAAI,UAAU;AAAW,aAAO,KAAK;AACrC,WAAO,KAAK,UAAU,SAAS,OAAO,OAAO;AAAA,EAC/C;AACF;AAeO,SAAS,SAEd,YAAe,cAAyD;AACxE,QAAM,gBAAY,+BAAa,UAAU;AACzC,SAAO,IAAI,kBAAkB,WAAW,YAAY;AACtD;",
+  "names": []
+}

package/dist/validators/optional.d.ts

@@ -0,0 +1,21 @@
+import { AbstractValidator } from '../types';
+import type { InferValidation, Validation, ValidationOptions, Validator } from '../types';
+/**
+ * A `Validator` for _optional_ properties (that is `type | undefined`).
+ */
+export declare class OptionalValidator<T = any, // the type of the "validation", that is the optional type to validate
+D = undefined> extends AbstractValidator<D extends undefined ? T | undefined : T> {
+    validator: Validator<T>;
+    defaultValue: T | undefined;
+    constructor(validator: Validator<T>);
+    constructor(validator: Validator<T>, defaultValue: D);
+    constructor(validator: Validator<T>, defaultValue?: void);
+    validate(value: unknown, options?: ValidationOptions): D extends undefined ? T | undefined : T;
+}
+/**
+ * Ensure that the property is marked as _optional_ in the `Schema`.
+ *
+ * @param validation - A `Validation` to be marked as _optional_.
+ */
+export declare function optional<V extends Validation>(validation: V): OptionalValidator<InferValidation<V>, undefined>;
+export declare function optional<V extends Validation, D>(validation: V, defaultValue: D): OptionalValidator<InferValidation<V>, D>;

package/dist/validators/optional.mjs

@@ -0,0 +1,35 @@
+// validators/optional.ts
+import { AbstractValidator, defaultValidationOptions } from "../types.mjs";
+import { getValidator } from "../utilities.mjs";
+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, defaultValidationOptions);
+    } 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);
+}
+export {
+  OptionalValidator,
+  optional
+};
+//# sourceMappingURL=optional.mjs.map

package/dist/validators/optional.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/optional.ts"],
+  "mappings": ";AAAA,SAAS,mBAAmB,gCAAgC;AAC5D,SAAS,oBAAoB;AAOtB,IAAM,oBAAN,cAGG,kBAA2D;AAAA,EACnE;AAAA,EACA;AAAA,EAKA,YAAY,WAAyB,cAAkB;AACrD,UAAM;AACN,SAAK,YAAY;AACjB,SAAK,WAAY,iBAAiB;AAClC,QAAI,KAAK,UAAU;AACjB,WAAK,eAAe;AACpB;AAAA,IACF;AAEA,QAAI;AACF,WAAK,eAAe,UAAU,SAAS,cAAc,wBAAwB;AAAA,IAC/E,SAAS,OAAP;AACA,YAAM,IAAI,UAAU,0CAA0C,EAAE,MAAM,CAAC;AAAA,IACzE;AAAA,EACF;AAAA,EAEA,SAAS,OAAgB,SAAsE;AAC7F,QAAI,UAAU;AAAW,aAAO,KAAK;AACrC,WAAO,KAAK,UAAU,SAAS,OAAO,OAAO;AAAA,EAC/C;AACF;AAeO,SAAS,SAEd,YAAe,cAAyD;AACxE,QAAM,YAAY,aAAa,UAAU;AACzC,SAAO,IAAI,kBAAkB,WAAW,YAAY;AACtD;",
+  "names": []
+}

package/dist/validators/string.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/string.ts
+var string_exports = {};
+__export(string_exports, {
+  AnyStringValidator: () => AnyStringValidator,
+  StringValidator: () => StringValidator,
+  string: () => string
+});
+module.exports = __toCommonJS(string_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var AnyStringValidator = class extends import_types.AbstractValidator {
+  validate(value) {
+    (0, import_errors.assertValidation)(typeof value == "string", 'Value is not a "string"');
+    return value;
+  }
+};
+var StringValidator = class extends import_types.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;
+    (0, import_errors.assertSchema)(minLength >= 0, `Constraint "minLength" (${minLength}) must be non-negative`);
+    (0, import_errors.assertSchema)(maxLength >= 0, `Constraint "maxLength" (${maxLength}) must be non-negative`);
+    (0, import_errors.assertSchema)(minLength <= maxLength, `Constraint "minLength" (${minLength}) is greater than "maxLength" (${maxLength})`);
+    this.maxLength = maxLength;
+    this.minLength = minLength;
+    this.pattern = pattern;
+  }
+  validate(value) {
+    (0, import_errors.assertValidation)(typeof value == "string", 'Value is not a "string"');
+    (0, import_errors.assertValidation)(
+      value.length >= this.minLength,
+      `String must have a minimum length of ${this.minLength}`
+    );
+    (0, import_errors.assertValidation)(
+      value.length <= this.maxLength,
+      `String must have a maximum length of ${this.maxLength}`
+    );
+    (0, import_errors.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 = (0, import_types.makeValidatorFactory)(new AnyStringValidator(), _string);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnyStringValidator,
+  StringValidator,
+  string
+});
+//# sourceMappingURL=string.cjs.map

package/dist/validators/string.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/string.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA+C;AAC/C,mBAAwD;AAqBjD,IAAM,qBAAN,cAAiC,+BAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,wCAAiB,OAAO,SAAS,UAAU,yBAAyB;AACpE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAyD,+BAAqB;AAAA,EAC1E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,oCAAa,aAAa,GAAG,2BAA2B,iCAAiC;AACzF,oCAAa,aAAa,GAAG,2BAA2B,iCAAiC;AACzF,oCAAa,aAAa,WAAW,2BAA2B,2CAA2C,YAAY;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,wCAAiB,OAAO,SAAS,UAAU,yBAAyB;AAEpE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK;AAAA,IAAW;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK;AAAA,IAAW;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK;AAAA,IAAS;AAE5D,WAAO;AAAA,EACT;AACF;AAKA,SAAS,QAAQ,aAAmD;AAClE,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,aAAS,mCAAqB,IAAI,mBAAmB,GAAG,OAAO;",
+  "names": []
+}

package/dist/validators/string.d.ts

@@ -0,0 +1,35 @@
+import { AbstractValidator } from '../types';
+import type { Branding } from '../types';
+/** Constraints to validate a `string` with. */
+export interface StringConstraints {
+    /** The _maximum_ length of a valid `string`: `value.length <= maxLength` */
+    maxLength?: number;
+    /** The _minimum_ length of a valid `string`: `value.length >= minLength` */
+    minLength?: number;
+    /** A `RegExp` enforcing a particular pattern for a valid `string`: `pattern.test(value)` */
+    pattern?: RegExp;
+}
+/** Constraints to validate a `string` with extra branding information. */
+export interface BrandedStringConstraints<B extends string> extends StringConstraints {
+    /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+    brand: B;
+}
+/** A `Validator` validating any `string`. */
+export declare class AnyStringValidator extends AbstractValidator<string> {
+    validate(value: unknown): string;
+}
+/** A `Validator` validating `string`s with constraints. */
+export declare class StringValidator<S extends string = string> extends AbstractValidator<S> {
+    readonly maxLength: number;
+    readonly minLength: number;
+    readonly pattern?: RegExp;
+    readonly brand?: string;
+    constructor(constraints?: StringConstraints);
+    validate(value: unknown): S;
+}
+declare function _string(constraints: StringConstraints): StringValidator<string>;
+declare function _string<S extends string>(constraints: StringConstraints): StringValidator<S>;
+declare function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>;
+/** Validate `string`s. */
+export declare const string: typeof _string & AnyStringValidator;
+export {};

package/dist/validators/string.mjs

@@ -0,0 +1,57 @@
+// validators/string.ts
+import { assertSchema, assertValidation } from "../errors.mjs";
+import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
+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);
+export {
+  AnyStringValidator,
+  StringValidator,
+  string
+};
+//# sourceMappingURL=string.mjs.map

package/dist/validators/string.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/string.ts"],
+  "mappings": ";AAAA,SAAS,cAAc,wBAAwB;AAC/C,SAAS,mBAAmB,4BAA4B;AAqBjD,IAAM,qBAAN,cAAiC,kBAA0B;AAAA,EAChE,SAAS,OAAwB;AAC/B,qBAAiB,OAAO,SAAS,UAAU,yBAAyB;AACpE,WAAO;AAAA,EACT;AACF;AAGO,IAAM,kBAAN,cAAyD,kBAAqB;AAAA,EAC1E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,cAAiC,CAAC,GAAG;AAC/C,UAAM;AAEN,UAAM;AAAA,MACJ,YAAY;AAAA,MACZ,YAAY,OAAO;AAAA,MACnB;AAAA,IACF,IAAI;AAEJ,QAAI,WAAW;AAAa,WAAK,QAAe,YAAa;AAE7D,iBAAa,aAAa,GAAG,2BAA2B,iCAAiC;AACzF,iBAAa,aAAa,GAAG,2BAA2B,iCAAiC;AACzF,iBAAa,aAAa,WAAW,2BAA2B,2CAA2C,YAAY;AAEvH,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,SAAS,OAAmB;AAC1B,qBAAiB,OAAO,SAAS,UAAU,yBAAyB;AAEpE;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK;AAAA,IAAW;AAE5D;AAAA,MAAiB,MAAM,UAAU,KAAK;AAAA,MAClC,wCAAwC,KAAK;AAAA,IAAW;AAE5D;AAAA,MAAiB,KAAK,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI;AAAA,MACvD,0CAA0C,KAAK;AAAA,IAAS;AAE5D,WAAO;AAAA,EACT;AACF;AAKA,SAAS,QAAQ,aAAmD;AAClE,SAAO,IAAI,gBAAgB,WAAW;AACxC;AAGO,IAAM,SAAS,qBAAqB,IAAI,mBAAmB,GAAG,OAAO;",
+  "names": []
+}

package/dist/validators/tuple.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/tuple.ts
+var tuple_exports = {};
+__export(tuple_exports, {
+  TupleValidator: () => TupleValidator,
+  tuple: () => tuple
+});
+module.exports = __toCommonJS(tuple_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var import_utilities = require("../utilities.cjs");
+var import_constant = require("./constant.cjs");
+var TupleValidator = class extends import_types.AbstractValidator {
+  members;
+  tuple;
+  constructor(tuple2) {
+    super();
+    const members = [];
+    for (const item of tuple2) {
+      if (item === null) {
+        members.push({ single: true, validator: import_constant.nullValidator });
+      } else if (typeof item === "object" && import_types.restValidator in item) {
+        members.push({ single: false, validator: item[import_types.restValidator] });
+      } else {
+        members.push({ single: true, validator: (0, import_utilities.getValidator)(item) });
+      }
+    }
+    this.members = members;
+    this.tuple = tuple2;
+  }
+  validate(value, options) {
+    (0, import_errors.assertValidation)(Array.isArray(value), 'Value is not an "array"');
+    if (this.members.length === 0) {
+      const size = value.length;
+      (0, import_errors.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 import_errors.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 import_errors.ValidationError("Tuple defines 1 missing validation");
+    } else if (missing > 1) {
+      throw new import_errors.ValidationError(`Tuple defines ${missing} missing validations`);
+    }
+    const extra = value.length - haystack;
+    (0, import_errors.assertValidation)(extra === 0, `Found ${extra} extra element${extra === 1 ? "" : "s"} in tuple`);
+    return clone;
+  }
+};
+function tuple(tuple2) {
+  return new TupleValidator(tuple2);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TupleValidator,
+  tuple
+});
+//# sourceMappingURL=tuple.cjs.map

package/dist/validators/tuple.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/tuple.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAkD;AAClD,mBAAiD;AAEjD,uBAA6B;AAC7B,sBAA8B;AAOvB,IAAM,iBAAN,cAA8C,+BAAiC;AAAA,EAC3E;AAAA,EACA;AAAA,EAET,YAAYA,QAAU;AACpB,UAAM;AAEN,UAAM,UAAyB,CAAC;AAChC,eAAW,QAAQA,QAAO;AACxB,UAAI,SAAS,MAAM;AACjB,gBAAQ,KAAK,EAAE,QAAQ,MAAM,WAAW,8BAAc,CAAC;AAAA,MACzD,WAAY,OAAO,SAAS,YAAc,8BAAiB,MAAO;AAChE,gBAAQ,KAAK,EAAE,QAAQ,OAAO,WAAiB,KAAM,0BAAa,EAAE,CAAC;AAAA,MACvE,OAAO;AACL,gBAAQ,KAAK,EAAE,QAAQ,MAAM,eAAW,+BAAa,IAAI,EAAE,CAAC;AAAA,MAC9D;AAAA,IACF;AAEA,SAAK,UAAU;AACf,SAAK,QAAQA;AAAA,EACf;AAAA,EAEA,SAAS,OAAgB,SAA4C;AACnE,wCAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAGhE,QAAI,KAAK,QAAQ,WAAW,GAAG;AAC7B,YAAM,OAAO,MAAM;AACnB,0CAAiB,SAAS,GAAG,SAAS,eAAe,SAAS,IAAI,KAAK,4BAA4B;AACnG,aAAO;AAAA,IACT;AAGA,UAAM,QAAQ,IAAI,MAAM,MAAM,MAAM;AACpC,QAAI,SAAS;AACb,QAAI,WAAW;AACf,QAAI,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,MAAM;AAE/C,WAAQ,SAAS,KAAK,QAAQ,UAAY,WAAW,MAAM,QAAS;AAClE,UAAI;AACF,cAAM,QAAQ,IAAI,UAAU,SAAS,MAAM,QAAQ,GAAG,OAAO;AAC7D,YAAI;AAAQ,WAAC,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,EAAG,MAAM,KAAK,CAAC;AACjE;AAAA,MACF,SAAS,OAAP;AACA,YAAI;AAAQ,gBAAM,IAAI,8BAAgB,OAAO,CAAE,QAAS,CAAC;AAAA;AACpD,WAAC,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,EAAG,MAAM,KAAK,CAAC;AAAA,MAC5D;AAAA,IACF;AAEA,WAAQ,SAAS,KAAK,QAAQ,UAAY,KAAK,QAAQ,MAAM,EAAE,WAAW,OAAQ;AAChF;AAAA,IACF;AAEA,UAAM,UAAU,KAAK,QAAQ,SAAS;AACtC,QAAK,YAAY,KAAM,QAAQ;AAC7B,YAAM,IAAI,8BAAgB,oCAAoC;AAAA,IAChE,WAAW,UAAU,GAAG;AACtB,YAAM,IAAI,8BAAgB,iBAAiB,6BAA6B;AAAA,IAC1E;AAEA,UAAM,QAAQ,MAAM,SAAS;AAC7B,wCAAiB,UAAU,GAAG,SAAS,sBAAsB,UAAU,IAAI,KAAK,cAAc;AAE9F,WAAO;AAAA,EACT;AACF;AAGO,SAAS,MAAuBA,QAAoC;AACzE,SAAO,IAAI,eAAeA,MAAK;AACjC;",
+  "names": ["tuple"]
+}

package/dist/validators/tuple.d.ts

@@ -0,0 +1,15 @@
+import { AbstractValidator } from '../types';
+import type { InferTuple, Tuple, ValidationOptions, Validator } from '../types';
+export interface TupleMember {
+    single: boolean;
+    validator: Validator;
+}
+/** A `Validator` for _tuples_. */
+export declare class TupleValidator<T extends Tuple> extends AbstractValidator<InferTuple<T>> {
+    readonly members: readonly TupleMember[];
+    readonly tuple: T;
+    constructor(tuple: T);
+    validate(value: unknown, options?: ValidationOptions): InferTuple<T>;
+}
+/** Validate _tuples_. */
+export declare function tuple<T extends Tuple>(tuple: T): Validator<InferTuple<T>>;

package/dist/validators/tuple.mjs

@@ -0,0 +1,69 @@
+// validators/tuple.ts
+import { assertValidation, ValidationError } from "../errors.mjs";
+import { AbstractValidator, restValidator } from "../types.mjs";
+import { getValidator } from "../utilities.mjs";
+import { nullValidator } from "./constant.mjs";
+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);
+}
+export {
+  TupleValidator,
+  tuple
+};
+//# sourceMappingURL=tuple.mjs.map

package/dist/validators/tuple.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/tuple.ts"],
+  "mappings": ";AAAA,SAAS,kBAAkB,uBAAuB;AAClD,SAAS,mBAAmB,qBAAqB;AAEjD,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAOvB,IAAM,iBAAN,cAA8C,kBAAiC;AAAA,EAC3E;AAAA,EACA;AAAA,EAET,YAAYA,QAAU;AACpB,UAAM;AAEN,UAAM,UAAyB,CAAC;AAChC,eAAW,QAAQA,QAAO;AACxB,UAAI,SAAS,MAAM;AACjB,gBAAQ,KAAK,EAAE,QAAQ,MAAM,WAAW,cAAc,CAAC;AAAA,MACzD,WAAY,OAAO,SAAS,YAAc,iBAAiB,MAAO;AAChE,gBAAQ,KAAK,EAAE,QAAQ,OAAO,WAAiB,KAAM,aAAa,EAAE,CAAC;AAAA,MACvE,OAAO;AACL,gBAAQ,KAAK,EAAE,QAAQ,MAAM,WAAW,aAAa,IAAI,EAAE,CAAC;AAAA,MAC9D;AAAA,IACF;AAEA,SAAK,UAAU;AACf,SAAK,QAAQA;AAAA,EACf;AAAA,EAEA,SAAS,OAAgB,SAA4C;AACnE,qBAAiB,MAAM,QAAQ,KAAK,GAAG,yBAAyB;AAGhE,QAAI,KAAK,QAAQ,WAAW,GAAG;AAC7B,YAAM,OAAO,MAAM;AACnB,uBAAiB,SAAS,GAAG,SAAS,eAAe,SAAS,IAAI,KAAK,4BAA4B;AACnG,aAAO;AAAA,IACT;AAGA,UAAM,QAAQ,IAAI,MAAM,MAAM,MAAM;AACpC,QAAI,SAAS;AACb,QAAI,WAAW;AACf,QAAI,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,MAAM;AAE/C,WAAQ,SAAS,KAAK,QAAQ,UAAY,WAAW,MAAM,QAAS;AAClE,UAAI;AACF,cAAM,QAAQ,IAAI,UAAU,SAAS,MAAM,QAAQ,GAAG,OAAO;AAC7D,YAAI;AAAQ,WAAC,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,EAAG,MAAM,KAAK,CAAC;AACjE;AAAA,MACF,SAAS,OAAP;AACA,YAAI;AAAQ,gBAAM,IAAI,gBAAgB,OAAO,CAAE,QAAS,CAAC;AAAA;AACpD,WAAC,EAAE,QAAQ,UAAU,IAAI,KAAK,QAAQ,EAAG,MAAM,KAAK,CAAC;AAAA,MAC5D;AAAA,IACF;AAEA,WAAQ,SAAS,KAAK,QAAQ,UAAY,KAAK,QAAQ,MAAM,EAAE,WAAW,OAAQ;AAChF;AAAA,IACF;AAEA,UAAM,UAAU,KAAK,QAAQ,SAAS;AACtC,QAAK,YAAY,KAAM,QAAQ;AAC7B,YAAM,IAAI,gBAAgB,oCAAoC;AAAA,IAChE,WAAW,UAAU,GAAG;AACtB,YAAM,IAAI,gBAAgB,iBAAiB,6BAA6B;AAAA,IAC1E;AAEA,UAAM,QAAQ,MAAM,SAAS;AAC7B,qBAAiB,UAAU,GAAG,SAAS,sBAAsB,UAAU,IAAI,KAAK,cAAc;AAE9F,WAAO;AAAA,EACT;AACF;AAGO,SAAS,MAAuBA,QAAoC;AACzE,SAAO,IAAI,eAAeA,MAAK;AACjC;",
+  "names": ["tuple"]
+}