ata-validator 1.61.2 → 1.62.0

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); }
         }
       }