ascertain 2.1.0 → 3.1.0

package/build/index.js

@@ -1,32 +1,105 @@
-class Operator {
-    schemas;
-    constructor(schemas){
-        this.schemas = schemas;
-        if (schemas.length === 0) {
-            throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);
-        }
-    }
-}
 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 Operator {
-}
-export const and = (...schemas)=>new And(schemas);
-class Optional extends Operator {
-    constructor(schema){
-        super([
-            schema
-        ]);
+const $op = Symbol.for('@@op');
+const OR = Symbol.for('@@or');
+const AND = Symbol.for('@@and');
+const OPTIONAL = Symbol.for('@@optional');
+const TUPLE = Symbol.for('@@tuple');
+const DISCRIMINATED = Symbol.for('@@discriminated');
+const CHECK = Symbol.for('@@check');
+const OrCtor = function(schemas) {
+    this.schemas = schemas;
+};
+OrCtor.prototype[$op] = OR;
+const AndCtor = function(schemas) {
+    this.schemas = schemas;
+};
+AndCtor.prototype[$op] = AND;
+const OptionalCtor = function(schema) {
+    this.schemas = [
+        schema
+    ];
+};
+OptionalCtor.prototype[$op] = OPTIONAL;
+const TupleCtor = function(schemas) {
+    this.schemas = schemas;
+};
+TupleCtor.prototype[$op] = TUPLE;
+const DiscriminatedCtor = function(schemas, key) {
+    this.schemas = schemas;
+    this.key = key;
+};
+DiscriminatedCtor.prototype[$op] = DISCRIMINATED;
+const CheckCtor = function(compileFn) {
+    this.compile = compileFn;
+};
+CheckCtor.prototype[$op] = CHECK;
+export const or = (...schemas)=>{
+    if (schemas.length === 0) throw new TypeError('Operator requires at least one schema');
+    return new OrCtor(schemas);
+};
+export const and = (...schemas)=>{
+    if (schemas.length === 0) throw new TypeError('Operator requires at least one schema');
+    return new AndCtor(schemas);
+};
+export const optional = (schema)=>new OptionalCtor(schema);
+export const tuple = (...schemas)=>{
+    if (schemas.length === 0) throw new TypeError('Operator requires at least one schema');
+    return new TupleCtor(schemas);
+};
+export const discriminated = (schemas, key)=>{
+    if (schemas.length === 0) throw new TypeError('discriminated requires at least one schema');
+    return new DiscriminatedCtor(schemas, key);
+};
+export const check = (fnOrOpts, message)=>{
+    if (typeof fnOrOpts === 'function') {
+        return new CheckCtor((v, ctx)=>{
+            const fnRef = ctx.ref(fnOrOpts);
+            return {
+                check: `!${fnRef}(${v})`,
+                message: message ? JSON.stringify(message) : `\`check failed for value \${${v}}\``
+            };
+        });
     }
-}
-export const optional = (schema)=>new Optional(schema);
-class Tuple extends Operator {
-}
-export const tuple = (...schemas)=>new Tuple(schemas);
+    return new CheckCtor(fnOrOpts.compile);
+};
+export const min = (n, message)=>new CheckCtor((v)=>({
+            check: `${v} < ${n}`,
+            message: message ? JSON.stringify(message) : `\`must be >= ${n}, got \${${v}}\``
+        }));
+export const max = (n, message)=>new CheckCtor((v)=>({
+            check: `${v} > ${n}`,
+            message: message ? JSON.stringify(message) : `\`must be <= ${n}, got \${${v}}\``
+        }));
+export const integer = (message)=>new CheckCtor((v)=>({
+            check: `!Number.isInteger(${v})`,
+            message: message ? JSON.stringify(message) : `\`must be an integer, got \${${v}}\``
+        }));
+export const minLength = (n, message)=>new CheckCtor((v)=>({
+            check: `${v}.length < ${n}`,
+            message: message ? JSON.stringify(message) : `\`length must be >= ${n}, got \${${v}.length}\``
+        }));
+export const maxLength = (n, message)=>new CheckCtor((v)=>({
+            check: `${v}.length > ${n}`,
+            message: message ? JSON.stringify(message) : `\`length must be <= ${n}, got \${${v}.length}\``
+        }));
+export const gt = (n, message)=>new CheckCtor((v)=>({
+            check: `${v} <= ${n}`,
+            message: message ? JSON.stringify(message) : `\`must be > ${n}, got \${${v}}\``
+        }));
+export const lt = (n, message)=>new CheckCtor((v)=>({
+            check: `${v} >= ${n}`,
+            message: message ? JSON.stringify(message) : `\`must be < ${n}, got \${${v}}\``
+        }));
+export const multipleOf = (n, message)=>new CheckCtor((v)=>({
+            check: `${v} % ${n} !== 0`,
+            message: message ? JSON.stringify(message) : `\`must be a multiple of ${n}, got \${${v}}\``
+        }));
+export const uniqueItems = (message)=>new CheckCtor((v)=>({
+            check: `new Set(${v}).size !== ${v}.length`,
+            message: message ? JSON.stringify(message) : `\`must have unique items\``
+        }));
 export const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
 const MULTIPLIERS = {
     ms: 1,
@@ -54,7 +127,7 @@ export const as = {
             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);
+        const result = value.trim() ? Number(value) : NaN;
         return Number.isNaN(result) ? asError(`Invalid value ${value}, expected a valid number`) : result;
     },
     date: (value)=>{
@@ -91,6 +164,86 @@ export const as = {
         }
     }
 };
+const DATETIME_RE = /^\d{4}-[01]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d{2}(?::?\d{2})?)$/i;
+const TIME_FMT_RE = /^(?:(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d{2}(?::?\d{2})?)$/i;
+const DURATION_RE = /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
+const EMAIL_RE = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
+const IDN_EMAIL_RE = /^[a-z0-9!#$%&'*+/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]+)*@(?:[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF](?:[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]*[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])?\.)+[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF](?:[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]*[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])?$/i;
+const HOSTNAME_RE = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*\.?$/i;
+const IDN_HOSTNAME_RE = /^(?=.{1,253}\.?$)[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF](?:[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]{0,61}[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])?(?:\.[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF](?:[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF-]{0,61}[a-z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])?)*\.?$/i;
+const IPV4_RE = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+const IPV6_RE = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?$/i;
+const URI_RE = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+const isUriRef = (s)=>URI_RE.test(s) || /^[a-z0-9\-._~:/?#\[\]@!$&'()*+,;=%]*$/i.test(s);
+const IRI_RE = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|%[0-9a-f]{2})*)?$/i;
+const isIriRef = (s)=>IRI_RE.test(s) || /^[a-z0-9\-._~:/?#\[\]@!$&'()*+,;=\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF%]*$/i.test(s);
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const URI_TEMPLATE_RE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+const JSON_POINTER_RE = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const REL_JSON_POINTER_RE = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const DAYS = [
+    0,
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+const isValidDate = (s)=>{
+    const m = /^\d{4}-(\d{2})-(\d{2})$/.exec(s);
+    if (!m) return false;
+    const month = +m[1], day = +m[2];
+    if (month < 1 || month > 12 || day < 1) return false;
+    if (month === 2) {
+        const y = +s.slice(0, 4);
+        return day <= (y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28);
+    }
+    return day <= DAYS[month];
+};
+const isValidRegex = (s)=>{
+    try {
+        new RegExp(s);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const regexFormat = (re, name, message)=>new CheckCtor((v, ctx)=>({
+            check: `!${ctx.ref(re)}.test(${v})`,
+            message: message ? JSON.stringify(message) : `\`must be a valid ${name}, got \${${v}}\``
+        }));
+const fnFormat = (fn, name, message)=>new CheckCtor((v, ctx)=>({
+            check: `!${ctx.ref(fn)}(${v})`,
+            message: message ? JSON.stringify(message) : `\`must be a valid ${name}, got \${${v}}\``
+        }));
+export const format = {
+    dateTime: (message)=>regexFormat(DATETIME_RE, 'date-time', message),
+    date: (message)=>fnFormat(isValidDate, 'date', message),
+    time: (message)=>regexFormat(TIME_FMT_RE, 'time', message),
+    duration: (message)=>regexFormat(DURATION_RE, 'duration', message),
+    email: (message)=>regexFormat(EMAIL_RE, 'email', message),
+    idnEmail: (message)=>regexFormat(IDN_EMAIL_RE, 'idn-email', message),
+    hostname: (message)=>regexFormat(HOSTNAME_RE, 'hostname', message),
+    idnHostname: (message)=>regexFormat(IDN_HOSTNAME_RE, 'idn-hostname', message),
+    ipv4: (message)=>regexFormat(IPV4_RE, 'ipv4', message),
+    ipv6: (message)=>regexFormat(IPV6_RE, 'ipv6', message),
+    uri: (message)=>regexFormat(URI_RE, 'uri', message),
+    uriReference: (message)=>fnFormat(isUriRef, 'uri-reference', message),
+    iri: (message)=>regexFormat(IRI_RE, 'iri', message),
+    iriReference: (message)=>fnFormat(isIriRef, 'iri-reference', message),
+    uuid: (message)=>regexFormat(UUID_RE, 'uuid', message),
+    uriTemplate: (message)=>regexFormat(URI_TEMPLATE_RE, 'uri-template', message),
+    jsonPointer: (message)=>regexFormat(JSON_POINTER_RE, 'json-pointer', message),
+    relativeJsonPointer: (message)=>regexFormat(REL_JSON_POINTER_RE, 'relative-json-pointer', message),
+    regex: (message)=>fnFormat(isValidRegex, 'regex', message)
+};
 class Context {
     registry = [];
     lookupMap = new Map();
@@ -110,193 +263,434 @@ class Context {
         return `${prefix}$$${this.varIndex++}`;
     }
 }
-const codeGenCollectErrors = (errorsAlias, code, extra = '')=>`try {${code}} catch (e) {${errorsAlias}.push(e.message);${extra}}`;
-const codeGenExpectNoErrors = (errorsAlias)=>`if (${errorsAlias}.length !== 0) { throw new TypeError(${errorsAlias}.join('\\n')); }`;
-const codeGenExpectNonError = (valueAlias, path)=>`if (${valueAlias} instanceof Error) { throw new TypeError(\`\${${valueAlias}.message} for path "${path}".\`); }`;
-const codeGenExpectNonNullable = (valueAlias, path)=>`if (${valueAlias} === null || ${valueAlias} === undefined) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected non-nullable.\`); }`;
-const codeGenExpectObject = (valueAlias, path, instanceOf)=>`if (typeof ${valueAlias} !== 'object') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected an instance of ${instanceOf}\`); }`;
-const codeGenExpectArray = (valueAlias, path)=>`if (!Array.isArray(${valueAlias})) { throw new TypeError(\`Invalid instance of \${${valueAlias}.constructor?.name} for path "${path}", expected an instance of Array.\`); }`;
-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.message); }`).join('\n');
-        return `// And
-  const ${errorsAlias} = [];
-  const ${valueAlias} = ${valuePath};
-  ${code}
-  ${codeGenExpectNoErrors(errorsAlias)}
-`;
-    } 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)=>codeGenCollectErrors(errorsAlias, code, result), codeGenExpectNoErrors(errorsAlias));
-        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} = [];`,
-            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}.\`); }`,
-            ...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 valueAlias = context.unique('v');
-        const code = [
-            `const ${valueAlias} = ${valuePath};`,
-            codeGenExpectNonNullable(valueAlias, path)
-        ];
-        if (schema !== Error && !(schema?.prototype instanceof Error)) {
-            code.push(codeGenExpectNonError(valueAlias, path));
+const isTagged = (schema)=>schema?.[$op] !== undefined;
+const childMode = (mode, key)=>{
+    if (typeof key === 'object' && 'dynamic' in key) {
+        return {
+            fast: false,
+            firstError: mode.firstError,
+            issues: mode.issues,
+            path: mode.path,
+            pathExpr: `[${mode.path.map((k)=>JSON.stringify(k)).join(',')}${mode.path.length ? ',' : ''}${key.dynamic}]`
+        };
+    }
+    const newPath = [
+        ...mode.path,
+        key
+    ];
+    return {
+        fast: false,
+        firstError: mode.firstError,
+        issues: mode.issues,
+        path: newPath,
+        pathExpr: JSON.stringify(newPath)
+    };
+};
+const toLiteral = (value)=>typeof value === 'bigint' ? `${value}n` : JSON.stringify(value);
+const codeGen = (schema, context, valuePath, mode)=>{
+    const emit = mode.fast ? null : mode.firstError ? (msg)=>`${mode.issues} = [{ message: ${msg}, path: ${mode.pathExpr} }]; return ${mode.issues};` : (msg)=>`(${mode.issues} || (${mode.issues} = [])).push({ message: ${msg}, path: ${mode.pathExpr} });`;
+    const fail = mode.fast ? mode.onFail ?? 'return false;' : '';
+    if (isTagged(schema)) {
+        const tag = schema[$op];
+        if (tag === AND) {
+            const valueAlias = context.unique('v');
+            const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, mode)).join('\n');
+            return `const ${valueAlias} = ${valuePath};\n${code}`;
+        } else if (tag === OR) {
+            const valueAlias = context.unique('v');
+            const foundValid = context.unique('valid');
+            if (mode.fast) {
+                const branches = schema.schemas.map((s)=>{
+                    const branchValid = context.unique('valid');
+                    const branchCode = codeGen(s, context, valueAlias, {
+                        ...mode,
+                        onFail: `${branchValid} = false;`
+                    });
+                    return `if (!${foundValid}) { let ${branchValid} = true; ${branchCode} if (${branchValid}) { ${foundValid} = true; } }`;
+                });
+                return `const ${valueAlias} = ${valuePath};\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { ${fail} }`;
+            } else if (mode.firstError) {
+                const firstBranchIssues = context.unique('iss');
+                const branches = schema.schemas.map((s, idx)=>{
+                    const branchIssues = context.unique('iss');
+                    const branchCode = codeGen(s, context, valueAlias, {
+                        fast: false,
+                        firstError: true,
+                        issues: branchIssues,
+                        path: mode.path,
+                        pathExpr: mode.pathExpr
+                    }).replace(new RegExp(`; return ${branchIssues};`, 'g'), ';');
+                    if (idx === 0) {
+                        return `if (!${foundValid}) { let ${branchIssues}; ${branchCode} if (!${branchIssues}) { ${foundValid} = true; } else { ${firstBranchIssues} = ${branchIssues}; } }`;
+                    }
+                    return `if (!${foundValid}) { let ${branchIssues}; ${branchCode} if (!${branchIssues}) { ${foundValid} = true; } }`;
+                });
+                return `const ${valueAlias} = ${valuePath};\nlet ${firstBranchIssues};\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { return ${firstBranchIssues}; }`;
+            } else {
+                const localIssues = context.unique('iss');
+                const branches = schema.schemas.map((s)=>{
+                    const branchIssues = context.unique('iss');
+                    const branchCode = codeGen(s, context, valueAlias, {
+                        fast: false,
+                        firstError: false,
+                        issues: branchIssues,
+                        path: mode.path,
+                        pathExpr: mode.pathExpr
+                    });
+                    return `if (!${foundValid}) { let ${branchIssues}; ${branchCode} if (!${branchIssues}) { ${foundValid} = true; } else { ${localIssues}.push(...${branchIssues}); } }`;
+                });
+                return `const ${valueAlias} = ${valuePath};\nconst ${localIssues} = [];\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { (${mode.issues} || (${mode.issues} = [])).push(...${localIssues}); }`;
+            }
+        } else if (tag === OPTIONAL) {
+            const valueAlias = context.unique('v');
+            return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, mode)} }`;
+        } else if (tag === TUPLE) {
+            const valueAlias = context.unique('v');
+            if (mode.fast) {
+                return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || typeof ${valueAlias} !== 'object' || !Array.isArray(${valueAlias}) || ${valueAlias}.length !== ${schema.schemas.length}) { ${fail} }\n${schema.schemas.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, mode)).join('\n')}`;
+            } else {
+                return [
+                    `const ${valueAlias} = ${valuePath};`,
+                    `if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`,
+                    `else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Array\``)} }`,
+                    `else if (!Array.isArray(${valueAlias})) { ${emit(`\`Invalid instance of \${${valueAlias}.constructor?.name}, expected an instance of Array\``)} }`,
+                    `else if (${valueAlias}.length !== ${schema.schemas.length}) { ${emit(`\`Invalid tuple length \${${valueAlias}.length}, expected ${schema.schemas.length}\``)} }`,
+                    `else { ${schema.schemas.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, childMode(mode, idx))).join('\n')} }`
+                ].join('\n');
+            }
+        } else if (tag === CHECK) {
+            const valueAlias = context.unique('v');
+            const ref = (v)=>`ctx.registry[${context.register(v)}]`;
+            const { check: cond, message } = schema.compile(valueAlias, {
+                ref
+            });
+            if (mode.fast) {
+                return `const ${valueAlias} = ${valuePath};\nif (${cond}) { ${fail} }`;
+            }
+            return `const ${valueAlias} = ${valuePath};\nif (${cond}) { ${emit(message)} }`;
+        } else {
+            const { key, schemas } = schema;
+            const valueAlias = context.unique('v');
+            const discriminantAlias = context.unique('d');
+            const keyStr = JSON.stringify(key);
+            const variants = [];
+            for (const s of schemas){
+                if (typeof s !== 'object' || s === null || !(key in s)) {
+                    throw new TypeError(`discriminated: each schema must have the discriminant key "${key}"`);
+                }
+                const discriminantValue = s[key];
+                if (typeof discriminantValue !== 'string' && typeof discriminantValue !== 'number' && typeof discriminantValue !== 'boolean') {
+                    throw new TypeError(`discriminated: discriminant value must be a string, number, or boolean literal`);
+                }
+                variants.push({
+                    value: discriminantValue,
+                    schema: s
+                });
+            }
+            if (mode.fast) {
+                const branches = variants.map(({ value, schema: s })=>{
+                    const branchCode = codeGen(s, context, valueAlias, mode);
+                    return `if (${discriminantAlias} === ${JSON.stringify(value)}) { ${branchCode} }`;
+                });
+                return [
+                    `const ${valueAlias} = ${valuePath};`,
+                    `if (${valueAlias} === null || ${valueAlias} === undefined || typeof ${valueAlias} !== 'object' || ${valueAlias} instanceof Error) { ${fail} }`,
+                    `const ${discriminantAlias} = ${valueAlias}[${keyStr}];`,
+                    branches.join(' else ') + ` else { ${fail} }`
+                ].join('\n');
+            } else {
+                const validValues = variants.map((v)=>JSON.stringify(v.value)).join(', ');
+                const branches = variants.map(({ value, schema: s })=>{
+                    const branchCode = codeGen(s, context, valueAlias, mode);
+                    return `if (${discriminantAlias} === ${JSON.stringify(value)}) { ${branchCode} }`;
+                });
+                return [
+                    `const ${valueAlias} = ${valuePath};`,
+                    `if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`,
+                    `else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an object\``)} }`,
+                    `else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`,
+                    `else {`,
+                    `  const ${discriminantAlias} = ${valueAlias}[${keyStr}];`,
+                    `  ${branches.join(' else ')} else { ${emit(`\`Invalid discriminant value \${JSON.stringify(${discriminantAlias})}, expected one of: ${validValues}\``)} }`,
+                    `}`
+                ].join('\n');
+            }
         }
+    }
+    if (typeof schema === 'function') {
+        const valueAlias = context.unique('v');
         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}\`); }`);
+        const s = schema;
+        const primitiveType = s === String ? 'string' : s === Number ? 'number' : s === Boolean ? 'boolean' : s === BigInt ? 'bigint' : s === Symbol ? 'symbol' : null;
+        if (mode.fast) {
+            if (primitiveType) {
+                const checks = [
+                    `typeof ${valueAlias} !== '${primitiveType}'`
+                ];
+                if (primitiveType === 'number') checks.push(`Number.isNaN(${valueAlias})`);
+                return `const ${valueAlias} = ${valuePath};\nif (${checks.join(' || ')}) { ${fail} }`;
+            } else if (name === 'Function') {
+                return `const ${valueAlias} = ${valuePath};\nif (typeof ${valueAlias} !== 'function') { ${fail} }`;
+            } else {
+                const isError = schema === Error || schema?.prototype instanceof Error;
+                const index = context.register(schema);
+                const registryAlias = context.unique('r');
+                return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined${isError ? '' : ` || ${valueAlias} instanceof Error`} || (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) || (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) || Number.isNaN(${valueAlias}?.valueOf?.())) { ${fail} }`;
             }
-        } 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}\`); }`);
+            const code = [
+                `const ${valueAlias} = ${valuePath};`
+            ];
+            if (primitiveType) {
+                code.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`);
+                code.push(`else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`);
+                code.push(`else if (typeof ${valueAlias} !== '${primitiveType}') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected type ${name}\``)} }`);
+                if (primitiveType === 'number') code.push(`else if (Number.isNaN(${valueAlias})) { ${emit(`\`Invalid value \${${valueAlias}}, expected a valid ${name}\``)} }`);
+            } else if (name === 'Function') {
+                code.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`);
+                code.push(`else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`);
+                code.push(`else if (typeof ${valueAlias} !== 'function') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected type Function\``)} }`);
+            } else {
+                const isError = schema === Error || schema?.prototype instanceof Error;
+                const index = context.register(schema);
+                const registryAlias = context.unique('r');
+                code.push(`const ${registryAlias} = ctx.registry[${index}];`);
+                code.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`);
+                if (!isError) code.push(`else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`);
+                code.push(`else if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { ${emit(`\`Invalid instance of \${${valueAlias}?.constructor?.name}, expected an instance of ${name}\``)} }`);
+                code.push(`else if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { ${emit(`\`Invalid type \${${valueAlias}?.constructor?.name}, expected type ${name}\``)} }`);
+                code.push(`else if (Number.isNaN(${valueAlias}?.valueOf?.())) { ${emit(`\`Invalid value \${${valueAlias}}, expected a valid ${name}\``)} }`);
+            }
+            return code.join('\n');
         }
-        return code.join('\n');
-    } else if (Array.isArray(schema)) {
+    }
+    if (Array.isArray(schema)) {
         const valueAlias = context.unique('v');
-        const code = [
-            `const ${valueAlias} = ${valuePath};`,
-            codeGenExpectNonNullable(valueAlias, path),
-            codeGenExpectNonError(valueAlias, path),
-            codeGenExpectObject(valueAlias, path, 'Array'),
-            codeGenExpectArray(valueAlias, path)
-        ];
-        if (schema.length > 0) {
-            const value = context.unique('val');
-            const key = context.unique('key');
-            const errorsAlias = context.unique('err');
-            code.push(`const ${errorsAlias} = [];`);
+        if (mode.fast) {
+            let code = `const ${valueAlias} = ${valuePath};\nif (!Array.isArray(${valueAlias})) { ${fail} }`;
             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}]`))));
+                const value = context.unique('val');
+                const key = context.unique('key');
+                code += `\nfor (let ${key} = 0; ${key} < ${valueAlias}.length; ${key}++) { const ${value} = ${valueAlias}[${key}]; ${codeGen(schema[0], context, value, mode)} }`;
+            } else if (schema.length > 1) {
+                code += `\nif (${valueAlias}.length > ${schema.length}) { ${fail} }`;
+                code += '\n' + schema.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, mode)).join('\n');
             }
-            code.push(codeGenExpectNoErrors(errorsAlias));
-        }
-        return code.join('\n');
-    } else if (typeof schema === 'object' && schema !== null) {
-        if (schema instanceof RegExp) {
-            const valueAlias = context.unique('v');
-            return `
-const ${valueAlias} = ${valuePath};
-${codeGenExpectNonNullable(valueAlias, path)}
-${codeGenExpectNonError(valueAlias, path)}
-if (!${schema.toString()}.test(String(${valueAlias}))) { throw new TypeError(\`Invalid value \${${valueAlias}} for path "${path}", expected to match ${schema.toString()}\`); }
-`;
+            return code;
         } else {
-            const valueAlias = context.unique('v');
             const code = [
                 `const ${valueAlias} = ${valuePath};`,
-                codeGenExpectNonNullable(valueAlias, path),
-                codeGenExpectObject(valueAlias, path, 'Object'),
-                codeGenExpectNonError(valueAlias, path)
+                `if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`,
+                `else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`,
+                `else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Array\``)} }`,
+                `else if (!Array.isArray(${valueAlias})) { ${emit(`\`Invalid instance of \${${valueAlias}.constructor?.name}, expected an instance of Array\``)} }`
             ];
-            if ($keys in schema) {
-                const keysAlias = context.unique('k');
-                const errorsAlias = context.unique('err');
-                const kAlias = context.unique('k');
-                code.push(`
-const ${keysAlias} = Object.keys(${valueAlias});
-const ${errorsAlias} = [];
-for (const ${kAlias} of ${keysAlias}) { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$keys], context, kAlias, `${path}[\${${kAlias}}]`))} }
-${codeGenExpectNoErrors(errorsAlias)}
-`);
+            if (schema.length > 0) {
+                const value = context.unique('val');
+                const key = context.unique('key');
+                if (schema.length === 1) {
+                    code.push(`else { for (let ${key} = 0; ${key} < ${valueAlias}.length; ${key}++) { const ${value} = ${valueAlias}[${key}]; ${codeGen(schema[0], context, value, childMode(mode, {
+                        dynamic: key
+                    }))} } }`);
+                } else {
+                    code.push(`else if (${valueAlias}.length > ${schema.length}) { ${emit(`\`Invalid tuple length \${${valueAlias}.length}, expected ${schema.length}\``)} }`);
+                    code.push(`else { ${schema.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, childMode(mode, idx))).join('\n')} }`);
+                }
             }
-            if ($values in schema) {
-                const vAlias = context.unique('val');
-                const kAlias = context.unique('k');
-                const entriesAlias = context.unique('en');
-                const errorsAlias = context.unique('err');
-                code.push(`
-const ${entriesAlias} = Object.entries(${valueAlias});
-const ${errorsAlias} = [];
-for (const [${kAlias}, ${vAlias}] of ${entriesAlias}) { ${codeGenCollectErrors(errorsAlias, codeGen(schema[$values], context, vAlias, `${path}[\${${kAlias}}]`))} }
-${codeGenExpectNoErrors(errorsAlias)}
-`);
+            return code.join('\n');
+        }
+    }
+    if (typeof schema === 'object' && schema !== null) {
+        if (schema instanceof RegExp) {
+            const valueAlias = context.unique('v');
+            if (mode.fast) {
+                return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || ${valueAlias} === undefined || ${valueAlias} instanceof Error || !${schema.toString()}.test(String(${valueAlias}))) { ${fail} }`;
+            } else {
+                return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }\nelse if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }\nelse if (!${schema.toString()}.test(String(${valueAlias}))) { ${emit(`\`Invalid value \${${valueAlias}}, expected to match ${schema.toString()}\``)} }`;
             }
-            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}"\`); }`);
+        } else {
+            const valueAlias = context.unique('v');
+            if (mode.fast) {
+                let code = `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || typeof ${valueAlias} !== 'object' || ${valueAlias} instanceof Error) { ${fail} }`;
+                if ($keys in schema) {
+                    const keysAlias = context.unique('k');
+                    const kAlias = context.unique('k');
+                    code += `\nconst ${keysAlias} = Object.keys(${valueAlias});\nfor (const ${kAlias} of ${keysAlias}) { ${codeGen(schema[$keys], context, kAlias, mode)} }`;
+                }
+                if ($values in schema) {
+                    const vAlias = context.unique('val');
+                    const kAlias = context.unique('k');
+                    const entriesAlias = context.unique('en');
+                    code += `\nconst ${entriesAlias} = Object.entries(${valueAlias});\nfor (const [${kAlias}, ${vAlias}] of ${entriesAlias}) { ${codeGen(schema[$values], context, vAlias, mode)} }`;
+                }
+                if ($strict in schema && schema[$strict]) {
+                    const keysAlias = context.unique('k');
+                    const kAlias = context.unique('k');
+                    const extraAlias = context.unique('ex');
+                    code += `\nconst ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});\nconst ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));\nif (${extraAlias}.length !== 0) { ${fail} }`;
+                }
+                code += '\n' + Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, mode)).join('\n');
+                return code;
+            } else {
+                const code = [
+                    `const ${valueAlias} = ${valuePath};`,
+                    `if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`,
+                    `else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Object\``)} }`,
+                    `else if (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }`,
+                    'else {'
+                ];
+                const innerCode = [];
+                if ($keys in schema) {
+                    const keysAlias = context.unique('k');
+                    const kAlias = context.unique('k');
+                    innerCode.push(`const ${keysAlias} = Object.keys(${valueAlias});`);
+                    innerCode.push(`for (const ${kAlias} of ${keysAlias}) { ${codeGen(schema[$keys], context, kAlias, childMode(mode, {
+                        dynamic: kAlias
+                    }))} }`);
+                }
+                if ($values in schema) {
+                    const vAlias = context.unique('val');
+                    const kAlias = context.unique('k');
+                    const entriesAlias = context.unique('en');
+                    innerCode.push(`const ${entriesAlias} = Object.entries(${valueAlias});`);
+                    innerCode.push(`for (const [${kAlias}, ${vAlias}] of ${entriesAlias}) { ${codeGen(schema[$values], context, vAlias, childMode(mode, {
+                        dynamic: kAlias
+                    }))} }`);
+                }
+                if ($strict in schema && schema[$strict]) {
+                    const keysAlias = context.unique('k');
+                    const kAlias = context.unique('k');
+                    const extraAlias = context.unique('ex');
+                    innerCode.push(`const ${keysAlias} = new Set(${JSON.stringify(Object.keys(schema))});`);
+                    innerCode.push(`const ${extraAlias} = Object.keys(${valueAlias}).filter(${kAlias} => !${keysAlias}.has(${kAlias}));`);
+                    innerCode.push(`if (${extraAlias}.length !== 0) { ${emit(`\`Extra properties: \${${extraAlias}}, are not allowed\``)} }`);
+                }
+                innerCode.push(...Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, childMode(mode, key))));
+                code.push(innerCode.join('\n'), '}');
+                return code.join('\n');
             }
-            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') {
+    }
+    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 TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected symbol\`); }
-if (${valueAlias} !== ${registryAlias}) { throw new TypeError(\`Invalid value \${${valueAlias}.toString()} for path "${path}", expected ${schema.toString()}\`); }
-    `;
-    } else if (schema === null || schema === undefined) {
+        if (mode.fast) {
+            return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol' || ${valueAlias} !== ${registryAlias}) { ${fail} }`;
+        } else {
+            return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected symbol\``)} }\nelse if (${valueAlias} !== ${registryAlias}) { ${emit(`\`Invalid value \${${valueAlias}.toString()}, expected ${schema.toString()}\``)} }`;
+        }
+    }
+    if (schema === null || schema === undefined) {
         const valueAlias = context.unique('v');
-        return `
-const ${valueAlias} = ${valuePath};
-if (${valueAlias} !== null && ${valueAlias} !== undefined ) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected nullable\`); }
-    `;
+        if (mode.fast) {
+            return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined) { ${fail} }`;
+        } else {
+            return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} !== null && ${valueAlias} !== undefined) { ${emit(`\`Invalid value \${String(${valueAlias})}, expected nullable\``)} }`;
+        }
+    }
+    const valueAlias = context.unique('v');
+    if (mode.fast) {
+        return `const ${valueAlias} = ${valuePath};\nif (typeof ${valueAlias} !== '${typeof schema}' || ${valueAlias} !== ${toLiteral(schema)}) { ${fail} }`;
     } else {
-        const valueAlias = context.unique('v');
         const value = context.unique('val');
-        return `
-const ${valueAlias} = ${valuePath};
-const ${value} = ${JSON.stringify(schema)};
-${codeGenExpectNonError(valueAlias, path)}
-if (typeof ${valueAlias} !== '${typeof schema}') { throw new TypeError(\`Invalid type \${typeof ${valueAlias}} for path "${path}", expected ${typeof schema}\`); }
-if (${valueAlias} !== ${value}) { throw new TypeError(\`Invalid value \${JSON.stringify(${valueAlias})} for path "${path}", expected ${JSON.stringify(schema)}\`); }
-`;
+        return `const ${valueAlias} = ${valuePath};\nconst ${value} = ${toLiteral(schema)};\nif (${valueAlias} instanceof Error) { ${emit(`\`\${${valueAlias}.message}\``)} }\nelse if (typeof ${valueAlias} !== '${typeof schema}') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected ${typeof schema}\``)} }\nelse if (${valueAlias} !== ${value}) { ${emit(`\`Invalid value \${String(${valueAlias})}, expected ${toLiteral(schema)}\``)} }`;
     }
 };
-export const compile = (schema, rootName)=>{
+const emptyIssues = [];
+export const compile = (schema, options)=>{
+    const allErrors = options?.allErrors ?? false;
+    if (allErrors) {
+        const fastContext = new Context();
+        const fastCode = `${codeGen(schema, fastContext, 'data', {
+            fast: true
+        })}\nreturn true;`;
+        const fastValidator = new Function('ctx', `return (data) => {\n${fastCode}\n};`)(fastContext);
+        const issueContext = new Context();
+        const issueCode = `let issues;\n${codeGen(schema, issueContext, 'data', {
+            fast: false,
+            firstError: false,
+            issues: 'issues',
+            path: [],
+            pathExpr: '[]'
+        })}\nreturn issues || [];`;
+        const issueValidator = new Function('ctx', `return (data) => {\n${issueCode}\n};`)(issueContext);
+        const validator = (data)=>{
+            if (fastValidator(data)) {
+                return true;
+            }
+            validator.issues = issueValidator(data);
+            return false;
+        };
+        validator.issues = emptyIssues;
+        return validator;
+    }
+    const fastContext = new Context();
+    const fastCode = `${codeGen(schema, fastContext, 'data', {
+        fast: true
+    })}\nreturn true;`;
+    const fastValidator = new Function('ctx', `return (data) => {\n${fastCode}\n};`)(fastContext);
     const context = new Context();
-    const code = codeGen(schema, context, 'data', rootName);
-    const validator = new Function('ctx', 'data', code);
-    return (data)=>validator(context, data);
+    const code = codeGen(schema, context, 'data', {
+        fast: false,
+        firstError: true,
+        issues: 'issues',
+        path: [],
+        pathExpr: '[]'
+    });
+    const firstErrorValidator = new Function('ctx', `return (data) => {\nlet issues;\n${code}\nreturn issues;\n};`)(context);
+    const validator = (data)=>{
+        if (fastValidator(data)) {
+            return true;
+        }
+        validator.issues = firstErrorValidator(data);
+        return false;
+    };
+    validator.issues = emptyIssues;
+    return validator;
 };
-export const ascertain = (schema, data, rootName = '[root]')=>{
-    compile(schema, rootName)(data);
+export const ascertain = (schema, data)=>{
+    const validator = compile(schema);
+    if (!validator(data)) {
+        throw new TypeError(validator.issues[0].message, {
+            cause: {
+                issues: validator.issues
+            }
+        });
+    }
 };
-export const createValidator = (config, rootName = '[root]')=>{
+export const createValidator = (config)=>{
     return (schema)=>{
-        ascertain(schema, config, rootName);
+        ascertain(schema, config);
         return config;
     };
 };
+export const standardSchema = (schema)=>{
+    const validator = compile(schema);
+    const fn = (data)=>{
+        if (!validator(data)) {
+            throw new TypeError(validator.issues[0].message, {
+                cause: {
+                    issues: validator.issues
+                }
+            });
+        }
+    };
+    fn['~standard'] = {
+        version: 1,
+        vendor: 'ascertain',
+        validate: (value)=>{
+            if (validator(value)) {
+                return {
+                    value: value
+                };
+            }
+            return {
+                issues: validator.issues
+            };
+        }
+    };
+    return fn;
+};
 
 //# sourceMappingURL=index.js.map