ata-validator 1.62.0 → 1.63.0

package/lib/formats-source.js

@@ -96,14 +96,23 @@ function dateTimeSource (v, isStr) {
 // third parameter here would silently receive a context object and emit
 // `_st=[object Object]`. That declines the whole compile, which is how it was
 // found.
+// Membership in a set of ASCII characters as one shift: the 32-bit word for
+// c's quarter of the range is picked by comparison and `>>>` reads bit c&31.
+// Four numbers rather than a 128-entry table, so a module carries a few bytes,
+// and one test per character where a chain of comparisons ran up to twelve.
+// tests/test_format_char_masks.js checks every code point against the rule.
+const maskSource = (v, w) => `((${v}<64?${v}<32?${w[0]}:${w[1]}:${v}<96?${w[2]}:${v}<128?${w[3]}:0)>>>${v}&1)`;
+// A hostname label character: a letter, a digit or the hyphen.
+const HOST_CHAR_WORDS = [0, 67051520, 134217726, 134217726];
+const HOST_CHAR_SRC = (v) => maskSource(v, HOST_CHAR_WORDS);
+
 function hostnameRangeSource (v, st, en) {
-  return `const _st=${st},_en=${en},_n=_en-_st;if(_n===0||_n>253)return false;let _ll=0,_pv=46;` +
-    `for(let _i=_st;_i<_en;_i++){const _c=${v}.charCodeAt(_i);` +
-    `if(_c===46){if(_ll===0||_pv===45)return false;_ll=0;_pv=_c;continue}` +
-    `const _an=(_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90);` +
-    `if(!_an&&_c!==45)return false;` +
-    `if(_c===45&&_pv===46)return false;` +
-    `if(++_ll>63)return false;_pv=_c}` +
+  // An empty name never counts a label, so the `_ll===0` test at the end
+  // refuses it without a length test of its own.
+  return `if(${en}-(${st})>253)return false;let _ll=0,_pv=46;` +
+    `for(let _i=${st};_i<${en};_i++){const _c=${v}.charCodeAt(_i);` +
+    `if(_c===46){if(_ll===0||_pv===45)return false;_ll=0}` +
+    `else if(!${HOST_CHAR_SRC('_c')}||_c===45&&_pv===46||++_ll>63)return false;_pv=_c}` +
     `if(_ll===0||_pv===45)return false`;
 }
 
@@ -257,19 +266,14 @@ function uriTemplateSource (v, isStr) {
 // trailing or doubled dot is not a mailbox. Domain is a hostname or a bracketed
 // address literal.
 // Local-part characters: alphanumerics, the RFC 5322 atext punctuation, and
-// the dot that separates atoms. Written as code ranges rather than a regular
-// expression because this lands inside every emitted module that validates an
-// email, and the expression cost more bytes there than the whole check.
-// The emitted form keeps the comparison chain: a standalone module pays for the
-// bytes of a 128-entry table in every file that validates an email, and the
-// runtime pays for the chain on every call. Different budgets, same answers,
-// which `tests/test_format_engine_parity.js` holds.
-// Stated as the complement: of the printable range, only twelve characters are
-// not atext or the dot, so excluding them is 54 source bytes shorter than listing
-// what is allowed, and a standalone module carries this expression. Checked
-// against the allowed-list form over every code point from 0 to 65536 in
-// tests/test_formats_single_pass.js.
-const EMAIL_LOCAL_SRC = (v) => `(${v}>32&&${v}<127&&${v}!==34&&${v}!==40&&${v}!==41&&${v}!==44&&${v}!==58&&${v}!==59&&${v}!==60&&${v}!==62&&${v}!==64&&${v}!==91&&${v}!==92&&${v}!==93)`;
+// the dot that separates atoms, as a mask (maskSource above): every printable
+// character except the twelve that are neither atext nor the dot. It replaced a
+// chain of twelve comparisons, which was more bytes in every module that checks
+// an email and up to twelve tests per character. Checked against the allowed-list
+// form over every code point from 0 to 65536 in tests/test_format_char_masks.js,
+// and against the runtime's check by `tests/test_format_engine_parity.js`.
+const EMAIL_LOCAL_WORDS = [0, 2751458554, 3355443198, 2147483647];
+const EMAIL_LOCAL_SRC = (v) => maskSource(v, EMAIL_LOCAL_WORDS);
 // Emitted rather than bound as a closure: a standalone module embeds format
 // functions by their source text, so anything reaching a free variable would
 // not survive the trip. The domain half reuses hostnameSource, which keeps
@@ -295,31 +299,26 @@ function emailSource (v, isStr) {
     // character, so in an unquoted address the first one is the separator and the
     // local part is checked on the way to it. A quoted local part may contain
     // '@' and keeps the backward scan, which is the rare shape.
-    // The bounds tests are merged into one condition per branch, and there is no
-    // separate length check: an empty local part fails `_at<=0` and an empty
-    // domain fails `_at===_n0-1`, so a short string is already refused. This
-    // lands in every emitted module that validates an email, and 25 bytes of it
-    // put the CLI smoke build over its --max-size once.
-    `const _n0=${v}.length;let _at;` +
+    // Both shapes share their variables and one bounds test after the local
+    // part: an empty local part fails `_at<1`, an empty domain `_at===_n0-1`,
+    // and `_pd` holds the character before the '@' (46 when it is a dot, which
+    // a quoted part sets aside). This lands in every emitted module that
+    // validates an email, so its bytes are counted (tests/test_email_bytes.js).
+    `const _n0=${v}.length;let _at=-1,_qi,_qc,_pd=46;` +
     `if(${v}.charCodeAt(0)===34){` +
-      `_at=${v}.lastIndexOf('@');` +
-      `if(_at<2||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)!==34)return false;` +
-      `for(let _qi=1;_qi<_at-1;_qi++){const _qc=${v}.charCodeAt(_qi);` +
-      `if(_qc===92){const _qp=${v}.charCodeAt(_qi+1);if(_qp<32||_qp>126||_qi+1>=_at-1)return false;_qi++;continue}` +
-      `if(_qc<32||_qc>126||_qc===34)return false}` +
-    `}else{` +
-      `if(${v}.charCodeAt(0)===46)return false;` +
-      `_at=-1;let _pd=false;` +
-      `for(let _i=0;_i<_n0;_i++){const _lc=${v}.charCodeAt(_i);if(_lc===64){_at=_i;break}if(!${EMAIL_LOCAL_SRC('_lc')})return false;if(_lc===46){if(_pd)return false;_pd=true}else _pd=false}` +
-      `if(_at<=0||_at===_n0-1||_at>64||${v}.charCodeAt(_at-1)===46)return false` +
-    `}` +
+      `_at=${v}.lastIndexOf('@');if(_at<2||${v}.charCodeAt(_at-1)!==34)return false;` +
+      `for(_qi=1;_qi<_at-1;_qi++){_qc=${v}.charCodeAt(_qi);` +
+      `if(_qc===92){_qc=${v}.charCodeAt(++_qi);if(_qc<32||_qc>126||_qi>=_at-1)return false}` +
+      `else if(_qc<32||_qc>126||_qc===34)return false}_pd=0` +
+    `}else for(_qi=0;_qi<_n0;_qi++){_qc=${v}.charCodeAt(_qi);if(_qc===64){_at=_qi;break}` +
+      `if(_qc===46?_pd===46:!${EMAIL_LOCAL_SRC('_qc')})return false;_pd=_qc}` +
+    `if(_at<1||_at>64||_at===_n0-1||_pd===46)return false;` +
     // An address literal is rare enough to pay for its own slice inside the
     // branch that needs it; the hostname path, which is every real address,
     // reads the domain in place.
     `if(${v}.charCodeAt(_at+1)===91){` +
-      `const _dm=${v}.slice(_at+1);` +
-      `if(_dm.charCodeAt(_dm.length-1)!==93||_dm.length<=2)return false;` +
-      `const _in=_dm.slice(1,-1);` +
+      `if(${v}.charCodeAt(_n0-1)!==93||_n0-_at<4)return false;` +
+      `const _in=${v}.slice(_at+2,-1);` +
       // The literal is rare, and checked by expression rather than by the
       // IPv6 and IPv4 parsers, which made it 72% of this check's source:
       // the same answers (tests/test_ipv6_expression.js), a fraction of the bytes.

package/lib/interpreter-core.js

@@ -89,8 +89,6 @@ function indexSchemas(rootSchema, schemaMap, flat) {
   state.rootBase = rootBase;
   if (flat === true && !schemaMap && typeof rootSchema === 'object' && rootSchema !== null) {
     state.resources.set(rootBase, rootSchema);
-    state.anchors.set(rootBase, new Map());
-    state.dynamicAnchors.set(rootBase, new Map());
     state.nodeBase.set(rootSchema, rootBase);
     return state;
   }
@@ -107,11 +105,15 @@ function indexSchemas(rootSchema, schemaMap, flat) {
   return state;
 }
 
+function anchorMap(maps, baseUri) {
+  let m = maps.get(baseUri);
+  if (m === undefined) maps.set(baseUri, (m = new Map()));
+  return m;
+}
+
 function indexResource(node, baseUri, state) {
   if (typeof node !== 'object' || node === null) return;
   if (!state.resources.has(baseUri)) state.resources.set(baseUri, node);
-  if (!state.anchors.has(baseUri)) state.anchors.set(baseUri, new Map());
-  if (!state.dynamicAnchors.has(baseUri)) state.dynamicAnchors.set(baseUri, new Map());
   walkSchema(node, baseUri, state, true);
 }
 
@@ -128,11 +130,14 @@ function walkSchema(node, baseUri, state, isResourceRoot) {
     return;
   }
 
-  if (typeof node.$anchor === 'string') state.anchors.get(baseUri).set(node.$anchor, node);
+  // A resource's anchor maps are made at its first anchor: most schemas have
+  // none, and two empty maps per resource were a sixth of a small schema's
+  // interpreter. Every reader takes a missing map as no anchor.
+  if (typeof node.$anchor === 'string') anchorMap(state.anchors, baseUri).set(node.$anchor, node);
   if (typeof node.$dynamicAnchor === 'string') {
-    state.dynamicAnchors.get(baseUri).set(node.$dynamicAnchor, node);
+    anchorMap(state.dynamicAnchors, baseUri).set(node.$dynamicAnchor, node);
     // A $dynamicAnchor is also addressable as a plain anchor.
-    state.anchors.get(baseUri).set(node.$dynamicAnchor, node);
+    anchorMap(state.anchors, baseUri).set(node.$dynamicAnchor, node);
   }
 
   for (const kw of SCHEMA_KEYWORDS.single) {
@@ -847,7 +852,8 @@ class Interpreter {
     // 2020-12 requires bookending for `$dynamicRef`; v1 removes the
     // requirement. See the `$dynamicRef` branch in eval().
     this.bookending = !opts.v1;
-    this.patternCache = new Map();
+    // Made at the first pattern.
+    this.patternCache = null;
     // Plans are built on first visit; a schema node is never re-read after.
     this.plans = new Map();
     this.rootNode = this.node(rootSchema);
@@ -919,6 +925,7 @@ class Interpreter {
   }
 
   pattern(src) {
+    if (this.patternCache === null) this.patternCache = new Map();
     let re = this.patternCache.get(src);
     if (!re) {
       if (/\\[pP]\{/.test(src)) {
@@ -1549,7 +1556,8 @@ function planCompiler() {
 let installCompat = null;
 let compatInstalled = null;
 function setCompat(install) {
-  installCompat = install;
+  // esm.sh hands over a module of one function as { default: fn }.
+  installCompat = typeof install === 'function' ? install : install && install.default;
   compatInstalled = null;
 }
 function compatExt() {

package/lib/ir/emit-deps.mjs

@@ -0,0 +1,131 @@
+// Generated by scripts/gen-ir-emit-deps.js from lib/js-compiler.js and lib/suggestions.js. Do not edit.
+const FIXED_LITERAL = /[A-Za-z0-9 _\-:@#%&=,;'"<>!~`\/]/
+function compilePatternInline(pattern, varName) {
+  let m = pattern.match(/^\^(\[[\w\-]+\])\{(\d+)\}\$$/)
+  if (m) {
+    const len = parseInt(m[2])
+    if (len <= 16) {
+      const checks = []
+      for (let i = 0; i < len; i++) {
+        const ck = charClassToCheck(m[1], `${varName}.charCodeAt(${i})`)
+        if (!ck) return null
+        checks.push(ck)
+      }
+      return `${varName}.length===${len}&&${checks.join('&&')}`
+    }
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    return `${varName}.length===${len}&&(()=>{for(let _pi=0;_pi<${len};_pi++){if(!(${rangeCheck}))return false}return true})()`
+  }
+  m = pattern.match(/^\^(\[[\w\-]+\])\+\$$/)
+  if (m) {
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    return `${varName}.length>0&&(()=>{for(let _pi=0;_pi<${varName}.length;_pi++){if(!(${rangeCheck}))return false}return true})()`
+  }
+  m = pattern.match(/^\^(\[[\w\-]+\])\{(\d+),(\d+)\}\$$/)
+  if (m) {
+    const rangeCheck = charClassToCheck(m[1], `${varName}.charCodeAt(_pi)`)
+    if (!rangeCheck) return null
+    const min = parseInt(m[2]), max = parseInt(m[3])
+    return `${varName}.length>=${min}&&${varName}.length<=${max}&&(()=>{for(let _pi=0;_pi<${varName}.length;_pi++){if(!(${rangeCheck}))return false}return true})()`
+  }
+  return fixedSequenceInline(pattern, varName)
+}
+function fixedSequenceInline(pattern, varName) {
+  if (pattern.length < 3 || pattern[0] !== '^' || pattern[pattern.length - 1] !== '$' || pattern[pattern.length - 2] === '\\') return null
+  const end = pattern.length - 1
+  const pieces = []
+  let i = 1
+  while (i < end) {
+    let piece
+    const c = pattern[i]
+    if (c === '[') {
+      const j = pattern.indexOf(']', i)
+      if (j < 0 || j >= end) return null
+      const cls = pattern.slice(i, j + 1)
+      if (!/^\[[\w-]+\]$/.test(cls)) return null
+      piece = { cls }
+      i = j + 1
+    } else if (c === '\\') {
+      const e = pattern[i + 1]
+      if (e === 'd') piece = { cls: '[0-9]' }
+      else if (e !== undefined && './()[]{}+*?^$|\\'.includes(e)) piece = { lit: e }
+      else return null
+      i += 2
+    } else if (FIXED_LITERAL.test(c)) {
+      piece = { lit: c }
+      i += 1
+    } else {
+      return null
+    }
+    let count = 1
+    if (pattern[i] === '{') {
+      const q = /^\{(\d+)\}/.exec(pattern.slice(i))
+      if (!q) return null
+      count = Number(q[1])
+      if (!Number.isSafeInteger(count) || count > 32 - pieces.length) return null
+      i += q[0].length
+    } else if (i < end && '*+?'.includes(pattern[i])) {
+      return null
+    }
+    for (let k = 0; k < count; k++) pieces.push(piece)
+    if (pieces.length > 32) return null
+  }
+  if (pieces.length === 0) return null
+  const checks = []
+  for (let k = 0; k < pieces.length; k++) {
+    const at = `${varName}.charCodeAt(${k})`
+    if (pieces[k].lit !== undefined) checks.push(`${at}===${pieces[k].lit.charCodeAt(0)}`)
+    else {
+      const ck = charClassToCheck(pieces[k].cls, at)
+      if (!ck) return null
+      checks.push(`(${ck})`)
+    }
+  }
+  return `${varName}.length===${pieces.length}&&${checks.join('&&')}`
+}
+function charClassToCheck(charClass, codeExpr) {
+  const inner = charClass.slice(1, -1)
+  const ranges = []
+  let i = 0
+  while (i < inner.length) {
+    if (i + 2 < inner.length && inner[i + 1] === '-') {
+      ranges.push([inner.charCodeAt(i), inner.charCodeAt(i + 2)])
+      i += 3
+    } else {
+      ranges.push([inner.charCodeAt(i), inner.charCodeAt(i)])
+      i++
+    }
+  }
+  if (ranges.length === 0) return null
+  const checks = ranges.map(([lo, hi]) =>
+    lo === hi ? `${codeExpr}===${lo}` : `(${codeExpr}>=${lo}&&${codeExpr}<=${hi})`
+  )
+  return `(${checks.join('||')})`
+}
+const FORMAT_HINTS = {
+  email: (val) => {
+    if (typeof val !== 'string') return null;
+    if (!val.includes('@')) return "missing '@' and domain part";
+    if (val.split('@').length > 2) return "multiple '@' characters";
+    const [, dom] = val.split('@');
+    if (!dom || !dom.includes('.')) return 'domain part missing dot';
+    return null;
+  },
+  date: (val) => {
+    if (typeof val !== 'string') return null;
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(val);
+    if (!m) return 'expected YYYY-MM-DD layout';
+    const mo = +m[2]; if (mo < 1 || mo > 12) return 'month must be 01-12';
+    const d = +m[3]; if (d < 1 || d > 31) return 'day must be 01-31';
+    return null;
+  },
+  uuid: (val) => {
+    if (typeof val !== 'string') return null;
+    if (!/^[0-9a-fA-F-]+$/.test(val)) return 'expected hex digits and dashes';
+    return 'expected 8-4-4-4-12 hex layout';
+  },
+  ipv4: (val) => typeof val === 'string' ? 'expected four 0-255 octets separated by dots' : null,
+};
+export { compilePatternInline, FORMAT_HINTS };