ata-validator 1.53.0 → 1.55.0

package/lib/uri-core.js

@@ -0,0 +1,155 @@
+'use strict';
+
+// RFC 3986 URI and URI-reference, RFC 3987 IRI and IRI-reference, as one walk
+// over the string with no slicing. `mode` bit 1 asks for a scheme (uri, iri),
+// bit 2 lets non-ASCII through (iri, iri-reference). The rules the walk holds
+// that a character-class scan does not: a second "@" in the authority, a port
+// that is not digits, square brackets anywhere but around an IP literal, the
+// literal itself (RFC 3986 IPv6 with an embedded IPv4 of no leading zeros, an
+// RFC 6874 zone id, IPvFuture), a colon in the first segment of a relative
+// path, and a second "#". A reference made only of unreserved characters,
+// sub-delimiters, "/" and "@" (a file name, a path) is one whatever its
+// shape, and is answered by one scan before any of that.
+//
+// A factory, like lib/safe-regex.js: the interpreted engine calls the
+// function it returns, and the code generator emits the factory's source
+// text (`source`) into the program it builds, so a standalone module carries
+// the same walk without importing it. Nothing inside the factory reads a
+// free variable, and no comments inside it: its text is what gets emitted.
+// `ip6` is the IPv6 check for a bracketed host, one string in: lib/formats.js
+// gives its own and the generator emits ipv6Source, so neither carries a
+// second copy. The slice it costs happens only on an IP literal.
+function __ataUri (ip6) {
+  const C = new Uint8Array(128);
+  for (let i = 48; i < 58; i++) C[i] = 3;
+  for (let i = 65; i < 91; i++) C[i] = 3;
+  for (let i = 97; i < 123; i++) C[i] = 3;
+  C[43] = 3; C[45] = 3; C[46] = 3;
+  C[95] = 1; C[126] = 1;
+  C[33] = 1; C[36] = 1; C[38] = 1; C[39] = 1; C[40] = 1; C[41] = 1; C[42] = 1; C[44] = 1; C[59] = 1; C[61] = 1;
+  const H = new Uint8Array(128);
+  for (let i = 48; i < 58; i++) H[i] = 1;
+  for (let i = 65; i < 71; i++) H[i] = 1;
+  for (let i = 97; i < 103; i++) H[i] = 1;
+  function pct (s, i) {
+    const a = s.charCodeAt(i + 1), b = s.charCodeAt(i + 2);
+    return a < 128 && b < 128 && H[a] === 1 && H[b] === 1;
+  }
+  const P = new Uint8Array(128);
+  for (let i = 0; i < 128; i++) P[i] = C[i] & 1;
+  P[58] = 1; P[64] = 1; P[47] = 1;
+  const Q = new Uint8Array(P);
+  Q[63] = 1;
+  const S = new Uint8Array(P);
+  S[58] = 0;
+  function literal (s, from, to) {
+    if (from >= to) return false;
+    const f = s.charCodeAt(from);
+    if (f === 118 || f === 86) {
+      let i = from + 1, h = 0;
+      for (; i < to; i++) { const c = s.charCodeAt(i); if (c < 128 && H[c] === 1) h++; else break; }
+      if (h === 0 || s.charCodeAt(i) !== 46 || i + 1 >= to) return false;
+      for (i++; i < to; i++) { const c = s.charCodeAt(i); if (!(c < 128 && ((C[c] & 1) === 1 || c === 58))) return false; }
+      return true;
+    }
+    let z = -1;
+    for (let i = from; i < to; i++) if (s.charCodeAt(i) === 37) { z = i; break; }
+    if (z === -1) return ip6(s.slice(from, to));
+    if (s.charCodeAt(z + 1) !== 50 || s.charCodeAt(z + 2) !== 53 || z + 3 >= to) return false;
+    for (let i = z + 3; i < to; i++) {
+      const c = s.charCodeAt(i);
+      if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+      if (!(c < 128 && (C[c] & 1) === 1)) return false;
+    }
+    return ip6(s.slice(from, z));
+  }
+  return function (s, mode) {
+    const n = s.length;
+    const wide = (mode & 2) !== 0;
+    if ((mode & 1) === 0 && !(s.charCodeAt(0) === 47 && s.charCodeAt(1) === 47)) {
+      let k = 0;
+      for (; k < n; k++) { const c = s.charCodeAt(k); if (c > 127 || S[c] === 0) break; }
+      if (k === n) return true;
+    }
+    let i = 0, c = s.charCodeAt(0), scheme = false;
+    if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122)) {
+      let j = 1;
+      while (j < n) { c = s.charCodeAt(j); if (c === 58 || c > 127 || (C[c] & 2) === 0) break; j++; }
+      if (j < n && c === 58) { scheme = true; i = j + 1; }
+    }
+    if (!scheme && (mode & 1) !== 0) return false;
+    let auth = false;
+    if (s.charCodeAt(i) === 47 && s.charCodeAt(i + 1) === 47) {
+      auth = true;
+      const st = i + 2;
+      let end = n, at = -1, br = false, brAt = false, colon = -1;
+      for (let k = st; k < n; k++) {
+        c = s.charCodeAt(k);
+        if (c === 47 || c === 63 || c === 35) { end = k; break; }
+        if (c < 128) {
+          if ((C[c] & 1) === 1) continue;
+          if (c === 37) { if (!pct(s, k)) return false; k += 2; continue; }
+          if (c === 58) { if (colon === -1) colon = k; continue; }
+          if (c === 64) { if (at !== -1) return false; at = k; brAt = br; colon = -1; continue; }
+          if (c === 91 || c === 93) { br = true; continue; }
+          return false;
+        }
+        if (!wide) return false;
+      }
+      if (brAt) return false;
+      const hs = at === -1 ? st : at + 1;
+      if (s.charCodeAt(hs) === 91) {
+        let close = -1;
+        for (let k = hs + 1; k < end; k++) if (s.charCodeAt(k) === 93) { close = k; break; }
+        if (close === -1 || !literal(s, hs + 1, close)) return false;
+        if (close + 1 < end) {
+          if (s.charCodeAt(close + 1) !== 58) return false;
+          for (let k = close + 2; k < end; k++) { c = s.charCodeAt(k); if (c < 48 || c > 57) return false; }
+        }
+      } else {
+        if (br) return false;
+        if (colon !== -1) for (let k = colon + 1; k < end; k++) { c = s.charCodeAt(k); if (c < 48 || c > 57) return false; }
+      }
+      i = end;
+    }
+    if (!scheme && !auth && s.charCodeAt(i) !== 47) {
+      for (; i < n; i++) {
+        c = s.charCodeAt(i);
+        if (c === 47 || c === 63 || c === 35) break;
+        if (c === 58) return false;
+        if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+        if (c < 128 ? P[c] === 0 : !wide) return false;
+      }
+    }
+    for (; i < n; i++) {
+      c = s.charCodeAt(i);
+      if (c < 128 ? P[c] === 0 : !wide) {
+        if (c === 63 || c === 35) break;
+        if (c === 37) { const a = s.charCodeAt(i + 1), b = s.charCodeAt(i + 2); if (!(a < 128 && b < 128 && H[a] === 1 && H[b] === 1)) return false; i += 2; continue; }
+        return false;
+      }
+    }
+    if (i >= n) return true;
+    if (c === 63) {
+      for (i++; i < n; i++) {
+        c = s.charCodeAt(i);
+        if (c < 128 ? Q[c] === 0 : !wide) {
+          if (c === 35) break;
+          if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+          return false;
+        }
+      }
+      if (i >= n) return true;
+    }
+    for (i++; i < n; i++) {
+      c = s.charCodeAt(i);
+      if (c < 128 ? Q[c] === 0 : !wide) {
+        if (c === 37) { if (!pct(s, i)) return false; i += 2; continue; }
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+module.exports = { __ataUri };

package/lib/validator-core.js

@@ -33,12 +33,13 @@ let _aotLoader = null;
 function _registerAot(load) {
   _aotLoader = load;
 }
-const { draftCode, normalizeDraft2019, normalizeDraft7, normalizeNullable, normalizeExclusiveBounds, stripFormatAssertions } = require("./draft7");
-const { enabledKeywords, stripDisabledKeywords } = require("./vocabularies");
+// draft7.js, vocabularies.js, shape-classifier.js and tier0.js load where
+// they are first used: a fresh process validating a 2020-12 schema runs none
+// of their code, and reading them cost it about a tenth of what it loads.
+const _draft7 = () => require("./draft7");
+const _vocabularies = () => require("./vocabularies");
 const { needsNormalization } = require("./schema-scan");
-const { isV1Dialect } = require("./dialect");
-const { classify } = require("./shape-classifier");
-const { buildTier0Plan, tier0Validate } = require("./tier0");
+const { isV1Dialect, draftCode } = require("./dialect");
 
 // The closure defaults pass. Only a validator without the generated
 // preprocess pass calls it, so it loads on that first call; loading it with
@@ -470,8 +471,9 @@ function _normalizeCallerSchema(s, inheritDraft7) {
 function _normalizeCallerSchemaUncached(s, inheritDraft7) {
   const declared = s && typeof s === 'object' ? s.$schema : undefined
   const code = declared !== undefined ? draftCode(declared) : (inheritDraft7 || 0)
-  const needsDraft7 = code === 1 || code === 2
-  const draft6 = code === 2
+  const needsDraft7 = code === 1 || code === 2 || code === 4
+  const draft4 = code === 4
+  const draft6 = code === 2 || draft4
   const draft2019 = code === 3
   // One walk answers whether there is anything to do. Almost always there is
   // not, and then the serialize, clone, normalize, serialize, compare below is
@@ -482,7 +484,8 @@ function _normalizeCallerSchemaUncached(s, inheritDraft7) {
   if (!draft6 && !draft2019 && !needsNormalization(s, needsDraft7)) return s
 
   const copy = _deepCloneWithSymbols(s)
-  if (needsDraft7) normalizeDraft7(copy, true, draft6)
+  const { normalizeDraft7, normalizeDraft2019, normalizeNullable, normalizeExclusiveBounds } = _draft7()
+  if (needsDraft7) normalizeDraft7(copy, true, draft6, draft4)
   if (draft2019) normalizeDraft2019(copy, true)
   normalizeNullable(copy)
   normalizeExclusiveBounds(copy)
@@ -615,7 +618,11 @@ function _applyVocabularies(schemaObj, original, schemaMap) {
   if (!schemaObj || typeof schemaObj !== 'object') return schemaObj
   const declared = schemaObj.$schema
   if (typeof declared !== 'string') return schemaObj
-  const enabled = enabledKeywords(schemaMap.get(declared))
+  // Only a meta-schema with a $vocabulary can disable a keyword.
+  const meta = schemaMap.get(declared)
+  if (!meta || typeof meta !== 'object' || !meta.$vocabulary || typeof meta.$vocabulary !== 'object') return schemaObj
+  const { enabledKeywords, stripDisabledKeywords } = _vocabularies()
+  const enabled = enabledKeywords(meta)
   if (!enabled) return schemaObj
   // `original` is the caller's own object when it reached here unchanged, and
   // that one is never mutated.
@@ -724,7 +731,7 @@ function _materializeSchema(self) {
     // Always on a copy: a normalized schema is shared by every validator built
     // from the same object (see _normalizeCallerSchema), so stripping in place
     // would take format checks away from the others.
-    schemaObj = stripFormatAssertions(_deepCloneWithSymbols(schemaObj));
+    schemaObj = _draft7().stripFormatAssertions(_deepCloneWithSymbols(schemaObj));
   }
   // A keyword used only in a schema reached through $ref counts too: the
   // interpreted engine applies it there, and every path that does not know the
@@ -2395,8 +2402,10 @@ _defineLazyMethod('isValidObject', (self) => {
     return self.isValidObject(data);
   }
   // Lazy: classify + build tier 0 plan on first call, not in constructor.
-  const _tier = classify(self._schemaObj);
+  const _tier = require("./shape-classifier").classify(self._schemaObj);
   if (_tier.tier === 0) {
+    // Bound once here, so the verdict below reads a local, not the module.
+    const { buildTier0Plan, tier0Validate } = require("./tier0");
     const _plan = buildTier0Plan(self._schemaObj);
     let _n = 0;
     _bindVerdict(self, (d) => {

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "1.53.0",
+  "version": "1.55.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
   "type": "commonjs",
   "main": "index.js",
@@ -88,7 +88,7 @@
     "rebuild": "cmake-js rebuild --target ata",
     "test": "node tests/run.js",
     "bench:size": "node benchmark/bench_aot_size.mjs",
-    "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1 && node tests/run_suite.js draft6 && node tests/run_suite.js draft2019-09",
+    "test:suite": "node tests/run_suite.js && node tests/run_suite.js draft7 && node tests/run_suite.js v1 && node tests/run_suite.js draft6 && node tests/run_suite.js draft2019-09 && node tests/run_suite.js draft4",
     "test:compat": "node tests/test_compat.js",
     "test:standard-schema": "node tests/test_standard_schema.js",
     "test:browser": "node tests/test_browser.js",
@@ -174,13 +174,13 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.53.0",
-    "@ata-validator/native-darwin-x64": "1.53.0",
-    "@ata-validator/native-linux-arm64-gnu": "1.53.0",
-    "@ata-validator/native-linux-arm64-musl": "1.53.0",
-    "@ata-validator/native-linux-x64-gnu": "1.53.0",
-    "@ata-validator/native-linux-x64-musl": "1.53.0",
-    "@ata-validator/native-win32-x64": "1.53.0"
+    "@ata-validator/native-darwin-arm64": "1.55.0",
+    "@ata-validator/native-darwin-x64": "1.55.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.55.0",
+    "@ata-validator/native-linux-arm64-musl": "1.55.0",
+    "@ata-validator/native-linux-x64-gnu": "1.55.0",
+    "@ata-validator/native-linux-x64-musl": "1.55.0",
+    "@ata-validator/native-win32-x64": "1.55.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"