ascertain 2.0.88 → 2.1.0

package/README.md

@@ -1,8 +1,6 @@
 # Ascertain
 
-### Ascertain what data is not suitable for your library
-
-0-Deps, simple, blazing fast, for browser and Node.js object schema validator
+Zero-dependency, high-performance schema validator for Node.js and browsers.
 
 [![Coverage Status][codecov-image]][codecov-url]
 [![Build Status][github-image]][github-url]
@@ -10,182 +8,216 @@
 [![Downloads][downloads-image]][npm-url]
 [![Snyk][snyk-image]][snyk-url]
 
-
 [Documentation](https://3axap4ehko.github.io/ascertain/)
 
 ## Features
 
-- Type-safe validation: Ensures your data conforms to predefined schemas.
-- 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.
+- **Zero dependencies**: Minimal footprint, no external dependencies
+- **High performance**: Compiles schemas to optimized JavaScript functions
+- **Type-safe**: Full TypeScript support with type inference
+- **Flexible schemas**: Supports AND, OR, optional, and tuple operators
+- **Type casting**: Built-in parsers for numbers, dates, JSON, base64, and more
+- **Object validation**: Validate keys and values with `$keys`, `$values`, and `$strict`
+- **Detailed errors**: Clear error messages with paths for debugging
+
+## Installation
+
+```bash
+npm install ascertain
+# or
+pnpm add ascertain
+```
+
+## Quick Start
 
-## Schema description
+```typescript
+import { ascertain, compile, or, optional } from 'ascertain';
+
+// Define a schema
+const userSchema = {
+  name: String,
+  age: Number,
+  email: optional(String),
+  role: or('admin', 'user', 'guest'),
+};
 
- - 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.
+// Validate data (throws on invalid)
+ascertain(userSchema, userData, 'User');
+```
 
+## Performance
 
+Ascertain compiles schemas into optimized JavaScript functions at runtime. This compilation step generates specialized validation code that runs significantly faster than interpreting schemas on each validation.
 
-## Usage Example
+**For best performance, compile schemas once and reuse the validator:**
 
-### 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,
-});
+import { compile } from 'ascertain';
+
+// Compile once at startup
+const validateUser = compile(userSchema, 'User');
+
+// Reuse for each validation (no recompilation)
+validateUser(user1);
+validateUser(user2);
+```
 
+Use `ascertain()` for one-off validations where convenience matters more than performance. Use `compile()` when validating the same schema repeatedly (e.g., API request handlers).
+
+### Benchmark
+
+| Library | Operations/sec | Relative Speed |
+|---------|----------------|----------------|
+| **Ascertain** | 58,962,264 | **1.0x (fastest)** |
+| AJV | 42,204,777 | 0.72x |
+| Zod | 32,309,133 | 0.55x |
+
+```bash
+pnpm bench
 ```
 
-### Runtime validation
-Create data ascertain
+## Schema Types
+
+| Schema | Description | Example |
+|--------|-------------|---------|
+| Primitives | Match exact values | `42`, `'active'`, `true`, `null` |
+| Constructors | Validate by type | `String`, `Number`, `Boolean`, `Date` |
+| Arrays | Validate array items | `[Number]` (array of numbers) |
+| Objects | Validate properties | `{ name: String, age: Number }` |
+| RegExp | Match string patterns | `/^[a-z]+$/` |
+| `or()` | Match any schema | `or(String, Number)` |
+| `and()` | Match all schemas | `and(Date, { toJSON: Function })` |
+| `optional()` | Allow null/undefined | `optional(String)` |
+| `tuple()` | Fixed-length arrays | `tuple(Number, Number)` |
+
+### Object Validation Symbols
+
 ```typescript
-import { ascertain, optional, and, or, $keys, $values, Schema, as } from 'ascertain';
-
-// create data sample
-const data = {
-  number: 1,
-  string: 'string',
-  boolean: true,
-  function: () => {},
-  array: [],
-  object: {},
-  date: new Date,
-  regexp: 'regexp',
-  oneOfValue: 1,
-  arrayOfNumbers: [1,2,3,4,5],
-  objectSchema: {
-    number: 1,
-  },
-  optional: null,
-  keyValue: {
-    keyOne: 1,
-    keyTwo: 2,
-    keyThree: 3,
-  },
-  // fault tolernat type casting
-  parsedNumber: as.number('1'),
-  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'),
+import { $keys, $values, $strict } from 'ascertain';
+
+const schema = {
+  [$keys]: /^[a-z]+$/,     // All keys must match pattern
+  [$values]: Number,        // All values must be numbers
+  [$strict]: true,          // No extra properties allowed
 };
+```
 
-// create data schema
-const schema: Schema<typeof data> = {
-  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,
+## Type Casting with `as`
+
+Parse and validate values from strings (useful for environment variables, query params, etc.):
+
+```typescript
+import { as } from 'ascertain';
+
+as.string('hello')           // 'hello'
+as.number('42')              // 42
+as.number('3.14')            // 3.14
+as.number('1e10')            // 10000000000
+as.number('0xFF')            // 255 (hex)
+as.number('0o77')            // 63 (octal)
+as.number('0b1010')          // 10 (binary)
+as.boolean('true')           // true
+as.boolean('1')              // true
+as.date('2024-12-31')        // Date object
+as.time('2m')                // 120000 (milliseconds)
+as.time('1h')                // 3600000
+as.array('a,b,c', ',')       // ['a', 'b', 'c']
+as.json('{"x":1}')           // { x: 1 }
+as.base64('dGVzdA==')        // 'test'
+```
+
+Invalid values return a `TypeError` instead of throwing, enabling deferred validation:
+
+```typescript
+const config = {
+  port: as.number(process.env.PORT),      // TypeError if invalid
+  host: as.string(process.env.HOST),
 };
 
-// validate
-const validate = ascertain<typeof data>(schema, data, '[DATA]');
+// Errors surface during schema validation with clear paths
+ascertain({ port: Number, host: String }, config, 'Config');
 ```
 
-### Benchmark VS zod and ajv
+## Config Validation with `createValidator`
+
+For configuration objects, `createValidator` provides type-safe partial validation:
+
+```typescript
+import { createValidator, as } from 'ascertain';
+
+const config = {
+  app: { name: as.string(process.env.APP_NAME), port: as.number(process.env.PORT) },
+  db: { host: as.string(process.env.DB_HOST), pool: as.number(process.env.DB_POOL) },
+  redis: { url: as.string(process.env.REDIS_URL) },
+};
+
+const validate = createValidator(config, 'Config');
+
+// Each module validates only what it needs
+const { app, db } = validate({
+  app: { name: String, port: Number },
+  db: { host: String, pool: Number },
+});
+// app.name is typed as string
+// app.port is typed as number
+// redis is not accessible (TypeScript error)
 ```
-⭐ 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 │
-        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+
+## Complete Example
+
+```typescript
+import { compile, or, optional, and, tuple, $keys, $values, $strict, as } from 'ascertain';
+
+const schema = {
+  // Type validation
+  id: Number,
+  name: String,
+  active: Boolean,
+
+  // Pattern matching
+  email: /^[^@]+@[^@]+$/,
+
+  // Union types
+  status: or('pending', 'active', 'disabled'),
+
+  // Optional fields
+  nickname: optional(String),
+
+  // Nested objects
+  profile: {
+    bio: String,
+    links: [String],
+  },
+
+  // Combined constraints
+  createdAt: and(Date, { toISOString: Function }),
+
+  // Tuples
+  coordinates: tuple(Number, Number),
+
+  // Dynamic objects
+  metadata: {
+    [$keys]: /^[a-z_]+$/,
+    [$values]: or(String, Number),
+    [$strict]: true,
+  },
+
+  // Parsed values
+  retryCount: as.number(process.env.RETRY_COUNT),
+  timeout: as.time(process.env.TIMEOUT),
+};
+
+const validate = compile(schema, 'AppConfig');
+
+// Throws TypeError with detailed path on validation failure
+validate(data);
 ```
 
 ## License
-License [The MIT License](http://opensource.org/licenses/MIT)
-Copyright (c) 2019-2025 Ivan Zakharchanka
+
+[The MIT License](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2019-2026 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

@@ -33,6 +33,9 @@ _export(exports, {
     get compile () {
         return compile;
     },
+    get createValidator () {
+        return createValidator;
+    },
     get fromBase64 () {
         return fromBase64;
     },
@@ -84,13 +87,25 @@ const MULTIPLIERS = {
     d: 86400000,
     w: 604800000
 };
+const TIME_REGEX = /^(\d*\.?\d*)(ms|s|m|h|d|w)?$/;
 const asError = (message)=>new TypeError(message);
 const as = {
     string: (value)=>{
         return typeof value === 'string' ? value : asError(`Invalid value "${value}", expected a string`);
     },
     number: (value)=>{
-        const result = parseFloat(value);
+        if (typeof value !== 'string') {
+            return asError(`Invalid value ${value}, expected a valid number`);
+        }
+        const start = value[0] === '-' || value[0] === '+' ? 1 : 0;
+        const c0 = value.charCodeAt(start);
+        const c1 = value.charCodeAt(start + 1) | 32;
+        if (c0 === 48 && (c1 === 120 || c1 === 111 || c1 === 98)) {
+            const result = Number(start ? value.slice(1) : value);
+            if (Number.isNaN(result)) return asError(`Invalid value ${value}, expected a valid number`);
+            return value[0] === '-' ? -result : result;
+        }
+        const result = value.includes('.') || value.includes('e') || value.includes('E') ? parseFloat(value) : parseInt(value, 10);
         return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;
     },
     date: (value)=>{
@@ -99,12 +114,16 @@ const as = {
         return Number.isNaN(date.valueOf()) ? asError(`Invalid value "${value}", expected a valid date format`) : date;
     },
     time: (value, conversionFactor = 1)=>{
-        const matches = value?.match(/^(\d*\.?\d*)(ms|s|m|h|d|w)?$/);
-        if (matches) {
-            const [, amount, unit = 'ms'] = matches;
-            return parseInt(`${parseFloat(amount) * MULTIPLIERS[unit] / conversionFactor}`);
+        if (!value) return asError(`Invalid value ${value}, expected a valid time format`);
+        const matches = value.match(TIME_REGEX);
+        if (!matches) return asError(`Invalid value ${value}, expected a valid time format`);
+        const [, amount, unit = 'ms'] = matches;
+        const multiplier = MULTIPLIERS[unit];
+        const parsed = parseFloat(amount);
+        if (!multiplier || Number.isNaN(parsed)) {
+            return asError(`Invalid value ${value}, expected a valid time format`);
         }
-        return asError(`Invalid value ${value}, expected a valid time format`);
+        return Math.floor(parsed * multiplier / conversionFactor);
     },
     boolean: (value)=>/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : asError(`Invalid value ${value}, expected a boolean like`),
     array: (value, delimiter)=>value?.split?.(delimiter) ?? asError(`Invalid value ${value}, expected an array`),
@@ -125,12 +144,18 @@ const as = {
 };
 class Context {
     registry = [];
+    lookupMap = new Map();
     varIndex = 0;
     register(value) {
-        if (!this.registry.includes(value)) {
-            this.registry.push(value);
+        const index = this.lookupMap.get(value);
+        if (index !== undefined) {
+            return index;
+        }
+        {
+            const index = this.registry.push(value) - 1;
+            this.lookupMap.set(value, index);
+            return index;
         }
-        return this.registry.indexOf(value);
     }
     unique(prefix) {
         return `${prefix}$$${this.varIndex++}`;
@@ -178,24 +203,34 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
             codeGenExpectNonNullable(valueAlias, path),
             codeGenExpectObject(valueAlias, path, 'Array'),
             codeGenExpectArray(valueAlias, path),
-            `if (${valueAlias}.length > ${schema.schemas.length}) { throw new TypeError(\`Invalid tuple length \${${valueAlias}.length} for path "${path}", expected ${schema.schemas.length}.\`); }`,
+            `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)=>codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))),
             codeGenExpectNoErrors(errorsAlias)
         ];
         return code.join('\n');
     } else if (typeof schema === 'function') {
-        const index = context.register(schema);
         const valueAlias = context.unique('v');
-        const registryAlias = context.unique('r');
         const code = [
             `const ${valueAlias} = ${valuePath};`,
-            `const ${registryAlias} = ctx.registry[${index}];`,
             codeGenExpectNonNullable(valueAlias, path)
         ];
         if (schema !== Error && !(schema?.prototype instanceof Error)) {
             code.push(codeGenExpectNonError(valueAlias, path));
         }
-        code.push(`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}\`); }`, `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected a valid ${schema?.name}\`); }`);
+        const name = schema?.name;
+        const primitiveType = name === 'String' ? 'string' : name === 'Number' ? 'number' : name === 'Boolean' ? 'boolean' : name === 'BigInt' ? 'bigint' : name === 'Symbol' ? 'symbol' : null;
+        if (primitiveType) {
+            code.push(`if (typeof ${valueAlias} !== '${primitiveType}') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected type ${schema?.name}\`); }`);
+            if (primitiveType === 'number') {
+                code.push(`if (Number.isNaN(${valueAlias})) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected a valid ${schema?.name}\`); }`);
+            }
+        } else if (name === 'Function') {
+            code.push(`if (typeof ${valueAlias} !== 'function') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected type Function\`); }`);
+        } else {
+            const index = context.register(schema);
+            const registryAlias = context.unique('r');
+            code.push(`const ${registryAlias} = ctx.registry[${index}];`, `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}\`); }`, `if (Number.isNaN(${valueAlias}?.valueOf?.())) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected a valid ${schema?.name}\`); }`);
+        }
         return code.join('\n');
     } else if (Array.isArray(schema)) {
         const valueAlias = context.unique('v');
@@ -211,7 +246,12 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
             const key = context.unique('key');
             const errorsAlias = context.unique('err');
             code.push(`const ${errorsAlias} = [];`);
-            code.push(...schema.map((s)=>`${valueAlias}.forEach((${value},${key}) => { ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\${${key}}]`))} });`));
+            if (schema.length === 1) {
+                code.push(...schema.map((s)=>`for (let ${key} = 0; ${key} < ${valueAlias}.length; ${key}++) { const ${value} = ${valueAlias}[${key}]; ${codeGenCollectErrors(errorsAlias, codeGen(s, context, value, `${path}[\${${key}}]`))} }`));
+            } else {
+                code.push(`if (${valueAlias}.length > ${schema.length}) { throw new TypeError(\`Invalid tuple length \${${valueAlias}.length} for path "${path}", expected ${schema.length}.\`); }`);
+                code.push(...schema.map((s, idx)=>codeGenCollectErrors(errorsAlias, codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`))));
+            }
             code.push(codeGenExpectNoErrors(errorsAlias));
         }
         return code.join('\n');
@@ -222,7 +262,7 @@ if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.sc
 const ${valueAlias} = ${valuePath};
 ${codeGenExpectNonNullable(valueAlias, path)}
 ${codeGenExpectNonError(valueAlias, path)}
-if (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected to match ${schema.toString()}\`); }
+if (!${schema.toString()}.test(String(${valueAlias}))) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected to match ${schema.toString()}\`); }
 `;
         } else {
             const valueAlias = context.unique('v');
@@ -239,7 +279,7 @@ if (!${schema.toString()}.test('' + ${valueAlias})) { throw new TypeError(\`Inva
                 code.push(`
 const ${keysAlias} = Object.keys(${valueAlias});
 const ${errorsAlias} = [];
-${keysAlias}.forEach(${kAlias} => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\${${kAlias}}]`))} });
+for (const ${kAlias} of ${keysAlias}) { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\${${kAlias}}]`))} }
 ${codeGenExpectNoErrors(errorsAlias)}
 `);
             }
@@ -251,7 +291,7 @@ ${codeGenExpectNoErrors(errorsAlias)}
                 code.push(`
 const ${entriesAlias} = Object.entries(${valueAlias});
 const ${errorsAlias} = [];
-${entriesAlias}.forEach(([${kAlias},${vAlias}]) => { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\${${kAlias}}]`))} });
+for (const [${kAlias}, ${vAlias}] of ${entriesAlias}) { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\${${kAlias}}]`))} }
 ${codeGenExpectNoErrors(errorsAlias)}
 `);
             }
@@ -263,7 +303,7 @@ ${codeGenExpectNoErrors(errorsAlias)}
                 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}"\`); }`);
             }
-            code.push(...Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}['${key}']`, `${path}.${key}`)));
+            code.push(...Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, `${path}.${key}`)));
             return `${code.join('\n')}`;
         }
     } else if (typeof schema === 'symbol') {
@@ -303,5 +343,11 @@ const compile = (schema, rootName)=>{
 const ascertain = (schema, data, rootName = '[root]')=>{
     compile(schema, rootName)(data);
 };
+const createValidator = (config, rootName = '[root]')=>{
+    return (schema)=>{
+        ascertain(schema, config, rootName);
+        return config;
+    };
+};
 
 //# sourceMappingURL=index.cjs.map