ascertain 3.2.21 → 3.2.22

package/build/index.js

@@ -8,6 +8,11 @@ const OPTIONAL = Symbol.for('@@optional');
 const TUPLE = Symbol.for('@@tuple');
 const DISCRIMINATED = Symbol.for('@@discriminated');
 const CHECK = Symbol.for('@@check');
+const ERR = Symbol.for('@@err');
+function ErrCtor(message) {
+    this.message = message;
+}
+ErrCtor.prototype[ERR] = true;
 const OrCtor = function(schemas) {
     this.schemas = schemas;
 };
@@ -109,7 +114,39 @@ export const oneOf = (values, message)=>{
             ].map(toLiteral).join(', ')}], got \${${v}}\``
         }));
 };
-export const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder('utf-8');
+const fromBase64Bytes = (value)=>{
+    const bin = atob(value);
+    const out = new Uint8Array(bin.length);
+    for(let i = 0; i < bin.length; i++)out[i] = bin.charCodeAt(i);
+    return out;
+};
+export const fromBase64 = (value)=>utf8Decoder.decode(fromBase64Bytes(value));
+const HEX_LUT = (()=>{
+    const t = new Int8Array(256).fill(-1);
+    for(let i = 0; i < 10; i++)t[48 + i] = i;
+    for(let i = 0; i < 6; i++){
+        t[97 + i] = 10 + i;
+        t[65 + i] = 10 + i;
+    }
+    return t;
+})();
+const fromHex = (value)=>{
+    let start = 0;
+    if (value.length >= 2 && value.charCodeAt(0) === 48 && (value.charCodeAt(1) | 32) === 120) {
+        start = 2;
+    }
+    const digits = value.length - start;
+    if (digits === 0 || digits % 2 !== 0) throw new TypeError('invalid hex length');
+    const out = new Uint8Array(digits / 2);
+    for(let i = 0; i < out.length; i++){
+        const byte = HEX_LUT[value.charCodeAt(start + i * 2)] << 4 | HEX_LUT[value.charCodeAt(start + i * 2 + 1)];
+        if (byte < 0) throw new TypeError('invalid hex digit');
+        out[i] = byte;
+    }
+    return out;
+};
 const MULTIPLIERS = {
     ms: 1,
     s: 1000,
@@ -119,7 +156,7 @@ const MULTIPLIERS = {
     w: 604800000
 };
 const TIME_REGEX = /^(\d*\.?\d*)(ms|s|m|h|d|w)?$/;
-export const asError = (message)=>new TypeError(message);
+export const asError = (message)=>new ErrCtor(message);
 export const as = {
     string: (value)=>{
         return typeof value === 'string' ? value : asError(`Invalid value "${value}", expected a string`);
@@ -171,6 +208,16 @@ export const as = {
         } catch  {
             return asError(`Invalid value ${value}, expected a valid base64 string`);
         }
+    },
+    data: (value, type = 'utf-8')=>{
+        if (typeof value !== 'string') return asError(`Invalid value ${value}, expected a string`);
+        try {
+            if (type === 'hex') return fromHex(value);
+            if (type === 'base64') return fromBase64Bytes(value);
+            return utf8Encoder.encode(value);
+        } catch  {
+            return asError(`Invalid value ${value}, expected a valid ${type} string`);
+        }
     }
 };
 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;
@@ -257,6 +304,7 @@ class Context {
     registry = [];
     lookupMap = new Map();
     varIndex = 0;
+    pure = false;
     register(value) {
         const index = this.lookupMap.get(value);
         if (index !== undefined) {
@@ -273,32 +321,128 @@ class Context {
     }
 }
 const isTagged = (schema)=>schema?.[$op] !== undefined;
-const childMode = (mode, key)=>{
+const buildDynamicPathExpr = (staticPath, dynamicParts)=>`[${[
+        ...staticPath.map((k)=>JSON.stringify(k)),
+        ...dynamicParts
+    ].join(',')}]`;
+const childMode = (mode, key, ctx)=>{
+    const carryReady = !mode.firstError && mode.issuesReady;
     if (typeof key === 'object' && 'dynamic' in key) {
-        return {
+        const dynamicParts = [
+            ...mode.dynamicParts ?? [],
+            key.dynamic
+        ];
+        const m = {
+            fast: false,
+            firstError: mode.firstError,
+            issues: mode.issues,
+            path: mode.path,
+            pathExpr: buildDynamicPathExpr(mode.path, dynamicParts),
+            dynamicParts
+        };
+        if (carryReady) m.issuesReady = true;
+        return m;
+    }
+    if (mode.dynamicParts) {
+        const dynamicParts = [
+            ...mode.dynamicParts,
+            JSON.stringify(key)
+        ];
+        const m = {
             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}]`
+            pathExpr: buildDynamicPathExpr(mode.path, dynamicParts),
+            dynamicParts
         };
+        if (carryReady) m.issuesReady = true;
+        return m;
     }
     const newPath = [
         ...mode.path,
         key
     ];
-    return {
+    const pathExpr = `reg[${ctx.register(Object.freeze(newPath))}]`;
+    const m = {
         fast: false,
         firstError: mode.firstError,
         issues: mode.issues,
         path: newPath,
-        pathExpr: JSON.stringify(newPath)
+        pathExpr
     };
+    if (carryReady) m.issuesReady = true;
+    return m;
 };
 const toLiteral = (value)=>typeof value === 'bigint' ? `${value}n` : JSON.stringify(value);
+const collapsibleTypeOf = (s)=>s === String ? 'string' : s === Number ? 'number' : s === Boolean ? 'boolean' : s === BigInt ? 'bigint' : s === Symbol ? 'symbol' : typeof s === 'function' && s?.name === 'Function' ? 'function' : null;
+const buildCollapsedOr = (schemas, v)=>{
+    let hasNull = false;
+    let hasUndefined = false;
+    const groups = new Map();
+    for (const s of schemas){
+        if (s === null) {
+            hasNull = true;
+            continue;
+        }
+        if (s === undefined) {
+            hasUndefined = true;
+            continue;
+        }
+        const ct = collapsibleTypeOf(s);
+        if (ct) {
+            let g = groups.get(ct);
+            if (!g) {
+                g = {
+                    ctor: false,
+                    literals: []
+                };
+                groups.set(ct, g);
+            }
+            g.ctor = true;
+            continue;
+        }
+        const t = typeof s;
+        let g = groups.get(t);
+        if (!g) {
+            g = {
+                ctor: false,
+                literals: []
+            };
+            groups.set(t, g);
+        }
+        g.literals.push(s);
+    }
+    const clauses = [];
+    if (hasNull) clauses.push(`${v} === null`);
+    if (hasUndefined) clauses.push(`${v} === undefined`);
+    for (const [type, { ctor, literals }] of groups){
+        if (ctor) {
+            clauses.push(type === 'number' ? `(typeof ${v} === 'number' && ${v} === ${v})` : `typeof ${v} === '${type}'`);
+        } else if (literals.length === 1) {
+            clauses.push(`${v} === ${toLiteral(literals[0])}`);
+        } else {
+            clauses.push(`(typeof ${v} === '${type}' && (${literals.map((l)=>`${v} === ${toLiteral(l)}`).join(' || ')}))`);
+        }
+    }
+    return clauses.join(' || ');
+};
+const buildExpectedDesc = (schemas)=>{
+    const parts = [];
+    for (const s of schemas){
+        if (s === null) parts.push('null');
+        else if (s === undefined) parts.push('undefined');
+        else if (collapsibleTypeOf(s) !== null) parts.push(s.name);
+        else parts.push(toLiteral(s));
+    }
+    return parts.join(', ');
+};
+const isCollapsible = (s)=>s === null || s === undefined || typeof s !== 'object' && typeof s !== 'function' && typeof s !== 'symbol' || collapsibleTypeOf(s) !== null;
 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 emit = mode.fast ? null : mode.firstError ? (msg)=>`${mode.issues} = [{ message: ${msg}, path: ${mode.pathExpr} }]; return ${mode.issues};` : !mode.firstError && mode.issuesReady ? (msg)=>`${mode.issues}.push({ message: ${msg}, path: ${mode.pathExpr} });` : (msg)=>`(${mode.issues} || (${mode.issues} = [])).push({ message: ${msg}, path: ${mode.pathExpr} });`;
     const fail = mode.fast ? mode.onFail ?? 'return false;' : '';
+    const errChk = (v)=>context.pure ? '' : ` || (typeof ${v} === 'object' && ${v} !== null && ${v}[err] === true)`;
+    const errBranch = (v)=>context.pure ? '' : `else if (typeof ${v} === 'object' && ${v} !== null && ${v}[err] === true) { ${emit(`\`\${${v}.message}\``)} }`;
     if (isTagged(schema)) {
         const tag = schema[$op];
         if (tag === AND) {
@@ -309,6 +453,27 @@ const codeGen = (schema, context, valuePath, mode)=>{
             const valueAlias = context.unique('v');
             const foundValid = context.unique('valid');
             if (mode.fast) {
+                const collapsible = [];
+                const complex = [];
+                for (const s of schema.schemas){
+                    if (isCollapsible(s)) collapsible.push(s);
+                    else complex.push(s);
+                }
+                if (collapsible.length > 0 && complex.length === 0) {
+                    return `const ${valueAlias} = ${valuePath};\nif (!(${buildCollapsedOr(collapsible, valueAlias)})) { ${fail} }`;
+                }
+                if (collapsible.length > 0) {
+                    const condition = buildCollapsedOr(collapsible, valueAlias);
+                    const branches = complex.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} = ${condition};\n${branches.join('\n')}\nif (!${foundValid}) { ${fail} }`;
+                }
                 const branches = schema.schemas.map((s)=>{
                     const branchValid = context.unique('valid');
                     const branchCode = codeGen(s, context, valueAlias, {
@@ -319,6 +484,11 @@ const codeGen = (schema, context, valuePath, mode)=>{
                 });
                 return `const ${valueAlias} = ${valuePath};\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { ${fail} }`;
             } else if (mode.firstError) {
+                if (schema.schemas.every(isCollapsible)) {
+                    const condition = buildCollapsedOr(schema.schemas, valueAlias);
+                    const expected = buildExpectedDesc(schema.schemas);
+                    return `const ${valueAlias} = ${valuePath};\nif (!(${condition})) { ${mode.issues} = [{ message: \`Invalid value \${${valueAlias}}, expected one of: ${expected}\`, path: ${mode.pathExpr} }]; return ${mode.issues}; }`;
+                }
                 const firstBranchIssues = context.unique('iss');
                 const branches = schema.schemas.map((s, idx)=>{
                     const branchIssues = context.unique('iss');
@@ -336,6 +506,12 @@ const codeGen = (schema, context, valuePath, mode)=>{
                 });
                 return `const ${valueAlias} = ${valuePath};\nlet ${firstBranchIssues};\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { return ${firstBranchIssues}; }`;
             } else {
+                if (schema.schemas.every(isCollapsible)) {
+                    const condition = buildCollapsedOr(schema.schemas, valueAlias);
+                    const expected = buildExpectedDesc(schema.schemas);
+                    const push = mode.issuesReady ? `${mode.issues}.push({ message: \`Invalid value \${${valueAlias}}, expected one of: ${expected}\`, path: ${mode.pathExpr} });` : `(${mode.issues} || (${mode.issues} = [])).push({ message: \`Invalid value \${${valueAlias}}, expected one of: ${expected}\`, path: ${mode.pathExpr} });`;
+                    return `const ${valueAlias} = ${valuePath};\nif (!(${condition})) { ${push} }`;
+                }
                 const localIssues = context.unique('iss');
                 const branches = schema.schemas.map((s)=>{
                     const branchIssues = context.unique('iss');
@@ -348,11 +524,42 @@ const codeGen = (schema, context, valuePath, mode)=>{
                     });
                     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}); }`;
+                const pushExpr = !mode.fast && !mode.firstError && mode.issuesReady ? `${mode.issues}.push(...${localIssues})` : `(${mode.issues} || (${mode.issues} = [])).push(...${localIssues})`;
+                return `const ${valueAlias} = ${valuePath};\nconst ${localIssues} = [];\nlet ${foundValid} = false;\n${branches.join('\n')}\nif (!${foundValid}) { ${pushExpr}; }`;
             }
         } 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)} }`;
+            const inner = schema.schemas[0];
+            if (!mode.fast && typeof inner === 'function') {
+                const iname = inner?.name;
+                const is = inner;
+                const pt = is === String ? 'string' : is === Number ? 'number' : is === Boolean ? 'boolean' : is === BigInt ? 'bigint' : is === Symbol ? 'symbol' : null;
+                if (pt) {
+                    const typeMsgs = Object.fromEntries([
+                        'string',
+                        'number',
+                        'boolean',
+                        'bigint',
+                        'symbol',
+                        'undefined',
+                        'object',
+                        'function'
+                    ].map((t)=>[
+                            t,
+                            `Invalid type ${t}, expected type ${iname}`
+                        ]));
+                    const typeMsgIdx = context.register(typeMsgs);
+                    const lines = [
+                        `const ${valueAlias} = ${valuePath};`,
+                        `if (${valueAlias} !== undefined && ${valueAlias} !== null) {`
+                    ];
+                    lines.push(`if (typeof ${valueAlias} !== '${pt}') { ${emit(`reg[${typeMsgIdx}][typeof ${valueAlias}]`)} }`);
+                    if (pt === 'number') lines.push(`else if (${valueAlias} !== ${valueAlias}) { ${emit(`"Invalid value NaN, expected a valid ${iname}"`)} }`);
+                    lines.push(`}`);
+                    return lines.join('\n');
+                }
+            }
+            return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(inner, context, valueAlias, mode)} }`;
         } else if (tag === TUPLE) {
             const valueAlias = context.unique('v');
             if (mode.fast) {
@@ -364,12 +571,12 @@ const codeGen = (schema, context, valuePath, mode)=>{
                     `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')} }`
+                    `else { ${schema.schemas.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, childMode(mode, idx, context))).join('\n')} }`
                 ].join('\n');
             }
         } else if (tag === CHECK) {
             const valueAlias = context.unique('v');
-            const ref = (v)=>`ctx.registry[${context.register(v)}]`;
+            const ref = (v)=>`reg[${context.register(v)}]`;
             const { check: cond, message } = schema.compile(valueAlias, {
                 ref
             });
@@ -396,31 +603,33 @@ const codeGen = (schema, context, valuePath, mode)=>{
                     schema: s
                 });
             }
+            const genVariantProps = (s, variantMode)=>{
+                const obj = s;
+                return Object.entries(obj).filter(([k])=>k !== key).map(([k, ps])=>codeGen(ps, context, `${valueAlias}[${JSON.stringify(k)}]`, variantMode.fast ? variantMode : childMode(variantMode, k, context))).join('\n');
+            };
             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 `if (${discriminantAlias} === ${JSON.stringify(value)}) { ${genVariantProps(s, mode)} }`;
                 });
                 return [
                     `const ${valueAlias} = ${valuePath};`,
-                    `if (${valueAlias} === null || ${valueAlias} === undefined || typeof ${valueAlias} !== 'object' || ${valueAlias} instanceof Error) { ${fail} }`,
+                    `if (${valueAlias} === null || ${valueAlias} === undefined || typeof ${valueAlias} !== 'object'${errChk(valueAlias)}) { ${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 `if (${discriminantAlias} === ${JSON.stringify(value)}) { ${genVariantProps(s, mode)} }`;
                 });
                 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}\``)} }`,
+                    `${errBranch(valueAlias)}`,
                     `else {`,
                     `  const ${discriminantAlias} = ${valueAlias}[${keyStr}];`,
-                    `  ${branches.join(' else ')} else { ${emit(`\`Invalid discriminant value \${JSON.stringify(${discriminantAlias})}, expected one of: ${validValues}\``)} }`,
+                    `  ${branches.join(' else ')} else { ${emit(`"Invalid discriminant value " + String(${discriminantAlias}) + ", expected one of: ${validValues.replace(/"/g, "'")}"`)} }`,
                     `}`
                 ].join('\n');
             }
@@ -436,7 +645,7 @@ const codeGen = (schema, context, valuePath, mode)=>{
                 const checks = [
                     `typeof ${valueAlias} !== '${primitiveType}'`
                 ];
-                if (primitiveType === 'number') checks.push(`Number.isNaN(${valueAlias})`);
+                if (primitiveType === 'number') checks.push(`${valueAlias} !== ${valueAlias}`);
                 return `const ${valueAlias} = ${valuePath};\nif (${checks.join(' || ')}) { ${fail} }`;
             } else if (name === 'Function') {
                 return `const ${valueAlias} = ${valuePath};\nif (typeof ${valueAlias} !== 'function') { ${fail} }`;
@@ -444,28 +653,42 @@ const codeGen = (schema, context, valuePath, mode)=>{
                 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} }`;
+                return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = reg[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined${isError || context.pure ? '' : ` || (typeof ${valueAlias} === 'object' && ${valueAlias}[err] === true)`} || (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) || (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) || Number.isNaN(${valueAlias}?.valueOf?.())) { ${fail} }`;
             }
         } else {
             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}\``)} }`);
+                const typeMsgs = Object.fromEntries([
+                    'string',
+                    'number',
+                    'boolean',
+                    'bigint',
+                    'symbol',
+                    'undefined',
+                    'object',
+                    'function'
+                ].map((t)=>[
+                        t,
+                        `Invalid type ${t}, expected type ${name}`
+                    ]));
+                const typeMsgIdx = context.register(typeMsgs);
+                code.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`${valueAlias} === null ? "Invalid value null, expected non-nullable" : "Invalid value undefined, expected non-nullable"`)} }`);
+                code.push(`${errBranch(valueAlias)}`);
+                code.push(`else if (typeof ${valueAlias} !== '${primitiveType}') { ${emit(`reg[${typeMsgIdx}][typeof ${valueAlias}]`)} }`);
+                if (primitiveType === 'number') code.push(`else if (${valueAlias} !== ${valueAlias}) { ${emit(`"Invalid value NaN, 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(`${errBranch(valueAlias)}`);
                 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(`const ${registryAlias} = reg[${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}\``)} }`);
+                if (!isError) code.push(`${errBranch(valueAlias)}`);
                 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}\``)} }`);
@@ -487,11 +710,24 @@ const codeGen = (schema, context, valuePath, mode)=>{
             }
             return code;
         } else {
+            const arrTypeMsgs = Object.fromEntries([
+                'string',
+                'number',
+                'boolean',
+                'bigint',
+                'symbol',
+                'undefined',
+                'function'
+            ].map((t)=>[
+                    t,
+                    `Invalid type ${t}, expected an instance of Array`
+                ]));
+            const arrTypeMsgIdx = context.register(arrTypeMsgs);
             const code = [
                 `const ${valueAlias} = ${valuePath};`,
-                `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\``)} }`,
+                `if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`${valueAlias} === null ? "Invalid value null, expected non-nullable" : "Invalid value undefined, expected non-nullable"`)} }`,
+                `${errBranch(valueAlias)}`,
+                `else if (typeof ${valueAlias} !== 'object') { ${emit(`reg[${arrTypeMsgIdx}][typeof ${valueAlias}]`)} }`,
                 `else if (!Array.isArray(${valueAlias})) { ${emit(`\`Invalid instance of \${${valueAlias}.constructor?.name}, expected an instance of Array\``)} }`
             ];
             if (schema.length > 0) {
@@ -500,10 +736,10 @@ const codeGen = (schema, context, valuePath, mode)=>{
                 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
-                    }))} } }`);
+                    }, context))} } }`);
                 } 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')} }`);
+                    code.push(`else { ${schema.map((s, idx)=>codeGen(s, context, `${valueAlias}[${idx}]`, childMode(mode, idx, context))).join('\n')} }`);
                 }
             }
             return code.join('\n');
@@ -513,68 +749,127 @@ const codeGen = (schema, context, valuePath, mode)=>{
         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} }`;
+                return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || ${valueAlias} === undefined${errChk(valueAlias)} || !${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()}\``)} }`;
+                return `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }\n${errBranch(valueAlias)}\n${context.pure ? '' : 'else '}if (!${schema.toString()}.test(String(${valueAlias}))) { ${emit(`\`Invalid value \${${valueAlias}}, expected to match ${schema.toString()}\``)} }`;
             }
         } else {
             const valueAlias = context.unique('v');
             if (mode.fast) {
-                let code = `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || typeof ${valueAlias} !== 'object' || ${valueAlias} instanceof Error) { ${fail} }`;
+                const indexed = mode.indexed && !mode.onFail;
+                const rootFail = indexed ? 'return 0;' : fail;
+                let code = `const ${valueAlias} = ${valuePath};\nif (${valueAlias} === null || typeof ${valueAlias} !== 'object'${errChk(valueAlias)}) { ${rootFail} }`;
                 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)} }`;
+                    code += `\nfor (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$keys], context, kAlias, indexed ? {
+                        fast: true,
+                        onFail: 'return 0;'
+                    } : 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)} }`;
+                    code += `\nfor (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$values], context, `${valueAlias}[${kAlias}]`, indexed ? {
+                        fast: true,
+                        onFail: 'return 0;'
+                    } : mode)} }`;
                 }
                 if ($strict in schema && schema[$strict]) {
-                    const keysAlias = context.unique('k');
+                    const allowedRef = `reg[${context.register(Object.fromEntries(Object.keys(schema).map((k)=>[
+                            k,
+                            1
+                        ])))}]`;
                     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 += `\nfor (const ${kAlias} in ${valueAlias}) { if (!Object.hasOwn(${allowedRef}, ${kAlias})) { ${rootFail} } }`;
                 }
-                code += '\n' + Object.entries(schema).map(([key, s])=>codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, mode)).join('\n');
+                const entries = Object.entries(schema);
+                code += '\n' + entries.map(([key, s], idx)=>{
+                    const propMode = indexed ? {
+                        fast: true,
+                        onFail: `return ${idx + 1};`
+                    } : mode;
+                    return codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, propMode);
+                }).join('\n');
+                if (indexed) code += `\nreturn -1;`;
                 return code;
             } else {
+                const sv = !mode.fast && mode.startVar;
                 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 ${valueAlias} = ${valuePath};`
                 ];
+                if (sv) {
+                    const rootCase = [];
+                    if (mode.firstError) {
+                        rootCase.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`);
+                        rootCase.push(`else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Object\``)} }`);
+                        rootCase.push(`${errBranch(valueAlias)}`);
+                    } else {
+                        rootCase.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} break; }`);
+                        rootCase.push(`else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Object\``)} break; }`);
+                        if (!context.pure) rootCase.push(`else if (typeof ${valueAlias} === 'object' && ${valueAlias}[err] === true) { ${emit(`\`\${${valueAlias}.message}\``)} break; }`);
+                    }
+                    if ($keys in schema) {
+                        const kAlias = context.unique('k');
+                        rootCase.push(`for (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$keys], context, kAlias, childMode(mode, {
+                            dynamic: kAlias
+                        }, context))} }`);
+                    }
+                    if ($values in schema) {
+                        const kAlias = context.unique('k');
+                        rootCase.push(`for (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$values], context, `${valueAlias}[${kAlias}]`, childMode(mode, {
+                            dynamic: kAlias
+                        }, context))} }`);
+                    }
+                    if ($strict in schema && schema[$strict]) {
+                        const allowedRef = `reg[${context.register(Object.fromEntries(Object.keys(schema).map((k)=>[
+                                k,
+                                1
+                            ])))}]`;
+                        const kAlias = context.unique('k');
+                        const extraAlias = context.unique('ex');
+                        rootCase.push(`const ${extraAlias} = [];`);
+                        rootCase.push(`for (const ${kAlias} in ${valueAlias}) { if (!Object.hasOwn(${allowedRef}, ${kAlias})) ${extraAlias}.push(${kAlias}); }`);
+                        rootCase.push(`if (${extraAlias}.length !== 0) { ${emit(`\`Extra properties: \${${extraAlias}}, are not allowed\``)} }`);
+                    }
+                    code.push(`switch (${sv}) {`);
+                    code.push(`case 0: { ${rootCase.join('\n')} }`);
+                    const entries = Object.entries(schema);
+                    entries.forEach(([key, s], idx)=>{
+                        const propCode = codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, childMode(mode, key, context));
+                        code.push(`case ${idx + 1}: { ${propCode} }`);
+                    });
+                    code.push(`}`);
+                    return code.join('\n');
+                }
+                code.push(`if (${valueAlias} === null || ${valueAlias} === undefined) { ${emit(`\`Invalid value \${${valueAlias}}, expected non-nullable\``)} }`);
+                code.push(`else if (typeof ${valueAlias} !== 'object') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected an instance of Object\``)} }`);
+                code.push(`${errBranch(valueAlias)}`);
+                code.push('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, {
+                    innerCode.push(`for (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$keys], context, kAlias, childMode(mode, {
                         dynamic: kAlias
-                    }))} }`);
+                    }, context))} }`);
                 }
                 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, {
+                    innerCode.push(`for (const ${kAlias} in ${valueAlias}) { ${codeGen(schema[$values], context, `${valueAlias}[${kAlias}]`, childMode(mode, {
                         dynamic: kAlias
-                    }))} }`);
+                    }, context))} }`);
                 }
                 if ($strict in schema && schema[$strict]) {
-                    const keysAlias = context.unique('k');
+                    const allowedRef = `reg[${context.register(Object.fromEntries(Object.keys(schema).map((k)=>[
+                            k,
+                            1
+                        ])))}]`;
                     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(`const ${extraAlias} = [];`);
+                    innerCode.push(`for (const ${kAlias} in ${valueAlias}) { if (!Object.hasOwn(${allowedRef}, ${kAlias})) ${extraAlias}.push(${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))));
+                const entries = Object.entries(schema);
+                innerCode.push(...entries.map(([key, s])=>codeGen(s, context, `${valueAlias}[${JSON.stringify(key)}]`, childMode(mode, key, context))));
                 code.push(innerCode.join('\n'), '}');
                 return code.join('\n');
             }
@@ -585,9 +880,9 @@ const codeGen = (schema, context, valuePath, mode)=>{
         const valueAlias = context.unique('v');
         const registryAlias = context.unique('r');
         if (mode.fast) {
-            return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (typeof ${valueAlias} !== 'symbol' || ${valueAlias} !== ${registryAlias}) { ${fail} }`;
+            return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = reg[${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()}\``)} }`;
+            return `const ${valueAlias} = ${valuePath};\nconst ${registryAlias} = reg[${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) {
@@ -603,27 +898,63 @@ const codeGen = (schema, context, valuePath, mode)=>{
         return `const ${valueAlias} = ${valuePath};\nif (typeof ${valueAlias} !== '${typeof schema}' || ${valueAlias} !== ${toLiteral(schema)}) { ${fail} }`;
     } else {
         const value = context.unique('val');
-        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)}\``)} }`;
+        return context.pure ? `const ${valueAlias} = ${valuePath};\nconst ${value} = ${toLiteral(schema)};\nif (typeof ${valueAlias} !== '${typeof schema}') { ${emit(`\`Invalid type \${typeof ${valueAlias}}, expected ${typeof schema}\``)} }\nelse if (${valueAlias} !== ${value}) { ${emit(`\`Invalid value \${String(${valueAlias})}, expected ${toLiteral(schema)}\``)} }` : `const ${valueAlias} = ${valuePath};\nconst ${value} = ${toLiteral(schema)};\nif (typeof ${valueAlias} === 'object' && ${valueAlias} !== null && ${valueAlias}[err] === true) { ${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)}\``)} }`;
     }
 };
 const emptyIssues = [];
 export const compile = (schema, options)=>{
     const allErrors = options?.allErrors ?? false;
+    const pure = options?.pure ?? false;
+    const canIndex = typeof schema === 'object' && schema !== null && !isTagged(schema) && !Array.isArray(schema) && !(schema instanceof RegExp);
     if (allErrors) {
+        if (canIndex) {
+            const fastContext = new Context();
+            fastContext.pure = pure;
+            const fastCode = codeGen(schema, fastContext, 'data', {
+                fast: true,
+                indexed: true
+            });
+            const indexedFast = new Function('reg', 'err', `return (data) => {\n${fastCode}\n};`)(fastContext.registry, ERR);
+            const issueContext = new Context();
+            issueContext.pure = pure;
+            const rootPath = `reg[${issueContext.register(Object.freeze([]))}]`;
+            const issueCode = `let issues = [];\n${codeGen(schema, issueContext, 'data', {
+                fast: false,
+                firstError: false,
+                issues: 'issues',
+                path: [],
+                pathExpr: rootPath,
+                startVar: 'start',
+                issuesReady: true
+            })}\nreturn issues;`;
+            const issueValidator = new Function('reg', 'err', `return (data, start) => {\n${issueCode}\n};`)(issueContext.registry, ERR);
+            const validator = (data)=>{
+                const idx = indexedFast(data);
+                if (idx === -1) return true;
+                validator.issues = issueValidator(data, idx);
+                return false;
+            };
+            validator.issues = emptyIssues;
+            return validator;
+        }
         const fastContext = new Context();
+        fastContext.pure = pure;
         const fastCode = `${codeGen(schema, fastContext, 'data', {
             fast: true
         })}\nreturn true;`;
-        const fastValidator = new Function('ctx', `return (data) => {\n${fastCode}\n};`)(fastContext);
+        const fastValidator = new Function('reg', 'err', `return (data) => {\n${fastCode}\n};`)(fastContext.registry, ERR);
         const issueContext = new Context();
-        const issueCode = `let issues;\n${codeGen(schema, issueContext, 'data', {
+        issueContext.pure = pure;
+        const rootPath2 = `reg[${issueContext.register(Object.freeze([]))}]`;
+        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);
+            pathExpr: rootPath2,
+            issuesReady: true
+        })}\nreturn issues;`;
+        const issueValidator = new Function('reg', 'err', `return (data) => {\n${issueCode}\n};`)(issueContext.registry, ERR);
         const validator = (data)=>{
             if (fastValidator(data)) {
                 return true;
@@ -634,20 +965,54 @@ export const compile = (schema, options)=>{
         validator.issues = emptyIssues;
         return validator;
     }
+    if (canIndex) {
+        const fastContext = new Context();
+        fastContext.pure = pure;
+        const fastCode = codeGen(schema, fastContext, 'data', {
+            fast: true,
+            indexed: true
+        });
+        const indexedFast = new Function('reg', 'err', `return (data) => {\n${fastCode}\n};`)(fastContext.registry, ERR);
+        const context = new Context();
+        context.pure = pure;
+        const rootPath = `reg[${context.register(Object.freeze([]))}]`;
+        const code = codeGen(schema, context, 'data', {
+            fast: false,
+            firstError: true,
+            issues: 'issues',
+            path: [],
+            pathExpr: rootPath,
+            startVar: 'start'
+        });
+        const firstErrorValidator = new Function('reg', 'err', `return (data, start) => {\nlet issues;\n${code}\nreturn issues;\n};`)(context.registry, ERR);
+        const validator = (data)=>{
+            const idx = indexedFast(data);
+            if (idx === -1) {
+                return true;
+            }
+            validator.issues = firstErrorValidator(data, idx);
+            return false;
+        };
+        validator.issues = emptyIssues;
+        return validator;
+    }
     const fastContext = new Context();
+    fastContext.pure = pure;
     const fastCode = `${codeGen(schema, fastContext, 'data', {
         fast: true
     })}\nreturn true;`;
-    const fastValidator = new Function('ctx', `return (data) => {\n${fastCode}\n};`)(fastContext);
+    const fastValidator = new Function('reg', 'err', `return (data) => {\n${fastCode}\n};`)(fastContext.registry, ERR);
     const context = new Context();
+    context.pure = pure;
+    const rootPath3 = `reg[${context.register(Object.freeze([]))}]`;
     const code = codeGen(schema, context, 'data', {
         fast: false,
         firstError: true,
         issues: 'issues',
         path: [],
-        pathExpr: '[]'
+        pathExpr: rootPath3
     });
-    const firstErrorValidator = new Function('ctx', `return (data) => {\nlet issues;\n${code}\nreturn issues;\n};`)(context);
+    const firstErrorValidator = new Function('reg', 'err', `return (data) => {\nlet issues;\n${code}\nreturn issues;\n};`)(context.registry, ERR);
     const validator = (data)=>{
         if (fastValidator(data)) {
             return true;