ata-validator 1.52.0 → 1.54.0

package/lib/keywords.js

@@ -10,6 +10,12 @@
 //   { macro(value, parent) -> schema }    the returned schema is applied in
 //                                         place, and the keyword reports an
 //                                         error of its own when it fails
+// with optional `dataContext: true`: the per-value function is also given
+// `{ instancePath, parentData, parentDataProperty, rootData }`, as the default
+// validator's keywords are, so it can read or change the value where it sits
+// (validate(value, data, parent, ctx), or the compiled fn(data, ctx)). Such a
+// schema runs on the interpreted engine's collecting walk, which knows where
+// every value is.
 // with optional `type`: a JSON Schema type name or a list of them. A typed
 // keyword is skipped for data of any other type, which is what makes
 // `{ type: 'number', ... }` safe next to `type: ['number', 'string']`.
@@ -72,6 +78,12 @@ function normalizeKeywords(defs) {
       validate: hasValidate ? def.validate : null,
       compile: hasCompile ? def.compile : null,
       macro: hasMacro ? def.macro : null,
+      dataContext: def.dataContext === true,
+      // Order among the custom keywords of one node, as the default
+      // validator's keywords declare it: `before` names a keyword this one
+      // runs ahead of, `post` runs it after the others.
+      before: typeof def.before === 'string' ? def.before : null,
+      post: def.post === true,
     };
   }
   return out;
@@ -110,4 +122,15 @@ const NAME_MAPS = new Set([
   'dependentSchemas', 'dependentRequired', 'dependencies', 'propertyDependencies',
 ]);
 
-module.exports = { normalizeKeywords, schemaUsesKeywords };
+// Does the schema use a registered keyword that asks for its data's context?
+function schemaUsesDataContext(schema, keywords) {
+  if (!keywords) return false;
+  let any = false;
+  for (const name of Object.keys(keywords)) if (keywords[name].dataContext) { any = true; break; }
+  if (!any) return false;
+  const only = Object.create(null);
+  for (const name of Object.keys(keywords)) if (keywords[name].dataContext) only[name] = keywords[name];
+  return schemaUsesKeywords(schema, only);
+}
+
+module.exports = { normalizeKeywords, schemaUsesKeywords, schemaUsesDataContext };

package/lib/levenshtein.js

@@ -1,20 +1,25 @@
 'use strict';
 
-// Bounded Levenshtein. Returns Infinity if distance > maxDistance (or, past
+// Bounded edit distance. Returns Infinity if distance > maxDistance (or, past
 // the bound, possibly some number greater than it; callers compare).
 //
+// Two adjacent characters swapped count as one edit, not two (the optimal
+// string alignment distance): `nmae` for `name` is the commonest typo there
+// is, and at two edits a four-letter name's budget of one turned it away.
+//
 // Only the cells within the bound of the diagonal are computed: a path
 // through any other cell already costs more than the bound. A typo hint asks
 // with a bound of one or two and compares the missing name with every key
 // present, so a row is five cells instead of the whole key. Without a bound
 // the band is the whole row.
 //
-// Two rows of scratch, reused across calls. The function is not recursive
+// Three rows of scratch, reused across calls. The function is not recursive
 // and the library is single-threaded, so nothing else is using them; growing
 // them once beats allocating two arrays on every comparison, which the
 // reject-path profile showed as most of this function's cost.
 let scratchA = new Int32Array(64);
 let scratchB = new Int32Array(64);
+let scratchC = new Int32Array(64);
 
 function levenshtein (a, b, maxDistance) {
   if (a === b) return 0;
@@ -28,7 +33,11 @@ function levenshtein (a, b, maxDistance) {
   if (scratchA.length < m + 2) {
     scratchA = new Int32Array(m + 2);
     scratchB = new Int32Array(m + 2);
+    scratchC = new Int32Array(m + 2);
   }
+  // The row before the previous one, read for a swap: within the band of
+  // row i the cell two back on the diagonal is inside the band of row i - 2.
+  let prev2 = scratchC;
   let prev = scratchA;
   let curr = scratchB;
   for (let j = 0; j <= m; j++) prev[j] = j <= max ? j : big;
@@ -40,20 +49,27 @@ function levenshtein (a, b, maxDistance) {
     // charCodeAt rather than indexing: reading a character by index allocates
     // a one-character string, and this is the innermost loop.
     const ca = a.charCodeAt(i - 1);
+    const pa = i > 1 ? a.charCodeAt(i - 2) : -1;
     for (let j = lo; j <= hi; j++) {
-      let v = prev[j - 1] + (ca === b.charCodeAt(j - 1) ? 0 : 1);
+      const cb = b.charCodeAt(j - 1);
+      let v = prev[j - 1] + (ca === cb ? 0 : 1);
       const del = curr[j - 1] + 1;
       if (del < v) v = del;
       const ins = prev[j] + 1;
       if (ins < v) v = ins;
+      if (j > 1 && ca !== cb && ca === b.charCodeAt(j - 2) && pa === cb) {
+        const swap = prev2[j - 2] + 1;
+        if (swap < v) v = swap;
+      }
       if (v > big) v = big;
       curr[j] = v;
       if (v < rowMin) rowMin = v;
     }
     if (hi < m) curr[hi + 1] = big;
     if (rowMin > max) return Infinity;
-    // A destructured swap builds an array per row; a temporary does not.
-    const t = prev;
+    // A destructured swap builds an array per row; temporaries do not.
+    const t = prev2;
+    prev2 = prev;
     prev = curr;
     curr = t;
   }

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
@@ -532,10 +541,19 @@ function install(deps) {
           const key = keys[k];
           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); required, it is missing.
           if (prop !== undefined) {
-            if (!((prop.fn.leaf && prop.fn.v(data[key], stack)) || prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
+            const value = data[key];
+            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;
           }
@@ -578,7 +596,9 @@ function install(deps) {
           for (let i = 0; i < n; i++) {
             const key = propKeys[i];
             if (!Object.hasOwn(data, key)) continue;
-            if (!propList[i].fn.v(data[key], stack)) return false;
+            const value = data[key];
+            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;
@@ -594,7 +614,9 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
-            if (!prop.fn.v(data[key], stack)) return false;
+            const value = data[key];
+            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,6 +30,11 @@ 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, 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
 // with whether the document is draft-07 at all.
@@ -53,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;
@@ -92,6 +97,12 @@ function scan(schema) {
     }
     // Every key, not just the subschema keywords, so this cannot miss a place
     // the normalizers would reach.
+    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]]);
   };
 
@@ -125,3 +136,11 @@ module.exports = {
   ENCODED_REF,
   DRAFT7_WORK,
 };
+
+// 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 };