ata-validator 1.53.0 → 1.54.0

package/lib/metaschemas.js

@@ -2,11 +2,12 @@
 
 // The official meta-schemas, vendored so a `$ref` to one of them resolves
 // without a network. Draft 2020-12 is eight documents joined by $dynamicRef;
-// draft-07 and draft-06 are one each; 2019-09 is seven. Sources:
+// draft-07, draft-06 and draft-04 are one each; 2019-09 is seven. Sources:
 // https://json-schema.org/draft/2020-12/schema and
-// http://json-schema.org/draft-07/schema, fetched 2026-08-23, and
+// http://json-schema.org/draft-07/schema, fetched 2026-08-23,
 // http://json-schema.org/draft-06/schema and
-// https://json-schema.org/draft/2019-09/schema, fetched 2026-10-10, unmodified.
+// https://json-schema.org/draft/2019-09/schema, fetched 2026-10-10, and
+// http://json-schema.org/draft-04/schema, fetched 2026-10-14, unmodified.
 // The 2019-09 documents are read through the same 2019-09 rewrite as a
 // caller's schema (lib/draft7.js) once, at load, since they use
 // `$recursiveRef`, which the engines read as `$dynamicRef`.
@@ -22,6 +23,7 @@ const METASCHEMAS = new Map([
   ["https://json-schema.org/draft/2020-12/meta/content", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/content","$dynamicAnchor":"meta","title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentEncoding":{"type":"string"},"contentMediaType":{"type":"string"},"contentSchema":{"$dynamicRef":"#meta"}}}],
   ["https://json-schema.org/draft/2020-12/meta/unevaluated", {"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/unevaluated","$dynamicAnchor":"meta","title":"Unevaluated applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"unevaluatedItems":{"$dynamicRef":"#meta"},"unevaluatedProperties":{"$dynamicRef":"#meta"}}}],
   ["http://json-schema.org/draft-07/schema#", {"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}],
+  ["http://json-schema.org/draft-04/schema#", {"id":"http://json-schema.org/draft-04/schema#","$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"positiveInteger":{"type":"integer","minimum":0},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"minItems":1,"uniqueItems":true}},"type":"object","properties":{"id":{"type":"string"},"$schema":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"multipleOf":{"type":"number","minimum":0,"exclusiveMinimum":true},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"boolean","default":false},"maxLength":{"$ref":"#/definitions/positiveInteger"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"dependencies":{"exclusiveMaximum":["maximum"],"exclusiveMinimum":["minimum"]},"default":{}}],
   ["http://json-schema.org/draft-06/schema#", {"$schema":"http://json-schema.org/draft-06/schema#","$id":"http://json-schema.org/draft-06/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"examples":{"type":"array","items":{}},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":{},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":{}}],
   ["https://json-schema.org/draft/2019-09/schema", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/schema","$vocabulary":{"https://json-schema.org/draft/2019-09/vocab/core":true,"https://json-schema.org/draft/2019-09/vocab/applicator":true,"https://json-schema.org/draft/2019-09/vocab/validation":true,"https://json-schema.org/draft/2019-09/vocab/meta-data":true,"https://json-schema.org/draft/2019-09/vocab/format":false,"https://json-schema.org/draft/2019-09/vocab/content":true},"$recursiveAnchor":true,"title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format"},{"$ref":"meta/content"}],"type":["object","boolean"],"properties":{"definitions":{"$comment":"While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.","type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"dependencies":{"$comment":"\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"","type":"object","additionalProperties":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"meta/validation#/$defs/stringArray"}]}}}}],
   ["https://json-schema.org/draft/2019-09/meta/core", {"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/core","$recursiveAnchor":true,"title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"type":"string","format":"uri"},"$anchor":{"type":"string","pattern":"^[A-Za-z][-A-Za-z0-9.:_]*$"},"$ref":{"type":"string","format":"uri-reference"},"$recursiveRef":{"type":"string","format":"uri-reference"},"$recursiveAnchor":{"type":"boolean","default":false},"$vocabulary":{"type":"object","propertyNames":{"type":"string","format":"uri"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}}}}],

package/lib/plan-compiler.js

@@ -213,11 +213,18 @@ function install(deps) {
       const objs = [];
       if (P.required !== null) {
         const req = P.required;
-        if (req.length === 1) { const k = req[0]; objs.push((d) => Object.hasOwn(d, k)); }
-        else objs.push((d) => {
+        // A required key holding undefined is missing; for a declared
+        // property the property step finds it (requiredInProps).
+        const undef = P.requiredUndef;
+        if (req.length === 1) { const k = req[0]; objs.push(undef !== null && undef[0] ? (d) => Object.hasOwn(d, k) && d[k] !== undefined : (d) => Object.hasOwn(d, k)); }
+        else if (undef === null) objs.push((d) => {
           for (let i = 0; i < req.length; i++) if (!Object.hasOwn(d, req[i])) return false;
           return true;
         });
+        else objs.push((d) => {
+          for (let i = 0; i < req.length; i++) if (!Object.hasOwn(d, req[i]) || (undef[i] && d[req[i]] === undefined)) return false;
+          return true;
+        });
       }
       if (P.minProperties !== undefined) { const m = P.minProperties; objs.push((d) => Object.keys(d).length >= m); }
       if (P.maxProperties !== undefined) { const m = P.maxProperties; objs.push((d) => Object.keys(d).length <= m); }
@@ -490,8 +497,10 @@ function install(deps) {
       // Declared properties: a linear scan over a short list beats a Map
       // lookup, and most schemas declare a handful.
       const propKeys = props !== null ? [...props.keys()] : null;
+      // req: the key is also required, so holding undefined it is missing.
+      const reqIn = P.requiredInProps;
       const propList = props !== null
-        ? [...props.values()].map((entry) => ({ fn: child(entry.node), seg: entry.seg, schemaSeg: entry.schemaSeg }))
+        ? [...props].map(([key, entry]) => ({ fn: child(entry.node), seg: entry.seg, schemaSeg: entry.schemaSeg, req: reqIn !== null && reqIn.has(key) }))
         : null;
       const propMap = props !== null && props.size > 8 ? new Map(propKeys.map((k, i) => [k, propList[i]])) : null;
       const lookup = propMap !== null
@@ -533,12 +542,18 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           // A declared property whose value is undefined is not checked (see
-          // the interpreter's eval).
+          // the interpreter's eval); required, it is missing.
           if (prop !== undefined) {
             const value = data[key];
-            if (value !== undefined && !((prop.fn.leaf && prop.fn.v(value, stack)) || prop.fn.c(value, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+            if (value !== undefined) {
+              if (!((prop.fn.leaf && prop.fn.v(value, stack)) || prop.fn.c(value, errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+                ok = false;
+                if (errors === NOERRORS) return false;
+              }
+            } else if (prop.req) {
               ok = false;
               if (errors === NOERRORS) return false;
+              errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`));
             }
             evaluated = true;
           }
@@ -582,7 +597,8 @@ function install(deps) {
             const key = propKeys[i];
             if (!Object.hasOwn(data, key)) continue;
             const value = data[key];
-            if (value !== undefined && !propList[i].fn.v(value, stack)) return false;
+            if (value !== undefined) { if (!propList[i].fn.v(value, stack)) return false; }
+            else if (propList[i].req) return false;
             if (collect) addProp(rec, key);
           }
           return true;
@@ -599,7 +615,8 @@ function install(deps) {
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
             const value = data[key];
-            if (value !== undefined && !prop.fn.v(value, stack)) return false;
+            if (value !== undefined) { if (!prop.fn.v(value, stack)) return false; }
+            else if (prop.req) return false;
             evaluated = true;
           }
           if (patterns !== null) {

package/lib/regex-linear.js

@@ -210,6 +210,86 @@ function deterministicRule (ast) {
   return unbounded === 0 || anchored(ast)
 }
 
+// Two more shapes the rules above decline, both anchored with `^` and `$`
+// around one top-level sequence.
+//
+// One choice: characters and classes, each repeated a fixed or bounded number
+// of times, with only one of the repeats able to vary, by at most 256
+// (`^[a-z0-9_-]{1,128}$`).
+// The engine backtracks through that one repeat and nowhere else, at most its
+// width per attempt, and the anchor allows one attempt.
+//
+// A delimited loop: `^P(Xd)*Q$` or with `+`, where d is one character or
+// class, X and Q match nothing d matches (Q may end with d, or an optional
+// d), and P holds no unbounded quantifier. Dotted identifiers and paths are
+// written so: `^([A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*$`, `^/?([^/]+/)*[^/]+/?$`.
+// Every iteration and Q's match end at a d or at the end, so each wrong
+// choice between another iteration and Q fails within one segment, and the
+// segments together are the input once. X and Q each hold at most one
+// unbounded quantifier, over a character or class, so a segment is not split
+// two ways either.
+function sequenceOf (ast) {
+  if (ast.t !== 'concat') return null
+  const parts = ast.parts
+  if (parts.length < 3 || parts[0].t !== 'bol' || parts[parts.length - 1].t !== 'eol') return null
+  return parts.slice(1, -1)
+}
+const repeatOfAtom = (n) => (n.t === 'star' || n.t === 'plus' || n.t === 'quest' || n.t === 'repeat') && atom(n.child)
+const unboundedNode = (n) => n.t === 'star' || n.t === 'plus' || (n.t === 'repeat' && n.max === Infinity)
+
+function oneChoiceRule (ast) {
+  const seq = sequenceOf(ast)
+  if (seq === null) return false
+  let varying = 0
+  for (const n of seq) {
+    if (atom(n)) continue
+    if (n.t === 'repeat' && atom(n.child) && n.max !== Infinity) {
+      if (n.max > 256) return false
+      if (n.max > n.min) varying++
+      continue
+    }
+    return false
+  }
+  return varying <= 1
+}
+
+function delimitedLoopRule (ast) {
+  const seq = sequenceOf(ast)
+  if (seq === null) return false
+  const loopAt = seq.findIndex((n) => unboundedNode(n) && !atom(n.child))
+  if (loopAt < 0) return false
+  let body = seq[loopAt].child
+  while (body.t === 'group') body = body.child
+  if (body.t !== 'concat' || body.parts.length < 2) return false
+  const d = body.parts[body.parts.length - 1]
+  if (!atom(d)) return false
+  const D = charSet(d)
+  // A run of characters, classes and their repeats that matches nothing in
+  // D, with at most one unbounded quantifier.
+  const run = (nodes) => {
+    let unbounded = 0
+    for (const n of nodes) {
+      const a = atom(n) ? n : repeatOfAtom(n) ? n.child : null
+      if (a === null || overlap(charSet(a), D)) return false
+      if (unboundedNode(n)) unbounded++
+      if (n.t === 'repeat' && n.max !== Infinity && n.max - n.min > 64) return false
+    }
+    return unbounded <= 1
+  }
+  if (!run(body.parts.slice(0, -1))) return false
+  const prefix = seq.slice(0, loopAt)
+  if (prefix.some(hasUnbounded)) return false
+  const pb = simpleRule({ t: 'concat', parts: prefix })
+  if (!pb && prefix.length > 0) return false
+  let suffix = seq.slice(loopAt + 1)
+  const last = suffix[suffix.length - 1]
+  if (last !== undefined) {
+    const tail = atom(last) ? last : last.t === 'quest' && atom(last.child) ? last.child : null
+    if (tail !== null && !overlap(charSet(tail), { bits: D.bits.map((b) => b ^ 1), high: D.high ? 0 : 1 })) suffix = suffix.slice(0, -1)
+  }
+  return run(suffix)
+}
+
 function nativeIsLinear (src) {
   if (typeof src !== 'string' || src.length > 512) return false
   for (let i = 0; i < src.length; i++) {
@@ -225,7 +305,7 @@ function nativeIsLinear (src) {
   }
   let ast
   try { ast = parse(src) } catch { return false }
-  return simpleRule(ast) || deterministicRule(ast)
+  return simpleRule(ast) || deterministicRule(ast) || oneChoiceRule(ast) || delimitedLoopRule(ast)
 }
 
 module.exports = { nativeIsLinear }

package/lib/safe-regex.js

@@ -473,25 +473,28 @@ function __ataSafeRegex () {
       }
       if (id < 0) return testNFA(s)
       if (len === 0) return (flags[id] & 1) === 1
-      // The last character is stepped with the end-of-input flag set and is
-      // handled after the loop, so the loop body selects no table and tests
-      // no position.
+      if ((flags[id] & 1) === 1) return true
+      // The last character, with the end flag, is stepped after the loop.
+      // Tables are locals, reread after `step` (which may grow them).
       const last = len - 1
+      let T = trans
+      let F = flags
       for (let pos = 0; pos < last; pos++) {
-        if ((flags[id] & 1) === 1) return true
         const c = s.charCodeAt(pos)
-        let nid
-        if (c < 128) {
-          nid = trans[(id << 7) | c]
-          if (nid === -2) { nid = step(states[id], c, false); if (nid >= 0 || overflow) trans[(id << 7) | c] = nid }
-        } else {
+        let nid = c < 128 ? T[(id << 7) | c] : -2
+        if (nid === -2) {
           nid = step(states[id], c, false)
+          T = trans; F = flags
+          if (c < 128 && (nid >= 0 || overflow)) T[(id << 7) | c] = nid
         }
         if (nid < 0) return testNFA(s)
         id = nid
-        if ((flags[id] & 2) === 2) return false
+        const f = F[id]
+        if (f !== 0) {
+          if ((f & 2) === 2) return false
+          return true
+        }
       }
-      if ((flags[id] & 1) === 1) return true
       const c = s.charCodeAt(last)
       let nid
       if (c < 128) {

package/lib/schema-scan.js

@@ -30,23 +30,10 @@ const TUPLE_ITEMS = 1 << 5;      // array-valued `items`, split into `prefixItem
 const EXCLUSIVE_BOOL = 1 << 6;   // draft-04's boolean `exclusiveMinimum`/`exclusiveMaximum`
 const ENCODED_REF = 1 << 7;      // a fragment `$ref` holding a percent escape, decoded by normalizeNullable's walk
 
-// Questions compat asks of a schema it is about to compile (compat.js), read
-// on the same walk so that a document is not walked again for them.
-const HAS_REF = 1 << 8;          // `$ref` anywhere
-const BEYOND_ITEMS = 1 << 9;     // a subschema keyword other than `properties` and object `items`
-const DISCRIMINATOR = 1 << 10;   // `discriminator` anywhere
-const HAS_DEFAULT = 1 << 11;     // `default` anywhere
-const HAS_ALLOF = 1 << 12;       // `allOf` anywhere
-const HAS_FORMAT = 1 << 13;      // `format` anywhere
-const KEY_BITS = new Map([
-  ['$ref', HAS_REF | BEYOND_ITEMS], ['$dynamicRef', BEYOND_ITEMS], ['allOf', HAS_ALLOF | BEYOND_ITEMS],
-  ['anyOf', BEYOND_ITEMS], ['oneOf', BEYOND_ITEMS], ['not', BEYOND_ITEMS], ['if', BEYOND_ITEMS],
-  ['then', BEYOND_ITEMS], ['else', BEYOND_ITEMS], ['additionalProperties', BEYOND_ITEMS],
-  ['patternProperties', BEYOND_ITEMS], ['prefixItems', BEYOND_ITEMS], ['additionalItems', BEYOND_ITEMS],
-  ['contains', BEYOND_ITEMS], ['dependentSchemas', BEYOND_ITEMS], ['dependencies', BEYOND_ITEMS],
-  ['propertyNames', BEYOND_ITEMS], ['unevaluatedProperties', BEYOND_ITEMS], ['unevaluatedItems', BEYOND_ITEMS],
-  ['discriminator', DISCRIMINATOR], ['default', HAS_DEFAULT], ['format', HAS_FORMAT],
-]);
+// Questions compat asks of a schema it is about to compile, read on the same
+// walk so that a document is not walked again for them. compat sets the keys
+// and their bits (setExtraKeys); without compat the walk reads none.
+let EXTRA = null;
 
 // Everything only draft-07 normalization acts on. A schema of another dialect
 // can carry these without them meaning anything, so they are read together
@@ -71,7 +58,7 @@ const ANCHOR_ID_RE = /^#[A-Za-z][A-Za-z0-9_.:-]*$/;
 // This assumes a schema is not mutated after being handed to a Validator,
 // which is already true of everything else here: the compile cache, the
 // identity cache and the schema map would all be stale too.
-const CACHE = new WeakMap();
+let CACHE = new WeakMap();
 
 function scan(schema) {
   if (typeof schema !== 'object' || schema === null) return 0;
@@ -110,11 +97,13 @@ function scan(schema) {
     }
     // Every key, not just the subschema keywords, so this cannot miss a place
     // the normalizers would reach.
-    for (let i = 0; i < keys.length; i++) {
-      const b = KEY_BITS.get(keys[i]);
-      if (b !== undefined) bits |= b;
-      walk(node[keys[i]]);
+    if (EXTRA !== null) {
+      for (let i = 0; i < keys.length; i++) {
+        const b = EXTRA.get(keys[i]);
+        if (b !== undefined) bits |= b;
+      }
     }
+    for (let i = 0; i < keys.length; i++) walk(node[keys[i]]);
   };
 
   walk(schema);
@@ -146,10 +135,12 @@ module.exports = {
   EXCLUSIVE_BOOL,
   ENCODED_REF,
   DRAFT7_WORK,
-  HAS_REF,
-  BEYOND_ITEMS,
-  DISCRIMINATOR,
-  HAS_DEFAULT,
-  HAS_ALLOF,
-  HAS_FORMAT,
 };
+
+// A schema scanned before the keys were set is scanned again: what was
+// remembered for it does not answer the new questions.
+function setExtraKeys(map) {
+  EXTRA = map;
+  CACHE = new WeakMap();
+}
+Object.defineProperty(module.exports, '_setExtraKeys', { value: setExtraKeys, enumerable: false });

package/lib/tier0.js

@@ -173,6 +173,7 @@ function tier0ValidateObject(plan, data) {
     // treated as absent, as the interpreted engine treats it.
     if (v !== undefined && (c.protoName || (_PN ? data.__proto__ : Object.getPrototypeOf(data)) !== Object.prototype) && !_hop.call(data, c.key)) v = undefined;
     if (v === undefined) {
+      // A required key holding undefined is missing, as in every engine.
       if (reqMask & (1 << i)) return false;
       continue;
     }

package/lib/unique-items.js

@@ -22,17 +22,28 @@ function _deq(a, b) {
   if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
   var aa = Array.isArray(a);
   if (aa !== Array.isArray(b)) return false;
-  var i;
+  var i, k, x, y;
   if (aa) {
     if (a.length !== b.length) return false;
-    for (i = 0; i < a.length; i++) if (!_deq(a[i], b[i])) return false;
+    for (i = a.length; i-- !== 0;) if (!_deq(a[i], b[i])) return false;
     return true;
   }
   var ka = Object.keys(a);
   if (ka.length !== Object.keys(b).length) return false;
-  for (i = 0; i < ka.length; i++) {
-    var k = ka[i];
-    if (!Object.prototype.hasOwnProperty.call(b, k) || !_deq(a[k], b[k])) return false;
+  // Keys and scalar values first, nested values after, from the last key back:
+  // two items of a list most often differ in a name, a path or an id, and
+  // walking a nested list first made each comparison of rust-project's crates
+  // three times what it needed (250 against 78 ns for the three; the default
+  // validator's deep equal takes 115).
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+    x = a[k]; y = b[k];
+    if (x !== y && (x === null || y === null || typeof x !== 'object' || typeof y !== 'object')) return false;
+  }
+  for (i = ka.length; i-- !== 0;) {
+    k = ka[i]; x = a[k];
+    if (x !== null && typeof x === 'object' && !_deq(x, b[k])) return false;
   }
   return true;
 }

package/lib/uri-core.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// RFC 3986 URI and URI-reference, RFC 3987 IRI and IRI-reference, as one walk
+// over the string with no slicing. `mode` bit 1 asks for a scheme (uri, iri),
+// bit 2 lets non-ASCII through (iri, iri-reference). The rules the walk holds
+// that a character-class scan does not: a second "@" in the authority, a port
+// that is not digits, square brackets anywhere but around an IP literal, the
+// literal itself (RFC 3986 IPv6 with an embedded IPv4 of no leading zeros, an
+// RFC 6874 zone id, IPvFuture), a colon in the first segment of a relative
+// path, and a second "#". A reference made only of unreserved characters,
+// sub-delimiters, "/" and "@" (a file name, a path) is one whatever its
+// shape, and is answered by one scan before any of that.
+//
+// A factory, like lib/safe-regex.js: the interpreted engine calls the
+// function it returns, and the code generator emits the factory's source
+// text (`source`) into the program it builds, so a standalone module carries
+// the same walk without importing it. Nothing inside the factory reads a
+// free variable, and no comments inside it: its text is what gets emitted.
+// `ip6` is the IPv6 check for a bracketed host, one string in: lib/formats.js
+// gives its own and the generator emits ipv6Source, so neither carries a
+// second copy. The slice it costs happens only on an IP literal.
+function __ataUri (ip6) {
+  const C = new Uint8Array(128);
+  for (let i = 48; i < 58; i++) C[i] = 3;
+  for (let i = 65; i < 91; i++) C[i] = 3;
+  for (let i = 97; i < 123; i++) C[i] = 3;
+  C[43] = 3; C[45] = 3; C[46] = 3;
+  C[95] = 1; C[126] = 1;
+  C[33] = 1; C[36] = 1; C[38] = 1; C[39] = 1; C[40] = 1; C[41] = 1; C[42] = 1; C[44] = 1; C[59] = 1; C[61] = 1;
+  const H = new Uint8Array(128);
+  for (let i = 48; i < 58; i++) H[i] = 1;
+  for (let i = 65; i < 71; i++) H[i] = 1;
+  for (let i = 97; i < 103; i++) H[i] = 1;
+  function pct (s, i) {
+    const a = s.charCodeAt(i + 1), b = s.charCodeAt(i + 2);
+    return a < 128 && b < 128 && H[a] === 1 && H[b] === 1;
+  }
+  const P = new Uint8Array(128);
+  for (let i = 0; i < 128; i++) P[i] = C[i] & 1;
+  P[58] = 1; P[64] = 1; P[47] = 1;
+  const Q = new Uint8Array(P);
+  Q[63] = 1;
+  const S = new Uint8Array(P);
+  S[58] = 0;
+  function literal (s, from, to) {
+    if (from >= to) return false;
+    const f = s.charCodeAt(from);
+    if (f === 118 || f === 86) {
+      let i = from + 1, h = 0;
+      for (; i < to; i++) { const c = s.charCodeAt(i); if (c < 128 && H[c] === 1) h++; else break; }
+      if (h === 0 || s.charCodeAt(i) !== 46 || i + 1 >= to) return false;
+      for (i++; i < to; i++) { const c = s.charCodeAt(i); if (!(c < 128 && ((C[c] & 1) === 1 || c === 58))) return false; }
+      return true;
+    }
+    let z = -1;
+    for (let i = from; i < to; i++) if (s.charCodeAt(i) === 37) { z = i; break; }
+    if (z === -1) return ip6(s.slice(from, to));
+    if (s.charCodeAt(z + 1) !== 50 || s.charCodeAt(z + 2) !== 53 || z + 3 >= to) return false;
+    for (let i = z + 3; i < to; i++) {
+      const c = s.charCodeAt(i);
+      if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+      if (!(c < 128 && (C[c] & 1) === 1)) return false;
+    }
+    return ip6(s.slice(from, z));
+  }
+  return function (s, mode) {
+    const n = s.length;
+    const wide = (mode & 2) !== 0;
+    if ((mode & 1) === 0 && !(s.charCodeAt(0) === 47 && s.charCodeAt(1) === 47)) {
+      let k = 0;
+      for (; k < n; k++) { const c = s.charCodeAt(k); if (c > 127 || S[c] === 0) break; }
+      if (k === n) return true;
+    }
+    let i = 0, c = s.charCodeAt(0), scheme = false;
+    if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122)) {
+      let j = 1;
+      while (j < n) { c = s.charCodeAt(j); if (c === 58 || c > 127 || (C[c] & 2) === 0) break; j++; }
+      if (j < n && c === 58) { scheme = true; i = j + 1; }
+    }
+    if (!scheme && (mode & 1) !== 0) return false;
+    let auth = false;
+    if (s.charCodeAt(i) === 47 && s.charCodeAt(i + 1) === 47) {
+      auth = true;
+      const st = i + 2;
+      let end = n, at = -1, br = false, brAt = false, colon = -1;
+      for (let k = st; k < n; k++) {
+        c = s.charCodeAt(k);
+        if (c === 47 || c === 63 || c === 35) { end = k; break; }
+        if (c < 128) {
+          if ((C[c] & 1) === 1) continue;
+          if (c === 37) { if (!pct(s, k)) return false; k += 2; continue; }
+          if (c === 58) { if (colon === -1) colon = k; continue; }
+          if (c === 64) { if (at !== -1) return false; at = k; brAt = br; colon = -1; continue; }
+          if (c === 91 || c === 93) { br = true; continue; }
+          return false;
+        }
+        if (!wide) return false;
+      }
+      if (brAt) return false;
+      const hs = at === -1 ? st : at + 1;
+      if (s.charCodeAt(hs) === 91) {
+        let close = -1;
+        for (let k = hs + 1; k < end; k++) if (s.charCodeAt(k) === 93) { close = k; break; }
+        if (close === -1 || !literal(s, hs + 1, close)) return false;
+        if (close + 1 < end) {
+          if (s.charCodeAt(close + 1) !== 58) return false;
+          for (let k = close + 2; k < end; k++) { c = s.charCodeAt(k); if (c < 48 || c > 57) return false; }
+        }
+      } else {
+        if (br) return false;
+        if (colon !== -1) for (let k = colon + 1; k < end; k++) { c = s.charCodeAt(k); if (c < 48 || c > 57) return false; }
+      }
+      i = end;
+    }
+    if (!scheme && !auth && s.charCodeAt(i) !== 47) {
+      for (; i < n; i++) {
+        c = s.charCodeAt(i);
+        if (c === 47 || c === 63 || c === 35) break;
+        if (c === 58) return false;
+        if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+        if (c < 128 ? P[c] === 0 : !wide) return false;
+      }
+    }
+    for (; i < n; i++) {
+      c = s.charCodeAt(i);
+      if (c < 128 ? P[c] === 0 : !wide) {
+        if (c === 63 || c === 35) break;
+        if (c === 37) { const a = s.charCodeAt(i + 1), b = s.charCodeAt(i + 2); if (!(a < 128 && b < 128 && H[a] === 1 && H[b] === 1)) return false; i += 2; continue; }
+        return false;
+      }
+    }
+    if (i >= n) return true;
+    if (c === 63) {
+      for (i++; i < n; i++) {
+        c = s.charCodeAt(i);
+        if (c < 128 ? Q[c] === 0 : !wide) {
+          if (c === 35) break;
+          if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+          return false;
+        }
+      }
+      if (i >= n) return true;
+    }
+    for (i++; i < n; i++) {
+      c = s.charCodeAt(i);
+      if (c < 128 ? Q[c] === 0 : !wide) {
+        if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+module.exports = { __ataUri };

package/lib/validator-core.js

@@ -33,12 +33,13 @@ let _aotLoader = null;
 function _registerAot(load) {
   _aotLoader = load;
 }
-const { draftCode, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions } = require("./draft7");
-const { enabledKeywords, stripDisabledKeywords } = require("./vocabularies");
+// draft7.js, vocabularies.js, shape-classifier.js and tier0.js load where
+// they are first used: a fresh process validating a 2020-12 schema runs none
+// of their code, and reading them cost it about a tenth of what it loads.
+const _draft7 = () => require("./draft7");
+const _vocabularies = () => require("./vocabularies");
 const { needsNormalization } = require("./schema-scan");
-const { isV1Dialect } = require("./dialect");
-const { classify } = require("./shape-classifier");
-const { buildTier0Plan, tier0Validate } = require("./tier0");
+const { isV1Dialect, draftCode } = require("./dialect");
 
 // The closure defaults pass. Only a validator without the generated
 // preprocess pass calls it, so it loads on that first call; loading it with
@@ -470,8 +471,9 @@ function _normalizeCallerSchema(s, inheritDraft7) {
 function _normalizeCallerSchemaUncached(s, inheritDraft7) {
   const declared = s && typeof s === 'object' ? s.$schema : undefined
   const code = declared !== undefined ? draftCode(declared) : (inheritDraft7 || 0)
-  const needsDraft7 = code === 1 || code === 2
-  const draft6 = code === 2
+  const needsDraft7 = code === 1 || code === 2 || code === 4
+  const draft4 = code === 4
+  const draft6 = code === 2 || draft4
   const draft2019 = code === 3
   // One walk answers whether there is anything to do. Almost always there is
   // not, and then the serialize, clone, normalize, serialize, compare below is
@@ -482,7 +484,8 @@ function _normalizeCallerSchemaUncached(s, inheritDraft7) {
   if (!draft6 && !draft2019 && !needsNormalization(s, needsDraft7)) return s
 
   const copy = _deepCloneWithSymbols(s)
-  if (needsDraft7) normalizeDraft7(copy, true, draft6)
+  const { normalizeDraft7, normalizeDraft2019, normalizeNullable, normalizeExclusiveBounds } = _draft7()
+  if (needsDraft7) normalizeDraft7(copy, true, draft6, draft4)
   if (draft2019) normalizeDraft2019(copy, true)
   normalizeNullable(copy)
   normalizeExclusiveBounds(copy)
@@ -615,7 +618,11 @@ function _applyVocabularies(schemaObj, original, schemaMap) {
   if (!schemaObj || typeof schemaObj !== 'object') return schemaObj
   const declared = schemaObj.$schema
   if (typeof declared !== 'string') return schemaObj
-  const enabled = enabledKeywords(schemaMap.get(declared))
+  // Only a meta-schema with a $vocabulary can disable a keyword.
+  const meta = schemaMap.get(declared)
+  if (!meta || typeof meta !== 'object' || !meta.$vocabulary || typeof meta.$vocabulary !== 'object') return schemaObj
+  const { enabledKeywords, stripDisabledKeywords } = _vocabularies()
+  const enabled = enabledKeywords(meta)
   if (!enabled) return schemaObj
   // `original` is the caller's own object when it reached here unchanged, and
   // that one is never mutated.
@@ -724,7 +731,7 @@ function _materializeSchema(self) {
     // Always on a copy: a normalized schema is shared by every validator built
     // from the same object (see _normalizeCallerSchema), so stripping in place
     // would take format checks away from the others.
-    schemaObj = stripFormatAssertions(_deepCloneWithSymbols(schemaObj));
+    schemaObj = _draft7().stripFormatAssertions(_deepCloneWithSymbols(schemaObj));
   }
   // A keyword used only in a schema reached through $ref counts too: the
   // interpreted engine applies it there, and every path that does not know the
@@ -2395,8 +2402,10 @@ _defineLazyMethod('isValidObject', (self) => {
     return self.isValidObject(data);
   }
   // Lazy: classify + build tier 0 plan on first call, not in constructor.
-  const _tier = classify(self._schemaObj);
+  const _tier = require("./shape-classifier").classify(self._schemaObj);
   if (_tier.tier === 0) {
+    // Bound once here, so the verdict below reads a local, not the module.
+    const { buildTier0Plan, tier0Validate } = require("./tier0");
     const _plan = buildTier0Plan(self._schemaObj);
     let _n = 0;
     _bindVerdict(self, (d) => {

package/lib/version.js

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