ata-validator 1.43.0 → 1.45.0

package/lib/levenshtein.js

@@ -1,7 +1,14 @@
 'use strict';
 
-// Bounded Levenshtein. Returns Infinity if distance > maxDistance.
-// Single-row DP. O(n*m) worst case but typical strings are <30 chars.
+// Bounded Levenshtein. Returns Infinity if distance > maxDistance (or, past
+// the bound, possibly some number greater than it; callers compare).
+//
+// 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
 // and the library is single-threaded, so nothing else is using them; growing
 // them once beats allocating two arrays on every comparison, which the
@@ -10,42 +17,47 @@ let scratchA = new Int32Array(64);
 let scratchB = new Int32Array(64);
 
 function levenshtein (a, b, maxDistance) {
-  const max = maxDistance == null ? Infinity : maxDistance;
   if (a === b) return 0;
-  if (Math.abs(a.length - b.length) > max) return Infinity;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  if (scratchA.length < b.length + 1) {
-    scratchA = new Int32Array(b.length + 1);
-    scratchB = new Int32Array(b.length + 1);
+  const n = a.length;
+  const m = b.length;
+  const max = maxDistance == null || maxDistance > n + m ? n + m : maxDistance;
+  if (Math.abs(n - m) > max) return Infinity;
+  if (n === 0) return m;
+  if (m === 0) return n;
+  const big = max + 1;
+  if (scratchA.length < m + 2) {
+    scratchA = new Int32Array(m + 2);
+    scratchB = new Int32Array(m + 2);
   }
   let prev = scratchA;
   let curr = scratchB;
-  const bn = b.length;
-  for (let j = 0; j <= bn; j++) prev[j] = j;
-  for (let i = 1; i <= a.length; i++) {
-    curr[0] = i;
-    let rowMin = i;
+  for (let j = 0; j <= m; j++) prev[j] = j <= max ? j : big;
+  for (let i = 1; i <= n; i++) {
+    const lo = i - max > 1 ? i - max : 1;
+    const hi = i + max < m ? i + max : m;
+    curr[lo - 1] = lo === 1 ? i : big;
+    let rowMin = curr[lo - 1];
     // 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);
-    for (let j = 1; j <= bn; j++) {
-      const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
-      let m = prev[j - 1] + cost;
+    for (let j = lo; j <= hi; j++) {
+      let v = prev[j - 1] + (ca === b.charCodeAt(j - 1) ? 0 : 1);
       const del = curr[j - 1] + 1;
-      if (del < m) m = del;
+      if (del < v) v = del;
       const ins = prev[j] + 1;
-      if (ins < m) m = ins;
-      curr[j] = m;
-      if (m < rowMin) rowMin = m;
+      if (ins < v) v = ins;
+      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;
     prev = curr;
     curr = t;
   }
-  return prev[bn];
+  return prev[m] > max ? Infinity : prev[m];
 }
 
 module.exports = { levenshtein };

package/lib/native-positions.js

@@ -0,0 +1,100 @@
+'use strict';
+
+// The entries buildTargetedPositionMap gives, found by the native addon where
+// it can: simdjson indexes the document's structure once and walks that
+// index to each pointer, where the script walk reads every character. On a
+// 5 MB log with the error near its end that is 3.1 ms against 8.3. Only for
+// a large ASCII string, where the addon's UTF-8 byte offsets are the string's
+// indexes, and only when every wanted pointer is found; otherwise null, and
+// the caller builds the map in script as before.
+const NATIVE_MIN = 32 * 1024;
+let _native;
+function nativeTargeted (text, wanted) {
+  if (typeof text !== 'string' || text.length < NATIVE_MIN) return null;
+  if (_native === undefined) {
+    try { _native = require('./native-load')(); } catch { _native = null; }
+    if (_native && typeof _native.locatePointers !== 'function') _native = null;
+  }
+  if (_native === null || typeof Buffer === 'undefined' || Buffer.byteLength(text, 'utf8') !== text.length) return null;
+  const ptrs = Array.from(wanted);
+  let found;
+  try { found = _native.locatePointers(text, ptrs); } catch { return null; }
+  const offs = [];
+  for (let k = 0; k < ptrs.length; k++) {
+    if (!(found[2 * k] >= 0)) return null;
+    offs.push(found[2 * k]);
+  }
+  // Line starts for the offsets that are asked about, in one forward pass.
+  const needed = [];
+  for (let k = 0; k < ptrs.length; k++) {
+    needed.push(offs[k]);
+    const ks = keyStartBefore(text, offs[k]);
+    if (ks >= 0) needed.push(ks);
+  }
+  const lineOf = lineFinder(text, needed);
+  const map = Object.create(null);
+  for (let k = 0; k < ptrs.length; k++) {
+    const off = offs[k];
+    const at = lineOf(off);
+    const entry = { byteOffset: off, length: found[2 * k + 1], line: at.line, col: off - at.start + 1, text: at.text };
+    const ks = keyStartBefore(text, off);
+    if (ks >= 0 && ptrs[k] !== '') {
+      const kat = lineOf(ks);
+      entry.keyOffset = ks;
+      entry.keyLength = keyEndAfter(text, ks) - ks + 1;
+      entry.keyLine = kat.line;
+      entry.keyCol = ks - kat.start + 1;
+    }
+    map[ptrs[k]] = entry;
+  }
+  return map;
+}
+
+// The opening quote of the member name before a value at `off`, or -1 where
+// the value is an array element or the root.
+function keyStartBefore (text, off) {
+  let j = off - 1;
+  while (j >= 0) { const c = text.charCodeAt(j); if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) j--; else break; }
+  if (j < 0 || text.charCodeAt(j) !== 0x3a) return -1;
+  j--;
+  while (j >= 0) { const c = text.charCodeAt(j); if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) j--; else break; }
+  if (j < 0 || text.charCodeAt(j) !== 0x22) return -1;
+  // Back to the quote that opens the name: one not preceded by an odd run of
+  // backslashes.
+  for (let q = j - 1; q >= 0; q--) {
+    if (text.charCodeAt(q) !== 0x22) continue;
+    let b = q - 1;
+    while (b >= 0 && text.charCodeAt(b) === 0x5c) b--;
+    if (((q - 1 - b) & 1) === 0) return q;
+  }
+  return -1;
+}
+function keyEndAfter (text, start) {
+  let q = start + 1;
+  for (;;) {
+    const c = text.charCodeAt(q);
+    if (c === 0x5c) { q += 2; continue; }
+    if (c === 0x22 || q >= text.length) return q;
+    q++;
+  }
+}
+// Line number, line start and line text for any of `offsets`, from one pass.
+function lineFinder (text, offsets) {
+  const sorted = Array.from(new Set(offsets)).sort((a, b) => a - b);
+  const info = new Map();
+  let line = 1, start = 0, s = 0;
+  while (s < sorted.length) {
+    const nl = text.indexOf('\n', start);
+    const end = nl === -1 ? text.length : nl;
+    while (s < sorted.length && sorted[s] <= end) {
+      info.set(sorted[s], { line, start, text: text.slice(start, end) });
+      s++;
+    }
+    if (nl === -1) break;
+    line++;
+    start = nl + 1;
+  }
+  return (off) => info.get(off);
+}
+
+module.exports = { nativeTargeted };

package/lib/plan-compiler.js

@@ -52,12 +52,16 @@ const branchTitle = (n) => (n && n.schema && typeof n.schema.title === 'string'
 
 function install(deps) {
   const { Plan, NOERRORS, err, evalLeaf, evalLeafV, runCustomV, dataBits, escapePointer,
-          deepEqual, multipleOfOk, cpAtLeast, cpAtMost,
+          deepEqual, enumMember, allDistinct, multipleOfOk, cpAtLeast, cpAtMost,
           T_STRING, T_ARRAY, T_OBJECT, resolveRef, splitFragment, resolveUri } = deps;
 
   const TRUE_FN = () => true;
-  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN };
+  // `leaf`: the node compiled no subschema of its own (see compileNode). A
+  // collecting caller asks a leaf for its verdict first and builds the paths
+  // for its errors only when it fails.
+  const TRUE_PAIR = { v: TRUE_FN, c: TRUE_FN, leaf: true };
   const FALSE_PAIR = {
+    leaf: true,
     v: () => false,
     c: (data, errors, instancePath, schemaPath) => {
       if (errors !== NOERRORS) errors.push(err('false schema', 'not', instancePath, schemaPath, {}, 'boolean schema is false'));
@@ -164,12 +168,8 @@ function install(deps) {
       checks.push((data, bits) => (bits & mask) !== 0);
     }
     if (P.enum !== null) {
-      const vals = P.enum;
-      if (vals.length === 0) checks.push(() => false);
-      else checks.push((data) => {
-        for (let i = 0; i < vals.length; i++) if (deepEqual(vals[i], data)) return true;
-        return false;
-      });
+      if (P.enum.length === 0) checks.push(() => false);
+      else checks.push((data) => enumMember(P, data));
     }
     if (P.hasConst) {
       const c = P.const;
@@ -205,14 +205,7 @@ function install(deps) {
       const arrs = [];
       if (P.minItems !== undefined) { const m = P.minItems; arrs.push((d) => d.length >= m); }
       if (P.maxItems !== undefined) { const m = P.maxItems; arrs.push((d) => d.length <= m); }
-      if (P.uniqueItems) {
-        arrs.push((d) => {
-          for (let i = 0; i < d.length; i++) {
-            for (let j = i + 1; j < d.length; j++) if (deepEqual(d[i], d[j])) return false;
-          }
-          return true;
-        });
-      }
+      if (P.uniqueItems) arrs.push(allDistinct);
       const run = combineValue(arrs);
       if (run !== null) { needsBits = true; checks.push((data, bits) => bits !== T_ARRAY || run(data)); }
     }
@@ -300,6 +293,7 @@ function install(deps) {
     const box = { v: null, c: null };
     const pair = {
       open: true,
+      leaf: false,
       v: (d, st, rec) => box.v(d, st, rec),
       c: (d, e, ip, sp, st, rec) => box.c(d, e, ip, sp, st, rec),
     };
@@ -308,8 +302,11 @@ function install(deps) {
     // In-place children collect when this node does; child applicators
     // never do. `rec` is threaded as the trailing argument of every step
     // and is undefined on non-collecting nodes, where nothing reads it.
-    const inPlace = (n, b) => compileNode(ctx, n, b, chain, collect);
-    const child = (n) => compileNode(ctx, n, base, chain, false);
+    // Whether this node compiles any subschema: a node that does not is a
+    // leaf, whose verdict is a few comparisons.
+    let nested = false;
+    const inPlace = (n, b) => { nested = true; return compileNode(ctx, n, b, chain, collect); };
+    const child = (n) => { nested = true; return compileNode(ctx, n, base, chain, false); };
 
     const steps = [];   // collect variant: (data, errors, ip, sp, stack, rec)
     const vsteps = [];  // verdict variant: (data, stack, rec)
@@ -399,7 +396,7 @@ function install(deps) {
         let ok = true;
         const n = Math.min(fns.length, data.length);
         for (let i = 0; i < n; i++) {
-          if (!fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack)) {
+          if (!((fns[i].leaf && fns[i].v(data[i], stack)) || fns[i].c(data[i], errors, instancePath + '/' + i, schemaPath + '/prefixItems/' + i, stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -422,7 +419,7 @@ function install(deps) {
         if (dataBits(data) !== T_ARRAY) return true;
         let ok = true;
         for (let i = start; i < data.length; i++) {
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/items', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -536,7 +533,7 @@ function install(deps) {
           let evaluated = false;
           const prop = lookup !== null ? lookup(key) : undefined;
           if (prop !== undefined) {
-            if (!prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack)) {
+            if (!((prop.fn.leaf && prop.fn.v(data[key], stack)) || prop.fn.c(data[key], errors, instancePath + prop.seg, schemaPath + prop.schemaSeg, stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -546,7 +543,7 @@ function install(deps) {
             for (let pi = 0; pi < patterns.length; pi++) {
               const pp = patterns[pi];
               if (pp.re.test(key)) {
-                if (!pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack)) {
+                if (!((pp.fn.leaf && pp.fn.v(data[key], stack)) || pp.fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/patternProperties/' + escapePointer(pp.src), stack))) {
                   ok = false;
                   if (errors === NOERRORS) return false;
                 }
@@ -559,7 +556,7 @@ function install(deps) {
               ok = false;
               if (errors === NOERRORS) return false;
               errors.push(err('additionalProperties', 'additionalProperties', instancePath, schemaPath + '/additionalProperties', { additionalProperty: key }, 'must NOT have additional properties'));
-            } else if (!apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack)) {
+            } else if (!((apFn.leaf && apFn.v(data[key], stack)) || apFn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/additionalProperties', stack))) {
               ok = false;
               if (errors === NOERRORS) return false;
             }
@@ -927,7 +924,7 @@ function install(deps) {
         for (let k = 0; k < keys.length; k++) {
           const key = keys[k];
           if (hasProp(rec, key)) continue;
-          if (!fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack)) {
+          if (!((fn.leaf && fn.v(data[key], stack)) || fn.c(data[key], errors, instancePath + '/' + escapePointer(key), schemaPath + '/unevaluatedProperties', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -983,7 +980,7 @@ function install(deps) {
         let ok = true;
         for (let i = 0; i < data.length; i++) {
           if (hasItem(rec, i)) continue;
-          if (!fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack)) {
+          if (!((fn.leaf && fn.v(data[i], stack)) || fn.c(data[i], errors, instancePath + '/' + i, schemaPath + '/unevaluatedItems', stack))) {
             ok = false;
             if (errors === NOERRORS) return false;
           }
@@ -1068,6 +1065,7 @@ function install(deps) {
     box.v = vfn;
     pair.c = cfn;
     pair.v = vfn;
+    pair.leaf = !nested;
     pair.open = false;
     return pair;
   }

package/lib/rejections.js

@@ -133,13 +133,18 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
 // touches none of it. The JSON text is held here rather than read back off the
 // validator, so the result does not depend on what the instance does next.
 class LazyJsonRejection {
-  constructor(result, jsonStr, self, enrich) {
+  // `parsed`, when given, is the document the inner path parsed from
+  // `jsonStr` and validated, after defaults, coercion and removal: reading the
+  // errors uses it instead of parsing the text again, which on a 5 MB
+  // document was a third of what reading them cost.
+  constructor(result, jsonStr, self, enrich, parsed) {
     this.valid = false;
     this._result = result;
     this._jsonStr = jsonStr;
     this._self = self;
     this._enrich = enrich;
     this._cached = null;
+    this._parsed = parsed;
   }
   toJSON() {
     return { valid: false, errors: this.errors };
@@ -159,12 +164,14 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
 
     // The enrich pass plucks `received` from the value tree and the suggestion
     // engine (required-typo, format hints, coercion nudges) walks it too.
-    let parsedData;
-    try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-    // What was checked is the document after defaults, coercion and removal,
-    // so `received` has to come from that, as it does for validate(). A
-    // default that failed its own schema has no value in the text at all.
-    if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    let parsedData = this._parsed;
+    if (parsedData === undefined) {
+      try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
+      // What was checked is the document after defaults, coercion and removal,
+      // so `received` has to come from that, as it does for validate(). A
+      // default that failed its own schema has no value in the text at all.
+      if (parsedData !== undefined && self._preprocess) self._preprocess(parsedData);
+    }
 
     // Errors the inner path already enriched carry a `received` key: enrich()
     // always sets one, even when there is no value to show. `code` is not a

package/lib/suggestions.js

@@ -29,22 +29,35 @@ const FORMAT_HINTS = {
   ipv4: (val) => typeof val === 'string' ? 'expected four 0-255 octets separated by dots' : null,
 };
 
-function suggestEnumTypo (received, enumValues) {
-  if (typeof received !== 'string') return null;
-  if (!Array.isArray(enumValues) || enumValues.length === 0 || enumValues.length > 30) return null;
+// Edits that still read as a typo of a name this long. With a flat two, a
+// missing `name` was "corrected" to `age`, and `c` to `a`.
+function typoBudget (name) {
+  const n = name.length;
+  return n < 3 ? 0 : n < 5 ? 1 : 2;
+}
+
+// The one string candidate nearest `target` within the budget, or null when
+// none is near enough or two are equally near.
+function nearest (target, candidates) {
+  const budget = typoBudget(target);
   let best = null;
-  let bestDist = Infinity;
+  let bestDist = budget + 1;
   let tied = false;
-  for (const v of enumValues) {
-    if (typeof v !== 'string') continue;
-    const d = levenshtein(received, v, 2);
-    if (d < bestDist) { best = v; bestDist = d; tied = false; }
+  for (const c of candidates) {
+    if (typeof c !== 'string') continue;
+    const d = levenshtein(target, c, budget);
+    if (d === 0 || d > budget) continue;
+    if (d < bestDist) { best = c; bestDist = d; tied = false; }
     else if (d === bestDist) tied = true;
   }
-  if (best && bestDist <= 2 && !tied) {
-    return { text: `did you mean \`${best}\`?`, kind: 'typo' };
-  }
-  return null;
+  return tied ? null : best;
+}
+
+function suggestEnumTypo (received, enumValues) {
+  if (typeof received !== 'string') return null;
+  if (!Array.isArray(enumValues) || enumValues.length === 0 || enumValues.length > 30) return null;
+  const best = nearest(received, enumValues);
+  return best === null ? null : { text: `did you mean \`${best}\`?`, kind: 'typo' };
 }
 
 // The widest container a typo hint is offered on. `suggestEnumTypo` caps its
@@ -56,14 +69,8 @@ const MAX_TYPO_CANDIDATES = 64;
 function suggestRequiredTypo (missing, presentKeys) {
   if (!missing || !Array.isArray(presentKeys)) return null;
   if (presentKeys.length > MAX_TYPO_CANDIDATES) return null;
-  for (const k of presentKeys) {
-    if (typeof k !== 'string') continue;
-    const d = levenshtein(missing, k, 2);
-    if (d <= 2 && d > 0) {
-      return { text: `did you mean \`${missing}\` instead of \`${k}\`?`, kind: 'similar-key' };
-    }
-  }
-  return null;
+  const best = nearest(missing, presentKeys);
+  return best === null ? null : { text: `did you mean \`${missing}\` instead of \`${best}\`?`, kind: 'similar-key' };
 }
 
 function suggestFormat (format, raw) {

package/lib/unique-items.js

@@ -0,0 +1,139 @@
+'use strict';
+
+// uniqueItems for every engine. These are real functions: the interpreted
+// engine calls them, and the code generator emits their source text
+// (`String(fn)`) into the function it builds, so both run the same code.
+// They read only each other, `_deq` and `_uqpI`, which the generator emits
+// beside them.
+//
+// Short arrays compare pairwise and allocate nothing. Longer arrays of
+// primitives key a Set or Map by the value itself. Longer arrays that hold an
+// object key a Map by a numeric structural hash, and only items whose hashes
+// collide are compared with `_deq`. Equal values always hash alike: numbers
+// by value (so 1 and 1.0, 0 and -0 agree), strings by their characters,
+// arrays by position, and objects by the sum of their own key-value hashes,
+// whatever the key order. The hash replaced a sorted-key canonical string
+// built for every item on every call, which was over a quarter of the time a
+// generated verdict spent on SchemaStore's sample documents.
+
+// JSON equality, the same function the generator hoists as DEQ_HELPER.
+function _deq(a, b) {
+  if (a === b) return true;
+  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;
+  if (aa) {
+    if (a.length !== b.length) return false;
+    for (i = 0; i < a.length; i++) 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;
+  }
+  return true;
+}
+
+function _uqh(x) {
+  if (x === null) return 1;
+  var t = typeof x, h, i;
+  if (t === 'boolean') return x ? 2 : 3;
+  if (t === 'number') {
+    if (x === 0) return 4;
+    h = x | 0;
+    return Math.imul(h ^ (((x - h) * 1e9) | 0), 0x9e3779b1) ^ 5;
+  }
+  if (t === 'string') {
+    h = 0x811c9dc5 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ x.charCodeAt(i), 16777619);
+    return h;
+  }
+  if (t !== 'object') return 6;
+  if (Array.isArray(x)) {
+    h = 0x2545f491 ^ x.length;
+    for (i = 0; i < x.length; i++) h = Math.imul(h ^ _uqh(x[i]), 16777619);
+    return h;
+  }
+  var ks = Object.keys(x);
+  h = 0x6c8e9cf5 ^ ks.length;
+  for (i = 0; i < ks.length; i++) h = (h + Math.imul(_uqh(ks[i]) ^ Math.imul(_uqh(x[ks[i]]), 0x5bd1e995), 0x27d4eb2d)) | 0;
+  return h;
+}
+
+// Whether every item is distinct.
+function _uq(a) {
+  var n = a.length, i, k;
+  if (n < 2) return true;
+  if (n <= 12) {
+    for (i = 1; i < n; i++) for (k = 0; k < i; k++) if (_deq(a[i], a[k])) return false;
+    return true;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  if (prim) {
+    var s = new Set();
+    for (i = 0; i < n; i++) { if (s.has(a[i])) return false; s.add(a[i]); }
+    return true;
+  }
+  var m = new Map();
+  for (i = 0; i < n; i++) {
+    var hh = _uqh(a[i]), b = m.get(hh);
+    if (b === undefined) m.set(hh, i);
+    else if (typeof b === 'number') { if (_deq(a[b], a[i])) return false; m.set(hh, [b, i]); }
+    else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) return false; b.push(i); }
+  }
+  return true;
+}
+
+// The duplicate pair an error reports: the first item that has a later
+// equal, and its first later equal. Returns that later index and leaves the
+// first in _uqpI, or returns -1 when every item is distinct.
+var _uqpI = 0;
+function _uqp(a) {
+  var n = a.length, i, k;
+  if (n < 2) return -1;
+  if (n <= 12) {
+    for (i = 0; i < n - 1; i++) for (k = i + 1; k < n; k++) if (_deq(a[i], a[k])) { _uqpI = i; return k; }
+    return -1;
+  }
+  var prim = true;
+  for (i = 0; i < n; i++) { var x = a[i]; if (x !== null && typeof x === 'object') { prim = false; break; } }
+  var bi = -1, bj = -1, m = new Map();
+  if (prim) {
+    for (i = 0; i < n; i++) {
+      var p = m.get(a[i]);
+      if (p === undefined) m.set(a[i], i);
+      else if (p >= 0) { if (bi < 0 || p < bi) { bi = p; bj = i; } m.set(a[i], -1); }
+    }
+  } else {
+    // Each bucket holds the first occurrence of every distinct value that
+    // hashed there, in index order; a value is paired with its first later
+    // equal only once.
+    var paired = null;
+    for (i = 0; i < n; i++) {
+      var hh = _uqh(a[i]), b = m.get(hh), r = -1;
+      if (b === undefined) { m.set(hh, i); continue; }
+      if (typeof b === 'number') { if (_deq(a[b], a[i])) r = b; else m.set(hh, [b, i]); }
+      else { for (k = 0; k < b.length; k++) if (_deq(a[b[k]], a[i])) { r = b[k]; break; } if (r < 0) b.push(i); }
+      if (r >= 0) {
+        if (paired === null) paired = new Set();
+        if (!paired.has(r)) { paired.add(r); if (bi < 0 || r < bi) { bi = r; bj = i; } }
+      }
+    }
+  }
+  if (bi < 0) return -1;
+  _uqpI = bi;
+  return bj;
+}
+
+// For the interpreted engine.
+function allDistinct(a) { return _uq(a); }
+function duplicatePair(a) {
+  var j = _uqp(a);
+  return j < 0 ? null : [_uqpI, j];
+}
+
+module.exports = { allDistinct, duplicatePair, _deq, _uqh, _uq, _uqp };