ata-validator 1.60.0 → 1.61.1

package/lib/compiled-bare-rich.js

@@ -0,0 +1,54 @@
+'use strict';
+
+// bareRich: the compiled-bare wrapper for a validator that reads ata's own
+// errors (`richErrors` left on) and is only ever called, never handed to other
+// code: validate() and isValidObject() as lib/compiled-object.js answers them,
+// down to the error objects, without the Standard Schema member and the
+// extension hook nothing can reach there, and without the option checks the
+// bundler plugin already made. A separate entry from lib/compiled-bare.js so
+// a bundle with only plain or verdict validators carries no error pipeline.
+// tests/test_compiled_bare.js holds it to the runtime.
+
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+
+const EMPTY_ERRORS = Object.freeze([]);
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+// The fields of a Validator the rejection classes read.
+class CompiledState {
+  constructor(schema, fill) {
+    this._schemaObj = schema;
+    this._schemaPositions = undefined;
+    this._source = undefined;
+    this._mutatesInput = fill !== null;
+    this._preprocess = fill;
+  }
+}
+
+function bareRich(mod, schema, useDefaults) {
+  const fill = useDefaults !== false && typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  const verdict = mod.isValid;
+  const isValid = fill ? (d) => { fill(d); return verdict(d); } : verdict;
+  const self = new CompiledState(schema, fill);
+  const errFn = mod.validate;
+  const rich = (data) => {
+    const r = errFn(data);
+    return new RichRejection(r && r.valid === false ? r : VERDICT_DISAGREES, data, null, self, schema, _enrichLazy);
+  };
+  const buildErrors = (data) => rich(data).errors;
+  const buildRawErrors = (data) => rich(data)._ataRaw();
+  return {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
+      return new LazyRejection(buildErrors, data, buildRawErrors);
+    },
+    isValidObject: isValid,
+  };
+}
+
+module.exports = { bareRich };

package/lib/compiled-bare.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// The smallest wrappers around a compiled module, for a validator the bundler
+// plugin sees used only through direct calls of its methods: never handed to
+// other code, so nothing reads `~standard` or registers a check on it with
+// `_extendChecks`, and its options were read at build time. What is left is
+// what those calls answer: defaults filled with the module's own pass, the
+// verdict, and for `richErrors: false` the module's plain errors as they are.
+// The same answers as fromCompiledVerdict and fromCompiledPlain
+// (tests/test_compiled_bare.js), without their API surface: 0.3 KB gzipped
+// against 1.6 and 2.6.
+
+const EMPTY_ERRORS = Object.freeze([]);
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+function verdictOf(mod, useDefaults) {
+  const fill = useDefaults !== false && typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  return fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
+}
+
+// isValidObject() only.
+function bareVerdict(mod, useDefaults) {
+  return { isValidObject: verdictOf(mod, useDefaults) };
+}
+
+// validate() and isValidObject() for `richErrors: false`, around a module
+// written with `plainErrors: true`.
+function barePlain(mod, useDefaults) {
+  const isValid = verdictOf(mod, useDefaults);
+  const errFn = mod.validate;
+  return {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      const r = errFn(data);
+      return r && r.valid === false ? { valid: false, errors: r.errors } : VERDICT_DISAGREES;
+    },
+    isValidObject: isValid,
+  };
+}
+
+module.exports = { bareVerdict, barePlain };

package/lib/compiled-common.js

@@ -5,7 +5,22 @@
 // points; lib/compiled-verdict.js answers only the two that return a boolean,
 // so a bundle that never reads errors does not carry the error pipeline.
 
-const { buildDefaultsApplier } = require('./defaults');
+// A module from 1.58.0 on fills its own defaults (`applyDefaults`, exported
+// when the schema has one, the same pass as the runtime's: tests hold the two
+// equal), so the wrapper takes that and the defaults engine stays out of a
+// bundle that wraps current modules. An older module, or one without the
+// version stamp, takes the runtime's pass as before (lib/compiled-defaults.js).
+const MODULE_DEFAULTS_SINCE = [1, 58, 0];
+function carriesDefaults (mod) {
+  const v = typeof mod.ataVersion === 'string' ? mod.ataVersion.split(/[.-]/).slice(0, 3).map(Number) : null;
+  if (!v || v.some((n) => !Number.isInteger(n))) return false;
+  for (let i = 0; i < 3; i++) if (v[i] !== MODULE_DEFAULTS_SINCE[i]) return v[i] > MODULE_DEFAULTS_SINCE[i];
+  return true;
+}
+function defaultsFor (mod, schema) {
+  if (carriesDefaults(mod)) return typeof mod.applyDefaults === 'function' ? mod.applyDefaults : null;
+  return require('./compiled-defaults')(schema);
+}
 
 // The Validator options the wrapper answers the same way as the runtime.
 // Anything else changes what the runtime does in a way the wrapper does not
@@ -23,7 +38,7 @@ function prepare(mod, schema, options, name) {
       throw new TypeError(`${name} does not support the ${key} option; a Validator with it has to stay on the runtime`);
     }
   }
-  const fill = options && options.useDefaults === false ? null : buildDefaultsApplier(schema);
+  const fill = options && options.useDefaults === false ? null : defaultsFor(mod, schema);
   const isValid = fill ? (d) => { fill(d); return mod.isValid(d); } : mod.isValid;
   return { fill, isValid };
 }

package/lib/compiled-defaults.browser.js

@@ -0,0 +1,9 @@
+'use strict';
+
+// Browser build of lib/compiled-defaults.js. A module from ata-validator 1.58.0
+// on carries `applyDefaults` when its schema has a default, and the wrapper
+// uses it; only an older module needs the runtime's pass, which this build
+// leaves out. Such a module is refused rather than run without its defaults.
+module.exports = function () {
+  throw new TypeError('This compiled module was built before ata-validator 1.58.0 and its schema has defaults; rebuild it to use it in a browser bundle.');
+};

package/lib/compiled-defaults.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// The runtime's defaults pass, for a module built before modules carried their
+// own (ata-validator 1.58.0, when the pass reached behind `$ref`, `allOf` and
+// array elements). The browser build maps this file to
+// lib/compiled-defaults.browser.js, so a page that wraps a current module does
+// not carry the defaults engine twice.
+module.exports = require('./defaults').buildDefaultsApplier;

package/lib/compiled-object.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// lib/compiled.js without the JSON entry points: validate(), isValidObject()
+// and Standard Schema, answered as a Validator with default options answers
+// them, down to the error objects. A bundler plugin puts this in place of
+// `new Validator(schema)` when the code reads errors but never calls
+// validateJSON() or isValidJSON(), so the position map those use to frame an
+// error in the JSON text (lib/data-position-cache.js and the walk behind it)
+// stays out of the bundle: 14.1 to 12.3 KB gzipped for the wrapper.
+// tests/test_compiled_parity.js holds it to the full wrapper.
+//
+// Only for a schema compiledEligible() accepts, and with the schema
+// compiledSchemaFor() returns: the one the runtime reads, after normalization.
+// Custom error messages stay on the runtime, and so does every option except
+// the ones COMPILED_OPTIONS lists. Defaults are applied as a default Validator
+// applies them, before any check, with the same code; `useDefaults: false`
+// leaves the input as it is, as the runtime then does.
+
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+const { prepare, installExtension, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
+
+const EMPTY_ERRORS = Object.freeze([]);
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+// The fields of a Validator the rejection classes read.
+class CompiledState {
+  constructor(schema) {
+    this._schemaObj = schema;
+    this._schemaPositions = undefined;
+    this._source = undefined;
+    this._mutatesInput = false;
+    this._preprocess = null;
+  }
+}
+
+function fromCompiledObject(mod, schema, options) {
+  const { fill, isValid } = prepare(mod, schema, options, 'fromCompiledObject');
+  const self = new CompiledState(schema);
+  if (fill) {
+    self._mutatesInput = true;
+    self._preprocess = fill;
+  }
+  const errFn = mod.validate;
+  // The generated function's own result, rejected: if it says valid where the
+  // verdict said no, the disagreement is reported rather than turned into an
+  // acceptance, as the core does.
+  const raw = (data) => {
+    const r = errFn(data);
+    return r && r.valid === false ? r : VERDICT_DISAGREES;
+  };
+  const rich = (data) => new RichRejection(raw(data), data, null, self, schema, _enrichLazy);
+  const buildErrors = (data) => rich(data).errors;
+  const buildRawErrors = (data) => rich(data)._ataRaw();
+  const api = {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      // The runtime returns the rich rejection directly when it rewrites input.
+      if (fill) return rich(data);
+      return new LazyRejection(buildErrors, data, buildRawErrors);
+    },
+    isValidObject(data) {
+      return isValid(data);
+    },
+  };
+  installExtension(api, schema, (base, ext) => {
+    return {
+      // The verdict is the schema's and the check's. A failure lists the
+      // schema's errors, then the check's, read when somebody asks.
+      validate(data) {
+        const r = base.validate(data);
+        if (r.valid && ext.check(data)) return r;
+        return new ExtendedRejection(r, data, ext.errors);
+      },
+      isValidObject: (d) => base.isValidObject(d) && ext.check(d),
+    };
+  });
+  // Standard Schema V1, as the runtime Validator hands it out, so a validator
+  // the build compiled away still works where the runtime one did (a form
+  // library, a router, an RPC layer). The schema it publishes is the one the
+  // module was built from, as the runtime reads it.
+  installStandard(api, () => schema, (self, value) => self.validate(value));
+  return api;
+}
+
+// validate() under a check, as the runtime reports it (ExtendedRejection in
+// validator-core.js): the inner result's errors, then the check's.
+class ExtendedRejection {
+  constructor(inner, data, collect) {
+    this.valid = false;
+    this._inner = inner;
+    this._data = data;
+    this._collect = collect;
+    this._errors = null;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+  _ataRaw() {
+    const inner = this._inner;
+    const more = this._collect(this._data) || [];
+    const raw = inner.valid ? more : (typeof inner._ataRaw === 'function' ? inner._ataRaw() : inner.errors).concat(more);
+    return raw.length ? raw : [EXT_FALLBACK];
+  }
+}
+Object.defineProperty(ExtendedRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._errors === null) {
+      const inner = this._inner;
+      const more = this._collect(this._data) || [];
+      const all = inner.valid ? more : inner.errors.concat(more);
+      this._errors = all.length ? all : [EXT_FALLBACK];
+    }
+    return this._errors;
+  },
+});
+
+module.exports = { fromCompiledObject };

package/lib/compiled-plain.js

@@ -0,0 +1,57 @@
+'use strict';
+
+// The compiled-module wrapper for `new Validator(schema, { richErrors: false })`:
+// validate(), isValidObject() and Standard Schema, answered as such a
+// Validator answers them, errors in its plain shape (keyword, instancePath,
+// schemaPath, params, message). The module is written with `plainErrors: true`
+// (compiledModuleFor in ata-validator/build), so its errors are already that
+// shape and in that order, and this wrapper hands them out as they are: no
+// rejection classes, no enrichment, no suggestions. 2.6 KB gzipped against
+// 10.9 for the rich wrapper without JSON entry points.
+// tests/test_compiled_plain.js holds it to the runtime over the suite.
+
+const { prepare, installExtension, EXT_FALLBACK } = require('./compiled-common');
+const { installStandard } = require('./standard-schema');
+
+const EMPTY_ERRORS = Object.freeze([]);
+// The module's own verdict and its error function disagree (the data changed
+// between them): reported, never turned into an acceptance, as the core does.
+const VERDICT_DISAGREES = Object.freeze({
+  valid: false,
+  errors: Object.freeze([Object.freeze({ keyword: 'validation', instancePath: '', schemaPath: '#', params: Object.freeze({}), message: 'schema validation failed' })]),
+});
+
+function fromCompiledPlain(mod, schema, options) {
+  const opts = options ? { ...options } : undefined;
+  // `richErrors: false` is what this wrapper is; anything else it is not.
+  if (opts) {
+    if (opts.richErrors !== false) throw new TypeError('fromCompiledPlain answers `richErrors: false`; a Validator with rich errors takes fromCompiled');
+    delete opts.richErrors;
+  }
+  const { isValid } = prepare(mod, schema, opts, 'fromCompiledPlain');
+  const errFn = mod.validate;
+  const api = {
+    validate(data) {
+      if (isValid(data)) return { valid: true, data, errors: EMPTY_ERRORS };
+      const r = errFn(data);
+      return r && r.valid === false ? { valid: false, errors: r.errors } : VERDICT_DISAGREES;
+    },
+    isValidObject(data) {
+      return isValid(data);
+    },
+  };
+  installExtension(api, schema, (base, ext) => ({
+    validate(data) {
+      const r = base.validate(data);
+      if (r.valid && ext.check(data)) return r;
+      const more = ext.errors(data) || [];
+      const all = r.valid ? more : r.errors.concat(more);
+      return { valid: false, errors: all.length ? all : [EXT_FALLBACK] };
+    },
+    isValidObject: (d) => base.isValidObject(d) && ext.check(d),
+  }));
+  installStandard(api, () => schema, (self, value) => self.validate(value));
+  return api;
+}
+
+module.exports = { fromCompiledPlain };

package/lib/compiled.js

@@ -15,7 +15,8 @@
 // applies them, before any check, with the same code; `useDefaults: false`
 // leaves the input as it is, as the runtime then does.
 
-const { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy } = require('./rejections');
+const { LazyRejection, RichRejection, _enrichLazy } = require('./rejections');
+const { LazyJsonRejection } = require('./json-rejections');
 const { COMPILED_OPTIONS, prepare, parse, installExtension, extendJSON, EXT_FALLBACK } = require('./compiled-common');
 const { installStandard } = require('./standard-schema');
 

package/lib/email-literal.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// Every RFC 4291 text form of an IPv6 address as one expression: eight groups,
+// or a "::" standing for one or more groups of zeros with up to seven groups
+// around it, the last 32 bits optionally a dotted quad. ipv6() in lib/formats.js
+// is the fast check; this is the short one, which an email address literal in a
+// compiled module carries instead of the parser (2.2 KB of every module that
+// checks an email). tests/test_ipv6_expression.js holds the two to the same
+// answer.
+const IPV6_RE = (() => {
+  // A dotted quad, as lib/formats.js reads one.
+  const v4 = require('./formats').IPV4.source.slice(1, -1);
+  const h = '[0-9A-Fa-f]{1,4}';
+  const alts = [`(?:${h}:){7}${h}`, `(?:${h}:){6}${v4}`];
+  for (let k = 0; k <= 7; k++) {
+    const left = k === 0 ? '' : `(?:${h}:){${k - 1}}${h}`;
+    alts.push(k === 7 ? `${left}::` : `${left}::(?:(?:${h}:){0,${6 - k}}${h})?`);
+    if (k <= 5) alts.push(`${left}::(?:(?:${h}:){0,${5 - k}})?${v4}`);
+  }
+  return new RegExp(`^(?:${alts.join('|')})$`);
+})();
+
+// `_in` is the text between the brackets; the check returns false from the
+// function it is written into when the literal is not an address.
+let _src = null;
+module.exports = () => _src || (_src =
+  `if((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);if(_i6.length>45||!${IPV6_RE}.test(_i6))return false}` +
+  `else if(_in.length>15||!${require('./formats').IPV4}.test(_in))return false`);
+module.exports.IPV6_RE = IPV6_RE;

package/lib/enrich-error.js

@@ -1,6 +1,10 @@
 'use strict';
 
-const { CODES, codeFor, fromNative } = require('./error-codes');
+const { CODES, codeFor } = require('./error-codes');
+// Only the native engine writes a numeric code, so its table loads with the
+// first such error (lib/native-codes.js), not with every process.
+let _fromNative = null;
+const fromNative = (ordinal, format) => (_fromNative || (_fromNative = require('./native-codes').fromNative))(ordinal, format);
 const { suggestFor } = require('./suggestions');
 const { resolvePointer } = require('./pointer');
 

package/lib/error-codes.js

@@ -26,16 +26,10 @@ const CODES = Object.freeze({
   ATA2013: { keyword: 'pattern', category: 'constraint', headline: 'string does not match pattern' },
 
   // ATA3xxx — format
-  ATA3001: { keyword: 'format', format: 'email', category: 'format', headline: 'value does not match format "email"' },
-  ATA3002: { keyword: 'format', format: 'date', category: 'format', headline: 'value does not match format "date"' },
-  ATA3003: { keyword: 'format', format: 'date-time', category: 'format', headline: 'value does not match format "date-time"' },
-  ATA3004: { keyword: 'format', format: 'time', category: 'format', headline: 'value does not match format "time"' },
-  ATA3005: { keyword: 'format', format: 'uri', category: 'format', headline: 'value does not match format "uri"' },
-  ATA3006: { keyword: 'format', format: 'uri-reference', category: 'format', headline: 'value does not match format "uri-reference"' },
-  ATA3007: { keyword: 'format', format: 'ipv4', category: 'format', headline: 'value does not match format "ipv4"' },
-  ATA3008: { keyword: 'format', format: 'ipv6', category: 'format', headline: 'value does not match format "ipv6"' },
-  ATA3009: { keyword: 'format', format: 'uuid', category: 'format', headline: 'value does not match format "uuid"' },
-  ATA3010: { keyword: 'format', format: 'hostname', category: 'format', headline: 'value does not match format "hostname"' },
+  // One entry per built-in format the engines name, in this order: the same
+  // object for each, so it is written once.
+  ...Object.fromEntries(['email', 'date', 'date-time', 'time', 'uri', 'uri-reference', 'ipv4', 'ipv6', 'uuid', 'hostname']
+    .map((format, i) => [`ATA30${String(i + 1).padStart(2, '0')}`, { keyword: 'format', format, category: 'format', headline: `value does not match format "${format}"` }])),
   ATA3099: { keyword: 'format', category: 'format', headline: 'value does not match user-defined format' },
 
   // ATA4xxx — composition
@@ -69,14 +63,6 @@ const CODES = Object.freeze({
   ATA9002: { keyword: '__compile__', category: 'system', headline: 'schema failed to compile' },
 });
 
-function get (code) {
-  return CODES[code];
-}
-
-function all () {
-  return Object.keys(CODES).sort();
-}
-
 // Reverse lookups, built once. codeFor runs per error on every failing
 // validation, so walking the table there showed up as most of the cost of
 // enriching a rejected payload. Insertion follows sorted code order, so the
@@ -101,62 +87,6 @@ function codeFor (keyword, format) {
 }
 
 
-// The native engine reports its own `error_code` enum from include/ata.h as an
-// ordinal. Nothing outside the addon should ever see one: an error that came
-// from there carries the same public code and keyword as the same failure from
-// the JavaScript engines. Ordinals are positional, so this table follows the
-// enum's declaration order and `tests/test_native_error_codes.js` fails if the
-// two drift apart.
-const NATIVE_KEYWORDS = [
-  null,                     // 0 ok
-  '__parse__',              // 1 invalid_json
-  '__compile__',            // 2 invalid_schema
-  'type',                   // 3 type_mismatch
-  'required',               // 4 required_property_missing
-  'additionalProperties',   // 5 additional_property_not_allowed
-  'enum',                   // 6 enum_mismatch
-  'const',                  // 7 const_mismatch
-  'minimum',                // 8 minimum_violation
-  'maximum',                // 9 maximum_violation
-  'exclusiveMinimum',       // 10 exclusive_minimum_violation
-  'exclusiveMaximum',       // 11 exclusive_maximum_violation
-  'minLength',              // 12 min_length_violation
-  'maxLength',              // 13 max_length_violation
-  'pattern',                // 14 pattern_mismatch
-  'format',                 // 15 format_mismatch
-  'minItems',               // 16 min_items_violation
-  'maxItems',               // 17 max_items_violation
-  'uniqueItems',            // 18 unique_items_violation
-  'minProperties',          // 19 min_properties_violation
-  'maxProperties',          // 20 max_properties_violation
-  'multipleOf',             // 21 multiple_of_violation
-  'allOf',                  // 22 all_of_failed
-  'anyOf',                  // 23 any_of_failed
-  'oneOf',                  // 24 one_of_failed
-  'not',                    // 25 not_failed
-  '$ref',                   // 26 ref_not_found
-  'if',                     // 27 if_then_else_failed
-  '__depth__',              // 28 depth_exceeded
-]
-
-// Keyword and public code for a native ordinal, or null when the ordinal is
-// outside the enum, which would mean the addon is newer than this table.
-function fromNative (ordinal, format) {
-  if (typeof ordinal !== 'number' || !Number.isInteger(ordinal)) return null
-  const keyword = NATIVE_KEYWORDS[ordinal]
-  if (!keyword) return null
-  // codeFor('format') answers with the first format code, which names a
-  // specific format. Without knowing which format failed, the generic one is
-  // the honest answer.
-  // The walker stopped at its depth limit and rejected the document. No
-  // public code names that: the APIs that ask the walker route schemas deep or
-  // recursive enough to reach it to validate() first (lib/buffer-gate.js), so
-  // it is the generic failure.
-  if (keyword === '__depth__') return { keyword, code: 'ATA9000' }
-  const code = keyword === 'format'
-    ? (format ? codeFor('format', format) || 'ATA3099' : 'ATA3099')
-    : codeFor(keyword) || 'ATA9001'
-  return { keyword, code }
-}
+// The native engine's ordinals are translated in lib/native-codes.js.
 
-module.exports = { CODES, get, all, codeFor, fromNative, NATIVE_KEYWORDS };
+module.exports = { CODES, codeFor };

package/lib/formats-source.js

@@ -263,6 +263,21 @@ const EMAIL_LOCAL_SRC = (v) => `(${v}>32&&${v}<127&&${v}!==34&&${v}!==40&&${v}!=
 // 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.
+// The check of an email address literal's inside (`_in`, between the
+// brackets). Where code is written for a module, by expression
+// (lib/email-literal.js), which is a fraction of the bytes of the parsers. A
+// browser build maps that module to nothing: its generator writes code for the
+// page alone, so it uses the parsers it carries anyway and the expression's
+// builder stays out of the page. tests/test_ipv6_expression.js holds both forms
+// to the same answers.
+const _literalByParsers = () =>
+  `if((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
+  `else{${ipv4Source('_in', true)}}`;
+const _emailLiteral = () => {
+  const byExpression = require('./email-literal');
+  return typeof byExpression === 'function' ? byExpression() : _literalByParsers();
+};
+
 function emailSource (v, isStr) {
   const inner =
     // One forward pass, and neither half sliced out. '@' is not a local-part
@@ -294,8 +309,10 @@ function emailSource (v, isStr) {
       `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((_in.charCodeAt(0)|32)===105&&(_in.charCodeAt(1)|32)===112&&(_in.charCodeAt(2)|32)===118&&_in.charCodeAt(3)===54&&_in.charCodeAt(4)===58){const _i6=_in.slice(5);${ipv6Source('_i6', true)}}` +
-      `else{${ipv4Source('_in', true)}}` +
+      // 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.
+      _emailLiteral() +
     `}` +
     `else{${hostnameRangeSource(v, '_at+1', `${v}.length`)}}`;
   return isStr ? `{${inner}}` : `if(typeof ${v}==='string'){${inner}}`;
@@ -304,4 +321,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 = { 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, timeSource, noReservedSource, jsonPointerSource, relativeJsonPointerSource, uriTemplateSource, emailSource, durationSource };

package/lib/formats.js

@@ -538,4 +538,4 @@ function email(s) {
 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); }
 
-module.exports = { IPV4, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };
+module.exports = { IPV4, DURATION_RE, IPV6_FULL, ipv4Range, URI_FAST, date, ipv4, dateTime, ipv6, hostname, uri, uriReference, uriWalk: _uriWalk, uuid, time, noReserved, jsonPointer, relativeJsonPointer, uriTemplate, email, duration, iri, iriReference, idnEmail, DURATION_RE, URI_TEMPLATE_EXPR };