ascertain 0.14.39 → 1.0.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-2024 Ivan Zakharchanka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,7 +2,7 @@
 
 ### Ascertain what data is not suitable for your library
 
-0-Deps, simple, blazing fast, for browser and node js object schema validator
+0-Deps, simple, blazing fast, for browser and Node.js object schema validator
 
 [![Coverage Status][codecov-image]][codecov-url]
 [![Build Status][github-image]][github-url]
@@ -12,19 +12,64 @@
 
 ## Features
 
- - value validation
- - class validation
- - structure validation
- - regexp validation
- - and/or validation
- - object keys validation
- - object values validation
+- Type-safe validation: Ensures your data conforms to predefined schemas.
+- Composite schemas: Supports logical AND, OR, and optional schemas.
+- Type casting: Automatically parses and casts strings to other types.
+- Error handling: Provides detailed error messages for invalid data.
+
+## Schema description
+
+ - Primitive Values: Any primitive value (e.g., string, number, bigint, boolean, undefined, symbol, null) is used as an expected constant to match against.
+ - Function Types: Functions are used as constructors for non-objects and instance types for object types.
+ - Array Values: Arrays are used to represent an expected array type, where every item in the array must match the specified type (acting as an "and" operator).
+ - Regular Expressions: Regular expressions are used to validate that a value matches a specified string pattern.
+ - Object Types: Non-null objects are used as templates for expected properties, where each property of the object must match the corresponding schema definition.
 
 ## Usage Example
 
+### Schema compilation
+```typescript
+import { compile, optional, and, or, $keys, $values, Schema, as } from 'ascertain';
+
+const validate = compile({
+  number: Number,
+  string: String,
+  boolean: Boolean,
+  function: Function,
+  array: Array,
+  object: Object,
+  date: and(Date, { toJSON: Function }),
+  regexp: /regexp/,
+  oneOfValue: or(1, 2, 3),
+  arrayOfNumbers: [Number],
+  objectSchema: {
+    number: Number,
+  },
+  optional: optional({
+    number: Number,
+  }),
+  keyValue: {
+    [$keys]: /^key[A-Z]/,
+    [$values]: Number
+  },
+  parsedNumber: Number,
+  parsedString: String,
+  parsedBoolean: Boolean,
+  parsedArray: [String],
+  parsedJSON: {
+    number: 1,
+  },
+  parsedBase64: String,
+  parsedTime: 2 * 60 * 1000, // two minutes
+  parsedDate: Date,
+});
+
+```
+
+### Runtime validation
 Create data ascertain
 ```typescript
-import ascertain, { optional, and, or, $keys, $values, Schema, as } from 'ascertain';
+import { ascertain, optional, and, or, $keys, $values, Schema, as } from 'ascertain';
 
 // create data sample
 const data = {
@@ -49,11 +94,13 @@ const data = {
   },
   // fault tolernat type casting
   parsedNumber: as.number('1'),
-  parsedString: as.number('string'),
+  parsedString: as.string('string'),
   parsedBoolean: as.boolean('false'),
   parsedArray: as.array('1,2,3,4,5', ','),
   parsedJSON: as.json('{ "number": 1 }'),
   parsedBase64: as.base64('dGVzdA=='),
+  parsedTime: as.time('2m'),
+  parsedDate: as.date('31-12-2024'),
 };
 
 // create data schema
@@ -86,15 +133,54 @@ const schema: Schema<typeof data> = {
     number: 1,
   },
   parsedBase64: String,
+  parsedTime: 2 * 60 * 1000, // two minutes
+  parsedDate: Date,
 };
 
 // validate
 const validate = ascertain<typeof data>(schema, data, '[DATA]');
 ```
 
+### Benchmark VS zod and ajv
+```
+⭐ Script ajv-vs-zod-vs-ascertain.js
+  ⇶ Suite ajv vs zod vs ascertain
+    ➤ Perform benchmark
+      ✓ Measure 500000 zod static schema validation
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total      │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.000699 │ 0.000788 │ 0.000996 │ 0.001624 │ 462.602373 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 zod dynamic schema validation
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total       │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼────────┤
+        │ 0.006248 │ 0.006918 │ 0.007524 │ 0.016948 │ 3780.465563 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴────────┘
+      ✓ Measure 500000 ascertain static schema validation
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total     │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000063 │ 0.000071 │ 0.000098 │ 0.000267 │ 41.673271 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 ascertain dynamic schema validation
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total      │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.000367 │ 0.000415 │ 0.000525 │ 0.001055 │ 239.078129 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 ajv compiled schema validation
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total     │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000063 │ 0.000072 │ 0.000124 │ 0.000307 │ 44.542936 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+```
+
 ## License
 License [The MIT License](http://opensource.org/licenses/MIT)
-Copyright (c) 2024 Ivan Zakharchanka
+Copyright (c) 2019-2024 Ivan Zakharchanka
 
 [npm-url]: https://www.npmjs.com/package/ascertain
 [downloads-image]: https://img.shields.io/npm/dw/ascertain.svg?maxAge=43200

package/build/index.cjs

@@ -15,6 +15,9 @@ _export(exports, {
     $values: function() {
         return $values;
     },
+    AssertError: function() {
+        return AssertError;
+    },
     and: function() {
         return and;
     },
@@ -24,8 +27,8 @@ _export(exports, {
     ascertain: function() {
         return ascertain;
     },
-    default: function() {
-        return _default;
+    compile: function() {
+        return compile;
     },
     fromBase64: function() {
         return fromBase64;
@@ -35,63 +38,50 @@ _export(exports, {
     },
     or: function() {
         return or;
+    },
+    tuple: function() {
+        return tuple;
     }
 });
-let AssertError = class AssertError {
+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;
     }
-    toString() {
-        return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;
-    }
-};
-function findFirstError(array, map) {
-    for(let i = 0; i < array.length; i++){
-        const error = map(array[i], i);
-        if (error) {
-            return error;
-        }
-    }
-    return false;
 }
-function findNotError(array, map) {
-    const errors = [];
-    for(let i = 0; i < array.length; i++){
-        const error = map(array[i], i);
-        if (!error) {
-            return false;
-        } else {
-            errors.push(error);
+class Operation {
+    schemas;
+    constructor(schemas){
+        this.schemas = schemas;
+        if (schemas.length === 0) {
+            throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);
         }
     }
-    return errors.reduce((result, error)=>{
-        return new AssertError(result.value, [
-            result.expected,
-            error.expected
-        ].join(' or '), result.path, result.string);
-    });
 }
-function Optional(schema) {
-    this.schema = schema;
+class Or extends Operation {
 }
-function And(schema) {
-    this.schema = schema;
+const or = (...schemas)=>new Or(schemas);
+class And extends Operation {
 }
-function Or(schema) {
-    this.schema = schema;
+const and = (...schemas)=>new And(schemas);
+class Optional extends Operation {
+    constructor(schema){
+        super([
+            schema
+        ]);
+    }
 }
-const optional = (schema)=>{
-    return new Optional(schema);
-};
-const and = (...schema)=>{
-    return new And(schema);
-};
-const or = (...schema)=>{
-    return new Or(schema);
-};
+const optional = (schema)=>new Optional(schema);
+class Tuple extends Operation {
+}
+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');
@@ -118,13 +108,13 @@ const as = {
     time: (value)=>{
         const matches = value?.match(/^(\d+)(ms|s|m|h|d|w)?$/);
         if (matches) {
-            const [_, amount, unit = 'ms'] = matches;
+            const [, amount, unit = 'ms'] = matches;
             return parseInt(amount, 10) * MULTIPLIERS[unit];
         }
         return undefined;
     },
     boolean: (value)=>/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined,
-    array: (value, delimiter)=>value?.split(delimiter) ?? undefined,
+    array: (value, delimiter)=>value?.split?.(delimiter) ?? undefined,
     json: (value)=>{
         try {
             return JSON.parse(value);
@@ -140,84 +130,266 @@ const as = {
         }
     }
 };
-function certain(target, schema, path, optional) {
-    if (schema === null || typeof schema === 'undefined') {
-        return new AssertError(schema, 'any value', path, 'schema value');
+class Context {
+    options;
+    Error;
+    registry;
+    varIndex;
+    constructor(options = {}){
+        this.options = options;
+        this.registry = [];
+        this.varIndex = 0;
+        this.Error = options.error ?? AssertError;
     }
-    if (schema instanceof Optional) {
-        return certain(target, schema.schema, path, true);
+    register(value) {
+        if (!this.registry.includes(value)) {
+            this.registry.push(value);
+        }
+        return this.registry.indexOf(value);
     }
-    const isValue = target !== null && typeof target !== 'undefined';
-    if (!isValue && optional) {
-        return;
+    unique(prefix) {
+        return `${prefix}$$${this.varIndex++}`;
     }
-    if (schema instanceof Or) {
-        if (!schema.schema.length) {
-            return new AssertError(target, 'values', path, 'OR schema');
+}
+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');
+        return `// And
+  const ${errorsAlias} = [];
+  const ${valueAlias} = ${valuePath};
+  ${code}
+  if (${errorsAlias}.length !== 0) { throw new AggregateError(${errorsAlias}, 'Invalid value for path "${path}"'); }
+`;
+    } 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}"');`);
+        return `// Or
+const ${errorsAlias} = [];
+const ${valueAlias} = ${valuePath};
+${code}
+    `;
+    } else if (schema instanceof Optional) {
+        const valueAlias = context.unique('v');
+        return `// Optional
+const ${valueAlias} = ${valuePath};
+if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }
+`;
+    } else if (schema instanceof Tuple) {
+        const valueAlias = context.unique('v');
+        const errorsAlias = context.unique('err');
+        const code = [
+            '// 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}"'); }`
+        ];
+        return code.join('\n');
+    } else if (typeof schema === 'function') {
+        const index = context.register(schema);
+        const valueAlias = context.unique('v');
+        const registryAlias = context.unique('r');
+        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'); }
+`;
+    } 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 (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}"'); }`);
         }
-        return findNotError(schema.schema, (schema)=>certain(target, schema, path));
+        return code.join('\n');
+    } else if (typeof schema === 'object' && schema !== null) {
+        if (schema instanceof RegExp) {
+            const valueAlias = context.unique('v');
+            return `
+const ${valueAlias} = ${valuePath};
+if (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \`${path}\`); }
+`;
+        } 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 ($keys in schema) {
+                const keysAlias = context.unique('key');
+                const errorsAlias = context.unique('err');
+                const value = context.unique('v');
+                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}"'); }
+`);
+            }
+            if ($values in schema) {
+                const vAlias = context.unique('val');
+                const valuesAlias = context.unique('vals');
+                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}"'); }
+}`);
+            }
+            const keys = Object.keys(schema);
+            code.push(...keys.map((key)=>codeGen(schema[key], context, `${valueAlias}['${key}']`, `${path}.${key}`)));
+            return `{${code.join('\n')}}`;
+        }
+    } else if (typeof schema === 'symbol') {
+        const index = context.register(schema);
+        const valueAlias = context.unique('v');
+        const registryAlias = context.unique('r');
+        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'); }
+    `;
+    } 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}'); }
+    `;
+    } 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}'); }
+`;
     }
+};
+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 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) {
-        if (!schema.schema.length) {
-            return new AssertError(target, 'values', path, 'AND schema');
+        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;
         }
-        return findFirstError(schema.schema, (schema)=>certain(target, schema, path));
-    }
-    if (typeof schema === 'function') {
-        if (!isValue) {
-            return new AssertError(target, schema.name, path);
+    } 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, schema.name, path);
+            return [
+                new AssertError(target?.constructor?.name, `instance of ${schema.name}`, path, 'instance of')
+            ];
         }
-        if (typeof target !== 'object' && target.constructor !== schema) {
-            return new AssertError(target, schema.name, path);
+        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, schema.constructor.name, path);
+            return [
+                new AssertError(target, 'array', path)
+            ];
         }
-        return findFirstError(target, (value, idx)=>{
-            return findNotError(schema, (itemSchemaType)=>certain(value, itemSchemaType, `${path}.${idx}`));
-        });
-    } else if (typeof schema === 'object') {
+        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.source}/`, path);
+                return [
+                    new AssertError(target, `matching ${schema.toString()}`, path)
+                ];
             }
+            return [];
         } else {
-            if (typeof target !== 'object') {
-                return new AssertError(target, schema.constructor.name, path);
+            if (target === null || target === undefined) {
+                return [
+                    new AssertError(target, 'object', path)
+                ];
             }
-            if (target === null) {
-                return new AssertError(target, 'an object', path);
+            if (typeof target !== 'object') {
+                return [
+                    new AssertError(target, schema.constructor.name, path)
+                ];
             }
             if ($keys in schema) {
                 const targetKeys = Object.keys(target);
-                const assertError = findFirstError(targetKeys, (targetKey)=>certain(targetKey, schema[$keys], `${path}.${targetKey}`));
-                if (assertError) {
-                    return assertError;
-                }
+                return targetKeys.flatMap((key)=>assert(key, schema[$keys], path)).filter((error)=>!!error);
             }
             if ($values in schema) {
                 const targetKeys = Object.keys(target);
-                const assertError = findFirstError(targetKeys, (targetKey)=>certain(target[targetKey], schema[$values], `${path}.${targetKey}`));
-                if (assertError) {
-                    return assertError;
-                }
+                return targetKeys.flatMap((key)=>assert(target[key], schema[$values], path)).filter((error)=>!!error);
             }
-            return findFirstError(Object.keys(schema), (key)=>certain(target[key], schema[key], `${path}.${key}`));
+            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 [
+            new AssertError(target, schema, path)
+        ];
     }
-}
+    return [];
+};
 const ascertain = (schema, data, rootName = '[root]')=>{
-    const result = certain(data, schema, rootName);
-    if (result instanceof AssertError) {
-        throw new TypeError(result.toString());
+    const result = assert(data, schema, rootName).filter((error)=>!!error);
+    if (result.length > 0) {
+        throw new AggregateError(result, 'Validation failure');
     }
 };
-const _default = ascertain;
 
 //# sourceMappingURL=index.cjs.map