ascertain 1.2.127 → 2.0.0-rc.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-2024 Ivan Zakharchanka
+Copyright (c) 2019-2025 Ivan Zakharchanka
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -10,6 +10,9 @@
 [![Downloads][downloads-image]][npm-url]
 [![Snyk][snyk-image]][snyk-url]
 
+
+[Documentation](https://3axap4ehko.github.io/ascertain/)
+
 ## Features
 
 - Type-safe validation: Ensures your data conforms to predefined schemas.
@@ -25,6 +28,8 @@
  - Regular Expressions: Regular expressions are used to validate that a value matches a specified string pattern.
  - Object Types: Non-null objects are used as templates for expected properties, where each property of the object must match the corresponding schema definition.
 
+
+
 ## Usage Example
 
 ### Schema compilation
@@ -180,7 +185,7 @@ const validate = ascertain<typeof data>(schema, data, '[DATA]');
 
 ## License
 License [The MIT License](http://opensource.org/licenses/MIT)
-Copyright (c) 2019-2024 Ivan Zakharchanka
+Copyright (c) 2019-2025 Ivan Zakharchanka
 
 [npm-url]: https://www.npmjs.com/package/ascertain
 [downloads-image]: https://img.shields.io/npm/dw/ascertain.svg?maxAge=43200

package/build/index.cjs

@@ -5,47 +5,44 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    $keys: function() {
+    get $keys () {
         return $keys;
     },
-    $strict: function() {
+    get $strict () {
         return $strict;
     },
-    $values: function() {
+    get $values () {
         return $values;
     },
-    and: function() {
+    get and () {
         return and;
     },
-    as: function() {
+    get as () {
         return as;
     },
-    asError: function() {
+    get asError () {
         return asError;
     },
-    ascertain: function() {
+    get ascertain () {
         return ascertain;
     },
-    compile: function() {
+    get compile () {
         return compile;
     },
-    formatError: function() {
-        return formatError;
-    },
-    fromBase64: function() {
+    get fromBase64 () {
         return fromBase64;
     },
-    optional: function() {
+    get optional () {
         return optional;
     },
-    or: function() {
+    get or () {
         return or;
     },
-    tuple: function() {
+    get tuple () {
         return tuple;
     }
 });
@@ -114,19 +111,18 @@ const as = {
     json: (value)=>{
         try {
             return JSON.parse(value);
-        } catch (e) {
+        } catch  {
             return asError(`Invalid value ${value}, expected a valid JSON string`);
         }
     },
     base64: (value)=>{
         try {
             return fromBase64(value);
-        } catch (e) {
+        } catch  {
             return asError(`Invalid value ${value}, expected a valid base64 string`);
         }
     }
 };
-const formatError = (value, expected, path, subject)=>`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;
 class Context {
     registry = [];
     varIndex = 0;
@@ -277,14 +273,14 @@ ${codeGenExpectNoErrors(errorsAlias)}
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for "path", expected symbol\`); }
+if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected symbol\`); }
 if (${valueAlias} !== ${registryAlias}) { throw new TypeError(\`Invalid value \${${valueAlias}.toString()} for path "${path}", expected ${schema.toString()}\`); }
     `;
     } else if (schema === null || schema === undefined) {
         const valueAlias = context.unique('v');
         return `
 const ${valueAlias} = ${valuePath};
-if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value ${valueAlias} for path "${path}", expected nullable\`); }
+if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected nullable\`); }
     `;
     } else {
         const valueAlias = context.unique('v');
@@ -294,7 +290,7 @@ const ${valueAlias} = ${valuePath};
 const ${value} = ${JSON.stringify(schema)};
 ${codeGenExpectNonError(valueAlias, path)}
 if (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected ${typeof schema}\`); }
-if (${valueAlias} !== ${value}) { throw new TypeError(\`Invalid value ${JSON.stringify(valueAlias)} for path "${path}", expected ${JSON.stringify(schema)}\`); }
+if (${valueAlias} !== ${value}) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected ${JSON.stringify(schema)}\`); }
 `;
     }
 };

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["abstract class Operator<T> {\n  constructor(public readonly schemas: Schema<T>[]) {\n    if (schemas.length === 0) {\n      throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);\n    }\n  }\n}\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\nexport const $strict = Symbol.for('@@strict');\n\nexport type Schema<T> =\n  T extends Record<string | number | symbol, unknown>\n    ? { [K in keyof T]?: Schema<T[K]> | unknown } & { [$keys]?: Schema<keyof T> } & { [$values]?: Schema<T[keyof T]> } & { [$strict]?: boolean }\n    : T extends Array<infer A>\n      ? Schema<A>[] | unknown\n      : unknown;\n\nclass Or<T> extends Operator<T> {}\nexport const or = <T>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T> extends Operator<T> {}\nexport const and = <T>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T> extends Operator<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\nexport const optional = <T>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T> extends Operator<T> {}\nexport const tuple = <T>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const fromBase64 = typeof Buffer === 'undefined' ? (value: string) => atob(value) : (value: string) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const asError = <T>(message: string) => new TypeError(message) as unknown as T;\n\nexport const as = {\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : asError(`Invalid value \"${value}\", expected a string`);\n  },\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;\n  },\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    const date = new Date(result);\n    return Number.isNaN(date.valueOf()) ? asError(`Invalid value \"${value}\", expected a valid date format`) : date;\n  },\n  time: (value: string | undefined, conversionFactor = 1): number => {\n    const matches = value?.match(/^(\\d*\\.?\\d*)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(`${(parseFloat(amount) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS]) / conversionFactor}`);\n    }\n    return asError(`Invalid value ${value}, expected a valid time format`);\n  },\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string)\n      ? /^(1|true|enabled)$/i.test(value as string)\n      : asError(`Invalid value ${value}, expected a boolean like`),\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? asError(`Invalid value ${value}, expected an array`),\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return asError(`Invalid value ${value}, expected a valid JSON string`);\n    }\n  },\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return asError(`Invalid value ${value}, expected a valid base64 string`);\n    }\n  },\n};\n\nexport interface ErrorFormatter {\n  (value: unknown, expected: unknown, path: string, subject: string): string;\n}\n\nexport const formatError: ErrorFormatter = (value, expected, path, subject) =>\n  `Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;\n\nclass Context {\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  register(value: unknown): number {\n    if (!this.registry.includes(value)) {\n      this.registry.push(value);\n    }\n    return this.registry.indexOf(value);\n  }\n\n  unique(prefix: string) {\n    return `${prefix}$$${this.varIndex++}`;\n  }\n}\n\nconst codeGenCollectErrors = (errorsAlias: string, code: string, extra: string = '') => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${extra}}`;\nconst codeGenExpectNoErrors = (errorsAlias: string) => `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`;\nconst codeGenExpectNonError = (valueAlias: string, path: string) =>\n  `if (${valueAlias} instanceof Error) { throw new TypeError(\\`\\${${valueAlias}.message} for path \"${path}\".\\`); }`;\nconst codeGenExpectNonNullable = (valueAlias: string, path: string) =>\n  `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`;\nconst codeGenExpectObject = (valueAlias: string, path: string, instanceOf: string) =>\n  `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of ${instanceOf}\\`); }`;\nconst codeGenExpectArray = (valueAlias: string, path: string) =>\n  `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`;\n\nconst codeGen = <T>(schema: Schema<T>, context: Context, valuePath: string, path: string): string => {\n  if (schema instanceof And) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas.map((s) => `try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  ${codeGenExpectNoErrors(errorsAlias)}\n`;\n  } else if (schema instanceof Or) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas\n      .map((s) => codeGen(s, context, valueAlias, path))\n      .reduceRight((result, code) => codeGenCollectErrors(errorsAlias, code, result), codeGenExpectNoErrors(errorsAlias));\n    return `// Or\nconst ${errorsAlias} = [];\nconst ${valueAlias} = ${valuePath};\n${code}\n    `;\n  } else if (schema instanceof Optional) {\n    const valueAlias = context.unique('v');\n    return `// Optional\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }\n`;\n  } else if (schema instanceof Tuple) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code: string[] = [\n      '// Tuple',\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${errorsAlias} = [];`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n      `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\\`Invalid tuple length \\${${valueAlias}.length} for path \"${path}\", expected ${schema.schemas.length}.\\`); }`,\n      ...schema.schemas.map((s, idx) => codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))),\n      codeGenExpectNoErrors(errorsAlias),\n    ];\n    return code.join('\\n');\n  } else if (typeof schema === 'function') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${registryAlias} = ctx.registry[${index}];`,\n      codeGenExpectNonNullable(valueAlias, path),\n    ];\n    if ((schema as unknown) !== Error && !(schema?.prototype instanceof Error)) {\n      code.push(codeGenExpectNonError(valueAlias, path));\n    }\n\n    code.push(\n      `if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }`,\n      `if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }`,\n      `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected a valid ${schema?.name}\\`); }`,\n    );\n    return code.join('\\n');\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectNonError(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n    ];\n    if (schema.length > 0) {\n      const value = context.unique('val');\n      const key = context.unique('key');\n      const errorsAlias = context.unique('err');\n      code.push(`const ${errorsAlias} = [];`);\n      code.push(\n        ...schema.map(\n          (s) => `${valueAlias}.forEach((${value},${key}) => { ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\\${${key}}]`))} });`,\n        ),\n      );\n\n      code.push(codeGenExpectNoErrors(errorsAlias));\n    }\n    return code.join('\\n');\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      const valueAlias = context.unique('v');\n      return `\nconst ${valueAlias} = ${valuePath};\n${codeGenExpectNonNullable(valueAlias, path)}\n${codeGenExpectNonError(valueAlias, path)}\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected to match ${schema.toString()}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        codeGenExpectNonNullable(valueAlias, path),\n        codeGenExpectObject(valueAlias, path, 'Object'),\n        codeGenExpectNonError(valueAlias, path),\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('k');\n        const errorsAlias = context.unique('err');\n        const kAlias = context.unique('k');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = [];\n${keysAlias}.forEach(${kAlias} => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const kAlias = context.unique('k');\n        const entriesAlias = context.unique('en');\n        const errorsAlias = context.unique('err');\n        code.push(`\nconst ${entriesAlias} = Object.entries(${valueAlias});\nconst ${errorsAlias} = [];\n${entriesAlias}.forEach(([${kAlias},${vAlias}]) => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($strict in schema && schema[$strict]) {\n        const keysAlias = context.unique('k');\n        const kAlias = context.unique('k');\n        const extraAlias = context.unique('ex');\n        code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);\n        code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);\n        code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\\`Extra properties: \\${${extraAlias}}, are not allowed for path \"${path}\"\\`); }`);\n      }\n      code.push(...Object.entries(schema).map(([key, s]) => codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));\n      return `${code.join('\\n')}`;\n    }\n  } else if (typeof schema === 'symbol') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for \"path\", expected symbol\\`); }\nif (${valueAlias} !== ${registryAlias}) { throw new TypeError(\\`Invalid value \\${${valueAlias}.toString()} for path \"${path}\", expected ${schema.toString()}\\`); }\n    `;\n  } else if (schema === null || schema === undefined) {\n    const valueAlias = context.unique('v');\n    return `\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\\`Invalid value ${valueAlias} for path \"${path}\", expected nullable\\`); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${value} = ${JSON.stringify(schema)};\n${codeGenExpectNonError(valueAlias, path)}\nif (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected ${typeof schema}\\`); }\nif (${valueAlias} !== ${value}) { throw new TypeError(\\`Invalid value ${JSON.stringify(valueAlias)} for path \"${path}\", expected ${JSON.stringify(schema)}\\`); }\n`;\n  }\n};\n\nexport const compile = <T>(schema: Schema<T>, rootName: string) => {\n  const context = new Context();\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: T) => validator(context, data);\n};\n\nexport const ascertain = <T>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  compile(schema, rootName)(data);\n};\n"],"names":["$keys","$strict","$values","and","as","asError","ascertain","compile","formatError","fromBase64","optional","or","tuple","Operator","constructor","schemas","length","TypeError","name","Symbol","for","Or","And","Optional","schema","Tuple","Buffer","value","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","message","string","number","result","parseFloat","Number","isNaN","date","Date","parse","valueOf","time","conversionFactor","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","JSON","e","base64","expected","path","subject","stringify","Context","registry","varIndex","register","includes","push","indexOf","unique","prefix","codeGenCollectErrors","errorsAlias","code","extra","codeGenExpectNoErrors","codeGenExpectNonError","valueAlias","codeGenExpectNonNullable","codeGenExpectObject","instanceOf","codeGenExpectArray","codeGen","context","valuePath","map","join","reduceRight","idx","index","registryAlias","Error","prototype","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","Object","keys","entries","undefined","rootName","validator","Function","data"],"mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Abstract base class for schema operators.\n *\n * Provides a common constructor that enforces having at least one schema.\n *\n * @template T - The type of data the operator validates.\n * @abstract\n * @internal\n */\nabstract class Operator<T> {\n  constructor(public readonly schemas: Schema<T>[]) {\n    if (schemas.length === 0) {\n      throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);\n    }\n  }\n}\n\n// https://standardschema.dev/\n\n/**\n * Symbol for validating object keys against a schema.\n */\nexport const $keys = Symbol.for('@@keys');\n/**\n * Symbol for validating object values against a schema.\n */\nexport const $values = Symbol.for('@@values');\n/**\n * Symbol for enforcing strict object validation (no extra properties allowed).\n */\nexport const $strict = Symbol.for('@@strict');\n\n/**\n * Represents a schema for validating data.\n *\n * Schemas can be defined for various data types, including objects, arrays, and primitives.\n *\n * @template T - The type of data the schema validates.\n */\nexport type Schema<T> =\n  T extends Record<string | number | symbol, unknown>\n    ? { [K in keyof T]?: Schema<T[K]> | unknown } & { [$keys]?: Schema<keyof T> } & { [$values]?: Schema<T[keyof T]> } & { [$strict]?: boolean }\n    : T extends Array<infer A>\n      ? Schema<A>[] | unknown\n      : unknown;\n\nclass Or<T> extends Operator<T> {}\n/**\n * Operator for validating data against any of the provided schemas (logical OR).\n *\n * Creates a schema that accepts data matching any one of the provided schemas.\n * This is useful for creating union types or alternative validation paths.\n *\n * @template T - The type of data the operator validates.\n * @param schemas - Multiple schemas where at least one must match the data.\n * @returns A schema that validates data against any of the provided schemas.\n *\n * @example\n * ```typescript\n * import { or, ascertain } from 'ascertain';\n *\n * // Create a schema that accepts either a string or number\n * const stringOrNumber = or(String, Number);\n *\n * ascertain(stringOrNumber, \"hello\", \"value\"); // ✓ Valid\n * ascertain(stringOrNumber, 42, \"value\");      // ✓ Valid\n * ascertain(stringOrNumber, true, \"value\");    // ✗ Throws error\n *\n * // Union of literal values\n * const statusSchema = or('pending', 'completed', 'failed');\n * ascertain(statusSchema, 'pending', \"status\"); // ✓ Valid\n *\n * // Complex schema combinations\n * const userIdSchema = or(Number, { id: Number, temp: Boolean });\n * ascertain(userIdSchema, 123, \"userId\");                    // ✓ Valid\n * ascertain(userIdSchema, { id: 456, temp: true }, \"userId\"); // ✓ Valid\n * ```\n */\nexport const or = <T>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T> extends Operator<T> {}\n/**\n * Operator for validating data against all provided schemas (logical AND).\n *\n * Creates a schema that requires data to match every one of the provided schemas.\n * This is useful for combining multiple validation requirements or adding constraints.\n *\n * @template T - The type of data the operator validates.\n * @param schemas - Multiple schemas that all must match the data.\n * @returns A schema that validates data against all of the provided schemas.\n *\n * @example\n * ```typescript\n * import { and, ascertain } from 'ascertain';\n *\n * // Combine object schema with additional constraints\n * const userSchema = and(\n *   { name: String, age: Number },\n *   { age: Number } // Additional constraint\n * );\n *\n * ascertain(userSchema, { name: \"John\", age: 25 }, \"user\"); // ✓ Valid\n *\n * // Ensure an object is both a Date and has specific methods\n * const validDateSchema = and(Date, { toISOString: Function });\n * ascertain(validDateSchema, new Date(), \"date\"); // ✓ Valid\n *\n * // Multiple validation layers\n * const positiveNumberSchema = and(Number, (n: number) => n > 0);\n * ascertain(positiveNumberSchema, 42, \"count\");   // ✓ Valid\n * ascertain(positiveNumberSchema, -5, \"count\");   // ✗ Throws error\n * ```\n */\nexport const and = <T>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T> extends Operator<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\n/**\n * Operator for making a schema optional (nullable).\n *\n * Creates a schema that accepts the provided schema or null/undefined values.\n * This is useful for optional object properties or nullable fields.\n *\n * @template T - The type of data the operator validates.\n * @param schema - The schema to make optional.\n * @returns A schema that validates data against the provided schema or accepts null/undefined.\n *\n * @example\n * ```typescript\n * import { optional, ascertain } from 'ascertain';\n *\n * // Optional string field\n * const userSchema = {\n *   name: String,\n *   nickname: optional(String),\n *   age: Number\n * };\n *\n * // All of these are valid\n * ascertain(userSchema, {\n *   name: \"John\",\n *   nickname: \"Johnny\",\n *   age: 30\n * }, \"user\"); // ✓ Valid\n *\n * ascertain(userSchema, {\n *   name: \"Jane\",\n *   nickname: null,\n *   age: 25\n * }, \"user\"); // ✓ Valid\n *\n * ascertain(userSchema, {\n *   name: \"Bob\",\n *   age: 35\n *   // nickname is undefined\n * }, \"user\"); // ✓ Valid\n *\n * // Optional complex objects\n * const profileSchema = {\n *   id: Number,\n *   settings: optional({\n *     theme: String,\n *     notifications: Boolean\n *   })\n * };\n * ```\n */\nexport const optional = <T>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T> extends Operator<T> {}\n/**\n * Operator for validating data against a fixed-length tuple of schemas.\n *\n * Creates a schema that validates arrays with a specific length and type for each position.\n * This is useful for coordinate pairs, RGB values, or any fixed-structure data.\n *\n * @template T - The type of data the operator validates (a tuple of types).\n * @param schemas - Schemas for each position in the tuple, in order.\n * @returns A schema that validates data as a tuple with the specified structure.\n *\n * @example\n * ```typescript\n * import { tuple, ascertain } from 'ascertain';\n *\n * // 2D coordinate tuple\n * const pointSchema = tuple(Number, Number);\n * ascertain(pointSchema, [10, 20], \"point\"); // ✓ Valid\n * ascertain(pointSchema, [1.5, 2.7], \"point\"); // ✓ Valid\n * ascertain(pointSchema, [10], \"point\"); // ✗ Throws error (too short)\n * ascertain(pointSchema, [10, 20, 30], \"point\"); // ✗ Throws error (too long)\n *\n * // RGB color tuple\n * const colorSchema = tuple(Number, Number, Number);\n * ascertain(colorSchema, [255, 128, 0], \"color\"); // ✓ Valid\n *\n * // Mixed type tuple\n * const userInfoSchema = tuple(String, Number, Boolean);\n * ascertain(userInfoSchema, [\"Alice\", 25, true], \"userInfo\"); // ✓ Valid\n *\n * // Nested tuple\n * const lineSchema = tuple(\n *   tuple(Number, Number), // start point\n *   tuple(Number, Number)  // end point\n * );\n * ascertain(lineSchema, [[0, 0], [10, 10]], \"line\"); // ✓ Valid\n * ```\n */\nexport const tuple = <T>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const fromBase64 = typeof Buffer === 'undefined' ? (value: string) => atob(value) : (value: string) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const asError = <T>(message: string) => new TypeError(message) as unknown as T;\n\nexport const as = {\n  /**\n   * Attempts to convert a value to a string.\n   *\n   * @param value - The value to convert.\n   * @returns The value as a string, or a TypeError if not a string.\n   */\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : asError(`Invalid value \"${value}\", expected a string`);\n  },\n  /**\n   * Attempts to convert a value to a number.\n   *\n   * @param value - The value to convert (expected to be a string representation of a number).\n   * @returns The value as a number, or a TypeError if not a valid number.\n   */\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;\n  },\n  /**\n   * Attempts to convert a value to a Date object.\n   *\n   * @param value - The value to convert (expected to be a string representation of a date).\n   * @returns The value as a Date object, or a TypeError if not a valid date.\n   */\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    const date = new Date(result);\n    return Number.isNaN(date.valueOf()) ? asError(`Invalid value \"${value}\", expected a valid date format`) : date;\n  },\n  /**\n   * Attempts to convert a value to a time duration in milliseconds.\n   *\n   * @param value - The value to convert (e.g., \"5s\" for 5 seconds).\n   * @param conversionFactor - Optional factor to divide the result by (default is 1).\n   * @returns The time duration in milliseconds, or a TypeError if the format is invalid.\n   */\n  time: (value: string | undefined, conversionFactor = 1): number => {\n    const matches = value?.match(/^(\\d*\\.?\\d*)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(`${(parseFloat(amount) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS]) / conversionFactor}`);\n    }\n    return asError(`Invalid value ${value}, expected a valid time format`);\n  },\n  /**\n   * Attempts to convert a value to a boolean.\n   *\n   * @param value - The boolean like value to convert (e.g., \"true\", \"1\", \"enabled\").\n   * @returns The value as a boolean, or a TypeError if it could not be converted to a boolean.\n   */\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string)\n      ? /^(1|true|enabled)$/i.test(value as string)\n      : asError(`Invalid value ${value}, expected a boolean like`),\n  /**\n   * Attempts to convert a string into an array of strings by splitting it using the given delimiter.\n   *\n   * @param value - The string value to attempt to split into an array.\n   * @param delimiter - The character or string used to separate elements in the input string.\n   * @returns An array of strings if the conversion is successful, or a TypeError if the value is not a string.\n   */\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? asError(`Invalid value ${value}, expected an array`),\n  /**\n   * Attempts to parse a JSON string into a JavaScript object.\n   *\n   * @template T - The expected type of the parsed JSON object.\n   * @param value - The JSON string to attempt to parse.\n   * @returns The parsed JSON object if successful, or a TypeError if the value is not valid JSON.\n   */\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch {\n      return asError(`Invalid value ${value}, expected a valid JSON string`);\n    }\n  },\n  /**\n   * Attempts to decode a base64-encoded string.\n   *\n   * @param value - The base64-encoded string to attempt to decode.\n   * @returns The decoded string if successful, or a TypeError if the value is not valid base64.\n   */\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch {\n      return asError(`Invalid value ${value}, expected a valid base64 string`);\n    }\n  },\n};\n\n/**\n * A class representing the context for schema validation.\n *\n * Stores a registry of values encountered during validation and provides methods for managing it.\n * @internal\n */\nclass Context {\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  register(value: unknown): number {\n    if (!this.registry.includes(value)) {\n      this.registry.push(value);\n    }\n    return this.registry.indexOf(value);\n  }\n\n  unique(prefix: string) {\n    return `${prefix}$$${this.varIndex++}`;\n  }\n}\n\nconst codeGenCollectErrors = (errorsAlias: string, code: string, extra: string = '') => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${extra}}`;\nconst codeGenExpectNoErrors = (errorsAlias: string) => `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`;\nconst codeGenExpectNonError = (valueAlias: string, path: string) =>\n  `if (${valueAlias} instanceof Error) { throw new TypeError(\\`\\${${valueAlias}.message} for path \"${path}\".\\`); }`;\nconst codeGenExpectNonNullable = (valueAlias: string, path: string) =>\n  `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`;\nconst codeGenExpectObject = (valueAlias: string, path: string, instanceOf: string) =>\n  `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of ${instanceOf}\\`); }`;\nconst codeGenExpectArray = (valueAlias: string, path: string) =>\n  `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`;\n\nconst codeGen = <T>(schema: Schema<T>, context: Context, valuePath: string, path: string): string => {\n  if (schema instanceof And) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas.map((s) => `try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  ${codeGenExpectNoErrors(errorsAlias)}\n`;\n  } else if (schema instanceof Or) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas\n      .map((s) => codeGen(s, context, valueAlias, path))\n      .reduceRight((result, code) => codeGenCollectErrors(errorsAlias, code, result), codeGenExpectNoErrors(errorsAlias));\n    return `// Or\nconst ${errorsAlias} = [];\nconst ${valueAlias} = ${valuePath};\n${code}\n    `;\n  } else if (schema instanceof Optional) {\n    const valueAlias = context.unique('v');\n    return `// Optional\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }\n`;\n  } else if (schema instanceof Tuple) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code: string[] = [\n      '// Tuple',\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${errorsAlias} = [];`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n      `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\\`Invalid tuple length \\${${valueAlias}.length} for path \"${path}\", expected ${schema.schemas.length}.\\`); }`,\n      ...schema.schemas.map((s, idx) => codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))),\n      codeGenExpectNoErrors(errorsAlias),\n    ];\n    return code.join('\\n');\n  } else if (typeof schema === 'function') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${registryAlias} = ctx.registry[${index}];`,\n      codeGenExpectNonNullable(valueAlias, path),\n    ];\n    if ((schema as unknown) !== Error && !(schema?.prototype instanceof Error)) {\n      code.push(codeGenExpectNonError(valueAlias, path));\n    }\n\n    code.push(\n      `if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }`,\n      `if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }`,\n      `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected a valid ${schema?.name}\\`); }`,\n    );\n    return code.join('\\n');\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectNonError(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n    ];\n    if (schema.length > 0) {\n      const value = context.unique('val');\n      const key = context.unique('key');\n      const errorsAlias = context.unique('err');\n      code.push(`const ${errorsAlias} = [];`);\n      code.push(\n        ...schema.map(\n          (s) => `${valueAlias}.forEach((${value},${key}) => { ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\\${${key}}]`))} });`,\n        ),\n      );\n\n      code.push(codeGenExpectNoErrors(errorsAlias));\n    }\n    return code.join('\\n');\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      const valueAlias = context.unique('v');\n      return `\nconst ${valueAlias} = ${valuePath};\n${codeGenExpectNonNullable(valueAlias, path)}\n${codeGenExpectNonError(valueAlias, path)}\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected to match ${schema.toString()}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        codeGenExpectNonNullable(valueAlias, path),\n        codeGenExpectObject(valueAlias, path, 'Object'),\n        codeGenExpectNonError(valueAlias, path),\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('k');\n        const errorsAlias = context.unique('err');\n        const kAlias = context.unique('k');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = [];\n${keysAlias}.forEach(${kAlias} => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const kAlias = context.unique('k');\n        const entriesAlias = context.unique('en');\n        const errorsAlias = context.unique('err');\n        code.push(`\nconst ${entriesAlias} = Object.entries(${valueAlias});\nconst ${errorsAlias} = [];\n${entriesAlias}.forEach(([${kAlias},${vAlias}]) => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($strict in schema && schema[$strict]) {\n        const keysAlias = context.unique('k');\n        const kAlias = context.unique('k');\n        const extraAlias = context.unique('ex');\n        code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);\n        code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);\n        code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\\`Extra properties: \\${${extraAlias}}, are not allowed for path \"${path}\"\\`); }`);\n      }\n      code.push(...Object.entries(schema).map(([key, s]) => codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));\n      return `${code.join('\\n')}`;\n    }\n  } else if (typeof schema === 'symbol') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected symbol\\`); }\nif (${valueAlias} !== ${registryAlias}) { throw new TypeError(\\`Invalid value \\${${valueAlias}.toString()} for path \"${path}\", expected ${schema.toString()}\\`); }\n    `;\n  } else if (schema === null || schema === undefined) {\n    const valueAlias = context.unique('v');\n    return `\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\\`Invalid value \\${JSON.stringify(${valueAlias})} for path \"${path}\", expected nullable\\`); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${value} = ${JSON.stringify(schema)};\n${codeGenExpectNonError(valueAlias, path)}\nif (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected ${typeof schema}\\`); }\nif (${valueAlias} !== ${value}) { throw new TypeError(\\`Invalid value \\${JSON.stringify(${valueAlias})} for path \"${path}\", expected ${JSON.stringify(schema)}\\`); }\n`;\n  }\n};\n\n/**\n * Compiles a schema into a validation function.\n *\n * This function takes a schema definition and generates a JavaScript function\n * that can be used to validate data against the schema.\n *\n * @template T - The type of data the schema validates.\n * @param schema - The schema to compile.\n * @param rootName - A name for the root of the data structure (used in error messages).\n * @returns A validation function that takes data as input and throws a TypeError if the data does not conform to the schema.\n *\n * @example\n * ```typescript\n * import { compile, optional, and, or } from 'ascertain';\n *\n * const userSchema = {\n *   name: String,\n *   age: Number,\n *   email: optional(String),\n *   role: or('admin', 'user', 'guest')\n * };\n *\n * const validateUser = compile(userSchema, 'User');\n *\n * // Valid data - no error thrown\n * validateUser({\n *   name: 'John Doe',\n *   age: 30,\n *   email: 'john@example.com',\n *   role: 'user'\n * });\n *\n * // Invalid data - throws TypeError\n * try {\n *   validateUser({\n *     name: 123, // Invalid: should be string\n *     age: 'thirty' // Invalid: should be number\n *   });\n * } catch (error) {\n *   console.error(error.message); // Detailed validation errors\n * }\n * ```\n */\nexport const compile = <T>(schema: Schema<T>, rootName: string) => {\n  const context = new Context();\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: T) => validator(context, data);\n};\n\n/**\n * Asserts that data conforms to a given schema.\n *\n * This function is a convenient wrapper around `compile`. It compiles the schema\n * and immediately validates the provided data against it.\n *\n * @template T - The type of data the schema validates.\n * @param schema - The schema to validate against.\n * @param data - The data to validate.\n * @param rootName - A name for the root of the data structure (used in error messages, defaults to '[root]').\n * @throws `{TypeError}` If the data does not conform to the schema.\n *\n * @example\n * ```typescript\n * import { ascertain, optional, and, or } from 'ascertain';\n *\n * const userSchema = {\n *   name: String,\n *   age: Number,\n *   email: optional(String),\n *   active: Boolean\n * };\n *\n * const userData = {\n *   name: 'Alice',\n *   age: 25,\n *   email: 'alice@example.com',\n *   active: true\n * };\n *\n * // Validate data - throws if invalid, otherwise continues silently\n * ascertain(userSchema, userData, 'UserData');\n * console.log('User data is valid!');\n *\n * // Example with invalid data\n * try {\n *   ascertain(userSchema, {\n *     name: 'Bob',\n *     age: 'twenty-five', // Invalid: should be number\n *     active: true\n *   }, 'UserData');\n * } catch (error) {\n *   console.error('Validation failed:', error.message);\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Array validation\n * const numbersSchema = [Number];\n * const numbers = [1, 2, 3, 4, 5];\n *\n * ascertain(numbersSchema, numbers, 'Numbers');\n *\n * // Tuple validation\n * const coordinateSchema = tuple(Number, Number);\n * const point = [10, 20];\n *\n * ascertain(coordinateSchema, point, 'Point');\n * ```\n */\nexport const ascertain = <T>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  compile(schema, rootName)(data);\n};\n"],"names":["$keys","$strict","$values","and","as","asError","ascertain","compile","fromBase64","optional","or","tuple","Operator","schemas","length","TypeError","name","Symbol","for","Or","And","Optional","schema","Tuple","Buffer","value","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","message","string","number","result","parseFloat","Number","isNaN","date","Date","parse","valueOf","time","conversionFactor","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","JSON","base64","Context","registry","varIndex","register","includes","push","indexOf","unique","prefix","codeGenCollectErrors","errorsAlias","code","extra","codeGenExpectNoErrors","codeGenExpectNonError","valueAlias","path","codeGenExpectNonNullable","codeGenExpectObject","instanceOf","codeGenExpectArray","codeGen","context","valuePath","map","join","reduceRight","idx","index","registryAlias","Error","prototype","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","stringify","Object","keys","entries","undefined","rootName","validator","Function","data"],"mappings":"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"}

package/build/index.d.ts

@@ -1,10 +1,35 @@
+/**
+ * Abstract base class for schema operators.
+ *
+ * Provides a common constructor that enforces having at least one schema.
+ *
+ * @template T - The type of data the operator validates.
+ * @abstract
+ * @internal
+ */
 declare abstract class Operator<T> {
     readonly schemas: Schema<T>[];
     constructor(schemas: Schema<T>[]);
 }
+/**
+ * Symbol for validating object keys against a schema.
+ */
 export declare const $keys: unique symbol;
+/**
+ * Symbol for validating object values against a schema.
+ */
 export declare const $values: unique symbol;
+/**
+ * Symbol for enforcing strict object validation (no extra properties allowed).
+ */
 export declare const $strict: unique symbol;
+/**
+ * Represents a schema for validating data.
+ *
+ * Schemas can be defined for various data types, including objects, arrays, and primitives.
+ *
+ * @template T - The type of data the schema validates.
+ */
 export type Schema<T> = T extends Record<string | number | symbol, unknown> ? {
     [K in keyof T]?: Schema<T[K]> | unknown;
 } & {
@@ -16,33 +41,334 @@ export type Schema<T> = T extends Record<string | number | symbol, unknown> ? {
 } : T extends Array<infer A> ? Schema<A>[] | unknown : unknown;
 declare class Or<T> extends Operator<T> {
 }
+/**
+ * Operator for validating data against any of the provided schemas (logical OR).
+ *
+ * Creates a schema that accepts data matching any one of the provided schemas.
+ * This is useful for creating union types or alternative validation paths.
+ *
+ * @template T - The type of data the operator validates.
+ * @param schemas - Multiple schemas where at least one must match the data.
+ * @returns A schema that validates data against any of the provided schemas.
+ *
+ * @example
+ * ```typescript
+ * import { or, ascertain } from 'ascertain';
+ *
+ * // Create a schema that accepts either a string or number
+ * const stringOrNumber = or(String, Number);
+ *
+ * ascertain(stringOrNumber, "hello", "value"); // ✓ Valid
+ * ascertain(stringOrNumber, 42, "value");      // ✓ Valid
+ * ascertain(stringOrNumber, true, "value");    // ✗ Throws error
+ *
+ * // Union of literal values
+ * const statusSchema = or('pending', 'completed', 'failed');
+ * ascertain(statusSchema, 'pending', "status"); // ✓ Valid
+ *
+ * // Complex schema combinations
+ * const userIdSchema = or(Number, { id: Number, temp: Boolean });
+ * ascertain(userIdSchema, 123, "userId");                    // ✓ Valid
+ * ascertain(userIdSchema, { id: 456, temp: true }, "userId"); // ✓ Valid
+ * ```
+ */
 export declare const or: <T>(...schemas: Schema<T>[]) => Or<T>;
 declare class And<T> extends Operator<T> {
 }
+/**
+ * Operator for validating data against all provided schemas (logical AND).
+ *
+ * Creates a schema that requires data to match every one of the provided schemas.
+ * This is useful for combining multiple validation requirements or adding constraints.
+ *
+ * @template T - The type of data the operator validates.
+ * @param schemas - Multiple schemas that all must match the data.
+ * @returns A schema that validates data against all of the provided schemas.
+ *
+ * @example
+ * ```typescript
+ * import { and, ascertain } from 'ascertain';
+ *
+ * // Combine object schema with additional constraints
+ * const userSchema = and(
+ *   { name: String, age: Number },
+ *   { age: Number } // Additional constraint
+ * );
+ *
+ * ascertain(userSchema, { name: "John", age: 25 }, "user"); // ✓ Valid
+ *
+ * // Ensure an object is both a Date and has specific methods
+ * const validDateSchema = and(Date, { toISOString: Function });
+ * ascertain(validDateSchema, new Date(), "date"); // ✓ Valid
+ *
+ * // Multiple validation layers
+ * const positiveNumberSchema = and(Number, (n: number) => n > 0);
+ * ascertain(positiveNumberSchema, 42, "count");   // ✓ Valid
+ * ascertain(positiveNumberSchema, -5, "count");   // ✗ Throws error
+ * ```
+ */
 export declare const and: <T>(...schemas: Schema<T>[]) => And<T>;
 declare class Optional<T> extends Operator<T> {
     constructor(schema: Schema<T>);
 }
+/**
+ * Operator for making a schema optional (nullable).
+ *
+ * Creates a schema that accepts the provided schema or null/undefined values.
+ * This is useful for optional object properties or nullable fields.
+ *
+ * @template T - The type of data the operator validates.
+ * @param schema - The schema to make optional.
+ * @returns A schema that validates data against the provided schema or accepts null/undefined.
+ *
+ * @example
+ * ```typescript
+ * import { optional, ascertain } from 'ascertain';
+ *
+ * // Optional string field
+ * const userSchema = {
+ *   name: String,
+ *   nickname: optional(String),
+ *   age: Number
+ * };
+ *
+ * // All of these are valid
+ * ascertain(userSchema, {
+ *   name: "John",
+ *   nickname: "Johnny",
+ *   age: 30
+ * }, "user"); // ✓ Valid
+ *
+ * ascertain(userSchema, {
+ *   name: "Jane",
+ *   nickname: null,
+ *   age: 25
+ * }, "user"); // ✓ Valid
+ *
+ * ascertain(userSchema, {
+ *   name: "Bob",
+ *   age: 35
+ *   // nickname is undefined
+ * }, "user"); // ✓ Valid
+ *
+ * // Optional complex objects
+ * const profileSchema = {
+ *   id: Number,
+ *   settings: optional({
+ *     theme: String,
+ *     notifications: Boolean
+ *   })
+ * };
+ * ```
+ */
 export declare const optional: <T>(schema: Schema<T>) => Optional<T>;
 declare class Tuple<T> extends Operator<T> {
 }
+/**
+ * Operator for validating data against a fixed-length tuple of schemas.
+ *
+ * Creates a schema that validates arrays with a specific length and type for each position.
+ * This is useful for coordinate pairs, RGB values, or any fixed-structure data.
+ *
+ * @template T - The type of data the operator validates (a tuple of types).
+ * @param schemas - Schemas for each position in the tuple, in order.
+ * @returns A schema that validates data as a tuple with the specified structure.
+ *
+ * @example
+ * ```typescript
+ * import { tuple, ascertain } from 'ascertain';
+ *
+ * // 2D coordinate tuple
+ * const pointSchema = tuple(Number, Number);
+ * ascertain(pointSchema, [10, 20], "point"); // ✓ Valid
+ * ascertain(pointSchema, [1.5, 2.7], "point"); // ✓ Valid
+ * ascertain(pointSchema, [10], "point"); // ✗ Throws error (too short)
+ * ascertain(pointSchema, [10, 20, 30], "point"); // ✗ Throws error (too long)
+ *
+ * // RGB color tuple
+ * const colorSchema = tuple(Number, Number, Number);
+ * ascertain(colorSchema, [255, 128, 0], "color"); // ✓ Valid
+ *
+ * // Mixed type tuple
+ * const userInfoSchema = tuple(String, Number, Boolean);
+ * ascertain(userInfoSchema, ["Alice", 25, true], "userInfo"); // ✓ Valid
+ *
+ * // Nested tuple
+ * const lineSchema = tuple(
+ *   tuple(Number, Number), // start point
+ *   tuple(Number, Number)  // end point
+ * );
+ * ascertain(lineSchema, [[0, 0], [10, 10]], "line"); // ✓ Valid
+ * ```
+ */
 export declare const tuple: <T>(...schemas: Schema<T>[]) => Tuple<T>;
 export declare const fromBase64: (value: string) => string;
 export declare const asError: <T>(message: string) => T;
 export declare const as: {
+    /**
+     * Attempts to convert a value to a string.
+     *
+     * @param value - The value to convert.
+     * @returns The value as a string, or a TypeError if not a string.
+     */
     string: (value: string | undefined) => string;
+    /**
+     * Attempts to convert a value to a number.
+     *
+     * @param value - The value to convert (expected to be a string representation of a number).
+     * @returns The value as a number, or a TypeError if not a valid number.
+     */
     number: (value: string | undefined) => number;
+    /**
+     * Attempts to convert a value to a Date object.
+     *
+     * @param value - The value to convert (expected to be a string representation of a date).
+     * @returns The value as a Date object, or a TypeError if not a valid date.
+     */
     date: (value: string | undefined) => Date;
+    /**
+     * Attempts to convert a value to a time duration in milliseconds.
+     *
+     * @param value - The value to convert (e.g., "5s" for 5 seconds).
+     * @param conversionFactor - Optional factor to divide the result by (default is 1).
+     * @returns The time duration in milliseconds, or a TypeError if the format is invalid.
+     */
     time: (value: string | undefined, conversionFactor?: number) => number;
+    /**
+     * Attempts to convert a value to a boolean.
+     *
+     * @param value - The boolean like value to convert (e.g., "true", "1", "enabled").
+     * @returns The value as a boolean, or a TypeError if it could not be converted to a boolean.
+     */
     boolean: (value: string | undefined) => boolean;
+    /**
+     * Attempts to convert a string into an array of strings by splitting it using the given delimiter.
+     *
+     * @param value - The string value to attempt to split into an array.
+     * @param delimiter - The character or string used to separate elements in the input string.
+     * @returns An array of strings if the conversion is successful, or a TypeError if the value is not a string.
+     */
     array: (value: string | undefined, delimiter: string) => string[];
+    /**
+     * Attempts to parse a JSON string into a JavaScript object.
+     *
+     * @template T - The expected type of the parsed JSON object.
+     * @param value - The JSON string to attempt to parse.
+     * @returns The parsed JSON object if successful, or a TypeError if the value is not valid JSON.
+     */
     json: <T = object>(value: string | undefined) => T;
+    /**
+     * Attempts to decode a base64-encoded string.
+     *
+     * @param value - The base64-encoded string to attempt to decode.
+     * @returns The decoded string if successful, or a TypeError if the value is not valid base64.
+     */
     base64: (value: string | undefined) => string;
 };
-export interface ErrorFormatter {
-    (value: unknown, expected: unknown, path: string, subject: string): string;
-}
-export declare const formatError: ErrorFormatter;
+/**
+ * Compiles a schema into a validation function.
+ *
+ * This function takes a schema definition and generates a JavaScript function
+ * that can be used to validate data against the schema.
+ *
+ * @template T - The type of data the schema validates.
+ * @param schema - The schema to compile.
+ * @param rootName - A name for the root of the data structure (used in error messages).
+ * @returns A validation function that takes data as input and throws a TypeError if the data does not conform to the schema.
+ *
+ * @example
+ * ```typescript
+ * import { compile, optional, and, or } from 'ascertain';
+ *
+ * const userSchema = {
+ *   name: String,
+ *   age: Number,
+ *   email: optional(String),
+ *   role: or('admin', 'user', 'guest')
+ * };
+ *
+ * const validateUser = compile(userSchema, 'User');
+ *
+ * // Valid data - no error thrown
+ * validateUser({
+ *   name: 'John Doe',
+ *   age: 30,
+ *   email: 'john@example.com',
+ *   role: 'user'
+ * });
+ *
+ * // Invalid data - throws TypeError
+ * try {
+ *   validateUser({
+ *     name: 123, // Invalid: should be string
+ *     age: 'thirty' // Invalid: should be number
+ *   });
+ * } catch (error) {
+ *   console.error(error.message); // Detailed validation errors
+ * }
+ * ```
+ */
 export declare const compile: <T>(schema: Schema<T>, rootName: string) => (data: T) => any;
+/**
+ * Asserts that data conforms to a given schema.
+ *
+ * This function is a convenient wrapper around `compile`. It compiles the schema
+ * and immediately validates the provided data against it.
+ *
+ * @template T - The type of data the schema validates.
+ * @param schema - The schema to validate against.
+ * @param data - The data to validate.
+ * @param rootName - A name for the root of the data structure (used in error messages, defaults to '[root]').
+ * @throws `{TypeError}` If the data does not conform to the schema.
+ *
+ * @example
+ * ```typescript
+ * import { ascertain, optional, and, or } from 'ascertain';
+ *
+ * const userSchema = {
+ *   name: String,
+ *   age: Number,
+ *   email: optional(String),
+ *   active: Boolean
+ * };
+ *
+ * const userData = {
+ *   name: 'Alice',
+ *   age: 25,
+ *   email: 'alice@example.com',
+ *   active: true
+ * };
+ *
+ * // Validate data - throws if invalid, otherwise continues silently
+ * ascertain(userSchema, userData, 'UserData');
+ * console.log('User data is valid!');
+ *
+ * // Example with invalid data
+ * try {
+ *   ascertain(userSchema, {
+ *     name: 'Bob',
+ *     age: 'twenty-five', // Invalid: should be number
+ *     active: true
+ *   }, 'UserData');
+ * } catch (error) {
+ *   console.error('Validation failed:', error.message);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Array validation
+ * const numbersSchema = [Number];
+ * const numbers = [1, 2, 3, 4, 5];
+ *
+ * ascertain(numbersSchema, numbers, 'Numbers');
+ *
+ * // Tuple validation
+ * const coordinateSchema = tuple(Number, Number);
+ * const point = [10, 20];
+ *
+ * ascertain(coordinateSchema, point, 'Point');
+ * ```
+ */
 export declare const ascertain: <T>(schema: Schema<T>, data: T, rootName?: string) => void;
 export {};

package/build/index.js

@@ -63,19 +63,18 @@ export const as = {
     json: (value)=>{
         try {
             return JSON.parse(value);
-        } catch (e) {
+        } catch  {
             return asError(`Invalid value ${value}, expected a valid JSON string`);
         }
     },
     base64: (value)=>{
         try {
             return fromBase64(value);
-        } catch (e) {
+        } catch  {
             return asError(`Invalid value ${value}, expected a valid base64 string`);
         }
     }
 };
-export const formatError = (value, expected, path, subject)=>`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;
 class Context {
     registry = [];
     varIndex = 0;
@@ -226,14 +225,14 @@ ${codeGenExpectNoErrors(errorsAlias)}
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for "path", expected symbol\`); }
+if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected symbol\`); }
 if (${valueAlias} !== ${registryAlias}) { throw new TypeError(\`Invalid value \${${valueAlias}.toString()} for path "${path}", expected ${schema.toString()}\`); }
     `;
     } else if (schema === null || schema === undefined) {
         const valueAlias = context.unique('v');
         return `
 const ${valueAlias} = ${valuePath};
-if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value ${valueAlias} for path "${path}", expected nullable\`); }
+if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected nullable\`); }
     `;
     } else {
         const valueAlias = context.unique('v');
@@ -243,7 +242,7 @@ const ${valueAlias} = ${valuePath};
 const ${value} = ${JSON.stringify(schema)};
 ${codeGenExpectNonError(valueAlias, path)}
 if (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected ${typeof schema}\`); }
-if (${valueAlias} !== ${value}) { throw new TypeError(\`Invalid value ${JSON.stringify(valueAlias)} for path "${path}", expected ${JSON.stringify(schema)}\`); }
+if (${valueAlias} !== ${value}) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected ${JSON.stringify(schema)}\`); }
 `;
     }
 };

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["abstract class Operator<T> {\n  constructor(public readonly schemas: Schema<T>[]) {\n    if (schemas.length === 0) {\n      throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);\n    }\n  }\n}\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\nexport const $strict = Symbol.for('@@strict');\n\nexport type Schema<T> =\n  T extends Record<string | number | symbol, unknown>\n    ? { [K in keyof T]?: Schema<T[K]> | unknown } & { [$keys]?: Schema<keyof T> } & { [$values]?: Schema<T[keyof T]> } & { [$strict]?: boolean }\n    : T extends Array<infer A>\n      ? Schema<A>[] | unknown\n      : unknown;\n\nclass Or<T> extends Operator<T> {}\nexport const or = <T>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T> extends Operator<T> {}\nexport const and = <T>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T> extends Operator<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\nexport const optional = <T>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T> extends Operator<T> {}\nexport const tuple = <T>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const fromBase64 = typeof Buffer === 'undefined' ? (value: string) => atob(value) : (value: string) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const asError = <T>(message: string) => new TypeError(message) as unknown as T;\n\nexport const as = {\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : asError(`Invalid value \"${value}\", expected a string`);\n  },\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;\n  },\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    const date = new Date(result);\n    return Number.isNaN(date.valueOf()) ? asError(`Invalid value \"${value}\", expected a valid date format`) : date;\n  },\n  time: (value: string | undefined, conversionFactor = 1): number => {\n    const matches = value?.match(/^(\\d*\\.?\\d*)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(`${(parseFloat(amount) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS]) / conversionFactor}`);\n    }\n    return asError(`Invalid value ${value}, expected a valid time format`);\n  },\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string)\n      ? /^(1|true|enabled)$/i.test(value as string)\n      : asError(`Invalid value ${value}, expected a boolean like`),\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? asError(`Invalid value ${value}, expected an array`),\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return asError(`Invalid value ${value}, expected a valid JSON string`);\n    }\n  },\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return asError(`Invalid value ${value}, expected a valid base64 string`);\n    }\n  },\n};\n\nexport interface ErrorFormatter {\n  (value: unknown, expected: unknown, path: string, subject: string): string;\n}\n\nexport const formatError: ErrorFormatter = (value, expected, path, subject) =>\n  `Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;\n\nclass Context {\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  register(value: unknown): number {\n    if (!this.registry.includes(value)) {\n      this.registry.push(value);\n    }\n    return this.registry.indexOf(value);\n  }\n\n  unique(prefix: string) {\n    return `${prefix}$$${this.varIndex++}`;\n  }\n}\n\nconst codeGenCollectErrors = (errorsAlias: string, code: string, extra: string = '') => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${extra}}`;\nconst codeGenExpectNoErrors = (errorsAlias: string) => `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`;\nconst codeGenExpectNonError = (valueAlias: string, path: string) =>\n  `if (${valueAlias} instanceof Error) { throw new TypeError(\\`\\${${valueAlias}.message} for path \"${path}\".\\`); }`;\nconst codeGenExpectNonNullable = (valueAlias: string, path: string) =>\n  `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`;\nconst codeGenExpectObject = (valueAlias: string, path: string, instanceOf: string) =>\n  `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of ${instanceOf}\\`); }`;\nconst codeGenExpectArray = (valueAlias: string, path: string) =>\n  `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`;\n\nconst codeGen = <T>(schema: Schema<T>, context: Context, valuePath: string, path: string): string => {\n  if (schema instanceof And) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas.map((s) => `try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  ${codeGenExpectNoErrors(errorsAlias)}\n`;\n  } else if (schema instanceof Or) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas\n      .map((s) => codeGen(s, context, valueAlias, path))\n      .reduceRight((result, code) => codeGenCollectErrors(errorsAlias, code, result), codeGenExpectNoErrors(errorsAlias));\n    return `// Or\nconst ${errorsAlias} = [];\nconst ${valueAlias} = ${valuePath};\n${code}\n    `;\n  } else if (schema instanceof Optional) {\n    const valueAlias = context.unique('v');\n    return `// Optional\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }\n`;\n  } else if (schema instanceof Tuple) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code: string[] = [\n      '// Tuple',\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${errorsAlias} = [];`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n      `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\\`Invalid tuple length \\${${valueAlias}.length} for path \"${path}\", expected ${schema.schemas.length}.\\`); }`,\n      ...schema.schemas.map((s, idx) => codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))),\n      codeGenExpectNoErrors(errorsAlias),\n    ];\n    return code.join('\\n');\n  } else if (typeof schema === 'function') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${registryAlias} = ctx.registry[${index}];`,\n      codeGenExpectNonNullable(valueAlias, path),\n    ];\n    if ((schema as unknown) !== Error && !(schema?.prototype instanceof Error)) {\n      code.push(codeGenExpectNonError(valueAlias, path));\n    }\n\n    code.push(\n      `if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }`,\n      `if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }`,\n      `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected a valid ${schema?.name}\\`); }`,\n    );\n    return code.join('\\n');\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectNonError(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n    ];\n    if (schema.length > 0) {\n      const value = context.unique('val');\n      const key = context.unique('key');\n      const errorsAlias = context.unique('err');\n      code.push(`const ${errorsAlias} = [];`);\n      code.push(\n        ...schema.map(\n          (s) => `${valueAlias}.forEach((${value},${key}) => { ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\\${${key}}]`))} });`,\n        ),\n      );\n\n      code.push(codeGenExpectNoErrors(errorsAlias));\n    }\n    return code.join('\\n');\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      const valueAlias = context.unique('v');\n      return `\nconst ${valueAlias} = ${valuePath};\n${codeGenExpectNonNullable(valueAlias, path)}\n${codeGenExpectNonError(valueAlias, path)}\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected to match ${schema.toString()}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        codeGenExpectNonNullable(valueAlias, path),\n        codeGenExpectObject(valueAlias, path, 'Object'),\n        codeGenExpectNonError(valueAlias, path),\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('k');\n        const errorsAlias = context.unique('err');\n        const kAlias = context.unique('k');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = [];\n${keysAlias}.forEach(${kAlias} => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const kAlias = context.unique('k');\n        const entriesAlias = context.unique('en');\n        const errorsAlias = context.unique('err');\n        code.push(`\nconst ${entriesAlias} = Object.entries(${valueAlias});\nconst ${errorsAlias} = [];\n${entriesAlias}.forEach(([${kAlias},${vAlias}]) => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($strict in schema && schema[$strict]) {\n        const keysAlias = context.unique('k');\n        const kAlias = context.unique('k');\n        const extraAlias = context.unique('ex');\n        code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);\n        code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);\n        code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\\`Extra properties: \\${${extraAlias}}, are not allowed for path \"${path}\"\\`); }`);\n      }\n      code.push(...Object.entries(schema).map(([key, s]) => codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));\n      return `${code.join('\\n')}`;\n    }\n  } else if (typeof schema === 'symbol') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for \"path\", expected symbol\\`); }\nif (${valueAlias} !== ${registryAlias}) { throw new TypeError(\\`Invalid value \\${${valueAlias}.toString()} for path \"${path}\", expected ${schema.toString()}\\`); }\n    `;\n  } else if (schema === null || schema === undefined) {\n    const valueAlias = context.unique('v');\n    return `\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\\`Invalid value ${valueAlias} for path \"${path}\", expected nullable\\`); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${value} = ${JSON.stringify(schema)};\n${codeGenExpectNonError(valueAlias, path)}\nif (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected ${typeof schema}\\`); }\nif (${valueAlias} !== ${value}) { throw new TypeError(\\`Invalid value ${JSON.stringify(valueAlias)} for path \"${path}\", expected ${JSON.stringify(schema)}\\`); }\n`;\n  }\n};\n\nexport const compile = <T>(schema: Schema<T>, rootName: string) => {\n  const context = new Context();\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: T) => validator(context, data);\n};\n\nexport const ascertain = <T>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  compile(schema, rootName)(data);\n};\n"],"names":["Operator","constructor","schemas","length","TypeError","name","$keys","Symbol","for","$values","$strict","Or","or","And","and","Optional","schema","optional","Tuple","tuple","fromBase64","Buffer","value","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","asError","message","as","string","number","result","parseFloat","Number","isNaN","date","Date","parse","valueOf","time","conversionFactor","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","JSON","e","base64","formatError","expected","path","subject","stringify","Context","registry","varIndex","register","includes","push","indexOf","unique","prefix","codeGenCollectErrors","errorsAlias","code","extra","codeGenExpectNoErrors","codeGenExpectNonError","valueAlias","codeGenExpectNonNullable","codeGenExpectObject","instanceOf","codeGenExpectArray","codeGen","context","valuePath","map","join","reduceRight","idx","index","registryAlias","Error","prototype","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","Object","keys","entries","undefined","compile","rootName","validator","Function","data","ascertain"],"mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Abstract base class for schema operators.\n *\n * Provides a common constructor that enforces having at least one schema.\n *\n * @template T - The type of data the operator validates.\n * @abstract\n * @internal\n */\nabstract class Operator<T> {\n  constructor(public readonly schemas: Schema<T>[]) {\n    if (schemas.length === 0) {\n      throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);\n    }\n  }\n}\n\n// https://standardschema.dev/\n\n/**\n * Symbol for validating object keys against a schema.\n */\nexport const $keys = Symbol.for('@@keys');\n/**\n * Symbol for validating object values against a schema.\n */\nexport const $values = Symbol.for('@@values');\n/**\n * Symbol for enforcing strict object validation (no extra properties allowed).\n */\nexport const $strict = Symbol.for('@@strict');\n\n/**\n * Represents a schema for validating data.\n *\n * Schemas can be defined for various data types, including objects, arrays, and primitives.\n *\n * @template T - The type of data the schema validates.\n */\nexport type Schema<T> =\n  T extends Record<string | number | symbol, unknown>\n    ? { [K in keyof T]?: Schema<T[K]> | unknown } & { [$keys]?: Schema<keyof T> } & { [$values]?: Schema<T[keyof T]> } & { [$strict]?: boolean }\n    : T extends Array<infer A>\n      ? Schema<A>[] | unknown\n      : unknown;\n\nclass Or<T> extends Operator<T> {}\n/**\n * Operator for validating data against any of the provided schemas (logical OR).\n *\n * Creates a schema that accepts data matching any one of the provided schemas.\n * This is useful for creating union types or alternative validation paths.\n *\n * @template T - The type of data the operator validates.\n * @param schemas - Multiple schemas where at least one must match the data.\n * @returns A schema that validates data against any of the provided schemas.\n *\n * @example\n * ```typescript\n * import { or, ascertain } from 'ascertain';\n *\n * // Create a schema that accepts either a string or number\n * const stringOrNumber = or(String, Number);\n *\n * ascertain(stringOrNumber, \"hello\", \"value\"); // ✓ Valid\n * ascertain(stringOrNumber, 42, \"value\");      // ✓ Valid\n * ascertain(stringOrNumber, true, \"value\");    // ✗ Throws error\n *\n * // Union of literal values\n * const statusSchema = or('pending', 'completed', 'failed');\n * ascertain(statusSchema, 'pending', \"status\"); // ✓ Valid\n *\n * // Complex schema combinations\n * const userIdSchema = or(Number, { id: Number, temp: Boolean });\n * ascertain(userIdSchema, 123, \"userId\");                    // ✓ Valid\n * ascertain(userIdSchema, { id: 456, temp: true }, \"userId\"); // ✓ Valid\n * ```\n */\nexport const or = <T>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T> extends Operator<T> {}\n/**\n * Operator for validating data against all provided schemas (logical AND).\n *\n * Creates a schema that requires data to match every one of the provided schemas.\n * This is useful for combining multiple validation requirements or adding constraints.\n *\n * @template T - The type of data the operator validates.\n * @param schemas - Multiple schemas that all must match the data.\n * @returns A schema that validates data against all of the provided schemas.\n *\n * @example\n * ```typescript\n * import { and, ascertain } from 'ascertain';\n *\n * // Combine object schema with additional constraints\n * const userSchema = and(\n *   { name: String, age: Number },\n *   { age: Number } // Additional constraint\n * );\n *\n * ascertain(userSchema, { name: \"John\", age: 25 }, \"user\"); // ✓ Valid\n *\n * // Ensure an object is both a Date and has specific methods\n * const validDateSchema = and(Date, { toISOString: Function });\n * ascertain(validDateSchema, new Date(), \"date\"); // ✓ Valid\n *\n * // Multiple validation layers\n * const positiveNumberSchema = and(Number, (n: number) => n > 0);\n * ascertain(positiveNumberSchema, 42, \"count\");   // ✓ Valid\n * ascertain(positiveNumberSchema, -5, \"count\");   // ✗ Throws error\n * ```\n */\nexport const and = <T>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T> extends Operator<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\n/**\n * Operator for making a schema optional (nullable).\n *\n * Creates a schema that accepts the provided schema or null/undefined values.\n * This is useful for optional object properties or nullable fields.\n *\n * @template T - The type of data the operator validates.\n * @param schema - The schema to make optional.\n * @returns A schema that validates data against the provided schema or accepts null/undefined.\n *\n * @example\n * ```typescript\n * import { optional, ascertain } from 'ascertain';\n *\n * // Optional string field\n * const userSchema = {\n *   name: String,\n *   nickname: optional(String),\n *   age: Number\n * };\n *\n * // All of these are valid\n * ascertain(userSchema, {\n *   name: \"John\",\n *   nickname: \"Johnny\",\n *   age: 30\n * }, \"user\"); // ✓ Valid\n *\n * ascertain(userSchema, {\n *   name: \"Jane\",\n *   nickname: null,\n *   age: 25\n * }, \"user\"); // ✓ Valid\n *\n * ascertain(userSchema, {\n *   name: \"Bob\",\n *   age: 35\n *   // nickname is undefined\n * }, \"user\"); // ✓ Valid\n *\n * // Optional complex objects\n * const profileSchema = {\n *   id: Number,\n *   settings: optional({\n *     theme: String,\n *     notifications: Boolean\n *   })\n * };\n * ```\n */\nexport const optional = <T>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T> extends Operator<T> {}\n/**\n * Operator for validating data against a fixed-length tuple of schemas.\n *\n * Creates a schema that validates arrays with a specific length and type for each position.\n * This is useful for coordinate pairs, RGB values, or any fixed-structure data.\n *\n * @template T - The type of data the operator validates (a tuple of types).\n * @param schemas - Schemas for each position in the tuple, in order.\n * @returns A schema that validates data as a tuple with the specified structure.\n *\n * @example\n * ```typescript\n * import { tuple, ascertain } from 'ascertain';\n *\n * // 2D coordinate tuple\n * const pointSchema = tuple(Number, Number);\n * ascertain(pointSchema, [10, 20], \"point\"); // ✓ Valid\n * ascertain(pointSchema, [1.5, 2.7], \"point\"); // ✓ Valid\n * ascertain(pointSchema, [10], \"point\"); // ✗ Throws error (too short)\n * ascertain(pointSchema, [10, 20, 30], \"point\"); // ✗ Throws error (too long)\n *\n * // RGB color tuple\n * const colorSchema = tuple(Number, Number, Number);\n * ascertain(colorSchema, [255, 128, 0], \"color\"); // ✓ Valid\n *\n * // Mixed type tuple\n * const userInfoSchema = tuple(String, Number, Boolean);\n * ascertain(userInfoSchema, [\"Alice\", 25, true], \"userInfo\"); // ✓ Valid\n *\n * // Nested tuple\n * const lineSchema = tuple(\n *   tuple(Number, Number), // start point\n *   tuple(Number, Number)  // end point\n * );\n * ascertain(lineSchema, [[0, 0], [10, 10]], \"line\"); // ✓ Valid\n * ```\n */\nexport const tuple = <T>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const fromBase64 = typeof Buffer === 'undefined' ? (value: string) => atob(value) : (value: string) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const asError = <T>(message: string) => new TypeError(message) as unknown as T;\n\nexport const as = {\n  /**\n   * Attempts to convert a value to a string.\n   *\n   * @param value - The value to convert.\n   * @returns The value as a string, or a TypeError if not a string.\n   */\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : asError(`Invalid value \"${value}\", expected a string`);\n  },\n  /**\n   * Attempts to convert a value to a number.\n   *\n   * @param value - The value to convert (expected to be a string representation of a number).\n   * @returns The value as a number, or a TypeError if not a valid number.\n   */\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;\n  },\n  /**\n   * Attempts to convert a value to a Date object.\n   *\n   * @param value - The value to convert (expected to be a string representation of a date).\n   * @returns The value as a Date object, or a TypeError if not a valid date.\n   */\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    const date = new Date(result);\n    return Number.isNaN(date.valueOf()) ? asError(`Invalid value \"${value}\", expected a valid date format`) : date;\n  },\n  /**\n   * Attempts to convert a value to a time duration in milliseconds.\n   *\n   * @param value - The value to convert (e.g., \"5s\" for 5 seconds).\n   * @param conversionFactor - Optional factor to divide the result by (default is 1).\n   * @returns The time duration in milliseconds, or a TypeError if the format is invalid.\n   */\n  time: (value: string | undefined, conversionFactor = 1): number => {\n    const matches = value?.match(/^(\\d*\\.?\\d*)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(`${(parseFloat(amount) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS]) / conversionFactor}`);\n    }\n    return asError(`Invalid value ${value}, expected a valid time format`);\n  },\n  /**\n   * Attempts to convert a value to a boolean.\n   *\n   * @param value - The boolean like value to convert (e.g., \"true\", \"1\", \"enabled\").\n   * @returns The value as a boolean, or a TypeError if it could not be converted to a boolean.\n   */\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string)\n      ? /^(1|true|enabled)$/i.test(value as string)\n      : asError(`Invalid value ${value}, expected a boolean like`),\n  /**\n   * Attempts to convert a string into an array of strings by splitting it using the given delimiter.\n   *\n   * @param value - The string value to attempt to split into an array.\n   * @param delimiter - The character or string used to separate elements in the input string.\n   * @returns An array of strings if the conversion is successful, or a TypeError if the value is not a string.\n   */\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? asError(`Invalid value ${value}, expected an array`),\n  /**\n   * Attempts to parse a JSON string into a JavaScript object.\n   *\n   * @template T - The expected type of the parsed JSON object.\n   * @param value - The JSON string to attempt to parse.\n   * @returns The parsed JSON object if successful, or a TypeError if the value is not valid JSON.\n   */\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch {\n      return asError(`Invalid value ${value}, expected a valid JSON string`);\n    }\n  },\n  /**\n   * Attempts to decode a base64-encoded string.\n   *\n   * @param value - The base64-encoded string to attempt to decode.\n   * @returns The decoded string if successful, or a TypeError if the value is not valid base64.\n   */\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch {\n      return asError(`Invalid value ${value}, expected a valid base64 string`);\n    }\n  },\n};\n\n/**\n * A class representing the context for schema validation.\n *\n * Stores a registry of values encountered during validation and provides methods for managing it.\n * @internal\n */\nclass Context {\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  register(value: unknown): number {\n    if (!this.registry.includes(value)) {\n      this.registry.push(value);\n    }\n    return this.registry.indexOf(value);\n  }\n\n  unique(prefix: string) {\n    return `${prefix}$$${this.varIndex++}`;\n  }\n}\n\nconst codeGenCollectErrors = (errorsAlias: string, code: string, extra: string = '') => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${extra}}`;\nconst codeGenExpectNoErrors = (errorsAlias: string) => `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`;\nconst codeGenExpectNonError = (valueAlias: string, path: string) =>\n  `if (${valueAlias} instanceof Error) { throw new TypeError(\\`\\${${valueAlias}.message} for path \"${path}\".\\`); }`;\nconst codeGenExpectNonNullable = (valueAlias: string, path: string) =>\n  `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`;\nconst codeGenExpectObject = (valueAlias: string, path: string, instanceOf: string) =>\n  `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of ${instanceOf}\\`); }`;\nconst codeGenExpectArray = (valueAlias: string, path: string) =>\n  `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`;\n\nconst codeGen = <T>(schema: Schema<T>, context: Context, valuePath: string, path: string): string => {\n  if (schema instanceof And) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas.map((s) => `try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  ${codeGenExpectNoErrors(errorsAlias)}\n`;\n  } else if (schema instanceof Or) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code = schema.schemas\n      .map((s) => codeGen(s, context, valueAlias, path))\n      .reduceRight((result, code) => codeGenCollectErrors(errorsAlias, code, result), codeGenExpectNoErrors(errorsAlias));\n    return `// Or\nconst ${errorsAlias} = [];\nconst ${valueAlias} = ${valuePath};\n${code}\n    `;\n  } else if (schema instanceof Optional) {\n    const valueAlias = context.unique('v');\n    return `// Optional\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }\n`;\n  } else if (schema instanceof Tuple) {\n    const valueAlias = context.unique('v');\n    const errorsAlias = context.unique('err');\n    const code: string[] = [\n      '// Tuple',\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${errorsAlias} = [];`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n      `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\\`Invalid tuple length \\${${valueAlias}.length} for path \"${path}\", expected ${schema.schemas.length}.\\`); }`,\n      ...schema.schemas.map((s, idx) => codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))),\n      codeGenExpectNoErrors(errorsAlias),\n    ];\n    return code.join('\\n');\n  } else if (typeof schema === 'function') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `const ${registryAlias} = ctx.registry[${index}];`,\n      codeGenExpectNonNullable(valueAlias, path),\n    ];\n    if ((schema as unknown) !== Error && !(schema?.prototype instanceof Error)) {\n      code.push(codeGenExpectNonError(valueAlias, path));\n    }\n\n    code.push(\n      `if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }`,\n      `if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }`,\n      `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected a valid ${schema?.name}\\`); }`,\n    );\n    return code.join('\\n');\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      codeGenExpectNonNullable(valueAlias, path),\n      codeGenExpectNonError(valueAlias, path),\n      codeGenExpectObject(valueAlias, path, 'Array'),\n      codeGenExpectArray(valueAlias, path),\n    ];\n    if (schema.length > 0) {\n      const value = context.unique('val');\n      const key = context.unique('key');\n      const errorsAlias = context.unique('err');\n      code.push(`const ${errorsAlias} = [];`);\n      code.push(\n        ...schema.map(\n          (s) => `${valueAlias}.forEach((${value},${key}) => { ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\\${${key}}]`))} });`,\n        ),\n      );\n\n      code.push(codeGenExpectNoErrors(errorsAlias));\n    }\n    return code.join('\\n');\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      const valueAlias = context.unique('v');\n      return `\nconst ${valueAlias} = ${valuePath};\n${codeGenExpectNonNullable(valueAlias, path)}\n${codeGenExpectNonError(valueAlias, path)}\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected to match ${schema.toString()}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        codeGenExpectNonNullable(valueAlias, path),\n        codeGenExpectObject(valueAlias, path, 'Object'),\n        codeGenExpectNonError(valueAlias, path),\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('k');\n        const errorsAlias = context.unique('err');\n        const kAlias = context.unique('k');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = [];\n${keysAlias}.forEach(${kAlias} => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const kAlias = context.unique('k');\n        const entriesAlias = context.unique('en');\n        const errorsAlias = context.unique('err');\n        code.push(`\nconst ${entriesAlias} = Object.entries(${valueAlias});\nconst ${errorsAlias} = [];\n${entriesAlias}.forEach(([${kAlias},${vAlias}]) => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`))} });\n${codeGenExpectNoErrors(errorsAlias)}\n`);\n      }\n      if ($strict in schema && schema[$strict]) {\n        const keysAlias = context.unique('k');\n        const kAlias = context.unique('k');\n        const extraAlias = context.unique('ex');\n        code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);\n        code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);\n        code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\\`Extra properties: \\${${extraAlias}}, are not allowed for path \"${path}\"\\`); }`);\n      }\n      code.push(...Object.entries(schema).map(([key, s]) => codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));\n      return `${code.join('\\n')}`;\n    }\n  } else if (typeof schema === 'symbol') {\n    const index = context.register(schema);\n    const valueAlias = context.unique('v');\n    const registryAlias = context.unique('r');\n\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected symbol\\`); }\nif (${valueAlias} !== ${registryAlias}) { throw new TypeError(\\`Invalid value \\${${valueAlias}.toString()} for path \"${path}\", expected ${schema.toString()}\\`); }\n    `;\n  } else if (schema === null || schema === undefined) {\n    const valueAlias = context.unique('v');\n    return `\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\\`Invalid value \\${JSON.stringify(${valueAlias})} for path \"${path}\", expected nullable\\`); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${value} = ${JSON.stringify(schema)};\n${codeGenExpectNonError(valueAlias, path)}\nif (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected ${typeof schema}\\`); }\nif (${valueAlias} !== ${value}) { throw new TypeError(\\`Invalid value \\${JSON.stringify(${valueAlias})} for path \"${path}\", expected ${JSON.stringify(schema)}\\`); }\n`;\n  }\n};\n\n/**\n * Compiles a schema into a validation function.\n *\n * This function takes a schema definition and generates a JavaScript function\n * that can be used to validate data against the schema.\n *\n * @template T - The type of data the schema validates.\n * @param schema - The schema to compile.\n * @param rootName - A name for the root of the data structure (used in error messages).\n * @returns A validation function that takes data as input and throws a TypeError if the data does not conform to the schema.\n *\n * @example\n * ```typescript\n * import { compile, optional, and, or } from 'ascertain';\n *\n * const userSchema = {\n *   name: String,\n *   age: Number,\n *   email: optional(String),\n *   role: or('admin', 'user', 'guest')\n * };\n *\n * const validateUser = compile(userSchema, 'User');\n *\n * // Valid data - no error thrown\n * validateUser({\n *   name: 'John Doe',\n *   age: 30,\n *   email: 'john@example.com',\n *   role: 'user'\n * });\n *\n * // Invalid data - throws TypeError\n * try {\n *   validateUser({\n *     name: 123, // Invalid: should be string\n *     age: 'thirty' // Invalid: should be number\n *   });\n * } catch (error) {\n *   console.error(error.message); // Detailed validation errors\n * }\n * ```\n */\nexport const compile = <T>(schema: Schema<T>, rootName: string) => {\n  const context = new Context();\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: T) => validator(context, data);\n};\n\n/**\n * Asserts that data conforms to a given schema.\n *\n * This function is a convenient wrapper around `compile`. It compiles the schema\n * and immediately validates the provided data against it.\n *\n * @template T - The type of data the schema validates.\n * @param schema - The schema to validate against.\n * @param data - The data to validate.\n * @param rootName - A name for the root of the data structure (used in error messages, defaults to '[root]').\n * @throws `{TypeError}` If the data does not conform to the schema.\n *\n * @example\n * ```typescript\n * import { ascertain, optional, and, or } from 'ascertain';\n *\n * const userSchema = {\n *   name: String,\n *   age: Number,\n *   email: optional(String),\n *   active: Boolean\n * };\n *\n * const userData = {\n *   name: 'Alice',\n *   age: 25,\n *   email: 'alice@example.com',\n *   active: true\n * };\n *\n * // Validate data - throws if invalid, otherwise continues silently\n * ascertain(userSchema, userData, 'UserData');\n * console.log('User data is valid!');\n *\n * // Example with invalid data\n * try {\n *   ascertain(userSchema, {\n *     name: 'Bob',\n *     age: 'twenty-five', // Invalid: should be number\n *     active: true\n *   }, 'UserData');\n * } catch (error) {\n *   console.error('Validation failed:', error.message);\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Array validation\n * const numbersSchema = [Number];\n * const numbers = [1, 2, 3, 4, 5];\n *\n * ascertain(numbersSchema, numbers, 'Numbers');\n *\n * // Tuple validation\n * const coordinateSchema = tuple(Number, Number);\n * const point = [10, 20];\n *\n * ascertain(coordinateSchema, point, 'Point');\n * ```\n */\nexport const ascertain = <T>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  compile(schema, rootName)(data);\n};\n"],"names":["Operator","schemas","length","TypeError","name","$keys","Symbol","for","$values","$strict","Or","or","And","and","Optional","schema","optional","Tuple","tuple","fromBase64","Buffer","value","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","asError","message","as","string","number","result","parseFloat","Number","isNaN","date","Date","parse","valueOf","time","conversionFactor","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","JSON","base64","Context","registry","varIndex","register","includes","push","indexOf","unique","prefix","codeGenCollectErrors","errorsAlias","code","extra","codeGenExpectNoErrors","codeGenExpectNonError","valueAlias","path","codeGenExpectNonNullable","codeGenExpectObject","instanceOf","codeGenExpectArray","codeGen","context","valuePath","map","join","reduceRight","idx","index","registryAlias","Error","prototype","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","stringify","Object","keys","entries","undefined","compile","rootName","validator","Function","data","ascertain"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ascertain",
-  "version": "1.2.127",
+  "version": "2.0.0-rc.1",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
   "type": "module",
   "types": "build/index.d.ts",
@@ -14,13 +14,6 @@
     "build",
     "src/index.js"
   ],
-  "scripts": {
-    "build": "rm -rf build && NODE_ENV=production inop src/ build -i __tests__ && tsc --declaration --emitDeclarationOnly",
-    "lint": "eslint src",
-    "test": "NODE_ENV=test jest --bail",
-    "test:cov": "CI=1 NODE_ENV=test jest",
-    "prepare": "husky"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/3axap4eHko/ascertain.git"
@@ -45,25 +38,39 @@
   },
   "homepage": "https://github.com/3axap4eHko/ascertain#readme",
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.31.0",
-    "@swc/jest": "^0.2.39",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^20.19.7",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
+    "@types/node": "^24.0.13",
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "@typescript-eslint/typescript-estree": "^8.36.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vuepress/bundler-vite": "2.0.0-rc.24",
+    "@vuepress/theme-default": "2.0.0-rc.112",
     "eslint": "^9.31.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.32.0",
+    "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^5.5.1",
+    "handlebars": "^4.7.8",
     "husky": "^9.1.7",
     "inop": "^0.7.8",
-    "jest": "^29.7.0",
     "overtake": "^0.1.2",
     "prettier": "^3.6.2",
+    "recast": "^0.23.11",
+    "sass-embedded": "^1.89.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.17",
+    "vuepress": "2.0.0-rc.24"
   },
-  "packageManager": "pnpm@9.15.9"
-}
+  "scripts": {
+    "build": "rm -rf build && NODE_ENV=production inop src/ build -i __tests__ && tsc --declaration --emitDeclarationOnly",
+    "lint": "eslint src",
+    "test": "NODE_ENV=test vitest run",
+    "docs:build": "vuepress build docs",
+    "docs:clean-dev": "vuepress dev docs --clean-cache",
+    "docs:dev": "vuepress dev docs",
+    "docs:gen": "node --loader ts-node/esm ./scripts/docgen.ts src/index.ts",
+    "docs:update-package": "pnpm dlx vp-update"
+  }
+}