@ibodr/validate 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1112 @@
+import { validateIndexKey, registerDrawLibraryVersion, exhaustiveSwitchError, hasOwnProperty, getOwnProperty, STRUCTURED_CLONE_OBJECT_PROTOTYPE } from '@ibodr/utils';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  ArrayOfValidator: () => ArrayOfValidator,
+  DictValidator: () => DictValidator,
+  ObjectValidator: () => ObjectValidator,
+  UnionValidator: () => UnionValidator,
+  ValidationError: () => ValidationError,
+  Validator: () => Validator,
+  any: () => any,
+  array: () => array,
+  arrayOf: () => arrayOf,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  dict: () => dict,
+  httpUrl: () => httpUrl,
+  indexKey: () => indexKey,
+  integer: () => integer,
+  jsonDict: () => jsonDict,
+  jsonValue: () => jsonValue,
+  linkUrl: () => linkUrl,
+  literal: () => literal,
+  literalEnum: () => literalEnum,
+  model: () => model,
+  nonZeroFiniteNumber: () => nonZeroFiniteNumber,
+  nonZeroInteger: () => nonZeroInteger,
+  nonZeroNumber: () => nonZeroNumber,
+  nullable: () => nullable,
+  number: () => number,
+  numberUnion: () => numberUnion,
+  object: () => object,
+  optional: () => optional,
+  or: () => or,
+  positiveInteger: () => positiveInteger,
+  positiveNumber: () => positiveNumber,
+  setEnum: () => setEnum,
+  srcUrl: () => srcUrl,
+  string: () => string,
+  union: () => union,
+  unitInterval: () => unitInterval,
+  unknown: () => unknown,
+  unknownObject: () => unknownObject
+});
+function formatPath(path) {
+  if (!path.length) {
+    return null;
+  }
+  let formattedPath = "";
+  for (const item of path) {
+    if (typeof item === "number") {
+      formattedPath += `.${item}`;
+    } else if (item.startsWith("(")) {
+      if (formattedPath.endsWith(")")) {
+        formattedPath = `${formattedPath.slice(0, -1)}, ${item.slice(1)}`;
+      } else {
+        formattedPath += item;
+      }
+    } else {
+      formattedPath += `.${item}`;
+    }
+  }
+  formattedPath = formattedPath.replace(/id = [^,]+, /, "").replace(/id = [^)]+/, "");
+  if (formattedPath.startsWith(".")) {
+    return formattedPath.slice(1);
+  }
+  return formattedPath;
+}
+var ValidationError = class extends Error {
+  /**
+   * Creates a new ValidationError with contextual information about where the error occurred.
+   *
+   * rawMessage - The raw error message without path information
+   * path - Array indicating the location in the data structure where validation failed
+   */
+  constructor(rawMessage, path = []) {
+    const formattedPath = formatPath(path);
+    const indentedMessage = rawMessage.split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n");
+    super(path ? `At ${formattedPath}: ${indentedMessage}` : indentedMessage);
+    this.rawMessage = rawMessage;
+    this.path = path;
+  }
+  rawMessage;
+  path;
+  name = "ValidationError";
+};
+function prefixError(path, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      throw new ValidationError(err.rawMessage, [path, ...err.path]);
+    }
+    throw new ValidationError(err.toString(), [path]);
+  }
+}
+function typeToString(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  const type = typeof value;
+  switch (type) {
+    case "bigint":
+    case "boolean":
+    case "function":
+    case "number":
+    case "string":
+    case "symbol":
+      return `a ${type}`;
+    case "object":
+      return `an ${type}`;
+    case "undefined":
+      return "undefined";
+    default:
+      exhaustiveSwitchError(type);
+  }
+}
+var Validator = class _Validator {
+  /**
+   * Creates a new Validator instance.
+   *
+   * validationFn - Function that validates and returns a value of type T
+   * validateUsingKnownGoodVersionFn - Optional performance-optimized validation function
+   * skipSameValueCheck - Internal flag to skip dev check for validators that transform values
+   */
+  constructor(validationFn, validateUsingKnownGoodVersionFn, skipSameValueCheck = false) {
+    this.validationFn = validationFn;
+    this.validateUsingKnownGoodVersionFn = validateUsingKnownGoodVersionFn;
+    this.skipSameValueCheck = skipSameValueCheck;
+  }
+  validationFn;
+  validateUsingKnownGoodVersionFn;
+  skipSameValueCheck;
+  /**
+   * Validates an unknown value and returns it with the correct type. The returned value is
+   * guaranteed to be referentially equal to the passed value.
+   *
+   * @param value - The unknown value to validate
+   * @returns The validated value with type T
+   * @throws ValidationError When validation fails
+   * @example
+   * ```ts
+   * import { T } from '@ibodr/validate'
+   *
+   * const name = T.string.validate("Alice") // Returns "Alice" as string
+   * const title = T.string.validate("") // Returns "" (empty strings are valid)
+   *
+   * // These will throw ValidationError:
+   * T.string.validate(123) // Expected string, got a number
+   * T.string.validate(null) // Expected string, got null
+   * T.string.validate(undefined) // Expected string, got undefined
+   * ```
+   */
+  validate(value) {
+    const validated = this.validationFn(value);
+    if (!this.skipSameValueCheck && !Object.is(value, validated)) {
+      throw new ValidationError("Validator functions must return the same value they were passed");
+    }
+    return validated;
+  }
+  /**
+   * Performance-optimized validation using a previously validated value. If the new value
+   * is referentially equal to the known good value, returns the known good value immediately.
+   *
+   * @param knownGoodValue - A previously validated value
+   * @param newValue - The new value to validate
+   * @returns The validated value, potentially reusing the known good value
+   * @throws ValidationError When validation fails
+   * @example
+   * ```ts
+   * import { T } from '@ibodr/validate'
+   *
+   * const userValidator = T.object({
+   *   name: T.string,
+   *   settings: T.object({ theme: T.literalEnum('light', 'dark') })
+   * })
+   *
+   * const user = userValidator.validate({ name: "Alice", settings: { theme: "light" } })
+   *
+   * // Later, with partially changed data:
+   * const newData = { name: "Alice", settings: { theme: "dark" } }
+   * const updated = userValidator.validateUsingKnownGoodVersion(user, newData)
+   * // Only validates the changed 'theme' field for better performance
+   * ```
+   */
+  validateUsingKnownGoodVersion(knownGoodValue, newValue) {
+    if (Object.is(knownGoodValue, newValue)) {
+      return knownGoodValue;
+    }
+    if (this.validateUsingKnownGoodVersionFn) {
+      return this.validateUsingKnownGoodVersionFn(knownGoodValue, newValue);
+    }
+    return this.validate(newValue);
+  }
+  /**
+   * Type guard that checks if a value is valid without throwing an error.
+   *
+   * @param value - The value to check
+   * @returns True if the value is valid, false otherwise
+   * @example
+   * ```ts
+   * import { T } from '@ibodr/validate'
+   *
+   * function processUserInput(input: unknown) {
+   *   if (T.string.isValid(input)) {
+   *     // input is now typed as string within this block
+   *     return input.toUpperCase()
+   *   }
+   *   if (T.number.isValid(input)) {
+   *     // input is now typed as number within this block
+   *     return input.toFixed(2)
+   *   }
+   *   throw new Error('Expected string or number')
+   * }
+   * ```
+   */
+  isValid(value) {
+    try {
+      this.validate(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Returns a new validator that also accepts null values.
+   *
+   * @returns A new validator that accepts T or null
+   * @example
+   * ```ts
+   * import { T } from '@ibodr/validate'
+   *
+   * const assetValidator = T.object({
+   *   id: T.string,
+   *   name: T.string,
+   *   src: T.srcUrl.nullable(), // Can be null if not loaded yet
+   *   mimeType: T.string.nullable()
+   * })
+   *
+   * const asset = assetValidator.validate({
+   *   id: "image-123",
+   *   name: "photo.jpg",
+   *   src: null, // Valid - asset not loaded yet
+   *   mimeType: "image/jpeg"
+   * })
+   * ```
+   */
+  nullable() {
+    return nullable(this);
+  }
+  /**
+   * Returns a new validator that also accepts undefined values.
+   *
+   * @returns A new validator that accepts T or undefined
+   * @example
+   * ```ts
+   * import { T } from '@ibodr/validate'
+   *
+   * const shapeConfigValidator = T.object({
+   *   type: T.literal('rectangle'),
+   *   x: T.number,
+   *   y: T.number,
+   *   label: T.string.optional(), // Optional property
+   *   metadata: T.object({ created: T.string }).optional()
+   * })
+   *
+   * // Both of these are valid:
+   * const shape1 = shapeConfigValidator.validate({ type: 'rectangle', x: 0, y: 0 })
+   * const shape2 = shapeConfigValidator.validate({
+   *   type: 'rectangle', x: 0, y: 0, label: "My Shape"
+   * })
+   * ```
+   */
+  optional() {
+    return optional(this);
+  }
+  /**
+   * Creates a new validator by refining this validator with additional logic that can transform
+   * the validated value to a new type.
+   *
+   * @param otherValidationFn - Function that transforms/validates the value to type U
+   * @returns A new validator that validates to type U
+   * @throws ValidationError When validation or refinement fails
+   * @example
+   * ```ts
+   * import { T, ValidationError } from '@ibodr/validate'
+   *
+   * // Transform string to ensure it starts with a prefix
+   * const prefixedIdValidator = T.string.refine((id) => {
+   *   return id.startsWith('shape:') ? id : `shape:${id}`
+   * })
+   *
+   * const id1 = prefixedIdValidator.validate("rectangle-123") // Returns "shape:rectangle-123"
+   * const id2 = prefixedIdValidator.validate("shape:circle-456") // Returns "shape:circle-456"
+   *
+   * // Parse and validate JSON strings
+   * const jsonValidator = T.string.refine((str) => {
+   *   try {
+   *     return JSON.parse(str)
+   *   } catch {
+   *     throw new ValidationError('Invalid JSON string')
+   *   }
+   * })
+   * ```
+   */
+  refine(otherValidationFn) {
+    return new _Validator(
+      (value) => {
+        return otherValidationFn(this.validate(value));
+      },
+      (knownGoodValue, newValue) => {
+        const validated = this.validateUsingKnownGoodVersion(knownGoodValue, newValue);
+        if (Object.is(knownGoodValue, validated)) {
+          return knownGoodValue;
+        }
+        return otherValidationFn(validated);
+      },
+      true
+      // skipSameValueCheck: refine is designed to transform values
+    );
+  }
+  check(nameOrCheckFn, checkFn) {
+    if (typeof nameOrCheckFn === "string") {
+      return this.refine((value) => {
+        prefixError(`(check ${nameOrCheckFn})`, () => checkFn(value));
+        return value;
+      });
+    } else {
+      return this.refine((value) => {
+        nameOrCheckFn(value);
+        return value;
+      });
+    }
+  }
+};
+var ArrayOfValidator = class extends Validator {
+  /**
+   * Creates a new ArrayOfValidator.
+   *
+   * itemValidator - Validator used to validate each array element
+   */
+  constructor(itemValidator) {
+    super(
+      (value) => {
+        const arr = array.validate(value);
+        for (let i = 0; i < arr.length; i++) {
+          {
+            prefixError(i, () => itemValidator.validate(arr[i]));
+          }
+        }
+        return arr;
+      },
+      (knownGoodValue, newValue) => {
+        if (Object.is(knownGoodValue, newValue)) {
+          return knownGoodValue;
+        }
+        if (!itemValidator.validateUsingKnownGoodVersion) return this.validate(newValue);
+        const arr = array.validate(newValue);
+        let isDifferent = knownGoodValue.length !== arr.length;
+        for (let i = 0; i < arr.length; i++) {
+          const item = arr[i];
+          if (i >= knownGoodValue.length) {
+            isDifferent = true;
+            {
+              prefixError(i, () => itemValidator.validate(item));
+            }
+            continue;
+          }
+          if (Object.is(knownGoodValue[i], item)) {
+            continue;
+          }
+          {
+            const checkedItem = prefixError(
+              i,
+              () => itemValidator.validateUsingKnownGoodVersion(knownGoodValue[i], item)
+            );
+            if (!Object.is(checkedItem, knownGoodValue[i])) {
+              isDifferent = true;
+            }
+          }
+        }
+        return isDifferent ? newValue : knownGoodValue;
+      }
+    );
+    this.itemValidator = itemValidator;
+  }
+  itemValidator;
+  /**
+   * Returns a new validator that ensures the array is not empty.
+   *
+   * @returns A new validator that rejects empty arrays
+   * @throws ValidationError When the array is empty
+   * @example
+   * ```ts
+   * const nonEmptyStrings = T.arrayOf(T.string).nonEmpty()
+   * nonEmptyStrings.validate(["hello"]) // Valid
+   * nonEmptyStrings.validate([]) // Throws ValidationError
+   * ```
+   */
+  nonEmpty() {
+    return this.check((value) => {
+      if (value.length === 0) {
+        throw new ValidationError("Expected a non-empty array");
+      }
+    });
+  }
+  /**
+   * Returns a new validator that ensures the array has more than one element.
+   *
+   * @returns A new validator that requires at least 2 elements
+   * @throws ValidationError When the array has 1 or fewer elements
+   * @example
+   * ```ts
+   * const multipleItems = T.arrayOf(T.string).lengthGreaterThan1()
+   * multipleItems.validate(["a", "b"]) // Valid
+   * multipleItems.validate(["a"]) // Throws ValidationError
+   * ```
+   */
+  lengthGreaterThan1() {
+    return this.check((value) => {
+      if (value.length <= 1) {
+        throw new ValidationError("Expected an array with length greater than 1");
+      }
+    });
+  }
+};
+var ObjectValidator = class _ObjectValidator extends Validator {
+  /**
+   * Creates a new ObjectValidator.
+   *
+   * config - Object mapping property names to their validators
+   * shouldAllowUnknownProperties - Whether to allow properties not defined in config
+   */
+  constructor(config, shouldAllowUnknownProperties = false) {
+    super(
+      (object2) => {
+        if (typeof object2 !== "object" || object2 === null) {
+          throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
+        }
+        for (const key in config) {
+          if (!hasOwnProperty(config, key)) continue;
+          const validator = config[key];
+          {
+            prefixError(key, () => {
+              ;
+              validator.validate(getOwnProperty(object2, key));
+            });
+          }
+        }
+        if (!shouldAllowUnknownProperties) {
+          for (const key of Object.keys(object2)) {
+            if (!hasOwnProperty(config, key)) {
+              throw new ValidationError(`Unexpected property`, [key]);
+            }
+          }
+        }
+        return object2;
+      },
+      (knownGoodValue, newValue) => {
+        if (Object.is(knownGoodValue, newValue)) {
+          return knownGoodValue;
+        }
+        if (typeof newValue !== "object" || newValue === null) {
+          throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
+        }
+        let isDifferent = false;
+        for (const key in config) {
+          if (!hasOwnProperty(config, key)) continue;
+          const validator = config[key];
+          const prev = getOwnProperty(knownGoodValue, key);
+          const next = getOwnProperty(newValue, key);
+          if (Object.is(prev, next)) {
+            continue;
+          }
+          {
+            const checked = prefixError(key, () => {
+              const validatable = validator;
+              if (validatable.validateUsingKnownGoodVersion) {
+                return validatable.validateUsingKnownGoodVersion(prev, next);
+              } else {
+                return validatable.validate(next);
+              }
+            });
+            if (!Object.is(checked, prev)) {
+              isDifferent = true;
+            }
+          }
+        }
+        if (!shouldAllowUnknownProperties) {
+          for (const key of Object.keys(newValue)) {
+            if (!hasOwnProperty(config, key)) {
+              throw new ValidationError(`Unexpected property`, [key]);
+            }
+          }
+        }
+        for (const key of Object.keys(knownGoodValue)) {
+          if (!hasOwnProperty(newValue, key)) {
+            isDifferent = true;
+            break;
+          }
+        }
+        return isDifferent ? newValue : knownGoodValue;
+      }
+    );
+    this.config = config;
+    this.shouldAllowUnknownProperties = shouldAllowUnknownProperties;
+  }
+  config;
+  shouldAllowUnknownProperties;
+  /**
+   * Returns a new validator that allows unknown properties in the validated object.
+   *
+   * @returns A new ObjectValidator that accepts extra properties
+   * @example
+   * ```ts
+   * const flexibleUser = T.object({ name: T.string }).allowUnknownProperties()
+   * flexibleUser.validate({ name: "Alice", extra: "allowed" }) // Valid
+   * ```
+   */
+  allowUnknownProperties() {
+    return new _ObjectValidator(this.config, true);
+  }
+  /**
+   * Creates a new ObjectValidator by extending this validator with additional properties.
+   *
+   * @param extension - Object mapping new property names to their validators
+   * @returns A new ObjectValidator that validates both original and extended properties
+   * @example
+   * ```ts
+   * const baseUser = T.object({ name: T.string, age: T.number })
+   * const adminUser = baseUser.extend({
+   *   permissions: T.arrayOf(T.string),
+   *   isAdmin: T.boolean
+   * })
+   * // adminUser validates: { name: string; age: number; permissions: string[]; isAdmin: boolean }
+   * ```
+   */
+  extend(extension) {
+    return new _ObjectValidator({ ...this.config, ...extension });
+  }
+};
+var UnionValidator = class _UnionValidator extends Validator {
+  /**
+   * Creates a new UnionValidator.
+   *
+   * key - The discriminator property name used to determine the variant
+   * config - Object mapping variant names to their validators
+   * unknownValueValidation - Function to handle unknown variants
+   * useNumberKeys - Whether the discriminator uses number keys instead of strings
+   */
+  constructor(key, config, unknownValueValidation, useNumberKeys) {
+    super(
+      (input) => {
+        this.expectObject(input);
+        const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(input);
+        if (matchingSchema === void 0) {
+          return this.unknownValueValidation(input, variant);
+        }
+        return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(input));
+      },
+      (prevValue, newValue) => {
+        this.expectObject(newValue);
+        this.expectObject(prevValue);
+        const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(newValue);
+        if (matchingSchema === void 0) {
+          return this.unknownValueValidation(newValue, variant);
+        }
+        if (getOwnProperty(prevValue, key) !== getOwnProperty(newValue, key)) {
+          return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(newValue));
+        }
+        return prefixError(`(${key} = ${variant})`, () => {
+          if (matchingSchema.validateUsingKnownGoodVersion) {
+            return matchingSchema.validateUsingKnownGoodVersion(prevValue, newValue);
+          } else {
+            return matchingSchema.validate(newValue);
+          }
+        });
+      }
+    );
+    this.key = key;
+    this.config = config;
+    this.unknownValueValidation = unknownValueValidation;
+    this.useNumberKeys = useNumberKeys;
+  }
+  key;
+  config;
+  unknownValueValidation;
+  useNumberKeys;
+  expectObject(value) {
+    if (typeof value !== "object" || value === null) {
+      throw new ValidationError(`Expected an object, got ${typeToString(value)}`, []);
+    }
+  }
+  getMatchingSchemaAndVariant(object2) {
+    const variant = getOwnProperty(object2, this.key);
+    if (!this.useNumberKeys && typeof variant !== "string") {
+      throw new ValidationError(
+        `Expected a string for key "${this.key}", got ${typeToString(variant)}`
+      );
+    } else if (this.useNumberKeys) {
+      const numVariant = Number(variant);
+      if (numVariant - numVariant !== 0) {
+        throw new ValidationError(
+          `Expected a number for key "${this.key}", got "${variant}"`
+        );
+      }
+    }
+    const matchingSchema = hasOwnProperty(this.config, variant) ? this.config[variant] : void 0;
+    return { matchingSchema, variant };
+  }
+  /**
+   * Returns a new UnionValidator that can handle unknown variants using the provided function.
+   *
+   * @param unknownValueValidation - Function to validate/transform unknown variants
+   * @returns A new UnionValidator that accepts unknown variants
+   * @example
+   * ```ts
+   * const shapeValidator = T.union('type', { circle: circleValidator })
+   *   .validateUnknownVariants((obj, variant) => {
+   *     console.warn(`Unknown shape type: ${variant}`)
+   *     return obj as UnknownShape
+   *   })
+   * ```
+   */
+  validateUnknownVariants(unknownValueValidation) {
+    return new _UnionValidator(this.key, this.config, unknownValueValidation, this.useNumberKeys);
+  }
+};
+var DictValidator = class extends Validator {
+  /**
+   * Creates a new DictValidator.
+   *
+   * keyValidator - Validator for object keys
+   * valueValidator - Validator for object values
+   */
+  constructor(keyValidator, valueValidator) {
+    super(
+      (object2) => {
+        if (typeof object2 !== "object" || object2 === null) {
+          throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
+        }
+        for (const key in object2) {
+          if (!hasOwnProperty(object2, key)) continue;
+          {
+            prefixError(key, () => {
+              keyValidator.validate(key);
+              valueValidator.validate(object2[key]);
+            });
+          }
+        }
+        return object2;
+      },
+      (knownGoodValue, newValue) => {
+        if (typeof newValue !== "object" || newValue === null) {
+          throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
+        }
+        const newObj = newValue;
+        let isDifferent = false;
+        let newKeyCount = 0;
+        for (const key in newObj) {
+          if (!hasOwnProperty(newObj, key)) continue;
+          newKeyCount++;
+          const next = newObj[key];
+          if (!hasOwnProperty(knownGoodValue, key)) {
+            isDifferent = true;
+            {
+              prefixError(key, () => {
+                keyValidator.validate(key);
+                valueValidator.validate(next);
+              });
+            }
+            continue;
+          }
+          const prev = knownGoodValue[key];
+          if (Object.is(prev, next)) {
+            continue;
+          }
+          {
+            const checked = prefixError(key, () => {
+              if (valueValidator.validateUsingKnownGoodVersion) {
+                return valueValidator.validateUsingKnownGoodVersion(prev, next);
+              } else {
+                return valueValidator.validate(next);
+              }
+            });
+            if (!Object.is(checked, prev)) {
+              isDifferent = true;
+            }
+          }
+        }
+        if (!isDifferent) {
+          let oldKeyCount = 0;
+          for (const key in knownGoodValue) {
+            if (hasOwnProperty(knownGoodValue, key)) {
+              oldKeyCount++;
+            }
+          }
+          if (oldKeyCount !== newKeyCount) {
+            isDifferent = true;
+          }
+        }
+        return isDifferent ? newValue : knownGoodValue;
+      }
+    );
+    this.keyValidator = keyValidator;
+    this.valueValidator = valueValidator;
+  }
+  keyValidator;
+  valueValidator;
+};
+function typeofValidator(type) {
+  return new Validator((value) => {
+    if (typeof value !== type) {
+      throw new ValidationError(`Expected ${type}, got ${typeToString(value)}`);
+    }
+    return value;
+  });
+}
+var unknown = new Validator((value) => value);
+var any = new Validator((value) => value);
+var string = typeofValidator("string");
+var number = new Validator((value) => {
+  if (Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  throw new ValidationError(`Expected a finite number, got ${value}`);
+});
+var positiveNumber = new Validator((value) => {
+  if (Number.isFinite(value) && value >= 0) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value < 0) {
+    throw new ValidationError(`Expected a positive number, got ${value}`);
+  }
+  throw new ValidationError(`Expected a finite number, got ${value}`);
+});
+var nonZeroNumber = new Validator((value) => {
+  if (Number.isFinite(value) && value > 0) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value <= 0) {
+    throw new ValidationError(`Expected a non-zero positive number, got ${value}`);
+  }
+  throw new ValidationError(`Expected a finite number, got ${value}`);
+});
+var nonZeroFiniteNumber = new Validator((value) => {
+  if (Number.isFinite(value) && value !== 0) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value === 0) {
+    throw new ValidationError(`Expected a non-zero number, got 0`);
+  }
+  throw new ValidationError(`Expected a finite number, got ${value}`);
+});
+var unitInterval = new Validator((value) => {
+  if (Number.isFinite(value) && value >= 0 && value <= 1) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  throw new ValidationError(`Expected a number between 0 and 1, got ${value}`);
+});
+var integer = new Validator((value) => {
+  if (Number.isInteger(value)) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value - value !== 0) {
+    throw new ValidationError(`Expected a finite number, got ${value}`);
+  }
+  throw new ValidationError(`Expected an integer, got ${value}`);
+});
+var positiveInteger = new Validator((value) => {
+  if (Number.isInteger(value) && value >= 0) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value - value !== 0) {
+    throw new ValidationError(`Expected a finite number, got ${value}`);
+  }
+  if (value < 0) {
+    throw new ValidationError(`Expected a positive integer, got ${value}`);
+  }
+  throw new ValidationError(`Expected an integer, got ${value}`);
+});
+var nonZeroInteger = new Validator((value) => {
+  if (Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value !== "number") {
+    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
+  }
+  if (value !== value) {
+    throw new ValidationError("Expected a number, got NaN");
+  }
+  if (value - value !== 0) {
+    throw new ValidationError(`Expected a finite number, got ${value}`);
+  }
+  if (value <= 0) {
+    throw new ValidationError(`Expected a non-zero positive integer, got ${value}`);
+  }
+  throw new ValidationError(`Expected an integer, got ${value}`);
+});
+var boolean = typeofValidator("boolean");
+var bigint = typeofValidator("bigint");
+function literal(expectedValue) {
+  return new Validator((actualValue) => {
+    if (actualValue !== expectedValue) {
+      throw new ValidationError(`Expected ${expectedValue}, got ${JSON.stringify(actualValue)}`);
+    }
+    return expectedValue;
+  });
+}
+var array = new Validator((value) => {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(`Expected an array, got ${typeToString(value)}`);
+  }
+  return value;
+});
+function arrayOf(itemValidator) {
+  return new ArrayOfValidator(itemValidator);
+}
+var unknownObject = new Validator((value) => {
+  if (typeof value !== "object" || value === null) {
+    throw new ValidationError(`Expected object, got ${typeToString(value)}`);
+  }
+  return value;
+});
+function object(config) {
+  return new ObjectValidator(config);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === STRUCTURED_CLONE_OBJECT_PROTOTYPE);
+}
+function isValidJson(value) {
+  if (value === null || typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isValidJson);
+  }
+  if (isPlainObject(value)) {
+    return Object.values(value).every(isValidJson);
+  }
+  return false;
+}
+var jsonValue = new Validator(
+  (value) => {
+    if (isValidJson(value)) {
+      return value;
+    }
+    throw new ValidationError(`Expected json serializable value, got ${typeof value}`);
+  },
+  (knownGoodValue, newValue) => {
+    if (Array.isArray(knownGoodValue) && Array.isArray(newValue)) {
+      let isDifferent = knownGoodValue.length !== newValue.length;
+      for (let i = 0; i < newValue.length; i++) {
+        if (i >= knownGoodValue.length) {
+          isDifferent = true;
+          jsonValue.validate(newValue[i]);
+          continue;
+        }
+        const prev = knownGoodValue[i];
+        const next = newValue[i];
+        if (Object.is(prev, next)) {
+          continue;
+        }
+        const checked = jsonValue.validateUsingKnownGoodVersion(prev, next);
+        if (!Object.is(checked, prev)) {
+          isDifferent = true;
+        }
+      }
+      return isDifferent ? newValue : knownGoodValue;
+    } else if (isPlainObject(knownGoodValue) && isPlainObject(newValue)) {
+      let isDifferent = false;
+      for (const key of Object.keys(newValue)) {
+        if (!hasOwnProperty(knownGoodValue, key)) {
+          isDifferent = true;
+          jsonValue.validate(newValue[key]);
+          continue;
+        }
+        const prev = knownGoodValue[key];
+        const next = newValue[key];
+        if (Object.is(prev, next)) {
+          continue;
+        }
+        const checked = jsonValue.validateUsingKnownGoodVersion(prev, next);
+        if (!Object.is(checked, prev)) {
+          isDifferent = true;
+        }
+      }
+      for (const key of Object.keys(knownGoodValue)) {
+        if (!hasOwnProperty(newValue, key)) {
+          isDifferent = true;
+          break;
+        }
+      }
+      return isDifferent ? newValue : knownGoodValue;
+    } else {
+      return jsonValue.validate(newValue);
+    }
+  }
+);
+function jsonDict() {
+  return dict(string, jsonValue);
+}
+function dict(keyValidator, valueValidator) {
+  return new DictValidator(keyValidator, valueValidator);
+}
+function union(key, config) {
+  return new UnionValidator(
+    key,
+    config,
+    (_unknownValue, unknownVariant) => {
+      throw new ValidationError(
+        `Expected one of ${Object.keys(config).map((key2) => JSON.stringify(key2)).join(" or ")}, got ${JSON.stringify(unknownVariant)}`,
+        [key]
+      );
+    },
+    false
+  );
+}
+function numberUnion(key, config) {
+  return new UnionValidator(
+    key,
+    config,
+    (unknownValue, unknownVariant) => {
+      throw new ValidationError(
+        `Expected one of ${Object.keys(config).map((key2) => JSON.stringify(key2)).join(" or ")}, got ${JSON.stringify(unknownVariant)}`,
+        [key]
+      );
+    },
+    true
+  );
+}
+function model(name, validator) {
+  return new Validator(
+    (value) => {
+      return prefixError(name, () => validator.validate(value));
+    },
+    (prevValue, newValue) => {
+      return prefixError(name, () => {
+        if (validator.validateUsingKnownGoodVersion) {
+          return validator.validateUsingKnownGoodVersion(prevValue, newValue);
+        } else {
+          return validator.validate(newValue);
+        }
+      });
+    }
+  );
+}
+function setEnum(values) {
+  return new Validator((value) => {
+    if (!values.has(value)) {
+      const valuesString = Array.from(values, (value2) => JSON.stringify(value2)).join(" or ");
+      throw new ValidationError(`Expected ${valuesString}, got ${value}`);
+    }
+    return value;
+  });
+}
+function optional(validator) {
+  return new Validator(
+    (value) => {
+      if (value === void 0) return void 0;
+      return validator.validate(value);
+    },
+    (knownGoodValue, newValue) => {
+      if (newValue === void 0) return void 0;
+      if (validator.validateUsingKnownGoodVersion && knownGoodValue !== void 0) {
+        return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
+      }
+      return validator.validate(newValue);
+    },
+    // Propagate skipSameValueCheck from inner validator to allow refine wrappers
+    validator instanceof Validator && validator.skipSameValueCheck
+  );
+}
+function nullable(validator) {
+  return new Validator(
+    (value) => {
+      if (value === null) return null;
+      return validator.validate(value);
+    },
+    (knownGoodValue, newValue) => {
+      if (newValue === null) return null;
+      if (validator.validateUsingKnownGoodVersion && knownGoodValue !== null) {
+        return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
+      }
+      return validator.validate(newValue);
+    },
+    // Propagate skipSameValueCheck from inner validator to allow refine wrappers
+    validator instanceof Validator && validator.skipSameValueCheck
+  );
+}
+function literalEnum(...values) {
+  return setEnum(new Set(values));
+}
+function parseUrl(str) {
+  try {
+    return new URL(str);
+  } catch {
+    if (str.startsWith("/") || str.startsWith("./")) {
+      try {
+        return new URL(str, "http://example.com");
+      } catch {
+        throw new ValidationError(`Expected a valid url, got ${JSON.stringify(str)}`);
+      }
+    }
+    throw new ValidationError(`Expected a valid url, got ${JSON.stringify(str)}`);
+  }
+}
+var validLinkProtocols = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
+var linkUrl = string.check((value) => {
+  if (value === "") return;
+  const url = parseUrl(value);
+  if (!validLinkProtocols.has(url.protocol.toLowerCase())) {
+    throw new ValidationError(
+      `Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`
+    );
+  }
+});
+var validSrcProtocols = /* @__PURE__ */ new Set(["http:", "https:", "data:", "asset:"]);
+var srcUrl = string.check((value) => {
+  if (value === "") return;
+  const url = parseUrl(value);
+  if (!validSrcProtocols.has(url.protocol.toLowerCase())) {
+    throw new ValidationError(
+      `Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`
+    );
+  }
+});
+var httpUrl = string.check((value) => {
+  if (value === "") return;
+  const url = parseUrl(value);
+  if (!url.protocol.toLowerCase().match(/^https?:$/)) {
+    throw new ValidationError(
+      `Expected a valid url, got ${JSON.stringify(value)} (invalid protocol)`
+    );
+  }
+});
+var indexKey = string.refine((key) => {
+  try {
+    validateIndexKey(key);
+    return key;
+  } catch {
+    throw new ValidationError(`Expected an index key, got ${JSON.stringify(key)}`);
+  }
+});
+function or(v1, v2) {
+  return new Validator((value) => {
+    try {
+      return v1.validate(value);
+    } catch {
+      return v2.validate(value);
+    }
+  });
+}
+
+// src/index.ts
+registerDrawLibraryVersion(
+  "@ibodr/validate",
+  "0.0.0",
+  "esm"
+);
+
+export { ArrayOfValidator, DictValidator, ObjectValidator, validation_exports as T, UnionValidator, Validator };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map