ata-validator 1.14.0 → 1.15.0

package/aot.d.ts

@@ -6,6 +6,11 @@ export interface StandaloneOptions {
   format?: 'esm' | 'cjs';
   /** Use stub error functions for the smallest output. Default: false. */
   abortEarly?: boolean;
+  /**
+   * Also export `parse(data)`: validate, then return a copy of the input
+   * holding only the properties the schema declares. Default: false.
+   */
+  parse?: boolean;
   [key: string]: unknown;
 }
 

package/build.d.ts

@@ -97,6 +97,14 @@ export interface ToStandaloneModuleOptions {
   formats?: Record<string, (value: string) => boolean>;
   /** See {@link BundleStandaloneOptions.formatMode}. */
   formatMode?: 'embed' | 'inject';
+  /**
+   * Also export `parse(data)`: validate, then return a copy of the input
+   * holding only the properties the schema declares. Off by default because
+   * it adds to the emitted module's size. Emitted only where the copy is
+   * provably exact; a schema using `$ref`, a composition, `patternProperties`,
+   * an `additionalProperties` schema or an array of objects gets no `parse`.
+   */
+  parse?: boolean;
 }
 
 /** Bundle multiple schemas into one self-contained module (no ata-validator runtime). */
@@ -105,5 +113,6 @@ export function bundleStandalone(schemas: unknown[], options?: BundleStandaloneO
 /** Like {@link bundleStandalone} but deduplicates shared bodies for smaller output. */
 export function bundleCompact(schemas: unknown[], options?: BundleStandaloneOptions): string;
 
-/** Emit a self-contained `validate`/`isValid` module string for a single schema. */
+/** Emit a self-contained `validate`/`isValid` module string for a single
+ * schema, plus `parse` when {@link ToStandaloneModuleOptions.parse} is set. */
 export function toStandaloneModule(schema: unknown, options?: ToStandaloneModuleOptions): string | null;

package/lib/formats.js

@@ -18,7 +18,10 @@ function date (s) {
   }
   const m = (s.charCodeAt(5) - 48) * 10 + (s.charCodeAt(6) - 48);
   const d = (s.charCodeAt(8) - 48) * 10 + (s.charCodeAt(9) - 48);
-  return m >= 1 && m <= 12 && d >= 1 && d <= 31;
+  if (m < 1 || m > 12 || d < 1) return false;
+  const y = (s.charCodeAt(0) - 48) * 1000 + (s.charCodeAt(1) - 48) * 100 +
+            (s.charCodeAt(2) - 48) * 10 + (s.charCodeAt(3) - 48);
+  return d <= daysInMonth(y, m);
 }
 
 // RFC 3339 date-time, read once. The form this replaces ran a regular
@@ -71,7 +74,7 @@ function dateTime (s) {
   const mi0 = s.charCodeAt(14) - 48, mi1 = s.charCodeAt(15) - 48;
   if ((mi0 >>> 0) > 5 || (mi1 >>> 0) > 9) return false;
   const se0 = s.charCodeAt(17) - 48, se1 = s.charCodeAt(18) - 48;
-  if ((se0 >>> 0) > 5 || (se1 >>> 0) > 9) return false;
+  if ((se0 >>> 0) > 6 || (se1 >>> 0) > 9 || se0 * 10 + se1 > 60) return false;
 
   let i = 19;
   if (s.charCodeAt(i) === 46) {
@@ -86,14 +89,27 @@ function dateTime (s) {
   }
 
   const c = s.charCodeAt(i);
-  if (c === 90 || c === 122) return i === n - 1;
-  if (c !== 43 && c !== 45) return false;
-  if (n - i !== 6) return false;
-  if (!isDigit(s.charCodeAt(i + 1)) || !isDigit(s.charCodeAt(i + 2))) return false;
-  if (s.charCodeAt(i + 3) !== 58) return false;
-  if (!isDigit(s.charCodeAt(i + 4)) || !isDigit(s.charCodeAt(i + 5))) return false;
-  if (twoDigits(s, i + 1) > 23) return false;
-  if (twoDigits(s, i + 4) > 59) return false;
+  const sec = se0 * 10 + se1;
+  const hh = h0 * 10 + h1, mi = mi0 * 10 + mi1;
+  let offMin = 0;
+  if (c === 90 || c === 122) {
+    if (i !== n - 1) return false;
+  } else {
+    if (c !== 43 && c !== 45) return false;
+    if (n - i !== 6) return false;
+    if (!isDigit(s.charCodeAt(i + 1)) || !isDigit(s.charCodeAt(i + 2))) return false;
+    if (s.charCodeAt(i + 3) !== 58) return false;
+    if (!isDigit(s.charCodeAt(i + 4)) || !isDigit(s.charCodeAt(i + 5))) return false;
+    const oh = twoDigits(s, i + 1), om = twoDigits(s, i + 4);
+    if (oh > 23 || om > 59) return false;
+    offMin = (c === 43 ? 1 : -1) * (oh * 60 + om);
+  }
+  // Same rule as time(): second 60 is the leap second and exists only at
+  // 23:59:60 UTC, whatever offset the string is written in.
+  if (sec === 60) {
+    const utc = ((hh * 60 + mi - offMin) % 1440 + 1440) % 1440;
+    if (utc !== 1439) return false;
+  }
   return true;
 }
 
@@ -225,7 +241,7 @@ function uri (s) {
       c === 43 || c === 45 || c === 46)) return false;
   }
   if (colon === -1) return false;
-  return noReserved(s, colon + 1);
+  return uriChars(s, colon + 1) && uriAuthority(s, colon + 1);
 }
 
 // The characters a URI cannot hold: C0 controls, space, DEL, and the rest of
@@ -238,6 +254,176 @@ function uri (s) {
 // than the engine on the common case, which is why it is not the first answer.
 const NON_PRINTABLE = /[^\u0021-\u007e]/;
 
+
+// RFC 3986 allows these ASCII characters in a URI and nothing else: the
+// unreserved set, the delimiters, and "%" when it introduces two hex digits.
+// The printable characters missing from that list are the ones this rejects:
+// " < > \ ^ ` { | }, plus everything below 0x21 and above 0x7e. The old check
+// only looked for whitespace and non-printables, so a backslash or a lone
+// percent sign passed as a URI.
+function uriChar (c) {
+  if (c < 33 || c > 126) return false;
+  return !(c === 34 || c === 60 || c === 62 || c === 92 ||
+           c === 94 || c === 96 || c === 123 || c === 124 || c === 125);
+}
+function isHex (c) {
+  return (c >= 48 && c <= 57) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70);
+}
+function uriChars (s, from) {
+  for (let i = from; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (!uriChar(c)) return false;
+    if (c === 37) { // '%'
+      if (!isHex(s.charCodeAt(i + 1)) || !isHex(s.charCodeAt(i + 2))) return false;
+      i += 2;
+    }
+  }
+  return true;
+}
+const uriCharsSource = (v, from) =>
+  `for(let _ri=${from};_ri<${v}.length;_ri++){const _rc=${v}.charCodeAt(_ri);` +
+  'if(_rc<33||_rc>126||_rc===34||_rc===60||_rc===62||_rc===92||_rc===94||_rc===96||_rc===123||_rc===124||_rc===125)return false;' +
+  `if(_rc===37){const _h1=${v}.charCodeAt(_ri+1),_h2=${v}.charCodeAt(_ri+2);` +
+  'if(!((_h1>=48&&_h1<=57)||(_h1>=97&&_h1<=102)||(_h1>=65&&_h1<=70))||' +
+  '!((_h2>=48&&_h2<=57)||(_h2>=97&&_h2<=102)||(_h2>=65&&_h2<=70)))return false;_ri+=2}}';
+
+// The authority sits between "//" and the next "/", "?" or "#". A bracketed
+// host must close, and a port is digits.
+function uriAuthority (s, start) {
+  if (s.charCodeAt(start) !== 47 || s.charCodeAt(start + 1) !== 47) return true;
+  let end = s.length;
+  for (let i = start + 2; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 47 || c === 63 || c === 35) { end = i; break; }
+  }
+  const auth = s.slice(start + 2, end);
+  const at = auth.lastIndexOf('@');
+  // Brackets belong to the host, so one before the "@" is not userinfo.
+  if (at !== -1 && /[[\]]/.test(auth.slice(0, at))) return false;
+  const hostPort = at === -1 ? auth : auth.slice(at + 1);
+  if (hostPort.charCodeAt(0) === 91) { // '['
+    const close = hostPort.indexOf(']');
+    if (close === -1) return false;
+    const rest = hostPort.slice(close + 1);
+    if (rest === '') return true;
+    if (rest.charCodeAt(0) !== 58) return false;
+    return /^[0-9]*$/.test(rest.slice(1));
+  }
+  const colon = hostPort.lastIndexOf(':');
+  if (colon === -1) return true;
+  // A host holding more than one colon is an IPv6 address, and those must be
+  // bracketed. Without that rule the last group reads as a port number.
+  if (hostPort.indexOf(':') !== colon) return false;
+  return /^[0-9]*$/.test(hostPort.slice(colon + 1));
+}
+const uriAuthoritySource = (v, start) =>
+  `if(${v}.charCodeAt(${start})===47&&${v}.charCodeAt(${start}+1)===47){` +
+  `let _ae=${v}.length;` +
+  `for(let _ai=${start}+2;_ai<${v}.length;_ai++){const _ac=${v}.charCodeAt(_ai);` +
+  'if(_ac===47||_ac===63||_ac===35){_ae=_ai;break}}' +
+  `const _au=${v}.slice(${start}+2,_ae);const _aat=_au.lastIndexOf('@');` +
+  'if(_aat!==-1&&/[[\\]]/.test(_au.slice(0,_aat)))return false;' +
+  'const _hp=_aat===-1?_au:_au.slice(_aat+1);' +
+  'if(_hp.charCodeAt(0)===91){const _cl=_hp.indexOf("]");' +
+  'if(_cl===-1)return false;const _rs=_hp.slice(_cl+1);' +
+  'if(_rs!==""){if(_rs.charCodeAt(0)!==58||!/^[0-9]*$/.test(_rs.slice(1)))return false}}' +
+  'else{const _co=_hp.lastIndexOf(":");' +
+  'if(_co!==-1){if(_hp.indexOf(":")!==_co)return false;' +
+  'if(!/^[0-9]*$/.test(_hp.slice(_co+1)))return false}}}';
+
+
+// An IRI is a URI that also admits non-ASCII. The ASCII rules are identical,
+// so the same character test runs with everything above 0x7e allowed through.
+function iriChar (c) { return c > 126 ? c !== 127 : uriChar(c); }
+function iriChars (s, from) {
+  for (let i = from; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (!iriChar(c)) return false;
+    if (c === 37) {
+      if (!isHex(s.charCodeAt(i + 1)) || !isHex(s.charCodeAt(i + 2))) return false;
+      i += 2;
+    }
+  }
+  return true;
+}
+const iriCharsSource = (v, from) =>
+  `for(let _ii=${from};_ii<${v}.length;_ii++){const _ic=${v}.charCodeAt(_ii);` +
+  'if(_ic===127||(_ic<127&&(_ic<33||_ic===34||_ic===60||_ic===62||_ic===92||_ic===94||_ic===96||_ic===123||_ic===124||_ic===125)))return false;' +
+  `if(_ic===37){const _j1=${v}.charCodeAt(_ii+1),_j2=${v}.charCodeAt(_ii+2);` +
+  'if(!((_j1>=48&&_j1<=57)||(_j1>=97&&_j1<=102)||(_j1>=65&&_j1<=70))||' +
+  '!((_j2>=48&&_j2<=57)||(_j2>=97&&_j2<=102)||(_j2>=65&&_j2<=70)))return false;_ii+=2}}';
+
+function iri (s) {
+  const n = s.length;
+  if (n === 0) return false;
+  const first = s.charCodeAt(0);
+  if (!((first >= 97 && first <= 122) || (first >= 65 && first <= 90))) return false;
+  let colon = -1;
+  for (let i = 1; i < n; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 58) { colon = i; break; }
+    if (!(isDigit(c) || (c >= 97 && c <= 122) || (c >= 65 && c <= 90) ||
+      c === 43 || c === 45 || c === 46)) return false;
+  }
+  if (colon === -1) return false;
+  return iriChars(s, colon + 1) && uriAuthority(s, colon + 1);
+}
+function iriSource (v, isStr) {
+  return guard(v, isStr, `const _n=${v}.length;if(_n===0)return false;` +
+    `const _f=${v}.charCodeAt(0);if(!((_f>=97&&_f<=122)||(_f>=65&&_f<=90)))return false;` +
+    `let _co=-1;for(let _i=1;_i<_n;_i++){const _c=${v}.charCodeAt(_i);if(_c===58){_co=_i;break}` +
+    `if(!((_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90)||_c===43||_c===45||_c===46))return false}` +
+    `if(_co===-1)return false;` +
+    iriCharsSource(v, '_co+1') +
+    uriAuthoritySource(v, '_co+1'));
+}
+function iriReference (s) { return iriChars(s, 0); }
+function iriReferenceSource (v, isStr) { return guard(v, isStr, iriCharsSource(v, '0')); }
+
+// An internationalised mailbox differs from a mailbox only in admitting
+// non-ASCII on both sides. The separator stays the ASCII "@": a fullwidth one
+// is a character in the local part, not a separator.
+function idnEmail (s) {
+  const at = s.lastIndexOf('@');
+  if (at <= 0 || at === s.length - 1) return false;
+  const local = s.slice(0, at);
+  const domain = s.slice(at + 1);
+  if (local.charCodeAt(0) === 34) {
+    return local.length >= 2 && local.charCodeAt(local.length - 1) === 34 && domain.length > 0;
+  }
+  if (local.charCodeAt(0) === 46 || local.charCodeAt(local.length - 1) === 46) return false;
+  if (local.indexOf('..') !== -1) return false;
+  if (domain.charCodeAt(0) === 91) {
+    return domain.charCodeAt(domain.length - 1) === 93 && domain.length > 2;
+  }
+  if (domain.charCodeAt(0) === 46 || domain.charCodeAt(domain.length - 1) === 46) return false;
+  if (domain.indexOf('..') !== -1) return false;
+  for (let i = 0; i < domain.length; i++) {
+    const c = domain.charCodeAt(i);
+    if (c <= 32 || c === 127 || c === 64) return false;
+  }
+  return true;
+}
+function idnEmailSource (v, isStr) {
+  const inner =
+    `const _at=${v}.lastIndexOf('@');` +
+    `if(_at<=0||_at===${v}.length-1)return false;` +
+    `const _lp=${v}.slice(0,_at),_dm=${v}.slice(_at+1);` +
+    `if(_lp.charCodeAt(0)===34){if(_lp.length<2||_lp.charCodeAt(_lp.length-1)!==34||_dm.length===0)return false}` +
+    `else{` +
+      `if(_lp.charCodeAt(0)===46||_lp.charCodeAt(_lp.length-1)===46)return false;` +
+      `if(_lp.indexOf('..')!==-1)return false;` +
+      `if(_dm.charCodeAt(0)===91){if(_dm.charCodeAt(_dm.length-1)!==93||_dm.length<=2)return false}` +
+      `else{` +
+        `if(_dm.charCodeAt(0)===46||_dm.charCodeAt(_dm.length-1)===46)return false;` +
+        `if(_dm.indexOf('..')!==-1)return false;` +
+        `for(let _di=0;_di<_dm.length;_di++){const _dc=_dm.charCodeAt(_di);` +
+        `if(_dc<=32||_dc===127||_dc===64)return false}` +
+      `}` +
+    `}`;
+  return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
+}
+
 function noReserved (s, from) {
   if (!NON_PRINTABLE.test(s)) return true;
   const n = s.length;
@@ -297,8 +483,10 @@ function time (s) {
   if (s.charCodeAt(2) !== 58 || s.charCodeAt(5) !== 58) return false;
   const m1 = s.charCodeAt(3) - 48, m2 = s.charCodeAt(4) - 48;
   if ((m1 >>> 0) > 5 || (m2 >>> 0) > 9) return false;
+  // Seconds reach 60 for the leap second, which the offset check below pins
+  // to 23:59:60 UTC; anything past that is not a clock reading.
   const c1 = s.charCodeAt(6) - 48, c2 = s.charCodeAt(7) - 48;
-  if ((c1 >>> 0) > 5 || (c2 >>> 0) > 9) return false;
+  if ((c1 >>> 0) > 6 || (c2 >>> 0) > 9 || c1 * 10 + c2 > 60) return false;
   let i = 8;
   if (i < n && s.charCodeAt(i) === 46) {
     i++;
@@ -310,21 +498,37 @@ function time (s) {
     }
     if (i === start) return false;
   }
-  if (i === n) return true;
+  // RFC 3339 full-time requires an offset; a bare wall clock is not a time.
+  if (i === n) return false;
+  const hh = h1 * 10 + h2, mm = m1 * 10 + m2, ss = c1 * 10 + c2;
   const z = s.charCodeAt(i);
-  if (z === 90 || z === 122) return i === n - 1;
-  if (z !== 43 && z !== 45) return false;
-  if (n - i !== 6 || s.charCodeAt(i + 3) !== 58) return false;
-  for (let k = 1; k <= 5; k++) {
-    if (k === 3) continue;
-    if ((s.charCodeAt(i + k) - 48 >>> 0) > 9) return false;
+  let offMin = 0;
+  if (z === 90 || z === 122) {
+    if (i !== n - 1) return false;
+  } else {
+    if (z !== 43 && z !== 45) return false;
+    if (n - i !== 6 || s.charCodeAt(i + 3) !== 58) return false;
+    for (let k = 1; k <= 5; k++) {
+      if (k === 3) continue;
+      if ((s.charCodeAt(i + k) - 48 >>> 0) > 9) return false;
+    }
+    const oh = (s.charCodeAt(i + 1) - 48) * 10 + (s.charCodeAt(i + 2) - 48);
+    const om = (s.charCodeAt(i + 4) - 48) * 10 + (s.charCodeAt(i + 5) - 48);
+    if (oh > 23 || om > 59) return false;
+    offMin = (z === 43 ? 1 : -1) * (oh * 60 + om);
+  }
+  // Second 60 exists only as the leap second, which is 23:59:60 in UTC. Any
+  // other clock reading with :60 is not a time.
+  if (ss === 60) {
+    const utc = ((hh * 60 + mm - offMin) % 1440 + 1440) % 1440;
+    if (utc !== 23 * 60 + 59) return false;
   }
   return true;
 }
 
 // Anything without a control character or whitespace.
 function uriReference (s) {
-  return noReserved(s, 0);
+  return uriChars(s, 0);
 }
 
 // Source twins. `v` is the expression holding the string; when `isStr` is
@@ -333,7 +537,7 @@ function uriReference (s) {
 function guard (v, isStr, body) { return isStr ? `{${body}}` : `if(typeof ${v}==='string'){${body}}`; }
 
 function dateSource (v, isStr) {
-  return guard(v, isStr, `if(${v}.length!==10)return false;for(let _i=0;_i<10;_i++){const _c=${v}.charCodeAt(_i);if(_i===4||_i===7){if(_c!==45)return false}else if(_c<48||_c>57)return false}const _m=(${v}.charCodeAt(5)-48)*10+(${v}.charCodeAt(6)-48),_d=(${v}.charCodeAt(8)-48)*10+(${v}.charCodeAt(9)-48);if(_m<1||_m>12||_d<1||_d>31)return false`);
+  return guard(v, isStr, `if(${v}.length!==10)return false;for(let _i=0;_i<10;_i++){const _c=${v}.charCodeAt(_i);if(_i===4||_i===7){if(_c!==45)return false}else if(_c<48||_c>57)return false}const _m=(${v}.charCodeAt(5)-48)*10+(${v}.charCodeAt(6)-48),_d=(${v}.charCodeAt(8)-48)*10+(${v}.charCodeAt(9)-48);if(_m<1||_m>12||_d<1)return false;const _y=(${v}.charCodeAt(0)-48)*1000+(${v}.charCodeAt(1)-48)*100+(${v}.charCodeAt(2)-48)*10+(${v}.charCodeAt(3)-48);const _dim=_m===2?(((_y%4===0&&_y%100!==0)||_y%400===0)?29:28):((_m===4||_m===6||_m===9||_m===11)?30:31);if(_d>_dim)return false`);
 }
 
 function dateTimeSource (v, isStr) {
@@ -354,15 +558,20 @@ function dateTimeSource (v, isStr) {
     `const _mi0=${v}.charCodeAt(14)-48,_mi1=${v}.charCodeAt(15)-48;` +
     'if((_mi0>>>0)>5||(_mi1>>>0)>9)return false;' +
     `const _se0=${v}.charCodeAt(17)-48,_se1=${v}.charCodeAt(18)-48;` +
-    'if((_se0>>>0)>5||(_se1>>>0)>9)return false;' +
+    'if((_se0>>>0)>6||(_se1>>>0)>9||_se0*10+_se1>60)return false;' +
     `let _i2=19;if(${v}.charCodeAt(19)===46){_i2=20;const _st=_i2;while(_i2<_n){const _c2=${v}.charCodeAt(_i2);if(_c2<48||_c2>57)break;_i2++}if(_i2===_st)return false}` +
-    `const _tz=${v}.charCodeAt(_i2);` +
+    `const _tz=${v}.charCodeAt(_i2);let _dtoff=0;` +
     `if(_tz===90||_tz===122){if(_i2!==_n-1)return false}` +
     `else{if(_tz!==43&&_tz!==45)return false;if(_n-_i2!==6)return false;` +
     `const _oh=${v}.charCodeAt(_i2+1),_oh2=${v}.charCodeAt(_i2+2),_om=${v}.charCodeAt(_i2+4),_om2=${v}.charCodeAt(_i2+5);` +
     `if(_oh<48||_oh>57||_oh2<48||_oh2>57||_om<48||_om>57||_om2<48||_om2>57)return false;` +
     `if(${v}.charCodeAt(_i2+3)!==58)return false;` +
-    `if((_oh-48)*10+(_oh2-48)>23)return false;if((_om-48)*10+(_om2-48)>59)return false}`);
+    `const _ohv=(_oh-48)*10+(_oh2-48),_omv=(_om-48)*10+(_om2-48);` +
+    `if(_ohv>23||_omv>59)return false;` +
+    `_dtoff=(_tz===43?1:-1)*(_ohv*60+_omv)}` +
+    `if(_se0*10+_se1===60){` +
+    `const _dtu=(((_h0*10+_h1)*60+(_mi0*10+_mi1)-_dtoff)%1440+1440)%1440;` +
+    `if(_dtu!==1439)return false}`);
 }
 
 function hostnameSource (v, isStr) {
@@ -393,17 +602,24 @@ function timeSource (v, isStr) {
     `const _m1=${v}.charCodeAt(3)-48,_m2=${v}.charCodeAt(4)-48;` +
     'if((_m1>>>0)>5||(_m2>>>0)>9)return false;' +
     `const _s1=${v}.charCodeAt(6)-48,_s2=${v}.charCodeAt(7)-48;` +
-    'if((_s1>>>0)>5||(_s2>>>0)>9)return false;' +
+    'if((_s1>>>0)>6||(_s2>>>0)>9||_s1*10+_s2>60)return false;' +
     `let _ti=8;if(_ti<_n&&${v}.charCodeAt(_ti)===46){_ti++;const _tf=_ti;` +
     `while(_ti<_n){const _tc=${v}.charCodeAt(_ti)-48;if((_tc>>>0)>9)break;_ti++}` +
     'if(_ti===_tf)return false}' +
-    'if(_ti!==_n){' +
-    `const _tz=${v}.charCodeAt(_ti);` +
+    'if(_ti===_n)return false;' +
+    `const _tz=${v}.charCodeAt(_ti);let _off=0;` +
     'if(_tz===90||_tz===122){if(_ti!==_n-1)return false}' +
     'else{if(_tz!==43&&_tz!==45)return false;' +
     `if(_n-_ti!==6||${v}.charCodeAt(_ti+3)!==58)return false;` +
     `if((${v}.charCodeAt(_ti+1)-48>>>0)>9||(${v}.charCodeAt(_ti+2)-48>>>0)>9||` +
-    `(${v}.charCodeAt(_ti+4)-48>>>0)>9||(${v}.charCodeAt(_ti+5)-48>>>0)>9)return false}}`);
+    `(${v}.charCodeAt(_ti+4)-48>>>0)>9||(${v}.charCodeAt(_ti+5)-48>>>0)>9)return false;` +
+    `const _oh=(${v}.charCodeAt(_ti+1)-48)*10+(${v}.charCodeAt(_ti+2)-48),` +
+    `_om=(${v}.charCodeAt(_ti+4)-48)*10+(${v}.charCodeAt(_ti+5)-48);` +
+    'if(_oh>23||_om>59)return false;' +
+    '_off=(_tz===43?1:-1)*(_oh*60+_om)}' +
+    'if(_s1*10+_s2===60){' +
+    'const _u=(((_h1*10+_h2)*60+(_m1*10+_m2)-_off)%1440+1440)%1440;' +
+    'if(_u!==1439)return false}');
 }
 
 function uriSource (v, isStr) {
@@ -412,7 +628,8 @@ function uriSource (v, isStr) {
     `let _co=-1;for(let _i=1;_i<_n;_i++){const _c=${v}.charCodeAt(_i);if(_c===58){_co=_i;break}` +
     `if(!((_c>=48&&_c<=57)||(_c>=97&&_c<=122)||(_c>=65&&_c<=90)||_c===43||_c===45||_c===46))return false}` +
     `if(_co===-1)return false;` +
-    noReservedSource(v, '_co+1'));
+    uriCharsSource(v, '_co+1') +
+    uriAuthoritySource(v, '_co+1'));
 }
 
 function ipv6Source (v, isStr) {
@@ -440,4 +657,161 @@ function ipv4Source (v, isStr) {
   return guard(v, isStr, `const _n=${v}.length;if(_n<7||_n>15)return false;let _o=0,_val=0,_dg=0;for(let _i=0;_i<=_n;_i++){const _c=_i<_n?${v}.charCodeAt(_i):46;if(_c===46){if(_dg===0||_val>255)return false;_o++;_val=0;_dg=0;if(_o>4)return false}else if(_c>=48&&_c<=57){if(_dg===1&&_val===0)return false;_val=_val*10+(_c-48);_dg++;if(_dg>3)return false}else return false}if(_o!==4)return false`);
 }
 
-module.exports = { date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource };
+
+// --- RFC 6901 JSON pointers -------------------------------------------------
+// A pointer is empty or a run of "/"-prefixed tokens, and the only escape is
+// "~" followed by 0 or 1. Everything else, including "#", is not a pointer:
+// the fragment form belongs to a URI, not to this format.
+function jsonPointer(s) {
+  if (s === '') return true;
+  if (s.charCodeAt(0) !== 47) return false; // '/'
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) !== 126) continue; // '~'
+    const n = s.charCodeAt(i + 1);
+    if (n !== 48 && n !== 49) return false; // '0' | '1'
+  }
+  return true;
+}
+function jsonPointerSource(v, isStr) {
+  const body = `{let _ok=${v}==='';if(!_ok&&${v}.charCodeAt(0)===47){_ok=true;for(let _i=0;_i<${v}.length;_i++){if(${v}.charCodeAt(_i)!==126)continue;const _n=${v}.charCodeAt(_i+1);if(_n!==48&&_n!==49){_ok=false;break}}}if(!_ok)return false}`;
+  return isStr ? body : `if(typeof ${v}==='string')${body}`;
+}
+
+// A relative pointer is a non-negative integer without leading zeros, then
+// either "#" or a JSON pointer.
+function relativeJsonPointer(s) {
+  let i = 0;
+  while (i < s.length) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) break;
+    i++;
+  }
+  if (i === 0) return false;
+  if (i > 1 && s.charCodeAt(0) === 48) return false; // leading zero
+  const rest = s.slice(i);
+  if (rest === '#') return true;
+  return jsonPointer(rest);
+}
+function relativeJsonPointerSource(v, isStr) {
+  const body = `{let _i=0;while(_i<${v}.length){const _c=${v}.charCodeAt(_i);if(_c<48||_c>57)break;_i++}let _ok=_i>0&&!(_i>1&&${v}.charCodeAt(0)===48);if(_ok){const _r=${v}.slice(_i);if(_r!=='#'){_ok=_r==='';if(!_ok&&_r.charCodeAt(0)===47){_ok=true;for(let _j=0;_j<_r.length;_j++){if(_r.charCodeAt(_j)!==126)continue;const _n=_r.charCodeAt(_j+1);if(_n!==48&&_n!==49){_ok=false;break}}}}}if(!_ok)return false}`;
+  return isStr ? body : `if(typeof ${v}==='string')${body}`;
+}
+
+// --- RFC 6570 URI templates -------------------------------------------------
+// Everything outside braces must be a literal, and each "{...}" must hold one
+// expression: an optional operator, then a comma-separated list of varspecs,
+// each a possibly dotted name of varchars with an optional ":n" prefix length
+// or "*" explode.
+const URI_TEMPLATE_EXPR = /^(?:[+#./;?&=,!@|]?)(?:[A-Za-z0-9_%]|%[0-9A-Fa-f]{2})+(?:\.(?:[A-Za-z0-9_%]|%[0-9A-Fa-f]{2})+)*(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[A-Za-z0-9_%]|%[0-9A-Fa-f]{2})+(?:\.(?:[A-Za-z0-9_%]|%[0-9A-Fa-f]{2})+)*(?::[1-9][0-9]{0,3}|\*)?)*$/;
+function uriTemplate(s) {
+  let i = 0;
+  while (i < s.length) {
+    const c = s.charCodeAt(i);
+    if (c === 125) return false; // '}' with no opening brace
+    // A literal excludes the controls, the space and DEL.
+    if (c !== 123 && (c <= 32 || c === 127)) return false;
+    if (c !== 123) { i++; continue; } // not '{'
+    const end = s.indexOf('}', i + 1);
+    if (end === -1) return false;
+    const expr = s.slice(i + 1, end);
+    if (expr === '' || expr.indexOf('{') !== -1) return false;
+    if (!URI_TEMPLATE_EXPR.test(expr)) return false;
+    i = end + 1;
+  }
+  return true;
+}
+function uriTemplateSource (v, isStr) {
+  const inner =
+    `let _i=0;` +
+    `while(_i<${v}.length){` +
+      `const _c=${v}.charCodeAt(_i);` +
+      `if(_c===125)return false;` +
+      `if(_c!==123&&(_c<=32||_c===127))return false;` +
+      `if(_c!==123){_i++;continue}` +
+      `const _e=${v}.indexOf('}',_i+1);` +
+      `if(_e===-1)return false;` +
+      `const _x=${v}.slice(_i+1,_e);` +
+      `if(_x===''||_x.indexOf('{')!==-1)return false;` +
+      `if(!${URI_TEMPLATE_EXPR.toString()}.test(_x))return false;` +
+      `_i=_e+1` +
+    `}`;
+  return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
+}
+
+// --- RFC 5321 mailbox -------------------------------------------------------
+// Local part is either a quoted string or dot-separated atoms, so a leading,
+// 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.
+function isEmailLocalChar (c) {
+  return (c >= 48 && c <= 57) || (c >= 97 && c <= 122) || (c >= 65 && c <= 90) ||
+    c === 46 || c === 33 || (c >= 35 && c <= 39) || c === 42 || c === 43 ||
+    c === 45 || c === 47 || c === 61 || c === 63 || (c >= 94 && c <= 96) ||
+    (c >= 123 && c <= 126);
+}
+const EMAIL_LOCAL_SRC = (v) => `((${v}>=48&&${v}<=57)||(${v}>=97&&${v}<=122)||(${v}>=65&&${v}<=90)||${v}===46||${v}===33||(${v}>=35&&${v}<=39)||${v}===42||${v}===43||${v}===45||${v}===47||${v}===61||${v}===63||(${v}>=94&&${v}<=96)||(${v}>=123&&${v}<=126))`;
+function email(s) {
+  const at = s.lastIndexOf('@');
+  if (at <= 0 || at === s.length - 1) return false;
+  const local = s.slice(0, at);
+  const domain = s.slice(at + 1);
+  if (local.length > 64) return false;
+  if (local.charCodeAt(0) === 34) {
+    // quoted string: must close, and the quote may only end the local part
+    if (local.charCodeAt(local.length - 1) !== 34 || local.length < 2) return false;
+  } else {
+    if (local.charCodeAt(0) === 46 || local.charCodeAt(local.length - 1) === 46) return false;
+    if (local.indexOf('..') !== -1) return false;
+    for (let i = 0; i < local.length; i++) if (!isEmailLocalChar(local.charCodeAt(i))) return false;
+  }
+  if (domain.charCodeAt(0) === 91) { // '['
+    if (domain.charCodeAt(domain.length - 1) !== 93 || domain.length <= 2) return false;
+    const inner = domain.slice(1, -1);
+    // IPv6 literals are tagged; anything else in brackets is an IPv4 address.
+    if (inner.startsWith('IPv6:')) return ipv6(inner.slice(5));
+    return ipv4(inner);
+  }
+  return hostname(domain);
+}
+// 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
+// one hostname implementation for both halves of this file.
+function emailSource (v, isStr) {
+  const inner =
+    `const _at=${v}.lastIndexOf('@');` +
+    `if(_at<=0||_at===${v}.length-1)return false;` +
+    `const _lp=${v}.slice(0,_at);const _dm=${v}.slice(_at+1);` +
+    `if(_lp.length>64)return false;` +
+    `if(_lp.charCodeAt(0)===34){if(_lp.length<2||_lp.charCodeAt(_lp.length-1)!==34)return false}` +
+    `else{` +
+      `if(_lp.charCodeAt(0)===46||_lp.charCodeAt(_lp.length-1)===46)return false;` +
+      `if(_lp.indexOf('..')!==-1)return false;` +
+      `for(let _i=0;_i<_lp.length;_i++){const _lc=_lp.charCodeAt(_i);if(!${EMAIL_LOCAL_SRC('_lc')})return false}` +
+    `}` +
+    `if(_dm.charCodeAt(0)===91){` +
+      `if(_dm.charCodeAt(_dm.length-1)!==93||_dm.length<=2)return false;` +
+      `const _in=_dm.slice(1,-1);` +
+      `if(_in.startsWith('IPv6:')){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
+      `else{${ipv4Source('_in', true)}}` +
+    `}` +
+    `else{${hostnameSource('_dm', true)}}`;
+  return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
+}
+
+
+// RFC 3339 appendix A duration. The units form a chain rather than a set: a
+// year may be followed by a month and a month by a day, and the same on the
+// time side, so "P1Y2D" and "PT1H2S" are not durations. Weeks stand alone and
+// no unit takes a fraction.
+const DURATION_RE = /^P(?:\d+W|(?:\d+Y(?:\d+M(?:\d+D)?)?|\d+M(?:\d+D)?|\d+D)(?:T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))?|T(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S))$/;
+function duration (s) { return DURATION_RE.test(s); }
+function durationSource (v, isStr) {
+  const inner = `if(!${DURATION_RE.toString()}.test(${v}))return false`;
+  return isStr ? inner : `if(typeof ${v}==='string'&&${inner.slice(3)}`;
+}
+
+module.exports = { date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, uriChars, uriAuthority, uriCharsSource, uriAuthoritySource, iri, iriReference, idnEmail, iriSource, iriReferenceSource, idnEmailSource, dateSource, ipv4Source, dateTimeSource, ipv6Source, hostnameSource, uriSource, uuidSource, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/interpreter.js

@@ -249,19 +249,24 @@ function multipleOfOk(d, m) {
 
 const _formats = require('./formats');
 const FORMAT_CHECKS = {
-  email: (s) => { const at = s.indexOf('@'); return at > 0 && at < s.length - 1 && s.indexOf('.', at) > at + 1; },
+  email: _formats.email,
   date: _formats.date,
   'date-time': _formats.dateTime,
   time: _formats.time,
-  duration: (s) => /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/.test(s) && s !== 'P' && !s.endsWith('T'),
+  duration: _formats.duration,
   uuid: _formats.uuid,
   uri: _formats.uri,
   'uri-reference': _formats.uriReference,
   ipv4: _formats.ipv4,
   ipv6: _formats.ipv6,
   hostname: _formats.hostname,
-  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { try { new RegExp(s); return true; } catch { return false; } } },
-  'json-pointer': (s) => s === '' || (/^\//.test(s) && !/~(?![01])/.test(s)),
+  regex: (s) => { try { new RegExp(s, 'u'); return true; } catch { return false; } },
+  'json-pointer': _formats.jsonPointer,
+  'relative-json-pointer': _formats.relativeJsonPointer,
+  'uri-template': _formats.uriTemplate,
+  iri: _formats.iri,
+  'iri-reference': _formats.iriReference,
+  'idn-email': _formats.idnEmail,
 };
 
 // ---------- evaluation ----------

package/lib/js-compiler.js

@@ -2024,7 +2024,7 @@ function genCode(schema, v, lines, ctx, knownType) {
   if (schema.format) {
     const fc = FORMAT_CODEGEN[schema.format]
     if (fc) {
-      lines.push(fc(v, isStr))
+      lines.push(fc(v, isStr, ctx))
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       // User-supplied format checker: thread the function via closure and call at runtime.
       const safeName = schema.format.replace(/[^a-zA-Z0-9_]/g, '_')
@@ -2959,24 +2959,37 @@ function genCode(schema, v, lines, ctx, knownType) {
   }
 }
 
+// Formats whose check is large enough that repeating it at every call site
+// costs more than the call. They are hoisted once per compiled function and
+// invoked by name: one real schema with four email fields grew by 20 KB when
+// the check was inlined at each of them.
+const EMAIL_HELPER = `function _em(_s){${_formats.emailSource('_s', true)}return true}`
+
 const FORMAT_CODEGEN = {
-  email: (v, isStr) => {
-    const guard = isStr ? '' : `typeof ${v}==='string'&&`
-    return isStr
-      ? `{const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
-      : `if(typeof ${v}==='string'){const _at=${v}.indexOf('@');if(_at<=0||_at>=${v}.length-1||${v}.indexOf('.',_at)<=_at+1)return false}`
+  email: (v, isStr, ctx) => {
+    if (!ctx) return _formats.emailSource(v, isStr)
+    hoistOnce(ctx, '_emHoisted', EMAIL_HELPER)
+    return isStr ? `if(!_em(${v}))return false` : `if(typeof ${v}==='string'&&!_em(${v}))return false`
+  },
+  'json-pointer': _formats.jsonPointerSource,
+  'relative-json-pointer': _formats.relativeJsonPointerSource,
+  'uri-template': _formats.uriTemplateSource,
+  iri: _formats.iriSource,
+  'iri-reference': _formats.iriReferenceSource,
+  'idn-email': _formats.idnEmailSource,
+  regex: (v, isStr) => {
+    const inner = `try{new RegExp(${v},'u')}catch(_er){return false}`
+    return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`
   },
   date: _formats.dateSource,
   uuid: _formats.uuidSource,
   'date-time': _formats.dateTimeSource,
   time: _formats.timeSource,
-  duration: (v, isStr) => isStr
-    ? `if(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T'))return false`
-    : `if(typeof ${v}==='string'&&(!/^P(?:\\d+Y)?(?:\\d+M)?(?:\\d+W)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?$/.test(${v})||${v}==='P'||${v}.endsWith('T')))return false`,
+  duration: _formats.durationSource,
   uri: _formats.uriSource,
   'uri-reference': (v, isStr) => isStr
-    ? `{${_formats.noReservedSource(v, '0')}}`
-    : `if(typeof ${v}==='string'){${_formats.noReservedSource(v, '0')}}`,
+    ? `{${_formats.uriCharsSource(v, '0')}}`
+    : `if(typeof ${v}==='string'){${_formats.uriCharsSource(v, '0')}}`,
   ipv4: _formats.ipv4Source,
   ipv6: _formats.ipv6Source,
   hostname: _formats.hostnameSource,
@@ -3522,7 +3535,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     // let every later statement of the same check push the same error again.
     if (fc) {
       const ri = ctx.varCounter++
-      const fmtCode = fc(v, isStr).replace(/return false/g, `{${failPush};break _fmt${ri}}`)
+      const fmtCode = fc(v, isStr, ctx).replace(/return false/g, `{${failPush};break _fmt${ri}}`)
       lines.push(`_fmt${ri}:{${fmtCode}}`)
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       // User-supplied format checker on the error path. Same closure plumbing
@@ -4158,7 +4171,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       // Same rule as the error codegen: one violation, one error. The first
       // failing statement pushes and leaves the labeled block.
       const ri = ctx.varCounter++
-      const code = fc(v, isStr).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`)
+      const code = fc(v, isStr, ctx).replace(/return false/g, `{${fail('format', 'format', `{format:'${esc(schema.format)}'}`, `'must match format "${esc(schema.format)}"'`)};break _fmt${ri}}`)
       lines.push(`_fmt${ri}:{${code}}`)
     } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
       const safeName = schema.format.replace(/[^a-zA-Z0-9_]/g, '_')

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.14.0';
+module.exports = '1.15.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "JSON Schema validation with first-class TypeScript and zero runtime cost. AOT compile to per-schema ESM modules with zero validator dependency. Generic Validator<T> for TypeBox/Zod/Valibot composition. Optional runtime API. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",
@@ -122,13 +122,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.14.0",
-    "@ata-validator/native-darwin-x64": "1.14.0",
-    "@ata-validator/native-linux-x64-gnu": "1.14.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.14.0",
-    "@ata-validator/native-linux-x64-musl": "1.14.0",
-    "@ata-validator/native-linux-arm64-musl": "1.14.0",
-    "@ata-validator/native-win32-x64": "1.14.0"
+    "@ata-validator/native-darwin-arm64": "1.15.0",
+    "@ata-validator/native-darwin-x64": "1.15.0",
+    "@ata-validator/native-linux-x64-gnu": "1.15.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.15.0",
+    "@ata-validator/native-linux-x64-musl": "1.15.0",
+    "@ata-validator/native-linux-arm64-musl": "1.15.0",
+    "@ata-validator/native-win32-x64": "1.15.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"