ata-validator 1.61.3 → 1.62.0

package/lib/defaults.js

@@ -23,11 +23,21 @@ const MAX_DEPTH = 512;
 
 // Build the pass for a schema: a function that fills defaults into a value in
 // place (mutates), or null when no default is reachable from the schema.
-function buildDefaultsApplier(schema) {
+// `keyMatcher` turns a patternProperties pattern into something with a
+// `test` method; without one the platform RegExp is used. The runtime hands
+// in the matcher validation uses (see safeKeyMatcher below), so a key that
+// makes a backtracking pattern run for seconds costs no more here than it
+// does to validate. A module written ahead of time embeds this function as
+// text and calls it without one.
+function buildDefaultsApplier(schema, keyMatcher) {
   if (typeof schema !== "object" || schema === null) return null;
-  const path = [];
-  const fn = compileNode(schema, schema, new Map(), new Map(), path);
-  return fn === null ? null : (data) => { path.length = 0; fn(data, 0, null); };
+  // `visits`: per call, the schemas already applied to each object through a
+  // `$ref` or an `allOf` member. Applying one twice to the same object fills
+  // nothing new, and following every edge of a chain such as
+  // n_i = allOf [n_(i-1), n_(i-1)] cost 2^n applications of one schema.
+  const ctx = { root: schema, memo: new Map(), reach: new Map(), path: [], res: resourceRoots(schema), match: keyMatcher || keyPattern, visits: null };
+  const fn = compileNode(schema, ctx);
+  return fn === null ? null : (data) => { ctx.path.length = 0; ctx.visits = null; fn(data, 0, null); };
 }
 
 // Write an own property. Plain assignment of a key named `__proto__` does
@@ -70,13 +80,45 @@ function localRef(root, ref) {
   return t !== null && typeof t === "object" ? t : null;
 }
 
+// For a schema that embeds other resources (a subschema with its own `$id`),
+// the resource each schema object belongs to: a fragment `$ref` inside one
+// is read against that resource, as validation reads it, not against the
+// outer root. Null when nothing is embedded, which is nearly always. An `$id`
+// that is only a fragment (`#foo`, a draft-07 anchor) starts no resource.
+// Values under `default`, `const`, `enum` and `examples` are data, not
+// schemas, and are not walked.
+function resourceRoots(root) {
+  if (root === null || typeof root !== "object") return null;
+  const map = new Map();
+  let embedded = false;
+  const walk = (node, res) => {
+    if (node === null || typeof node !== "object" || map.has(node)) return;
+    if (Array.isArray(node)) { map.set(node, res); for (let i = 0; i < node.length; i++) walk(node[i], res); return; }
+    if (node !== root && typeof node.$id === "string" && node.$id.charCodeAt(0) !== 35) { res = node; embedded = true; }
+    map.set(node, res);
+    for (const k of Object.keys(node)) {
+      if (k === "default" || k === "const" || k === "enum" || k === "examples") continue;
+      walk(node[k], res);
+    }
+  };
+  walk(root, root);
+  return embedded ? map : null;
+}
+
+// The schema a `$ref` on `node` names, read against the resource `node`
+// belongs to.
+function refTarget(root, res, node) {
+  const base = res !== null ? res.get(node) : undefined;
+  return localRef(base !== undefined ? base : root, node.$ref);
+}
+
 // Whether a default is reachable from a schema, through the same places the
 // pass goes: 1 yes, 0 no, 2 not known yet because the walk came back to a
 // schema it is still deciding (a recursive reference). Answers are kept per
 // schema object in `memo`, except one that rests on an undecided schema,
 // which is worked out again when asked; the walk used to start over for every
 // schema object it compiled, quadratic in the depth of the schema.
-function reachesDefault(node, root, memo, stack) {
+function reachesDefault(node, root, memo, stack, res) {
   if (node === null || typeof node !== "object") return 0;
   const known = memo.get(node);
   if (known !== undefined) return known;
@@ -85,9 +127,9 @@ function reachesDefault(node, root, memo, stack) {
   const props = valuesOf(node.properties);
   let yes = props.some((p) => p && typeof p === "object" && p.default !== undefined);
   let open = false;
-  const below = props.concat(localRef(root, node.$ref), listOf(node.allOf), listOf(node.prefixItems), node.items, node.additionalProperties, valuesOf(node.patternProperties), valuesOf(node.dependentSchemas));
+  const below = props.concat(refTarget(root, res, node), listOf(node.allOf), listOf(node.prefixItems), node.items, node.additionalProperties, valuesOf(node.patternProperties), valuesOf(node.dependentSchemas));
   for (let i = 0; !yes && i < below.length; i++) {
-    const r = reachesDefault(below[i], root, memo, stack);
+    const r = reachesDefault(below[i], root, memo, stack, res);
     if (r === 1) yes = true;
     else if (r === 2) open = true;
   }
@@ -119,10 +161,11 @@ function copyOf(v) {
 // applied to the same value. A schema reached again (a recursive reference)
 // takes the function being built for it, so a cycle in the schema is a loop
 // in the calls, bounded by the depth of the data.
-function compileNode(node, root, memo, reach, path) {
+function compileNode(node, ctx) {
   if (node === null || typeof node !== "object") return null;
+  const memo = ctx.memo, path = ctx.path;
   if (memo.has(node)) return memo.get(node);
-  if (reachesDefault(node, root, reach, new Set()) !== 1) { memo.set(node, null); return null; }
+  if (reachesDefault(node, ctx.root, ctx.reach, new Set(), ctx.res) !== 1) { memo.set(node, null); return null; }
   let body = null;
   // `path`: the schemas applied to the enclosing values, outermost first.
   // `made`: inside a value the pass itself made from a default, the same as a
@@ -133,6 +176,16 @@ function compileNode(node, root, memo, reach, path) {
   // schema, and Renovate's took this pass to the heap limit.
   const fn = (data, depth, made) => {
     if (depth > MAX_DEPTH) return;
+    // Only what is applied through a `$ref` or `allOf` is counted (fn.shared,
+    // set below), and only outside a made value, where every application
+    // does the same work.
+    if (fn.shared === true && made === null && typeof data === "object" && data !== null) {
+      const visits = ctx.visits || (ctx.visits = new Map());
+      let done = visits.get(data);
+      if (done === undefined) visits.set(data, (done = new Set()));
+      if (done.has(node)) return;
+      done.add(node);
+    }
     if (made !== null) {
       if (made.has(node)) return;
       made.add(node);
@@ -154,31 +207,31 @@ function compileNode(node, root, memo, reach, path) {
       const p = props[key];
       if (!p || typeof p !== "object") continue;
       if (p.default !== undefined) own.push([key, p.default]);
-      const child = compileNode(p, root, memo, reach, path);
+      const child = compileNode(p, ctx);
       if (child !== null) below.push([key, child]);
     }
   }
   // Arrays: every element under `items`, the elements `prefixItems` names by
   // position (then `items` covers only the ones after them).
-  const tuple = Array.isArray(node.prefixItems) ? node.prefixItems.map((s) => compileNode(s, root, memo, reach, path)) : [];
-  const each = compileNode(node.items, root, memo, reach, path);
+  const tuple = Array.isArray(node.prefixItems) ? node.prefixItems.map((s) => compileNode(s, ctx)) : [];
+  const each = compileNode(node.items, ctx);
   // Objects: keys a pattern matches, and the keys neither `properties` nor a
   // pattern names; and a schema for each key present.
   const patterns = [];
   if (node.patternProperties && typeof node.patternProperties === "object") {
     for (const src of Object.keys(node.patternProperties)) {
-      const re = keyPattern(src);
-      const t = compileNode(node.patternProperties[src], root, memo, reach, path);
+      const re = ctx.match(src);
+      const t = compileNode(node.patternProperties[src], ctx);
       if (re === null) continue;
       patterns.push([re, t]);
     }
   }
-  const extra = compileNode(node.additionalProperties, root, memo, reach, path);
+  const extra = compileNode(node.additionalProperties, ctx);
   const declared = props && typeof props === "object" ? props : null;
   const dependent = [];
   if (node.dependentSchemas && typeof node.dependentSchemas === "object") {
     for (const key of Object.keys(node.dependentSchemas)) {
-      const t = compileNode(node.dependentSchemas[key], root, memo, reach, path);
+      const t = compileNode(node.dependentSchemas[key], ctx);
       if (t !== null) dependent.push([key, t]);
     }
   }
@@ -186,19 +239,22 @@ function compileNode(node, root, memo, reach, path) {
 
   const also = [];
   if (typeof node.$ref === "string") {
-    const t = compileNode(localRef(root, node.$ref), root, memo, reach, path);
-    if (t !== null) also.push(t);
+    const t = compileNode(refTarget(ctx.root, ctx.res, node), ctx);
+    if (t !== null) { t.shared = true; also.push(t); }
   }
   if (Array.isArray(node.allOf)) {
     for (const s of node.allOf) {
-      const t = compileNode(s, root, memo, reach, path);
-      if (t !== null) also.push(t);
+      const t = compileNode(s, ctx);
+      if (t !== null) { t.shared = true; also.push(t); }
     }
   }
 
   body = (data, depth, made) => {
+    // A value that is not an object has nothing to fill, here or in any
+    // schema applied to it.
+    if (typeof data !== "object" || data === null) return;
     let fresh = null;
-    if (typeof data === "object" && data !== null) {
+    {
       for (let i = 0; i < own.length; i++) {
         const key = own[i][0];
         if (!Object.hasOwn(data, key)) {
@@ -240,6 +296,28 @@ function compileNode(node, root, memo, reach, path) {
 
 // The functions a module written ahead of time embeds as its applyDefaults
 // where the generated pass declines a schema (lib/aot-impl.js).
-const EMBED = ['buildDefaultsApplier', 'setOwn', 'localRef', 'reachesDefault', 'valuesOf', 'listOf', 'keyPattern', 'copyOf', 'compileNode'];
+const EMBED = ['buildDefaultsApplier', 'setOwn', 'localRef', 'resourceRoots', 'refTarget', 'reachesDefault', 'valuesOf', 'listOf', 'keyPattern', 'copyOf', 'compileNode'];
+
+// patternProperties keys tested in linear time: the linear-time engine
+// (lib/safe-regex.js, which validation uses for these patterns too) for a
+// pattern in its subset, the platform RegExp otherwise, as validation does.
+// A key that makes a backtracking pattern run for seconds then costs no more
+// here than it does to validate. lib/js-compiler.js also hands patterns the
+// RegExp runs in linear time to the RegExp, for speed; that check is left
+// out here so the closure pass, which lite carries, does not pull it in.
+// Loaded on the first pattern; most schemas have none.
+const PROP_ESCAPE = /\\[pP]\{/;
+function safeKeyMatcher(src) {
+  if (!PROP_ESCAPE.test(src)) {
+    try {
+      const safe = require("./safe-regex");
+      if (safe.patternIsSafe(src)) return safe.compileSafe(src);
+    } catch {}
+  }
+  return keyPattern(src);
+}
 
-module.exports = { buildDefaultsApplier, setOwn, localRef, MAX_DEPTH, EMBED };
+module.exports = {
+  buildDefaultsApplier: (schema) => buildDefaultsApplier(schema, safeKeyMatcher),
+  setOwn, localRef, resourceRoots, refTarget, safeKeyMatcher, MAX_DEPTH, EMBED,
+};

package/lib/describe-schema.js

@@ -26,6 +26,10 @@
 // $defs. Anything else is described as `any` rather than guessed at.
 
 const MAX_DEPTH = 12;
+// anyOf branches that each lead to the same next definition describe
+// width^layers lines, 16 million for 4 wide and 12 deep. A prompt has no use
+// for more than this; past it the description stops and says so.
+const MAX_LINES = 2000;
 
 function lit (v) {
   try { return JSON.stringify(v); } catch (_) { return String(v); }
@@ -95,6 +99,7 @@ function describeObjectBody (schema, depth, defs, lines) {
 }
 
 function describeNode (schema, label, depth, defs, lines) {
+  if (lines.length >= MAX_LINES) return;
   const pad = '  '.repeat(depth);
   if (schema === true || schema === undefined) { lines.push(`${pad}${label}: any`); return; }
   if (schema === false) { lines.push(`${pad}${label}: nothing is allowed here`); return; }
@@ -103,19 +108,43 @@ function describeNode (schema, label, depth, defs, lines) {
     return;
   }
 
-  const target = schema.$ref ? resolveRef(schema, defs) : null;
-  if (target) { describeNode(target, label, depth, defs, lines); return; }
+  // A chain of references is followed here, each definition once: one that
+  // leads back to itself without a property in between describes no value.
+  let target = schema.$ref ? resolveRef(schema, defs) : null;
+  if (target) {
+    const chain = new Set([schema]);
+    while (target && typeof target === 'object' && target.$ref && !chain.has(target)) {
+      chain.add(target);
+      const next = resolveRef(target, defs);
+      if (!next) break;
+      target = next;
+    }
+    if (chain.has(target)) { lines.push(`${pad}${label}: any`); return; }
+    describeNode(target, label, depth, defs, lines);
+    return;
+  }
 
-  // allOf is the intersection, so its parts describe the same value.
+  // allOf is the intersection, so its parts describe the same value. The
+  // parts' own allOf are merged in the same pass, each schema once: a part
+  // that led back to this schema copied its allOf back in and the merge
+  // recursed until the stack ran out.
   if (Array.isArray(schema.allOf) && schema.allOf.length) {
     const merged = Object.assign({}, schema);
     delete merged.allOf;
-    for (const part of schema.allOf) {
+    const seen = new Set([schema]);
+    const queue = schema.allOf.slice();
+    while (queue.length) {
+      const part = queue.shift();
       const resolved = part && part.$ref ? resolveRef(part, defs) || part : part;
-      if (resolved && typeof resolved === 'object') Object.assign(merged, resolved, {
+      if (!resolved || typeof resolved !== 'object' || seen.has(resolved)) continue;
+      seen.add(resolved);
+      if (Array.isArray(resolved.allOf)) queue.push(...resolved.allOf);
+      Object.assign(merged, resolved, {
         properties: Object.assign({}, merged.properties, resolved.properties),
         required: [].concat(merged.required || [], resolved.required || []),
       });
+      delete merged.allOf;
+      if (resolved.$ref !== undefined && resolved !== part) delete merged.$ref;
     }
     if (!merged.properties) delete merged.properties;
     if (!merged.required || !merged.required.length) delete merged.required;
@@ -170,6 +199,10 @@ function describeSchema (schema, opts) {
   const defs = (schema && (schema.$defs || schema.definitions)) || null;
   const lines = [];
   describeNode(schema, name, 0, defs, lines);
+  if (lines.length >= MAX_LINES) {
+    lines.length = MAX_LINES;
+    lines.push(`(description cut at ${MAX_LINES} lines)`);
+  }
   return lines.join('\n');
 }
 

package/lib/diagnose.js

@@ -111,21 +111,53 @@ function frameFor (err, resolved) {
   // A caret on the key token when the error names a property, on the value
   // otherwise. Never wider than the line it is drawn under.
   const useKey = named != null && hit.keyOffset !== undefined;
-  const col = useKey ? hit.keyCol : hit.col;
-  const rawLen = useKey ? hit.keyLength : hit.length;
-  const lineLen = (hit.text || '').length;
-  const length = Math.max(1, Math.min(rawLen || 1, Math.max(1, lineLen - col + 1)));
+  return frameOf(hit, useKey ? hit : null, resolved.synthesized);
+}
 
+// The frame a renderer draws. `col` is the column in the line, for the
+// location; `textCol` is where the caret goes in `text`, which differs when
+// the line was long and `text` is the part of it around the value. Never
+// wider than the text it is drawn under.
+function frameOf (at, key, synthesized) {
+  const shift = typeof at.textCol === 'number' && (!key || key.keyLine === at.line) ? at.col - at.textCol : 0;
+  const col = key ? key.keyCol : at.col;
+  const textCol = Math.max(1, col - shift);
+  const rawLen = key ? key.keyLength : at.length;
+  const lineLen = termLine(at.text || '').length;
+  const length = Math.max(1, Math.min(rawLen || 1, Math.max(1, lineLen - textCol + 1)));
   return {
-    line: useKey ? hit.keyLine : hit.line,
+    line: key ? key.keyLine : at.line,
     col,
+    textCol,
     length,
-    text: hit.text,
+    text: termLine(at.text),
     spans: rawLen > length,
-    synthesized: resolved.synthesized,
+    synthesized,
   };
 }
 
+// Text from a document or a schema on its way to a terminal: control
+// characters, DEL, the C1 range and the Unicode line separators written as
+// escapes, so a property name cannot start a line, move the cursor or set a
+// colour.
+const TERM_UNSAFE = /[\x00-\x1f\x7f-\x9f\u2028\u2029]/g;
+function term (s) {
+  if (typeof s !== 'string') return s;
+  return s.replace(TERM_UNSAFE, (c) => {
+    if (c === '\n') return '\\n';
+    if (c === '\r') return '\\r';
+    if (c === '\t') return '\\t';
+    return '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0');
+  });
+}
+// A source line drawn above a caret: one character for one, a space for a
+// tab or a carriage return and U+FFFD for the rest, so the caret stays under
+// the value.
+function termLine (s) {
+  if (typeof s !== 'string') return s;
+  return s.replace(TERM_UNSAFE, (c) => (c === '\t' || c === '\r' ? ' ' : '\ufffd'));
+}
+
 // No position map in hand, but the error itself may carry one: validateJSON
 // attaches `dataFrame` and `anchor` at enrichment time, and errors handed
 // over from another process or a fixture arrive with only those.
@@ -135,18 +167,7 @@ function frameFromError (err) {
   const a = err.anchor;
   const named = (err.params && (err.params.additionalProperty || err.params.unevaluatedProperty)) || null;
   const useKey = named != null && a && a.keyLine !== undefined;
-  const col = useKey ? a.keyCol : df.col;
-  const rawLen = useKey ? a.keyLength : df.length;
-  const lineLen = (df.text || '').length;
-  const length = Math.max(1, Math.min(rawLen || 1, Math.max(1, lineLen - col + 1)));
-  return {
-    line: useKey ? a.keyLine : df.line,
-    col,
-    length,
-    text: df.text,
-    spans: rawLen > length,
-    synthesized: false,
-  };
+  return frameOf(df, useKey ? a : null, false);
 }
 
 function headlineFor (err, src) {
@@ -210,6 +231,7 @@ function decorateBranches (subs, src) {
       const got = valueAt(src.data, sub.instancePath);
       if (got !== null) copy.received = got;
     }
+    for (const k of ['keyword', 'message', 'expected', 'received']) if (typeof copy[k] === 'string') copy[k] = term(copy[k]);
     if (Array.isArray(sub.branchErrors)) copy.branchErrors = decorateBranches(sub.branchErrors, src);
     return copy;
   });
@@ -262,13 +284,13 @@ function singleDiagnostic (e, index, resolved, src) {
 
   return {
     code: e.code,
-    headline: headlineFor(e, src),
+    headline: term(headlineFor(e, src)),
     pointer,
-    dotted: pathToDotted(anchorErr.instancePath != null ? anchorErr.instancePath : pointer),
+    dotted: term(pathToDotted(anchorErr.instancePath != null ? anchorErr.instancePath : pointer)),
     frame,
-    found,
-    help: e.suggestion ? e.suggestion.text : null,
-    notes,
+    found: term(found),
+    help: e.suggestion ? term(e.suggestion.text) : null,
+    notes: notes.map(term),
     branchErrors: e.branchErrors ? decorateBranches(e.branchErrors, src) : null,
     mergedFrom: [e],
     rank: typeof e.rank === 'number' ? e.rank : 2,
@@ -295,13 +317,13 @@ function mergedDiagnostic (errors, i, j, resolved, src) {
   const pointer = missing.instancePath != null ? missing.instancePath : (missing.path || '');
   return {
     code: missing.code,
-    headline: `unknown property "${extraName}"`,
+    headline: term(`unknown property "${extraName}"`),
     pointer,
-    dotted: pathToDotted(pointer),
+    dotted: term(pathToDotted(pointer)),
     frame,
     found: null,
-    help: `did you mean "${missingName}"?`,
-    notes,
+    help: term(`did you mean "${missingName}"?`),
+    notes: notes.map(term),
     branchErrors: null,
     mergedFrom: [missing, extra],
     rank: 0,
@@ -309,4 +331,4 @@ function mergedDiagnostic (errors, i, j, resolved, src) {
   };
 }
 
-module.exports = { toDiagnostics };
+module.exports = { term, termLine, toDiagnostics };

package/lib/enrich-error.js

@@ -87,6 +87,15 @@ function reprValue (v) {
     // fallback prints, so it is taken once either way; the walk and the
     // serialisation used to run on every container an error named, and a
     // `required` or `unevaluatedProperties` error names its container.
+    // A wide object is counted once per synchronous run: every error that
+    // names the same container (additionalProperties: false on an object
+    // with N unknown keys gives N of them) counted its keys again, N times N
+    // key reads, and 16000 extra keys took 11.8 s to read. The answer is
+    // kept until the running synchronous code finishes (a microtask drops
+    // it), which covers reading one list. The limit: an object changed and
+    // read again within that same run reports the count it had first.
+    const known = _wide !== null ? _wide.get(v) : undefined;
+    if (known !== undefined) return known;
     let n;
     try {
       n = Object.keys(v).length;
@@ -101,10 +110,21 @@ function reprValue (v) {
         return '[object, unserializable]';
       }
     }
-    return `[object, ${n} ${n === 1 ? 'key' : 'keys'}]`;
+    const r = `[object, ${n} ${n === 1 ? 'key' : 'keys'}]`;
+    if (n > WIDE) {
+      if (_wide === null) {
+        _wide = new Map();
+        queueMicrotask(() => { _wide = null; });
+      }
+      _wide.set(v, r);
+    }
+    return r;
   }
   return `[${t}]`;
 }
+// Past this many keys a count is worth keeping (see reprValue).
+const WIDE = 64;
+let _wide = null;
 
 function expectedFor (err) {
   switch (err.keyword) {
@@ -298,6 +318,7 @@ function enrich (rawErr, opts) {
   if (positions && positions[path]) {
     const p = positions[path];
     out.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+    if (p.textCol !== undefined) out.dataFrame.textCol = p.textCol;
   } else if (!positions && opts && opts.lazyPositions) {
     defineLazyFrames(out, path, named, opts.lazyPositions);
   }
@@ -360,6 +381,7 @@ function defineLazyFrames (out, path, named, lazy) {
     const positions = lazy();
     const own = positions ? positions[path] : null;
     const dataFrame = own ? { byteOffset: own.byteOffset, length: own.length, line: own.line, col: own.col, text: own.text } : undefined;
+    if (dataFrame !== undefined && own.textCol !== undefined) dataFrame.textCol = own.textCol;
     const child = positions && named ? positions[(path === '' ? '' : path) + '/' + named] : null;
     const src = child || own;
     let anchor;

package/lib/error-sort-rank.js

@@ -46,6 +46,18 @@ function sortErrorsByRank(rootSchema, errors) {
     prev = r;
   }
   if (sorted) return errors;
+  // Insertion sort is quadratic: a document with 20000 unknown keys under
+  // additionalProperties: false, reported out of order, took seconds here.
+  // Past a short list the platform's sort, which is stable, gives the same
+  // order, ties kept as they came.
+  if (n > 16) {
+    const idx = new Array(n);
+    for (let i = 0; i < n; i++) idx[i] = i;
+    idx.sort((a, b) => compareRanks(keys[a], keys[b]) || a - b);
+    const res = new Array(n);
+    for (let i = 0; i < n; i++) res[i] = errors[idx[i]];
+    return res;
+  }
   const res = errors.slice();
   for (let i = 1; i < n; i++) {
     const k = keys[i];

package/lib/formats-source.js

@@ -111,6 +111,17 @@ function hostnameSource (v, isStr) {
   return guard(v, isStr, hostnameRangeSource(v, '0', `${v}.length`));
 }
 
+// The hoisted form: two tables built once per compiled function, a character
+// class (1 hex digit, 2 hyphen) and the class each of the 36 positions wants,
+// and a loop that ORs the mismatches instead of branching on every character.
+// On the 900 ids of the order body: 85 to 35 ns against the per-run loops below.
+const uuidHelperSource = (name) =>
+  `const ${name}H=new Uint8Array(128),${name}M=new Uint8Array(36).fill(1);` +
+  `for(let _i=48;_i<58;_i++)${name}H[_i]=1;for(let _i=97;_i<103;_i++)${name}H[_i]=1;for(let _i=65;_i<71;_i++)${name}H[_i]=1;` +
+  `${name}H[45]=2;${name}M[8]=${name}M[13]=${name}M[18]=${name}M[23]=2;` +
+  `function ${name}(_s){if(_s.length!==36)return false;let _b=0;for(let _i=0;_i<36;_i++)_b|=${name}H[_s.charCodeAt(_i)]^${name}M[_i];return _b===0}`
+
+// The inline form, for a caller with no function to hoist into.
 function uuidSource (v, isStr) {
   const run = (from, to) => `for(let _ui=${from};_ui<${to};_ui++){const _uc=${v}.charCodeAt(_ui);` +
     'if(!((_uc-48>>>0)<10||((_uc|32)-97>>>0)<6))return false}';
@@ -321,4 +332,4 @@ function durationSource (v, isStr) {
   const inner = `if(!${_formats().DURATION_RE.toString()}.test(${v}))return false`;
   return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
 }
-module.exports = { _literalByParsers, uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };
+module.exports = { _literalByParsers, uriHelperSource, uriHelperCompactSource, uriSource, uriReferenceSource, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uuidSource, uuidHelperSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/formats.js

@@ -4,9 +4,8 @@
 // and no allocation. Each has a twin that emits the same check as source for
 // the code generator; tests/test_formats_single_pass.js holds the two
 // together and fuzzes both against the regular-expression forms they replaced.
-// Measured, interleaved medians: date 45.7 to 14.2 ns, ipv4 54.5 to 27.1 ns.
-// uuid was tried the same way and measured 57.3 against 59.4 ns: V8's regular
-// expression for a fixed-length hex pattern is already that fast, so it stays.
+// Measured, interleaved medians: date 45.7 to 14.2 ns, ipv4 54.5 to 27.1 ns,
+// uuid 85 to 35 ns with the class tables below.
 
 function isDigit (c) { return c >= 48 && c <= 57; }
 
@@ -328,25 +327,26 @@ function noReserved (s, from) {
   return true;
 }
 
-// 8-4-4-4-12 hexadecimal digits. The four hyphens are read by index, then
-// each run of hex digits is read with fixed bounds, so no character pays for a
-// test of where it sits. A digit is one unsigned compare and a letter is one
-// more after folding case with a single OR, which is what a case-insensitive
-// regex spends a state machine on.
-function hexRun (s, from, to) {
-  for (let i = from; i < to; i++) {
-    const c = s.charCodeAt(i);
-    if (!((c - 48 >>> 0) < 10 || ((c | 32) - 97 >>> 0) < 6)) return false;
-  }
-  return true;
-}
+// 8-4-4-4-12 hexadecimal digits. Two tables: the class of a character (1 a
+// hex digit in either case, 2 a hyphen, 0 anything else, including anything
+// past ASCII, which indexes past the table and reads as undefined) and the
+// class each of the 36 positions wants. The loop ORs the mismatches and
+// decides once at the end, so no character costs a branch: 85 to 35 ns on
+// the order body's ids against the earlier per-run loops with two compares a
+// character.
+const UUID_CLASS = new Uint8Array(128);
+for (let i = 48; i < 58; i++) UUID_CLASS[i] = 1;
+for (let i = 97; i < 103; i++) UUID_CLASS[i] = 1;
+for (let i = 65; i < 71; i++) UUID_CLASS[i] = 1;
+UUID_CLASS[45] = 2;
+const UUID_WANT = new Uint8Array(36).fill(1);
+UUID_WANT[8] = UUID_WANT[13] = UUID_WANT[18] = UUID_WANT[23] = 2;
 
 function uuid (s) {
   if (s.length !== 36) return false;
-  if (s.charCodeAt(8) !== 45 || s.charCodeAt(13) !== 45 ||
-    s.charCodeAt(18) !== 45 || s.charCodeAt(23) !== 45) return false;
-  return hexRun(s, 0, 8) && hexRun(s, 9, 13) && hexRun(s, 14, 18) &&
-    hexRun(s, 19, 23) && hexRun(s, 24, 36);
+  let bad = 0;
+  for (let i = 0; i < 36; i++) bad |= UUID_CLASS[s.charCodeAt(i)] ^ UUID_WANT[i];
+  return bad === 0;
 }
 
 // RFC 3339 full-time: HH:MM:SS, an optional fraction, an optional offset.

package/lib/interpreter-core.js

@@ -429,9 +429,15 @@ class Plan {
     this.format = schema.format;
     this.formatFn = null;
     if (schema.format !== undefined) {
+      // Own properties only, as the generated code reads them: an inherited
+      // Object member ('hasOwnProperty', 'constructor') is not a check.
+      const own = Object.prototype.hasOwnProperty;
       const uf = interp.userFormats;
-      const fc = (uf && typeof uf[schema.format] === 'function') ? uf[schema.format] : require('./formats').formatChecks()[schema.format];
-      this.formatFn = fc || null;
+      const f = schema.format;
+      const table = require('./formats').formatChecks();
+      const fc = (uf && typeof f === 'string' && own.call(uf, f) && typeof uf[f] === 'function') ? uf[f]
+        : (typeof f === 'string' && own.call(table, f) && typeof table[f] === 'function' ? table[f] : null);
+      this.formatFn = fc;
     }
     this.hasString = this.minLength !== undefined || this.maxLength !== undefined || this.pattern !== null || this.formatFn !== null;
     // A format compat registered for numbers (`type: 'number'`), checked on
@@ -917,14 +923,27 @@ class Interpreter {
     if (!re) {
       if (/\\[pP]\{/.test(src)) {
         // Unicode property escapes need a real RegExp in unicode mode; the
-        // linear engine does not understand them.
+        // linear engine does not understand them (compileSafe refuses them),
+        // so the RegExp answers whether or not it runs this pattern in linear
+        // time. Asking lib/regex-linear.js would change no answer and would
+        // add it to lite. A nested loop around a property escape can
+        // backtrack here; SECURITY.md says so.
         try { re = new RegExp(src, 'u'); } catch { re = new RegExp(src); }
       } else if (plainLinear(src)) {
         re = new RegExp(src);
       } else {
         try {
           re = compileSafe(src);
-        } catch {
+        } catch (e) {
+          // A parse failure means the engine cannot represent the pattern
+          // (a backreference, a lookaround, an escape it does not implement,
+          // a repeat past its instruction budget) and the platform RegExp
+          // takes it.
+          // The stub of a shared error runtime built without the engine
+          // (lib/error-runtime.js) throws too, and that one is rethrown: a
+          // module whose runtime lacks the engine must fail, not quietly
+          // match on a RegExp that can backtrack.
+          if (e && typeof e.message === 'string' && e.message.includes('built without the pattern engine')) throw e;
           try { re = new RegExp(src, 'u'); } catch { re = new RegExp(src); }
         }
       }