ata-validator 1.31.2 → 1.32.0

package/lib/js-compiler.js

@@ -489,24 +489,24 @@ function compileToJS(schema, defs, schemaMap) {
   // answer differently for it.
   if (schema.minimum !== undefined) {
     const min = schema.minimum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d >= min)
+    checks.push((d) => !Number.isFinite(d) || d >= min)
   }
   if (schema.maximum !== undefined) {
     const max = schema.maximum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d <= max)
+    checks.push((d) => !Number.isFinite(d) || d <= max)
   }
   if (schema.exclusiveMinimum !== undefined) {
     const min = schema.exclusiveMinimum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d > min)
+    checks.push((d) => !Number.isFinite(d) || d > min)
   }
   if (schema.exclusiveMaximum !== undefined) {
     const max = schema.exclusiveMaximum
-    checks.push((d) => typeof d !== 'number' || !isFinite(d) || d < max)
+    checks.push((d) => !Number.isFinite(d) || d < max)
   }
   if (schema.multipleOf !== undefined) {
     const div = schema.multipleOf
     checks.push((d) => {
-      if (typeof d !== 'number' || !isFinite(d)) return true
+      if (!Number.isFinite(d)) return true
       if (div === 0) return false
       const q = d / div
       return Number.isInteger(q) || Math.abs(q - Math.round(q)) < 1e-9
@@ -850,7 +850,7 @@ function multipleOfBad(v, m) {
 
 const TYPE_CHECKS = {
   string: (d) => typeof d === 'string',
-  number: (d) => typeof d === 'number' && isFinite(d),
+  number: (d) => Number.isFinite(d),
   integer: (d) => Number.isInteger(d),
   boolean: (d) => typeof d === 'boolean',
   null: (d) => d === null,
@@ -912,17 +912,66 @@ const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '_
 // Declared once per compiled function and called by name: spelled out at each
 // property, the test grew a 50-property module by a tenth. Both are small
 // enough for the engine to inline.
-const OWN_HELPERS = 'const _hop=Object.prototype.hasOwnProperty;' +
-  'function _own(o,k){return o.__proto__===Object.prototype?k in o:_hop.call(o,k)}'
+//
+// The `in` stays at the call site with the key as a constant: inside a shared
+// helper the key is a parameter, the engine cannot keep that `in` monomorphic,
+// and reading the errors of a product document went from 3.9 to 5.8 us. The
+// helper only runs once `in` has said yes, and on an ordinary object it
+// answers from the prototype without looking at the key.
+const OWN_HELPERS = 'const _hop=Object.prototype.hasOwnProperty;function _h(o,k){return _hop.call(o,k)}' +
+  'function _ok(o,k){return o.__proto__===Object.prototype||_hop.call(o,k)}' +
+  'function _hall(o,ks){for(let i=0;i<ks.length;i++)if(!_hop.call(o,ks[i]))return false;return true}'
+//
+// Better still, the prototype is read once per object: a node that asks about
+// presence declares `_pkN`, whether its value is an ordinary object, before
+// anything else, and every key test in that node reads the local. A shared
+// helper reading `__proto__` for each key was megamorphic, since it saw every
+// object shape in the document, and cost the error path about a microsecond
+// on a product document.
 function ownKeyExpr (ctx, v, key) {
   hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
   const k = JSON.stringify(key)
-  return PROTO_NAMES.has(key) ? `_hop.call(${v},${k})` : `_own(${v},${k})`
+  if (PROTO_NAMES.has(key)) return `_h(${v},${k})`
+  const pk = ctx.plainOf ? ctx.plainOf.get(v) : undefined
+  return pk !== undefined ? `(${pk}?${k} in ${v}:_h(${v},${k}))` : `(${k} in ${v}&&_ok(${v},${k}))`
 }
 // For a value already read as `v[key]` and found not to be undefined: whether
-// it came from `v` itself. Same test; `in` is already known to hold.
+// it came from `v` itself. `in` is known to hold, so only the second half runs.
 function ownGuard (ctx, v, key) {
-  return ownKeyExpr(ctx, v, key)
+  hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
+  const k = JSON.stringify(key)
+  if (PROTO_NAMES.has(key)) return `_h(${v},${k})`
+  const pk = ctx.plainOf ? ctx.plainOf.get(v) : undefined
+  return pk !== undefined ? `(${pk}||_h(${v},${k}))` : `_ok(${v},${k})`
+}
+
+// Declares the per-object prototype flag for a node that asks about presence,
+// and records it for the key tests emitted while the node is generated. The
+// record is restored on the way out, so a nested node over the same value
+// expression, an allOf branch say, cannot leave its name behind.
+function withPlain (schema, v, lines, ctx, run) {
+  if (typeof schema !== 'object' || schema === null ||
+      !(schema.required || schema.properties || schema.dependentRequired || schema.dependentSchemas)) {
+    return run()
+  }
+  if (!ctx.plainOf) ctx.plainOf = new Map()
+  const name = '_pk' + ctx.varCounter++
+  const at = lines.length
+  lines.push(`const ${name}=typeof ${v}==='object'&&${v}!==null&&${v}.__proto__===Object.prototype`)
+  const prev = ctx.plainOf.get(v)
+  ctx.plainOf.set(v, name)
+  try {
+    return run()
+  } finally {
+    if (prev === undefined) ctx.plainOf.delete(v)
+    else ctx.plainOf.set(v, prev)
+    // A node whose keys are all typed never reads the flag; declaring it
+    // anyway cost a strict-object check about five percent. Unused, it goes.
+    const re = new RegExp('\\b' + name + '\\b')
+    let used = false
+    for (let i = at + 1; i < lines.length && !used; i++) if (re.test(lines[i])) used = true
+    if (!used && lines[at] === `const ${name}=typeof ${v}==='object'&&${v}!==null&&${v}.__proto__===Object.prototype`) lines.splice(at, 1)
+  }
 }
 // The same test at run time, for the closure compiler.
 const _hop = Object.prototype.hasOwnProperty
@@ -934,6 +983,56 @@ function hasOwnKey (d, key) {
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'toString', 'valueOf',
   'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString'])
 
+// The nodes the removeAdditional pass deletes from, when deleting them during
+// the verdict gives the answer removing them first would, or null when it may
+// not. It may not whenever a keyword could look at a key before it is deleted
+// and pass where it would fail after: minProperties, a const or enum object
+// that holds the extra key, uniqueItems over objects that differ only in one,
+// a branch that requires it, a `required` naming a key the node does not
+// declare. So the whole schema is held to keywords that only look at declared
+// properties or at scalar values. The node set mirrors emitRemovals in
+// index.js: reached through `properties` from the root, with
+// additionalProperties false and at least one declared property.
+const FUSED_REMOVAL_KEYS = new Set(['type', 'properties', 'required', 'additionalProperties', 'items',
+  'minItems', 'maxItems', 'minLength', 'maxLength', 'pattern', 'format', 'minimum', 'maximum',
+  'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'enum', 'const', 'title', 'description',
+  '$comment', '$schema'])
+function fusedRemovalNodes (root) {
+  const isScalar = (x) => x === null || (typeof x !== 'object' && typeof x !== 'function')
+  const safe = (node) => {
+    if (typeof node === 'boolean') return true
+    if (!node || typeof node !== 'object' || Array.isArray(node)) return false
+    for (const k of Object.keys(node)) if (!FUSED_REMOVAL_KEYS.has(k)) return false
+    if (node.enum !== undefined && !(Array.isArray(node.enum) && node.enum.every(isScalar))) return false
+    if (node.const !== undefined && !isScalar(node.const)) return false
+    if (node.properties !== undefined) {
+      if (!node.properties || typeof node.properties !== 'object' || Array.isArray(node.properties)) return false
+      for (const k of Object.keys(node.properties)) if (!safe(node.properties[k])) return false
+    }
+    if (node.additionalProperties === false) {
+      const declared = node.properties ? Object.keys(node.properties) : []
+      if (declared.length === 0) return false
+      if (Array.isArray(node.required) && node.required.some((r) => !declared.includes(r))) return false
+    } else if (node.additionalProperties !== undefined && node.additionalProperties !== true && !safe(node.additionalProperties)) {
+      return false
+    }
+    if (node.items !== undefined && (Array.isArray(node.items) || !safe(node.items))) return false
+    return true
+  }
+  if (!safe(root)) return null
+  const nodes = new Set()
+  const walk = (node) => {
+    if (!node || typeof node !== 'object' || !node.properties) return
+    if (node.additionalProperties === false && Object.keys(node.properties).length > 0) nodes.add(node)
+    for (const k of Object.keys(node.properties)) {
+      const p = node.properties[k]
+      if (p && typeof p === 'object' && p.properties) walk(p)
+    }
+  }
+  walk(root)
+  return nodes.size > 0 ? nodes : null
+}
+
 // Check if all $dynamicRef in a target schema can be resolved via the calling schema's anchors.
 function canResolveDynamicRefs(target, callingSchema, schemaMap) {
   // Collect anchors from calling schema
@@ -1546,9 +1645,18 @@ function sharedCodegenGate(schema, schemaMap) {
 
 // --- Codegen mode: generates a single Function (NOT CSP-safe) ---
 // This matches ajv's approach: one monolithic function, V8 JIT fully inlines it
-function compileToJSCodegen(schema, schemaMap, userFormats) {
+function compileToJSCodegen(schema, schemaMap, userFormats, opts) {
   if (typeof schema === 'boolean') return schema ? () => true : () => false
   if (typeof schema !== 'object' || schema === null) return null
+  // removeAdditional: a verdict function that deletes the keys the remover
+  // would delete, in the walk the verdict already makes, instead of rejecting
+  // them. Only for schemas where that cannot change an answer; see
+  // fusedRemovalNodes.
+  let removeNodes = null
+  if (opts && opts.removeAdditional) {
+    removeNodes = fusedRemovalNodes(schema)
+    if (removeNodes === null) return null
+  }
 
   if (!sharedCodegenGate(schema, schemaMap)) return null
 
@@ -1608,7 +1716,7 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
   if (hasUnresolvableRef(schema, rootDefs, anchors, schemaMap, new Set())) return null
   if (needsBaseTracking(schema, schemaMap, new Set())) return null
 
-  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null }
+  const ctx = { varCounter: 0, helpers: [], helperCode: [], preamble: [], shared: [], closureVars: ['_cpLen'], closureVals: [_cpLen], rootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors, rootSchema: schema, userFormats: userFormats || null, removeNodes }
   const lines = []
   genCode(schema, 'd', lines, ctx)
 
@@ -1897,7 +2005,7 @@ function tryGenCombined(schema, access, ctx) {
   }
 
   if (t === 'number') {
-    const conds = [`typeof _v!=='number'||!isFinite(_v)`]
+    const conds = [`!Number.isFinite(_v)`]
     if (schema.minimum !== undefined) conds.push(`_v<${schema.minimum}`)
     if (schema.maximum !== undefined) conds.push(`_v>${schema.maximum}`)
     if (schema.exclusiveMinimum !== undefined) conds.push(`_v<=${schema.exclusiveMinimum}`)
@@ -1930,6 +2038,9 @@ function _deferOrInline(ctx, lines, v, check) {
 // 'array'  = we know v is an array
 // 'string' / 'number' / 'integer' = we know the primitive type
 function genCode(schema, v, lines, ctx, knownType) {
+  return withPlain(schema, v, lines, ctx, () => genCodeNode(schema, v, lines, ctx, knownType))
+}
+function genCodeNode(schema, v, lines, ctx, knownType) {
   // A boolean schema is a constant. false rejects whatever reached it; true
   // constrains nothing and emits nothing, which is correct only because the
   // caller's own checks still stand around this call.
@@ -2079,7 +2190,7 @@ function genCode(schema, v, lines, ctx, knownType) {
           case 'object': lines.push(`if(typeof ${v}!=='object'||${v}===null||Array.isArray(${v}))return false`); break
           case 'array': lines.push(`if(!Array.isArray(${v}))return false`); break
           case 'string': lines.push(`if(typeof ${v}!=='string')return false`); break
-          case 'number': lines.push(`if(typeof ${v}!=='number'||!isFinite(${v}))return false`); break
+          case 'number': lines.push(`if(!Number.isFinite(${v}))return false`); break
           case 'integer': lines.push(`if(!Number.isInteger(${v}))return false`); break
           case 'boolean': lines.push(`if(typeof ${v}!=='boolean')return false`); break
           case 'null': lines.push(`if(${v}!==null)return false`); break
@@ -2090,7 +2201,7 @@ function genCode(schema, v, lines, ctx, knownType) {
             case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
             case 'array': return `Array.isArray(${v})`
             case 'string': return `typeof ${v}==='string'`
-            case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+            case 'number': return `Number.isFinite(${v})`
             case 'integer': return `Number.isInteger(${v})`
             case 'boolean': return `typeof ${v}==='boolean'`
             case 'null': return `${v}===null`
@@ -2156,7 +2267,10 @@ function genCode(schema, v, lines, ctx, knownType) {
     // On an object with another prototype the typed ones may be inherited.
     if (typed.length > 0) {
       hoistOnce(ctx, '_ownHoisted', OWN_HELPERS)
-      lines.push(`if(${v}.__proto__!==Object.prototype&&!(${typed.map((k) => `_hop.call(${v},${JSON.stringify(k)})`).join('&&')}))return false`)
+      // Read directly: the object type is already established here, and a
+      // flag declared for this alone costs more than it saves. The list is
+      // built only on that path, which an ordinary object never takes.
+      lines.push(`if(${v}.__proto__!==Object.prototype&&!_hall(${v},${JSON.stringify(typed)}))return false`)
     }
   } else if (schema.required && schema.required.length > 0) {
     const checks = schema.required.map(key => `!${ownKeyExpr(ctx, v, key)}`)
@@ -2194,7 +2308,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   // non-finite value through: it carries no type, an empty schema accepts it,
   // and the interpreted engine reads it the same way. With `type: number` the
   // type check has already turned it away, so the guard is only needed here.
-  const numGuard = isNum ? '' : `typeof ${v}==='number'&&isFinite(${v})&&`
+  const numGuard = isNum ? '' : `Number.isFinite(${v})&&`
   if (schema.minimum !== undefined) lines.push(`if(${numGuard}${v}<${schema.minimum})return false`)
   if (schema.maximum !== undefined) lines.push(`if(${numGuard}${v}>${schema.maximum})return false`)
   if (schema.exclusiveMinimum !== undefined) lines.push(`if(${numGuard}${v}<=${schema.exclusiveMinimum})return false`)
@@ -2316,7 +2430,21 @@ function genCode(schema, v, lines, ctx, knownType) {
   // additionalProperties -- deferred to end of function for better V8 optimization
   // (type checks run first in hot path, expensive prop count check last)
   // Skip if patternProperties is present — it will handle additionalProperties in a unified loop
-  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
+  if (schema.additionalProperties === false && schema.properties && !schema.patternProperties && ctx.removeNodes && ctx.removeNodes.has(schema)) {
+    const kv = `_rk${ctx.varCounter++}`
+    const declared = Object.keys(schema.properties)
+    let loop = `for(var ${kv} in ${v})if(${declared.map((k) => `${kv}!==${JSON.stringify(k)}`).join('&&')})delete ${v}[${kv}]`
+    // When every declared property is required, the verdict has already
+    // established they are all there, so a key count equal to the declared
+    // count means nothing is extra and the deleting walk, which compares every
+    // key against the declared names, need not run.
+    const req = new Set(schema.required || [])
+    if (declared.length <= 15 && declared.every((k) => req.has(k))) {
+      const n = `_rn${ctx.varCounter++}`
+      loop = `{var ${n}=0;for(var ${kv} in ${v})${n}++;if(${n}!==${declared.length}){${loop}}}`
+    }
+    _deferOrInline(ctx, lines, v, isObj ? loop : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${loop}}`)
+  } else if (schema.additionalProperties === false && schema.properties && !schema.patternProperties) {
     const propCount = Object.keys(schema.properties).length
     const allRequired = schema.required && schema.required.length === propCount
     const inner = allRequired
@@ -3731,6 +3859,9 @@ function emitBranchCollapse (branches, keyword, v, pathExpr, lines, ctx, schemaP
 // Instead of `return false`, pushes to `_e` array and optionally early-returns.
 // `_all` parameter: if falsy, return after first error.
 function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  return withPlain(schema, v, lines, ctx, () => genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix))
+}
+function genCodeENode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   // A false schema reports one error at the value that reached it, with the
   // keyword the interpreter has always used for it, `not` (lib/plan-compiler.js
@@ -3842,7 +3973,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
         case 'array': return `Array.isArray(${v})`
         case 'string': return `typeof ${v}==='string'`
-        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'number': return `Number.isFinite(${v})`
         case 'integer': return `Number.isInteger(${v})`
         case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`
@@ -4451,6 +4582,9 @@ function compileToJSCombined(schema, VALID_RESULT, schemaMap, userFormats) {
 // After type check passes → use optimizations (destructuring, no guards).
 // If type check fails → push error, skip property checks (they'd crash).
 function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
+  return withPlain(schema, v, lines, ctx, () => genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix))
+}
+function genCodeCNode(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   if (!schemaPrefix) schemaPrefix = '#'
   // Per-node, for the reason spelled out in genCode.
   let ppHandledPropertyNames = false
@@ -4576,7 +4710,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
         case 'object': return `(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`
         case 'array': return `Array.isArray(${v})`
         case 'string': return `typeof ${v}==='string'`
-        case 'number': return `(typeof ${v}==='number'&&isFinite(${v}))`
+        case 'number': return `Number.isFinite(${v})`
         case 'integer': return `Number.isInteger(${v})`
         case 'boolean': return `typeof ${v}==='boolean'`
         case 'null': return `${v}===null`

package/lib/plan-compiler.js

@@ -182,7 +182,7 @@ function install(deps) {
       // no type bit, and an empty schema accepts it. So the numeric keywords
       // must not apply to it either, or `{ minimum: 3 }` rejects a value that
       // `{}` accepts and the compiled engine admits.
-      if (run !== null) checks.push((data) => typeof data !== 'number' || !isFinite(data) || run(data));
+      if (run !== null) checks.push((data) => !Number.isFinite(data) || run(data));
     }
     if (P.hasString) {
       const strs = [];

package/lib/plan-source.js

@@ -0,0 +1,281 @@
+'use strict';
+
+// Generated source from interpreter plans: the verdict function.
+//
+// The interpreted engine is the reference every other engine is tested
+// against, and its Plan is a schema node with every keyword resolved once.
+// lib/plan-compiler.js turns plans into closures; this turns them into source,
+// deciding at compile time exactly what plan-compiler decides, and calling the
+// same helpers (deepEqual, the code point bounds, multipleOfOk, the format
+// functions and compiled patterns the plan already holds), so the answers
+// cannot drift the way three hand-written generators did.
+//
+// The scope is deliberately narrow for now: value-level keywords, properties
+// and additionalProperties, prefixItems and items, and the in-place
+// applicators. Everything else, references, unevaluated*, contains,
+// propertyNames, patternProperties, dependentSchemas, custom keywords, makes
+// the compiler return null. It never emits a function with a keyword missing.
+
+const { createInterpreter, _planInternals: I } = require('./interpreter');
+const { Plan, deepEqual, cpAtLeast, cpAtMost, multipleOfOk, T_STRING, T_NUMBER, T_INTEGER, T_BOOLEAN, T_NULL, T_OBJECT, T_ARRAY } = I;
+
+const DECLINE = Symbol('plan-source.decline');
+const ALL_TYPES = T_STRING | T_NUMBER | T_INTEGER | T_BOOLEAN | T_NULL | T_OBJECT | T_ARRAY;
+
+// The own-property test the generators use; see ownKeyExpr in js-compiler.js.
+const HELPERS = 'const _hop=Object.prototype.hasOwnProperty;';
+
+const PROTO_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), '__proto__']);
+
+function isPrimitive(x) {
+  return x === null || typeof x === 'string' || typeof x === 'boolean' || Number.isFinite(x);
+}
+
+function lit(x) {
+  return JSON.stringify(x);
+}
+
+function createCtx() {
+  return { n: 0, argNames: [], argVals: [], fns: [], fnFor: new Map() };
+}
+
+// A value the emitted code needs by reference: a function, a RegExp, a list.
+function arg(ctx, value) {
+  const i = ctx.argVals.indexOf(value);
+  if (i !== -1) return ctx.argNames[i];
+  const name = '_a' + ctx.argVals.length;
+  ctx.argNames.push(name);
+  ctx.argVals.push(value);
+  return name;
+}
+
+function local(ctx) {
+  return '_v' + ctx.n++;
+}
+
+// JSON Schema type bits, exactly as dataBits() assigns them: a non-finite
+// number has no type, so it matches neither number nor integer.
+function typeTest(mask, v) {
+  const parts = [];
+  if (mask & T_STRING) parts.push(`typeof ${v}==='string'`);
+  if (mask & T_NUMBER) parts.push(`Number.isFinite(${v})`);
+  else if (mask & T_INTEGER) parts.push(`Number.isInteger(${v})`);
+  if (mask & T_BOOLEAN) parts.push(`typeof ${v}==='boolean'`);
+  if (mask & T_NULL) parts.push(`${v}===null`);
+  if ((mask & T_OBJECT) && (mask & T_ARRAY)) parts.push(`(typeof ${v}==='object'&&${v}!==null)`);
+  else if (mask & T_OBJECT) parts.push(`(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v}))`);
+  else if (mask & T_ARRAY) parts.push(`Array.isArray(${v})`);
+  return parts.length ? parts.join('||') : 'false';
+}
+
+// `plain` names a local holding `v.__proto__===Object.prototype`, read once per
+// object. With the key a constant at the `in`, the engine keeps the check
+// monomorphic; through a shared helper the key is a parameter and it is not.
+function ownTest(v, key, plain) {
+  const k = lit(key);
+  return PROTO_NAMES.has(key) ? `_hop.call(${v},${k})` : `(${plain}?${k} in ${v}:_hop.call(${v},${k}))`;
+}
+
+const K_NUM = T_NUMBER | T_INTEGER;
+// The body under a guard for one kind of value, given what the type check
+// already established: unconditional when the value can only be that kind,
+// nothing at all when it cannot be.
+function guarded(known, kind, cond, body) {
+  if (!body) return '';
+  if ((known & kind) === 0) return '';
+  if ((known & ~kind) === 0) return body;
+  return `if(${cond}){${body}}`;
+}
+
+// Value-level keywords, in compileLeafV's order and with its meaning.
+function emitLeaf(ctx, P, v, known) {
+  let out = '';
+  if (P.hasType) out += `if(!(${typeTest(P.typeMask, v)}))return false;`;
+  if (P.enum !== null) {
+    const vals = P.enum;
+    if (vals.length === 0) out += 'return false;';
+    else if (vals.every(isPrimitive)) out += `if(!(${vals.map((x) => `${v}===${lit(x)}`).join('||')}))return false;`;
+    else {
+      const a = arg(ctx, vals);
+      const de = arg(ctx, deepEqual);
+      const i = local(ctx);
+      out += `{let ${i}=0;for(;${i}<${a}.length;${i}++)if(${de}(${a}[${i}],${v}))break;if(${i}===${a}.length)return false}`;
+    }
+  }
+  if (P.hasConst) {
+    out += isPrimitive(P.const)
+      ? `if(${v}!==${lit(P.const)})return false;`
+      : `if(!${arg(ctx, deepEqual)}(${arg(ctx, P.const)},${v}))return false;`;
+  }
+  if (P.hasNumber) {
+    let n = '';
+    if (P.minimum !== undefined) n += `if(${v}<${lit(P.minimum)})return false;`;
+    if (P.maximum !== undefined) n += `if(${v}>${lit(P.maximum)})return false;`;
+    if (P.exclusiveMinimum !== undefined) n += `if(${v}<=${lit(P.exclusiveMinimum)})return false;`;
+    if (P.exclusiveMaximum !== undefined) n += `if(${v}>=${lit(P.exclusiveMaximum)})return false;`;
+    if (P.multipleOf !== undefined) n += `if(!${arg(ctx, multipleOfOk)}(${v},${lit(P.multipleOf)}))return false;`;
+    out += guarded(known, K_NUM, `Number.isFinite(${v})`, n);
+  }
+  if (P.hasString) {
+    let s = '';
+    if (P.minLength !== undefined) s += `if(!${arg(ctx, cpAtLeast)}(${v},${lit(P.minLength)}))return false;`;
+    if (P.maxLength !== undefined) s += `if(!${arg(ctx, cpAtMost)}(${v},${lit(P.maxLength)}))return false;`;
+    if (P.pattern !== null) s += `if(!${arg(ctx, P.pattern)}.test(${v}))return false;`;
+    if (P.formatFn !== null) s += `if(!${arg(ctx, P.formatFn)}(${v}))return false;`;
+    out += guarded(known, T_STRING, `typeof ${v}==='string'`, s);
+  }
+  if (P.minItems !== undefined || P.maxItems !== undefined || P.uniqueItems) {
+    let a = '';
+    if (P.minItems !== undefined) a += `if(${v}.length<${lit(P.minItems)})return false;`;
+    if (P.maxItems !== undefined) a += `if(${v}.length>${lit(P.maxItems)})return false;`;
+    if (P.uniqueItems) {
+      const de = arg(ctx, deepEqual);
+      const i = local(ctx), j = local(ctx);
+      a += `for(let ${i}=0;${i}<${v}.length;${i}++)for(let ${j}=${i}+1;${j}<${v}.length;${j}++)if(${de}(${v}[${i}],${v}[${j}]))return false;`;
+    }
+    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
+  }
+  return out;
+}
+
+// The object-level keywords of a node, value-level and structural together, so
+// the prototype of the object is read once for all of them.
+function emitObjectLeaf(ctx, P, v, plain) {
+  let o = '';
+  if (P.required !== null || P.minProperties !== undefined || P.maxProperties !== undefined || P.dependentRequired !== null) {
+    if (P.required !== null) for (const k of P.required) o += `if(!${ownTest(v, k, plain)})return false;`;
+    if (P.minProperties !== undefined) o += `if(Object.keys(${v}).length<${lit(P.minProperties)})return false;`;
+    if (P.maxProperties !== undefined) o += `if(Object.keys(${v}).length>${lit(P.maxProperties)})return false;`;
+    if (P.dependentRequired !== null) {
+      for (const [key, deps] of P.dependentRequired) {
+        o += `if(${ownTest(v, key, plain)}){${deps.map((dep) => `if(!${ownTest(v, dep, plain)})return false;`).join('')}}`;
+      }
+    }
+  }
+  return o;
+}
+
+// A subschema asked for a verdict of its own (a branch of anyOf/oneOf, the
+// subject of not/if) becomes a named function, emitted once per plan.
+function branchFn(ctx, node) {
+  if (node === true) return '_t';
+  if (node === false) return '_f';
+  let name = ctx.fnFor.get(node);
+  if (name !== undefined) return name;
+  name = '_b' + ctx.fnFor.size;
+  ctx.fnFor.set(node, name);
+  const body = emitNode(ctx, node, 'd');
+  ctx.fns.push(`function ${name}(d){${body}return true}`);
+  return name;
+}
+
+function emitNode(ctx, node, v) {
+  if (node === true) return '';
+  if (node === false) return 'return false;';
+  if (!(node instanceof Plan)) return '';
+  const P = node;
+  if (P.tracked || P.hasUnevaluated || P.hasCustom || P.macros !== null ||
+      P.contains !== undefined || P.propertyNames !== undefined || P.patternProperties !== null ||
+      P.dependentSchemas !== null || P.propertyDependencies !== null) {
+    throw DECLINE;
+  }
+  const known = P.hasType ? P.typeMask : ALL_TYPES;
+  let out = emitLeaf(ctx, P, v, known);
+
+  if (P.prefixItems !== null || P.items !== undefined) {
+    let a = '';
+    if (P.prefixItems !== null) {
+      P.prefixItems.forEach((child, i) => {
+        const x = local(ctx);
+        const body = emitNode(ctx, child, x);
+        if (body) a += `if(${v}.length>${i}){const ${x}=${v}[${i}];${body}}`;
+      });
+    }
+    if (P.items !== undefined) {
+      const start = P.prefixItems !== null ? P.prefixItems.length : 0;
+      const i = local(ctx);
+      const x = local(ctx);
+      const body = emitNode(ctx, P.items, x);
+      if (body) a += `for(let ${i}=${start};${i}<${v}.length;${i}++){const ${x}=${v}[${i}];${body}}`;
+    }
+    out += guarded(known, T_ARRAY, `Array.isArray(${v})`, a);
+  }
+
+  const plain = local(ctx);
+  let o = emitObjectLeaf(ctx, P, v, plain);
+  if (P.properties !== null || P.additionalProperties !== undefined) {
+    const declared = P.properties !== null ? [...P.properties.keys()] : [];
+    if (P.properties !== null) {
+      for (const [key, entry] of P.properties) {
+        const x = local(ctx);
+        const body = emitNode(ctx, entry.node, x);
+        if (body) o += `if(${ownTest(v, key, plain)}){const ${x}=${v}[${lit(key)}];${body}}`;
+      }
+    }
+    const ap = P.additionalProperties;
+    if (ap !== undefined && ap !== true) {
+      const k = local(ctx);
+      let isDeclared = 'false';
+      if (declared.length > 8) {
+        const set = Object.create(null);
+        for (const key of declared) set[key] = 1;
+        isDeclared = `${arg(ctx, set)}[${k}]===1`;
+      } else if (declared.length > 0) {
+        isDeclared = declared.map((key) => `${k}===${lit(key)}`).join('||');
+      }
+      let apBody;
+      if (ap === false) apBody = 'return false;';
+      else {
+        const x = local(ctx);
+        const body = emitNode(ctx, ap, x);
+        apBody = body ? `const ${x}=${v}[${k}];${body}` : '';
+      }
+      if (apBody) o += `for(const ${k} in ${v}){if(!${plain}&&!_hop.call(${v},${k}))continue;if(${isDeclared})continue;${apBody}}`;
+    }
+  }
+  if (o) out += guarded(known, T_OBJECT, `typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})`, `const ${plain}=${v}.__proto__===Object.prototype;${o}`);
+
+  if (P.allOf !== null) for (const child of P.allOf) out += emitNode(ctx, child, v);
+  if (P.anyOf !== null) out += `if(!(${P.anyOf.map((c) => `${branchFn(ctx, c)}(${v})`).join('||')}))return false;`;
+  if (P.oneOf !== null) {
+    const c = local(ctx);
+    out += `{let ${c}=0;${P.oneOf.map((b) => `if(${branchFn(ctx, b)}(${v})&&++${c}>1)return false;`).join('')}if(${c}!==1)return false}`;
+  }
+  if (P.not !== undefined) out += `if(${branchFn(ctx, P.not)}(${v}))return false;`;
+  if (P.if !== undefined) {
+    const t = P.then !== undefined ? emitNode(ctx, P.then, v) : '';
+    const e = P.else !== undefined ? emitNode(ctx, P.else, v) : '';
+    if (t || e) out += `if(${branchFn(ctx, P.if)}(${v})){${t}}else{${e}}`;
+  }
+  return out;
+}
+
+// Returns { fn, source } or null when the schema is outside what this emits.
+function compileVerdict(schema, options) {
+  let interp;
+  try {
+    interp = createInterpreter(schema, options || {});
+  } catch {
+    return null;
+  }
+  const ctx = createCtx();
+  let body;
+  try {
+    body = emitNode(ctx, interp.rootNode, 'd');
+  } catch (e) {
+    if (e === DECLINE) return null;
+    throw e;
+  }
+  const source = HELPERS + 'function _t(){return true}function _f(){return false}' +
+    ctx.fns.join('') + `return function(d){${body}return true}`;
+  let fn;
+  try {
+    // eslint-disable-next-line no-new-func
+    fn = new Function(...ctx.argNames, source)(...ctx.argVals);
+  } catch {
+    return null;
+  }
+  return { fn, source };
+}
+
+module.exports = { compileVerdict };

package/lib/tier0.js

@@ -137,7 +137,7 @@ function checkPrimitive(c, v) {
       if ((f & F_MULT) && !_multipleOk(v, c.multipleOf)) return false;
     }
   } else if (m === T_NUMBER) {
-    if (typeof v !== 'number' || !isFinite(v)) return false;
+    if (!Number.isFinite(v)) return false;
     const f = c.numFlags;
     if (f !== 0) {
       if ((f & F_MIN) && v < c.min) return false;
@@ -194,7 +194,7 @@ function tier0ValidateObject(plan, data) {
         if ((f & F_MULT) && !_multipleOk(v, c.multipleOf)) return false;
       }
     } else if (m === T_NUMBER) {
-      if (typeof v !== 'number' || !isFinite(v)) return false;
+      if (!Number.isFinite(v)) return false;
       const f = c.numFlags;
       if (f !== 0) {
         if ((f & F_MIN) && v < c.min) return false;

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.31.2';
+module.exports = '1.32.0';