ascertain 1.0.2 → 1.0.4

package/build/index.cjs

@@ -12,12 +12,12 @@ _export(exports, {
     $keys: function() {
         return $keys;
     },
+    $strict: function() {
+        return $strict;
+    },
     $values: function() {
         return $values;
     },
-    AssertError: function() {
-        return AssertError;
-    },
     and: function() {
         return and;
     },
@@ -30,6 +30,9 @@ _export(exports, {
     compile: function() {
         return compile;
     },
+    formatError: function() {
+        return formatError;
+    },
     fromBase64: function() {
         return fromBase64;
     },
@@ -43,20 +46,7 @@ _export(exports, {
         return tuple;
     }
 });
-class AssertError extends TypeError {
-    value;
-    expected;
-    path;
-    subject;
-    constructor(value, expected, path, subject = 'value'){
-        super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);
-        this.value = value;
-        this.expected = expected;
-        this.path = path;
-        this.subject = subject;
-    }
-}
-class Operation {
+class Operator {
     schemas;
     constructor(schemas){
         this.schemas = schemas;
@@ -65,13 +55,16 @@ class Operation {
         }
     }
 }
-class Or extends Operation {
+const $keys = Symbol.for('@@keys');
+const $values = Symbol.for('@@values');
+const $strict = Symbol.for('@@strict');
+class Or extends Operator {
 }
 const or = (...schemas)=>new Or(schemas);
-class And extends Operation {
+class And extends Operator {
 }
 const and = (...schemas)=>new And(schemas);
-class Optional extends Operation {
+class Optional extends Operator {
     constructor(schema){
         super([
             schema
@@ -79,11 +72,9 @@ class Optional extends Operation {
     }
 }
 const optional = (schema)=>new Optional(schema);
-class Tuple extends Operation {
+class Tuple extends Operator {
 }
 const tuple = (...schemas)=>new Tuple(schemas);
-const $keys = Symbol.for('@@keys');
-const $values = Symbol.for('@@values');
 const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
 const MULTIPLIERS = {
     ms: 1,
@@ -130,17 +121,10 @@ const as = {
         }
     }
 };
+const formatError = (value, expected, path, subject)=>`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;
 class Context {
-    options;
-    Error;
-    registry;
-    varIndex;
-    constructor(options = {}){
-        this.options = options;
-        this.registry = [];
-        this.varIndex = 0;
-        this.Error = options.error ?? AssertError;
-    }
+    registry = [];
+    varIndex = 0;
     register(value) {
         if (!this.registry.includes(value)) {
             this.registry.push(value);
@@ -155,17 +139,17 @@ const codeGen = (schema, context, valuePath, path)=>{
     if (schema instanceof And) {
         const valueAlias = context.unique('v');
         const errorsAlias = context.unique('err');
-        const code = schema.schemas.map((s)=>`try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e); }`).join('\n');
+        const code = schema.schemas.map((s)=>`try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\n');
         return `// And
   const ${errorsAlias} = [];
   const ${valueAlias} = ${valuePath};
   ${code}
-  if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
+  if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
 `;
     } else if (schema instanceof Or) {
         const valueAlias = context.unique('v');
         const errorsAlias = context.unique('err');
-        const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, path)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"');`);
+        const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, path)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e.message);${result}}`, `throw new TypeError(${errorsAlias}.join('\\n'));`);
         return `// Or
 const ${errorsAlias} = [];
 const ${valueAlias} = ${valuePath};
@@ -184,9 +168,12 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
             '// Tuple',
             `const ${valueAlias} = ${valuePath};`,
             `const ${errorsAlias} = [];`,
-            `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \`${path}\`); }`,
-            ...schema.schemas.map((s, idx)=>`try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`),
-            `if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }`
+            `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+            `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected an instance of Array\`); }`,
+            `if (!Array.isArray(${valueAlias})) { throw new TypeError(\`Invalid instance of \${${valueAlias}.constructor?.name} for path "${path}", expected an instance of Array.\`); }`,
+            `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\`Invalid tuple length \${${valueAlias}.length} for path "${path}", expected ${schema.schemas.length}.\`); }`,
+            ...schema.schemas.map((s, idx)=>`try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e.message); }`),
+            `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }`
         ];
         return code.join('\n');
     } else if (typeof schema === 'function') {
@@ -196,23 +183,25 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \`${path}\`); }
-if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \`instance of \${${registryAlias}.name}\`, \`${path}\`, 'instance of'); }
-if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \`${path}\`, 'type'); }
+if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }
+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}\`); }
+if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\`Invalid type \${${valueAlias}?.constructor?.name} for path "${path}", expected type ${schema?.name}\`); }
 `;
     } else if (Array.isArray(schema)) {
         const valueAlias = context.unique('v');
         const code = [
             `const ${valueAlias} = ${valuePath};`,
-            `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \`${path}\`); }`
+            `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+            `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected an instance of Array.\`); }`,
+            `if (!Array.isArray(${valueAlias})) { throw new TypeError(\`Invalid instance of \${${valueAlias}.constructor?.name} for path "${path}", expected an instance of Array.\`); }`
         ];
         if (schema.length > 0) {
             const value = context.unique('val');
             const key = context.unique('key');
             const errorsAlias = context.unique('err');
             code.push(`const ${errorsAlias} = [];`);
-            code.push(...schema.map((s)=>`${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e); } });`));
-            code.push(`if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }`);
+            code.push(...schema.map((s)=>`${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e.message); } });`));
+            code.push(`if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }`);
         }
         return code.join('\n');
     } else if (typeof schema === 'object' && schema !== null) {
@@ -220,38 +209,46 @@ if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${regist
             const valueAlias = context.unique('v');
             return `
 const ${valueAlias} = ${valuePath};
-if (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \`${path}\`); }
+if (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected to match ${schema.toString()}\`); }
 `;
         } else {
             const valueAlias = context.unique('v');
             const code = [
                 `const ${valueAlias} = ${valuePath};`,
-                `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'object', \`${path}\`); }`,
-                `if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \`${path}\`); }`
+                `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+                `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected type is object.\`); }`
             ];
             if ($keys in schema) {
-                const keysAlias = context.unique('key');
+                const keysAlias = context.unique('k');
                 const errorsAlias = context.unique('err');
-                const value = context.unique('v');
+                const kAlias = context.unique('k');
                 code.push(`
 const ${keysAlias} = Object.keys(${valueAlias});
-const ${errorsAlias} = ${keysAlias}.flatMap((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).filter(Boolean);
-if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
+const ${errorsAlias} = ${keysAlias}.map(${kAlias} => { try { ${codeGen(schema[$keys], context, kAlias, `${path}[\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);
+if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
 `);
             }
             if ($values in schema) {
                 const vAlias = context.unique('val');
-                const valuesAlias = context.unique('vals');
+                const kAlias = context.unique('k');
+                const entriesAlias = context.unique('en');
                 const errorsAlias = context.unique('err');
-                code.push(`{
-const ${valuesAlias} = Object.values(${valuePath});
-const ${errorsAlias} = ${valuesAlias}.flatMap((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).filter(Boolean);
-if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
-}`);
+                code.push(`
+const ${entriesAlias} = Object.entries(${valueAlias});
+const ${errorsAlias} = ${entriesAlias}.map(([${kAlias},${vAlias}]) => { try { ${codeGen(schema[$values], context, vAlias, `${path}[\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);
+if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
+`);
+            }
+            if ($strict in schema && schema[$strict]) {
+                const keysAlias = context.unique('k');
+                const kAlias = context.unique('k');
+                const extraAlias = context.unique('ex');
+                code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);
+                code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);
+                code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\`Extra properties: \${${extraAlias}}, are not allowed for path "${path}"\`); }`);
             }
-            const keys = Object.keys(schema);
-            code.push(...keys.map((key)=>codeGen(schema[key], context, `${valueAlias}['${key}']`, `${path}.${key}`)));
-            return `{${code.join('\n')}}`;
+            code.push(...Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));
+            return `${code.join('\n')}`;
         }
     } else if (typeof schema === 'symbol') {
         const index = context.register(schema);
@@ -260,136 +257,34 @@ if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Inv
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (typeof ${valueAlias} !== 'symbol') { throw new ctx.Error(typeof ${valueAlias}, 'symbol', '${path}', 'type of'); }
-if (${valueAlias} !== ${registryAlias}) { throw new ctx.Error(${valueAlias}.toString(), ${registryAlias}.toString(), '${path}', 'symbol'); }
+if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for "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 ctx.Error(${valueAlias}, 'nullable', '${path}'); }
+if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value ${valueAlias} for path "${path}", expected nullable\`); }
     `;
     } else {
         const valueAlias = context.unique('v');
-        const typeAlias = context.unique('t');
         const value = context.unique('val');
         return `
 const ${valueAlias} = ${valuePath};
-const ${typeAlias} = '${typeof schema}';
 const ${value} = ${JSON.stringify(schema)};
-if (typeof ${valueAlias} !== ${typeAlias}) { throw new ctx.Error(typeof ${valueAlias}, ${typeAlias}, '${path}', 'type of'); }
-if (${valueAlias} !== ${value}) { throw new ctx.Error(${valueAlias}, ${value}, '${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)}\`); }
 `;
     }
 };
-const flatAggregateError = (error)=>{
-    return error.errors.flatMap((e)=>e instanceof AggregateError ? flatAggregateError(e) : e);
-};
-const compile = (schema, rootName, options = {})=>{
-    const context = new Context(options);
+const compile = (schema, rootName)=>{
+    const context = new Context();
     const code = codeGen(schema, context, 'data', rootName);
     const validator = new Function('ctx', 'data', code);
-    return (data)=>{
-        try {
-            validator(context, data);
-        } catch (e) {
-            const errors = e instanceof AggregateError ? flatAggregateError(e) : [
-                e
-            ];
-            throw new AggregateError(errors, 'Validation failure');
-        }
-    };
-};
-const assert = (target, schema, path)=>{
-    if (schema instanceof And) {
-        return schema.schemas.flatMap((schema)=>assert(target, schema, path)).filter((error)=>!!error);
-    } else if (schema instanceof Or) {
-        const errors = schema.schemas.flatMap((schema)=>assert(target, schema, path));
-        const filteredErrors = errors.filter((error)=>!!error);
-        if (filteredErrors.length === schema.schemas.length) {
-            return filteredErrors;
-        }
-    } else if (schema instanceof Optional) {
-        if (target !== undefined && target !== null) {
-            return assert(target, schema.schemas[0], path);
-        }
-    } else if (schema instanceof Tuple) {
-        if (!Array.isArray(target)) {
-            return [
-                new AssertError(target, 'array', path)
-            ];
-        }
-        return schema.schemas.flatMap((s, idx)=>assert(target[idx], s, `${path}[${idx}]`)).filter((error)=>!!error);
-    } else if (typeof schema === 'function') {
-        if (target === null || target === undefined) {
-            return [
-                new AssertError(target, 'a non-nullable', path)
-            ];
-        }
-        if (typeof target === 'object' && !(target instanceof schema)) {
-            return [
-                new AssertError(target?.constructor?.name, `instance of ${schema.name}`, path, 'instance of')
-            ];
-        }
-        if (typeof target !== 'object' && target?.constructor !== schema) {
-            return [
-                new AssertError(target?.constructor?.name, schema.name, path, 'type')
-            ];
-        }
-    } else if (Array.isArray(schema)) {
-        if (!Array.isArray(target)) {
-            return [
-                new AssertError(target, 'array', path)
-            ];
-        }
-        return schema.flatMap((s)=>target.flatMap((value, idx)=>assert(value, s, `${path}[${idx}]`))).filter((error)=>!!error);
-    } else if (typeof schema === 'object' && schema !== null) {
-        if (schema instanceof RegExp) {
-            if (!schema.test('' + target)) {
-                return [
-                    new AssertError(target, `matching ${schema.toString()}`, path)
-                ];
-            }
-            return [];
-        } else {
-            if (target === null || target === undefined) {
-                return [
-                    new AssertError(target, 'object', path)
-                ];
-            }
-            if (typeof target !== 'object') {
-                return [
-                    new AssertError(target, schema.constructor.name, path)
-                ];
-            }
-            if ($keys in schema) {
-                const targetKeys = Object.keys(target);
-                return targetKeys.flatMap((key)=>assert(key, schema[$keys], path)).filter((error)=>!!error);
-            }
-            if ($values in schema) {
-                const targetKeys = Object.keys(target);
-                return targetKeys.flatMap((key)=>assert(target[key], schema[$values], path)).filter((error)=>!!error);
-            }
-            return Object.keys(schema).flatMap((key)=>assert(target[key], schema[key], path)).filter((error)=>!!error);
-        }
-    } else if (schema === null || schema === undefined) {
-        if (target !== null && target !== undefined) {
-            return [
-                new AssertError(target, 'nullable', path)
-            ];
-        }
-    } else if (target !== schema) {
-        return [
-            new AssertError(target, schema, path)
-        ];
-    }
-    return [];
+    return (data)=>validator(context, data);
 };
 const ascertain = (schema, data, rootName = '[root]')=>{
-    const result = assert(data, schema, rootName).filter((error)=>!!error);
-    if (result.length > 0) {
-        throw new AggregateError(result, 'Validation failure');
-    }
+    compile(schema, rootName)(data);
 };
 
 //# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export class AssertError extends TypeError {\n  constructor(\n    public readonly value: unknown,\n    public readonly expected: unknown,\n    public readonly path: string,\n    public readonly subject = 'value',\n  ) {\n    super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);\n  }\n}\n\ntype Keys = string | number | symbol;\ntype DataValue = any;\nexport type Data = Record<Keys, unknown>;\ntype DataArray = DataValue[];\n\nexport type Schema<T> = T extends Data ? { [S in keyof T]?: Schema<T[S]> } : T extends DataArray ? [Schema<T[number]>] : DataValue;\n\nexport type SchemaData<S> =\n  S extends Record<Keys, unknown>\n    ? { [K in keyof S as Exclude<K, typeof $keys | typeof $values>]?: SchemaData<S[K]> } & Record<string, unknown>\n    : S extends unknown[]\n      ? unknown[]\n      : unknown;\n\nabstract class Operation<T extends Data = DataValue> {\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\nclass Or<T extends Data = DataValue> extends Operation<T> {}\nexport const or = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T extends Data = DataValue> extends Operation<T> {}\nexport const and = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T extends Data = DataValue> extends Operation<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\nexport const optional = <T extends Data = DataValue>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T extends Data = DataValue> extends Operation<T> {}\nexport const tuple = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\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 as = {\n  string: (value: string | undefined) => {\n    return typeof value === 'string' ? value : undefined;\n  },\n  number: (value: string | undefined) => {\n    const result = parseFloat(value as string);\n    return Number.isFinite(result) ? result : undefined;\n  },\n  date: (value: string | undefined) => {\n    const result = Date.parse(value as string);\n    return Number.isFinite(result) ? new Date(result) : undefined;\n  },\n  time: (value: string | undefined) => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS];\n    }\n    return undefined;\n  },\n  boolean: (value: string | undefined) =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string) ? /^(1|true|enabled)$/i.test(value as string) : undefined,\n  array: (value: string | undefined, delimiter: string) => value?.split?.(delimiter) ?? undefined,\n  json: (value: string | undefined) => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return undefined;\n    }\n  },\n  base64: (value: string | undefined) => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return undefined;\n    }\n  },\n};\n\nclass Context {\n  public readonly Error: typeof AssertError;\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  constructor(public readonly options: CompilerOptions = {}) {\n    this.Error = options.error ?? AssertError;\n  }\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\nexport interface CompilerOptions {\n  error?: typeof AssertError;\n}\n\nconst codeGen = <T extends Data = DataValue>(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); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\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(\n        (result, code) => `try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`,\n        `throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"');`,\n      );\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      `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \\`${path}\\`); }`,\n      ...schema.schemas.map((s, idx) => `try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`),\n      `if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }`,\n    ];\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    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \\`${path}\\`); }\nif (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \\`instance of \\${${registryAlias}.name}\\`, \\`${path}\\`, 'instance of'); }\nif (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \\`${path}\\`, 'type'); }\n`;\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \\`${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) =>\n            `${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e); } });`,\n        ),\n      );\n\n      code.push(`if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }`);\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};\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \\`${path}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'object', \\`${path}\\`); }`,\n        `if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \\`${path}\\`); }`,\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('key');\n        const errorsAlias = context.unique('err');\n        const value = context.unique('v');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = ${keysAlias}.flatMap((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const valuesAlias = context.unique('vals');\n        const errorsAlias = context.unique('err');\n        code.push(`{\nconst ${valuesAlias} = Object.values(${valuePath});\nconst ${errorsAlias} = ${valuesAlias}.flatMap((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\n}`);\n      }\n      const keys = Object.keys(schema);\n      code.push(...keys.map((key) => codeGen(schema[key], 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 ctx.Error(typeof ${valueAlias}, 'symbol', '${path}', 'type of'); }\nif (${valueAlias} !== ${registryAlias}) { throw new ctx.Error(${valueAlias}.toString(), ${registryAlias}.toString(), '${path}', 'symbol'); }\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 ctx.Error(${valueAlias}, 'nullable', '${path}'); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const typeAlias = context.unique('t');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${typeAlias} = '${typeof schema}';\nconst ${value} = ${JSON.stringify(schema)};\nif (typeof ${valueAlias} !== ${typeAlias}) { throw new ctx.Error(typeof ${valueAlias}, ${typeAlias}, '${path}', 'type of'); }\nif (${valueAlias} !== ${value}) { throw new ctx.Error(${valueAlias}, ${value}, '${path}'); }\n`;\n  }\n};\n\nconst flatAggregateError = (error: AggregateError): AssertError[] => {\n  return error.errors.flatMap((e) => (e instanceof AggregateError ? flatAggregateError(e) : e));\n};\n\nexport const compile = <S>(schema: S, rootName: string, options: CompilerOptions = {}) => {\n  const context = new Context(options);\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: SchemaData<S>) => {\n    try {\n      validator(context, data);\n    } catch (e) {\n      const errors = e instanceof AggregateError ? flatAggregateError(e) : [e];\n      throw new AggregateError(errors, 'Validation failure');\n    }\n  };\n};\n\nconst assert = (target: unknown, schema: unknown, path: string): AssertError[] => {\n  if (schema instanceof And) {\n    return schema.schemas.flatMap((schema) => assert(target, schema, path)).filter((error) => !!error);\n  } else if (schema instanceof Or) {\n    const errors = schema.schemas.flatMap((schema) => assert(target, schema, path));\n    const filteredErrors = errors.filter((error) => !!error);\n    if (filteredErrors.length === schema.schemas.length) {\n      return filteredErrors;\n    }\n  } else if (schema instanceof Optional) {\n    if (target !== undefined && target !== null) {\n      return assert(target, schema.schemas[0], path);\n    }\n  } else if (schema instanceof Tuple) {\n    if (!Array.isArray(target)) {\n      return [new AssertError(target, 'array', path)];\n    }\n    return schema.schemas.flatMap((s, idx) => assert(target[idx], s, `${path}[${idx}]`)).filter((error) => !!error);\n  } else if (typeof schema === 'function') {\n    if (target === null || target === undefined) {\n      return [new AssertError(target, 'a non-nullable', path)];\n    }\n    if (typeof target === 'object' && !(target instanceof schema)) {\n      return [new AssertError(target?.constructor?.name, `instance of ${schema.name}`, path, 'instance of')];\n    }\n    if (typeof target !== 'object' && target?.constructor !== schema) {\n      return [new AssertError(target?.constructor?.name, schema.name, path, 'type')];\n    }\n  } else if (Array.isArray(schema)) {\n    if (!Array.isArray(target)) {\n      return [new AssertError(target, 'array', path)];\n    }\n    return schema.flatMap((s) => target.flatMap((value, idx) => assert(value, s, `${path}[${idx}]`))).filter((error) => !!error);\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      if (!schema.test('' + target)) {\n        return [new AssertError(target, `matching ${schema.toString()}`, path)];\n      }\n      return [];\n    } else {\n      if (target === null || target === undefined) {\n        return [new AssertError(target, 'object', path)];\n      }\n      if (typeof target !== 'object') {\n        return [new AssertError(target, schema.constructor.name, path)];\n      }\n      if ($keys in schema) {\n        const targetKeys = Object.keys(target);\n        return targetKeys.flatMap((key) => assert(key, schema[$keys], path)).filter((error) => !!error);\n      }\n      if ($values in schema) {\n        const targetKeys = Object.keys(target);\n        return targetKeys.flatMap((key) => assert(target[key as keyof typeof target], schema[$values], path)).filter((error) => !!error);\n      }\n      return Object.keys(schema)\n        .flatMap((key) => assert(target[key as keyof typeof target], schema[key as keyof typeof target], path))\n        .filter((error) => !!error);\n    }\n  } else if (schema === null || schema === undefined) {\n    if (target !== null && target !== undefined) {\n      return [new AssertError(target, 'nullable', path)];\n    }\n  } else if (target !== schema) {\n    return [new AssertError(target, schema, path)];\n  }\n  return [];\n};\n\nexport const ascertain = <T extends Data = DataValue>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  const result = assert(data, schema, rootName).filter((error) => !!error);\n  if (result.length > 0) {\n    throw new AggregateError(result, 'Validation failure');\n  }\n};\n"],"names":["$keys","$values","AssertError","and","as","ascertain","compile","fromBase64","optional","or","tuple","TypeError","constructor","value","expected","path","subject","JSON","stringify","Operation","schemas","length","name","Or","And","Optional","schema","Tuple","Symbol","for","Buffer","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","string","undefined","number","result","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","e","base64","Context","Error","registry","varIndex","options","error","register","includes","push","indexOf","unique","prefix","codeGen","context","valuePath","valueAlias","errorsAlias","code","map","join","reduceRight","idx","index","registryAlias","Array","isArray","key","RegExp","keysAlias","vAlias","valuesAlias","keys","Object","typeAlias","flatAggregateError","errors","flatMap","AggregateError","rootName","validator","Function","data","assert","target","filter","filteredErrors","targetKeys"],"mappings":"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"}
+{"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 as = {\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : (undefined as unknown as string);\n  },\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isFinite(result) ? result : (undefined as unknown as number);\n  },\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    return Number.isFinite(result) ? new Date(result) : (undefined as unknown as Date);\n  },\n  time: (value: string | undefined): number => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS];\n    }\n    return undefined as unknown as number;\n  },\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string) ? /^(1|true|enabled)$/i.test(value as string) : (undefined as unknown as boolean),\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? (undefined as unknown as string[]),\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return undefined as unknown as T;\n    }\n  },\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return undefined as unknown as 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 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  if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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) => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${result}}`, `throw new TypeError(${errorsAlias}.join('\\\\n'));`);\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      `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n      `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of Array\\`); }`,\n      `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`,\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(\n        (s, idx) => `try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e.message); }`,\n      ),\n      `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`,\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    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }\nif (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }\nif (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }\n`;\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n      `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of Array.\\`); }`,\n      `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`,\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) =>\n            `${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e.message); } });`,\n        ),\n      );\n\n      code.push(`if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`);\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};\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        `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n        `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected type is object.\\`); }`,\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} = ${keysAlias}.map(${kAlias} => { try { ${codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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} = ${entriesAlias}.map(([${kAlias},${vAlias}]) => { try { ${codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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)};\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","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","string","undefined","number","result","parseFloat","Number","isFinite","date","Date","parse","time","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","codeGen","context","valuePath","valueAlias","errorsAlias","code","map","join","reduceRight","idx","index","registryAlias","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","Object","keys","entries","rootName","validator","Function","data"],"mappings":"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"}

package/build/index.d.ts

@@ -1,53 +1,47 @@
-export declare class AssertError extends TypeError {
-    readonly value: unknown;
-    readonly expected: unknown;
-    readonly path: string;
-    readonly subject: string;
-    constructor(value: unknown, expected: unknown, path: string, subject?: string);
-}
-type Keys = string | number | symbol;
-type DataValue = any;
-export type Data = Record<Keys, unknown>;
-type DataArray = DataValue[];
-export type Schema<T> = T extends Data ? {
-    [S in keyof T]?: Schema<T[S]>;
-} : T extends DataArray ? [Schema<T[number]>] : DataValue;
-export type SchemaData<S> = S extends Record<Keys, unknown> ? {
-    [K in keyof S as Exclude<K, typeof $keys | typeof $values>]?: SchemaData<S[K]>;
-} & Record<string, unknown> : S extends unknown[] ? unknown[] : unknown;
-declare abstract class Operation<T extends Data = DataValue> {
+declare abstract class Operator<T> {
     readonly schemas: Schema<T>[];
     constructor(schemas: Schema<T>[]);
 }
-declare class Or<T extends Data = DataValue> extends Operation<T> {
+export declare const $keys: unique symbol;
+export declare const $values: unique symbol;
+export declare const $strict: unique symbol;
+export type Schema<T> = T extends Record<string | number | symbol, unknown> ? {
+    [K in keyof T]?: Schema<T[K]> | unknown;
+} & {
+    [$keys]?: Schema<keyof T>;
+} & {
+    [$values]?: Schema<T[keyof T]>;
+} & {
+    [$strict]?: boolean;
+} : T extends Array<infer A> ? Schema<A>[] | unknown : unknown;
+declare class Or<T> extends Operator<T> {
 }
-export declare const or: <T extends Data = any>(...schemas: Schema<T>[]) => Or<T>;
-declare class And<T extends Data = DataValue> extends Operation<T> {
+export declare const or: <T>(...schemas: Schema<T>[]) => Or<T>;
+declare class And<T> extends Operator<T> {
 }
-export declare const and: <T extends Data = any>(...schemas: Schema<T>[]) => And<T>;
-declare class Optional<T extends Data = DataValue> extends Operation<T> {
+export declare const and: <T>(...schemas: Schema<T>[]) => And<T>;
+declare class Optional<T> extends Operator<T> {
     constructor(schema: Schema<T>);
 }
-export declare const optional: <T extends Data = any>(schema: Schema<T>) => Optional<T>;
-declare class Tuple<T extends Data = DataValue> extends Operation<T> {
+export declare const optional: <T>(schema: Schema<T>) => Optional<T>;
+declare class Tuple<T> extends Operator<T> {
 }
-export declare const tuple: <T extends Data = any>(...schemas: Schema<T>[]) => Tuple<T>;
-export declare const $keys: unique symbol;
-export declare const $values: unique symbol;
+export declare const tuple: <T>(...schemas: Schema<T>[]) => Tuple<T>;
 export declare const fromBase64: (value: string) => string;
 export declare const as: {
-    string: (value: string | undefined) => string | undefined;
-    number: (value: string | undefined) => number | undefined;
-    date: (value: string | undefined) => Date | undefined;
-    time: (value: string | undefined) => number | undefined;
-    boolean: (value: string | undefined) => boolean | undefined;
-    array: (value: string | undefined, delimiter: string) => string[] | undefined;
-    json: (value: string | undefined) => any;
-    base64: (value: string | undefined) => string | undefined;
+    string: (value: string | undefined) => string;
+    number: (value: string | undefined) => number;
+    date: (value: string | undefined) => Date;
+    time: (value: string | undefined) => number;
+    boolean: (value: string | undefined) => boolean;
+    array: (value: string | undefined, delimiter: string) => string[];
+    json: <T = object>(value: string | undefined) => T;
+    base64: (value: string | undefined) => string;
 };
-export interface CompilerOptions {
-    error?: typeof AssertError;
+export interface ErrorFormatter {
+    (value: unknown, expected: unknown, path: string, subject: string): string;
 }
-export declare const compile: <S>(schema: S, rootName: string, options?: CompilerOptions) => (data: SchemaData<S>) => void;
-export declare const ascertain: <T extends Data = any>(schema: Schema<T>, data: T, rootName?: string) => void;
+export declare const formatError: ErrorFormatter;
+export declare const compile: <T>(schema: Schema<T>, rootName: string) => (data: T) => any;
+export declare const ascertain: <T>(schema: Schema<T>, data: T, rootName?: string) => void;
 export {};

package/build/index.js

@@ -1,17 +1,4 @@
-export class AssertError extends TypeError {
-    value;
-    expected;
-    path;
-    subject;
-    constructor(value, expected, path, subject = 'value'){
-        super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);
-        this.value = value;
-        this.expected = expected;
-        this.path = path;
-        this.subject = subject;
-    }
-}
-class Operation {
+class Operator {
     schemas;
     constructor(schemas){
         this.schemas = schemas;
@@ -20,13 +7,16 @@ class Operation {
         }
     }
 }
-class Or extends Operation {
+export const $keys = Symbol.for('@@keys');
+export const $values = Symbol.for('@@values');
+export const $strict = Symbol.for('@@strict');
+class Or extends Operator {
 }
 export const or = (...schemas)=>new Or(schemas);
-class And extends Operation {
+class And extends Operator {
 }
 export const and = (...schemas)=>new And(schemas);
-class Optional extends Operation {
+class Optional extends Operator {
     constructor(schema){
         super([
             schema
@@ -34,11 +24,9 @@ class Optional extends Operation {
     }
 }
 export const optional = (schema)=>new Optional(schema);
-class Tuple extends Operation {
+class Tuple extends Operator {
 }
 export const tuple = (...schemas)=>new Tuple(schemas);
-export const $keys = Symbol.for('@@keys');
-export const $values = Symbol.for('@@values');
 export const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
 const MULTIPLIERS = {
     ms: 1,
@@ -85,17 +73,10 @@ export const as = {
         }
     }
 };
+export const formatError = (value, expected, path, subject)=>`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`;
 class Context {
-    options;
-    Error;
-    registry;
-    varIndex;
-    constructor(options = {}){
-        this.options = options;
-        this.registry = [];
-        this.varIndex = 0;
-        this.Error = options.error ?? AssertError;
-    }
+    registry = [];
+    varIndex = 0;
     register(value) {
         if (!this.registry.includes(value)) {
             this.registry.push(value);
@@ -110,17 +91,17 @@ const codeGen = (schema, context, valuePath, path)=>{
     if (schema instanceof And) {
         const valueAlias = context.unique('v');
         const errorsAlias = context.unique('err');
-        const code = schema.schemas.map((s)=>`try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e); }`).join('\n');
+        const code = schema.schemas.map((s)=>`try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e.message); }`).join('\n');
         return `// And
   const ${errorsAlias} = [];
   const ${valueAlias} = ${valuePath};
   ${code}
-  if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
+  if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
 `;
     } else if (schema instanceof Or) {
         const valueAlias = context.unique('v');
         const errorsAlias = context.unique('err');
-        const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, path)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"');`);
+        const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, path)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e.message);${result}}`, `throw new TypeError(${errorsAlias}.join('\\n'));`);
         return `// Or
 const ${errorsAlias} = [];
 const ${valueAlias} = ${valuePath};
@@ -139,9 +120,12 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
             '// Tuple',
             `const ${valueAlias} = ${valuePath};`,
             `const ${errorsAlias} = [];`,
-            `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \`${path}\`); }`,
-            ...schema.schemas.map((s, idx)=>`try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`),
-            `if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }`
+            `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+            `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected an instance of Array\`); }`,
+            `if (!Array.isArray(${valueAlias})) { throw new TypeError(\`Invalid instance of \${${valueAlias}.constructor?.name} for path "${path}", expected an instance of Array.\`); }`,
+            `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\`Invalid tuple length \${${valueAlias}.length} for path "${path}", expected ${schema.schemas.length}.\`); }`,
+            ...schema.schemas.map((s, idx)=>`try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e.message); }`),
+            `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }`
         ];
         return code.join('\n');
     } else if (typeof schema === 'function') {
@@ -151,23 +135,25 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \`${path}\`); }
-if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \`instance of \${${registryAlias}.name}\`, \`${path}\`, 'instance of'); }
-if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \`${path}\`, 'type'); }
+if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }
+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}\`); }
+if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\`Invalid type \${${valueAlias}?.constructor?.name} for path "${path}", expected type ${schema?.name}\`); }
 `;
     } else if (Array.isArray(schema)) {
         const valueAlias = context.unique('v');
         const code = [
             `const ${valueAlias} = ${valuePath};`,
-            `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \`${path}\`); }`
+            `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+            `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected an instance of Array.\`); }`,
+            `if (!Array.isArray(${valueAlias})) { throw new TypeError(\`Invalid instance of \${${valueAlias}.constructor?.name} for path "${path}", expected an instance of Array.\`); }`
         ];
         if (schema.length > 0) {
             const value = context.unique('val');
             const key = context.unique('key');
             const errorsAlias = context.unique('err');
             code.push(`const ${errorsAlias} = [];`);
-            code.push(...schema.map((s)=>`${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e); } });`));
-            code.push(`if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }`);
+            code.push(...schema.map((s)=>`${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e.message); } });`));
+            code.push(`if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }`);
         }
         return code.join('\n');
     } else if (typeof schema === 'object' && schema !== null) {
@@ -175,38 +161,46 @@ if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${regist
             const valueAlias = context.unique('v');
             return `
 const ${valueAlias} = ${valuePath};
-if (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \`${path}\`); }
+if (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected to match ${schema.toString()}\`); }
 `;
         } else {
             const valueAlias = context.unique('v');
             const code = [
                 `const ${valueAlias} = ${valuePath};`,
-                `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'object', \`${path}\`); }`,
-                `if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \`${path}\`); }`
+                `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`,
+                `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected type is object.\`); }`
             ];
             if ($keys in schema) {
-                const keysAlias = context.unique('key');
+                const keysAlias = context.unique('k');
                 const errorsAlias = context.unique('err');
-                const value = context.unique('v');
+                const kAlias = context.unique('k');
                 code.push(`
 const ${keysAlias} = Object.keys(${valueAlias});
-const ${errorsAlias} = ${keysAlias}.flatMap((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).filter(Boolean);
-if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
+const ${errorsAlias} = ${keysAlias}.map(${kAlias} => { try { ${codeGen(schema[$keys], context, kAlias, `${path}[\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);
+if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
 `);
             }
             if ($values in schema) {
                 const vAlias = context.unique('val');
-                const valuesAlias = context.unique('vals');
+                const kAlias = context.unique('k');
+                const entriesAlias = context.unique('en');
                 const errorsAlias = context.unique('err');
-                code.push(`{
-const ${valuesAlias} = Object.values(${valuePath});
-const ${errorsAlias} = ${valuesAlias}.flatMap((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).filter(Boolean);
-if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
-}`);
+                code.push(`
+const ${entriesAlias} = Object.entries(${valueAlias});
+const ${errorsAlias} = ${entriesAlias}.map(([${kAlias},${vAlias}]) => { try { ${codeGen(schema[$values], context, vAlias, `${path}[\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);
+if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }
+`);
+            }
+            if ($strict in schema && schema[$strict]) {
+                const keysAlias = context.unique('k');
+                const kAlias = context.unique('k');
+                const extraAlias = context.unique('ex');
+                code.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);
+                code.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);
+                code.push(`if (${extraAlias}.length !== 0) { throw new TypeError(\`Extra properties: \${${extraAlias}}, are not allowed for path "${path}"\`); }`);
             }
-            const keys = Object.keys(schema);
-            code.push(...keys.map((key)=>codeGen(schema[key], context, `${valueAlias}['${key}']`, `${path}.${key}`)));
-            return `{${code.join('\n')}}`;
+            code.push(...Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));
+            return `${code.join('\n')}`;
         }
     } else if (typeof schema === 'symbol') {
         const index = context.register(schema);
@@ -215,136 +209,34 @@ if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Inv
         return `
 const ${valueAlias} = ${valuePath};
 const ${registryAlias} = ctx.registry[${index}];
-if (typeof ${valueAlias} !== 'symbol') { throw new ctx.Error(typeof ${valueAlias}, 'symbol', '${path}', 'type of'); }
-if (${valueAlias} !== ${registryAlias}) { throw new ctx.Error(${valueAlias}.toString(), ${registryAlias}.toString(), '${path}', 'symbol'); }
+if (typeof ${valueAlias} !== 'symbol') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for "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 ctx.Error(${valueAlias}, 'nullable', '${path}'); }
+if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value ${valueAlias} for path "${path}", expected nullable\`); }
     `;
     } else {
         const valueAlias = context.unique('v');
-        const typeAlias = context.unique('t');
         const value = context.unique('val');
         return `
 const ${valueAlias} = ${valuePath};
-const ${typeAlias} = '${typeof schema}';
 const ${value} = ${JSON.stringify(schema)};
-if (typeof ${valueAlias} !== ${typeAlias}) { throw new ctx.Error(typeof ${valueAlias}, ${typeAlias}, '${path}', 'type of'); }
-if (${valueAlias} !== ${value}) { throw new ctx.Error(${valueAlias}, ${value}, '${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)}\`); }
 `;
     }
 };
-const flatAggregateError = (error)=>{
-    return error.errors.flatMap((e)=>e instanceof AggregateError ? flatAggregateError(e) : e);
-};
-export const compile = (schema, rootName, options = {})=>{
-    const context = new Context(options);
+export const compile = (schema, rootName)=>{
+    const context = new Context();
     const code = codeGen(schema, context, 'data', rootName);
     const validator = new Function('ctx', 'data', code);
-    return (data)=>{
-        try {
-            validator(context, data);
-        } catch (e) {
-            const errors = e instanceof AggregateError ? flatAggregateError(e) : [
-                e
-            ];
-            throw new AggregateError(errors, 'Validation failure');
-        }
-    };
-};
-const assert = (target, schema, path)=>{
-    if (schema instanceof And) {
-        return schema.schemas.flatMap((schema)=>assert(target, schema, path)).filter((error)=>!!error);
-    } else if (schema instanceof Or) {
-        const errors = schema.schemas.flatMap((schema)=>assert(target, schema, path));
-        const filteredErrors = errors.filter((error)=>!!error);
-        if (filteredErrors.length === schema.schemas.length) {
-            return filteredErrors;
-        }
-    } else if (schema instanceof Optional) {
-        if (target !== undefined && target !== null) {
-            return assert(target, schema.schemas[0], path);
-        }
-    } else if (schema instanceof Tuple) {
-        if (!Array.isArray(target)) {
-            return [
-                new AssertError(target, 'array', path)
-            ];
-        }
-        return schema.schemas.flatMap((s, idx)=>assert(target[idx], s, `${path}[${idx}]`)).filter((error)=>!!error);
-    } else if (typeof schema === 'function') {
-        if (target === null || target === undefined) {
-            return [
-                new AssertError(target, 'a non-nullable', path)
-            ];
-        }
-        if (typeof target === 'object' && !(target instanceof schema)) {
-            return [
-                new AssertError(target?.constructor?.name, `instance of ${schema.name}`, path, 'instance of')
-            ];
-        }
-        if (typeof target !== 'object' && target?.constructor !== schema) {
-            return [
-                new AssertError(target?.constructor?.name, schema.name, path, 'type')
-            ];
-        }
-    } else if (Array.isArray(schema)) {
-        if (!Array.isArray(target)) {
-            return [
-                new AssertError(target, 'array', path)
-            ];
-        }
-        return schema.flatMap((s)=>target.flatMap((value, idx)=>assert(value, s, `${path}[${idx}]`))).filter((error)=>!!error);
-    } else if (typeof schema === 'object' && schema !== null) {
-        if (schema instanceof RegExp) {
-            if (!schema.test('' + target)) {
-                return [
-                    new AssertError(target, `matching ${schema.toString()}`, path)
-                ];
-            }
-            return [];
-        } else {
-            if (target === null || target === undefined) {
-                return [
-                    new AssertError(target, 'object', path)
-                ];
-            }
-            if (typeof target !== 'object') {
-                return [
-                    new AssertError(target, schema.constructor.name, path)
-                ];
-            }
-            if ($keys in schema) {
-                const targetKeys = Object.keys(target);
-                return targetKeys.flatMap((key)=>assert(key, schema[$keys], path)).filter((error)=>!!error);
-            }
-            if ($values in schema) {
-                const targetKeys = Object.keys(target);
-                return targetKeys.flatMap((key)=>assert(target[key], schema[$values], path)).filter((error)=>!!error);
-            }
-            return Object.keys(schema).flatMap((key)=>assert(target[key], schema[key], path)).filter((error)=>!!error);
-        }
-    } else if (schema === null || schema === undefined) {
-        if (target !== null && target !== undefined) {
-            return [
-                new AssertError(target, 'nullable', path)
-            ];
-        }
-    } else if (target !== schema) {
-        return [
-            new AssertError(target, schema, path)
-        ];
-    }
-    return [];
+    return (data)=>validator(context, data);
 };
 export const ascertain = (schema, data, rootName = '[root]')=>{
-    const result = assert(data, schema, rootName).filter((error)=>!!error);
-    if (result.length > 0) {
-        throw new AggregateError(result, 'Validation failure');
-    }
+    compile(schema, rootName)(data);
 };
 
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export class AssertError extends TypeError {\n  constructor(\n    public readonly value: unknown,\n    public readonly expected: unknown,\n    public readonly path: string,\n    public readonly subject = 'value',\n  ) {\n    super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);\n  }\n}\n\ntype Keys = string | number | symbol;\ntype DataValue = any;\nexport type Data = Record<Keys, unknown>;\ntype DataArray = DataValue[];\n\nexport type Schema<T> = T extends Data ? { [S in keyof T]?: Schema<T[S]> } : T extends DataArray ? [Schema<T[number]>] : DataValue;\n\nexport type SchemaData<S> =\n  S extends Record<Keys, unknown>\n    ? { [K in keyof S as Exclude<K, typeof $keys | typeof $values>]?: SchemaData<S[K]> } & Record<string, unknown>\n    : S extends unknown[]\n      ? unknown[]\n      : unknown;\n\nabstract class Operation<T extends Data = DataValue> {\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\nclass Or<T extends Data = DataValue> extends Operation<T> {}\nexport const or = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T extends Data = DataValue> extends Operation<T> {}\nexport const and = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T extends Data = DataValue> extends Operation<T> {\n  constructor(schema: Schema<T>) {\n    super([schema]);\n  }\n}\nexport const optional = <T extends Data = DataValue>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T extends Data = DataValue> extends Operation<T> {}\nexport const tuple = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\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 as = {\n  string: (value: string | undefined) => {\n    return typeof value === 'string' ? value : undefined;\n  },\n  number: (value: string | undefined) => {\n    const result = parseFloat(value as string);\n    return Number.isFinite(result) ? result : undefined;\n  },\n  date: (value: string | undefined) => {\n    const result = Date.parse(value as string);\n    return Number.isFinite(result) ? new Date(result) : undefined;\n  },\n  time: (value: string | undefined) => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS];\n    }\n    return undefined;\n  },\n  boolean: (value: string | undefined) =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string) ? /^(1|true|enabled)$/i.test(value as string) : undefined,\n  array: (value: string | undefined, delimiter: string) => value?.split?.(delimiter) ?? undefined,\n  json: (value: string | undefined) => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return undefined;\n    }\n  },\n  base64: (value: string | undefined) => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return undefined;\n    }\n  },\n};\n\nclass Context {\n  public readonly Error: typeof AssertError;\n  public readonly registry: unknown[] = [];\n  private varIndex = 0;\n\n  constructor(public readonly options: CompilerOptions = {}) {\n    this.Error = options.error ?? AssertError;\n  }\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\nexport interface CompilerOptions {\n  error?: typeof AssertError;\n}\n\nconst codeGen = <T extends Data = DataValue>(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); }`).join('\\n');\n    return `// And\n  const ${errorsAlias} = [];\n  const ${valueAlias} = ${valuePath};\n  ${code}\n  if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\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(\n        (result, code) => `try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`,\n        `throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"');`,\n      );\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      `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \\`${path}\\`); }`,\n      ...schema.schemas.map((s, idx) => `try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`),\n      `if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }`,\n    ];\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    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \\`${path}\\`); }\nif (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \\`instance of \\${${registryAlias}.name}\\`, \\`${path}\\`, 'instance of'); }\nif (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \\`${path}\\`, 'type'); }\n`;\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'array', \\`${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) =>\n            `${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e); } });`,\n        ),\n      );\n\n      code.push(`if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }`);\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};\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \\`${path}\\`); }\n`;\n    } else {\n      const valueAlias = context.unique('v');\n      const code: string[] = [\n        `const ${valueAlias} = ${valuePath};`,\n        `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'object', \\`${path}\\`); }`,\n        `if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \\`${path}\\`); }`,\n      ];\n      if ($keys in schema) {\n        const keysAlias = context.unique('key');\n        const errorsAlias = context.unique('err');\n        const value = context.unique('v');\n        code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = ${keysAlias}.flatMap((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\n`);\n      }\n      if ($values in schema) {\n        const vAlias = context.unique('val');\n        const valuesAlias = context.unique('vals');\n        const errorsAlias = context.unique('err');\n        code.push(`{\nconst ${valuesAlias} = Object.values(${valuePath});\nconst ${errorsAlias} = ${valuesAlias}.flatMap((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path \"${path}\"'); }\n}`);\n      }\n      const keys = Object.keys(schema);\n      code.push(...keys.map((key) => codeGen(schema[key], 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 ctx.Error(typeof ${valueAlias}, 'symbol', '${path}', 'type of'); }\nif (${valueAlias} !== ${registryAlias}) { throw new ctx.Error(${valueAlias}.toString(), ${registryAlias}.toString(), '${path}', 'symbol'); }\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 ctx.Error(${valueAlias}, 'nullable', '${path}'); }\n    `;\n  } else {\n    const valueAlias = context.unique('v');\n    const typeAlias = context.unique('t');\n    const value = context.unique('val');\n    return `\nconst ${valueAlias} = ${valuePath};\nconst ${typeAlias} = '${typeof schema}';\nconst ${value} = ${JSON.stringify(schema)};\nif (typeof ${valueAlias} !== ${typeAlias}) { throw new ctx.Error(typeof ${valueAlias}, ${typeAlias}, '${path}', 'type of'); }\nif (${valueAlias} !== ${value}) { throw new ctx.Error(${valueAlias}, ${value}, '${path}'); }\n`;\n  }\n};\n\nconst flatAggregateError = (error: AggregateError): AssertError[] => {\n  return error.errors.flatMap((e) => (e instanceof AggregateError ? flatAggregateError(e) : e));\n};\n\nexport const compile = <S>(schema: S, rootName: string, options: CompilerOptions = {}) => {\n  const context = new Context(options);\n  const code = codeGen(schema, context, 'data', rootName);\n  const validator = new Function('ctx', 'data', code);\n  return (data: SchemaData<S>) => {\n    try {\n      validator(context, data);\n    } catch (e) {\n      const errors = e instanceof AggregateError ? flatAggregateError(e) : [e];\n      throw new AggregateError(errors, 'Validation failure');\n    }\n  };\n};\n\nconst assert = (target: unknown, schema: unknown, path: string): AssertError[] => {\n  if (schema instanceof And) {\n    return schema.schemas.flatMap((schema) => assert(target, schema, path)).filter((error) => !!error);\n  } else if (schema instanceof Or) {\n    const errors = schema.schemas.flatMap((schema) => assert(target, schema, path));\n    const filteredErrors = errors.filter((error) => !!error);\n    if (filteredErrors.length === schema.schemas.length) {\n      return filteredErrors;\n    }\n  } else if (schema instanceof Optional) {\n    if (target !== undefined && target !== null) {\n      return assert(target, schema.schemas[0], path);\n    }\n  } else if (schema instanceof Tuple) {\n    if (!Array.isArray(target)) {\n      return [new AssertError(target, 'array', path)];\n    }\n    return schema.schemas.flatMap((s, idx) => assert(target[idx], s, `${path}[${idx}]`)).filter((error) => !!error);\n  } else if (typeof schema === 'function') {\n    if (target === null || target === undefined) {\n      return [new AssertError(target, 'a non-nullable', path)];\n    }\n    if (typeof target === 'object' && !(target instanceof schema)) {\n      return [new AssertError(target?.constructor?.name, `instance of ${schema.name}`, path, 'instance of')];\n    }\n    if (typeof target !== 'object' && target?.constructor !== schema) {\n      return [new AssertError(target?.constructor?.name, schema.name, path, 'type')];\n    }\n  } else if (Array.isArray(schema)) {\n    if (!Array.isArray(target)) {\n      return [new AssertError(target, 'array', path)];\n    }\n    return schema.flatMap((s) => target.flatMap((value, idx) => assert(value, s, `${path}[${idx}]`))).filter((error) => !!error);\n  } else if (typeof schema === 'object' && schema !== null) {\n    if (schema instanceof RegExp) {\n      if (!schema.test('' + target)) {\n        return [new AssertError(target, `matching ${schema.toString()}`, path)];\n      }\n      return [];\n    } else {\n      if (target === null || target === undefined) {\n        return [new AssertError(target, 'object', path)];\n      }\n      if (typeof target !== 'object') {\n        return [new AssertError(target, schema.constructor.name, path)];\n      }\n      if ($keys in schema) {\n        const targetKeys = Object.keys(target);\n        return targetKeys.flatMap((key) => assert(key, schema[$keys], path)).filter((error) => !!error);\n      }\n      if ($values in schema) {\n        const targetKeys = Object.keys(target);\n        return targetKeys.flatMap((key) => assert(target[key as keyof typeof target], schema[$values], path)).filter((error) => !!error);\n      }\n      return Object.keys(schema)\n        .flatMap((key) => assert(target[key as keyof typeof target], schema[key as keyof typeof target], path))\n        .filter((error) => !!error);\n    }\n  } else if (schema === null || schema === undefined) {\n    if (target !== null && target !== undefined) {\n      return [new AssertError(target, 'nullable', path)];\n    }\n  } else if (target !== schema) {\n    return [new AssertError(target, schema, path)];\n  }\n  return [];\n};\n\nexport const ascertain = <T extends Data = DataValue>(schema: Schema<T>, data: T, rootName = '[root]') => {\n  const result = assert(data, schema, rootName).filter((error) => !!error);\n  if (result.length > 0) {\n    throw new AggregateError(result, 'Validation failure');\n  }\n};\n"],"names":["AssertError","TypeError","constructor","value","expected","path","subject","JSON","stringify","Operation","schemas","length","name","Or","or","And","and","Optional","schema","optional","Tuple","tuple","$keys","Symbol","for","$values","fromBase64","Buffer","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","as","string","undefined","number","result","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","e","base64","Context","Error","registry","varIndex","options","error","register","includes","push","indexOf","unique","prefix","codeGen","context","valuePath","valueAlias","errorsAlias","code","map","join","reduceRight","idx","index","registryAlias","Array","isArray","key","RegExp","keysAlias","vAlias","valuesAlias","keys","Object","typeAlias","flatAggregateError","errors","flatMap","AggregateError","compile","rootName","validator","Function","data","assert","target","filter","filteredErrors","targetKeys","ascertain"],"mappings":"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"}
+{"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 as = {\n  string: (value: string | undefined): string => {\n    return typeof value === 'string' ? value : (undefined as unknown as string);\n  },\n  number: (value: string | undefined): number => {\n    const result = parseFloat(value as string);\n    return Number.isFinite(result) ? result : (undefined as unknown as number);\n  },\n  date: (value: string | undefined): Date => {\n    const result = Date.parse(value as string);\n    return Number.isFinite(result) ? new Date(result) : (undefined as unknown as Date);\n  },\n  time: (value: string | undefined): number => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS];\n    }\n    return undefined as unknown as number;\n  },\n  boolean: (value: string | undefined): boolean =>\n    /^(0|1|true|false|enabled|disabled)$/i.test(value as string) ? /^(1|true|enabled)$/i.test(value as string) : (undefined as unknown as boolean),\n  array: (value: string | undefined, delimiter: string): string[] => value?.split?.(delimiter) ?? (undefined as unknown as string[]),\n  json: <T = object>(value: string | undefined): T => {\n    try {\n      return JSON.parse(value as string);\n    } catch (e) {\n      return undefined as unknown as T;\n    }\n  },\n  base64: (value: string | undefined): string => {\n    try {\n      return fromBase64(value as string);\n    } catch (e) {\n      return undefined as unknown as 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 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  if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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) => `try {${code}} catch (e) {${errorsAlias}.push(e.message);${result}}`, `throw new TypeError(${errorsAlias}.join('\\\\n'));`);\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      `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n      `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of Array\\`); }`,\n      `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`,\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(\n        (s, idx) => `try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e.message); }`,\n      ),\n      `if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`,\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    return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }\nif (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected an instance of ${schema?.name}\\`); }\nif (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new TypeError(\\`Invalid type \\${${valueAlias}?.constructor?.name} for path \"${path}\", expected type ${schema?.name}\\`); }\n`;\n  } else if (Array.isArray(schema)) {\n    const valueAlias = context.unique('v');\n    const code: string[] = [\n      `const ${valueAlias} = ${valuePath};`,\n      `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n      `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected an instance of Array.\\`); }`,\n      `if (!Array.isArray(${valueAlias})) { throw new TypeError(\\`Invalid instance of \\${${valueAlias}.constructor?.name} for path \"${path}\", expected an instance of Array.\\`); }`,\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) =>\n            `${valueAlias}.forEach((${value},${key}) => { try { ${codeGen(s, context, value, `${path}[\\${${key}}]`)} } catch(e){ ${errorsAlias}.push(e.message); } });`,\n        ),\n      );\n\n      code.push(`if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }`);\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};\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        `if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\\`Invalid value \\${${valueAlias}} for path \"${path}\", expected non-nullable.\\`); }`,\n        `if (typeof ${valueAlias} !== 'object') { throw new TypeError(\\`Invalid type \\${typeof ${valueAlias}} for path \"${path}\", expected type is object.\\`); }`,\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} = ${keysAlias}.map(${kAlias} => { try { ${codeGen(schema[$keys], context, kAlias, `${path}[\\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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} = ${entriesAlias}.map(([${kAlias},${vAlias}]) => { try { ${codeGen(schema[$values], context, vAlias, `${path}[\\${${kAlias}}]`)} } catch (e) { return e.message; } }).filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\\\n')); }\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)};\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","as","string","undefined","number","result","parseFloat","Number","isFinite","date","Date","parse","time","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","codeGen","context","valuePath","valueAlias","errorsAlias","code","map","join","reduceRight","idx","index","registryAlias","Array","isArray","key","RegExp","keysAlias","kAlias","vAlias","entriesAlias","extraAlias","Object","keys","entries","compile","rootName","validator","Function","data","ascertain"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ascertain",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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"
@@ -65,5 +58,10 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.5.3"
   },
-  "packageManager": "pnpm@9.4.0+sha512.f549b8a52c9d2b8536762f99c0722205efc5af913e77835dbccc3b0b0b2ca9e7dc8022b78062c17291c48e88749c70ce88eb5a74f1fa8c4bf5e18bb46c8bd83a"
-}
+  "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"
+  }
+}