ata-validator 1.62.1 → 1.63.1

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) {
@@ -242,6 +247,7 @@ function enumMember(P, data) {
 // JSON equality: the same function the code generator emits as `_deq`, so the
 // engines agree on what equal means (an object's own keys, in any order).
 const deepEqual = _deq;
+const propEnum = Object.prototype.propertyIsEnumerable;
 
 function codePointLength(s) {
   let n = 0;
@@ -364,6 +370,60 @@ function isObjectMap(v) {
 // per section so eval() can skip whole blocks without touching the schema
 // object. Plans have a fixed shape, which keeps eval() monomorphic where the
 // raw schema objects are not.
+// The keyword values of a schema node, from one pass over its enumerable
+// names (its own, as JSON gives them), in a record of one shape for link().
+const KEYWORD_RECORD = () => ({ '$ref': undefined, '$dynamicRef': undefined, type: undefined, enum: undefined, const: undefined, minimum: undefined, maximum: undefined, exclusiveMinimum: undefined, exclusiveMaximum: undefined, multipleOf: undefined, minLength: undefined, maxLength: undefined, pattern: undefined, format: undefined, minItems: undefined, maxItems: undefined, uniqueItems: undefined, prefixItems: undefined, items: undefined, contains: undefined, minContains: undefined, maxContains: undefined, required: undefined, minProperties: undefined, maxProperties: undefined, dependentRequired: undefined, propertyNames: undefined, properties: undefined, patternProperties: undefined, additionalProperties: undefined, dependentSchemas: undefined, propertyDependencies: undefined, allOf: undefined, anyOf: undefined, oneOf: undefined, not: undefined, if: undefined, then: undefined, else: undefined, unevaluatedProperties: undefined, unevaluatedItems: undefined });
+function readKeywords (schema) {
+  const S = KEYWORD_RECORD();
+  for (const k in schema) {
+    const v = schema[k];
+    switch (k) {
+      case '$ref': S['$ref'] = v; break;
+      case '$dynamicRef': S['$dynamicRef'] = v; break;
+      case 'type': S.type = v; break;
+      case 'enum': S.enum = v; break;
+      case 'const': S.const = v; break;
+      case 'minimum': S.minimum = v; break;
+      case 'maximum': S.maximum = v; break;
+      case 'exclusiveMinimum': S.exclusiveMinimum = v; break;
+      case 'exclusiveMaximum': S.exclusiveMaximum = v; break;
+      case 'multipleOf': S.multipleOf = v; break;
+      case 'minLength': S.minLength = v; break;
+      case 'maxLength': S.maxLength = v; break;
+      case 'pattern': S.pattern = v; break;
+      case 'format': S.format = v; break;
+      case 'minItems': S.minItems = v; break;
+      case 'maxItems': S.maxItems = v; break;
+      case 'uniqueItems': S.uniqueItems = v; break;
+      case 'prefixItems': S.prefixItems = v; break;
+      case 'items': S.items = v; break;
+      case 'contains': S.contains = v; break;
+      case 'minContains': S.minContains = v; break;
+      case 'maxContains': S.maxContains = v; break;
+      case 'required': S.required = v; break;
+      case 'minProperties': S.minProperties = v; break;
+      case 'maxProperties': S.maxProperties = v; break;
+      case 'dependentRequired': S.dependentRequired = v; break;
+      case 'propertyNames': S.propertyNames = v; break;
+      case 'properties': S.properties = v; break;
+      case 'patternProperties': S.patternProperties = v; break;
+      case 'additionalProperties': S.additionalProperties = v; break;
+      case 'dependentSchemas': S.dependentSchemas = v; break;
+      case 'propertyDependencies': S.propertyDependencies = v; break;
+      case 'allOf': S.allOf = v; break;
+      case 'anyOf': S.anyOf = v; break;
+      case 'oneOf': S.oneOf = v; break;
+      case 'not': S.not = v; break;
+      case 'if': S.if = v; break;
+      case 'then': S.then = v; break;
+      case 'else': S.else = v; break;
+      case 'unevaluatedProperties': S.unevaluatedProperties = v; break;
+      case 'unevaluatedItems': S.unevaluatedItems = v; break;
+    }
+  }
+  return S;
+}
+
 class Plan {
   // The plan is registered in the cache before `link` runs, so a schema
   // object that contains itself structurally resolves to the same plan
@@ -374,6 +434,13 @@ class Plan {
 
   link(interp) {
     const schema = this.schema;
+    // The keywords read once, by one pass over the schema's own names, into
+    // a record of one shape: read by name on the schema, each absent keyword
+    // was a lookup that missed on an object of yet another shape, and with
+    // many schemas in a process the 41 reads cost 3.7 us a node against 8 ns
+    // for the pass (measured on 64 shapes). Reads on the record hit one
+    // shape every time.
+    const S = readKeywords(schema);
     // Children are linked as plans (or booleans) up front, so a visit never
     // goes back through the plan cache. Reference targets are resolved at
     // evaluation time and cached per base URI.
@@ -382,21 +449,21 @@ class Plan {
     this.refBase0 = undefined;
     this.refRes0 = null;
     this.dynCache = null;
-    this.ref = typeof schema.$ref === 'string' ? schema.$ref : null;
-    this.dynamicRef = typeof schema.$dynamicRef === 'string' ? schema.$dynamicRef : null;
+    this.ref = typeof S.$ref === 'string' ? S.$ref : null;
+    this.dynamicRef = typeof S.$dynamicRef === 'string' ? S.$dynamicRef : null;
     this.tracked = this.ref !== null || this.dynamicRef !== null;
 
     this.typeMask = 0;
     this.typeNames = null;
-    if (schema.type !== undefined) {
-      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (S.type !== undefined) {
+      const types = Array.isArray(S.type) ? S.type : [S.type];
       let mask = 0;
       for (const t of types) mask |= typeBit(t);
       this.typeMask = mask;
       this.typeNames = types;
     }
-    this.hasType = schema.type !== undefined;
-    this.enum = schema.enum !== undefined ? schema.enum : null;
+    this.hasType = S.type !== undefined;
+    this.enum = S.enum !== undefined ? S.enum : null;
     // Membership for enumMember(): the primitive values in a Set, so a long
     // enum answers in one lookup, and the object and array values, which only
     // deepEqual can compare, in a list. Scanning every value with deepEqual
@@ -412,28 +479,28 @@ class Plan {
         else if (!(typeof v === 'number' && v !== v)) this.enumPrims.add(v);
       }
     }
-    this.hasConst = schema.const !== undefined;
-    this.const = schema.const;
-
-    this.minimum = typeof schema.minimum === 'number' ? schema.minimum : undefined;
-    this.maximum = typeof schema.maximum === 'number' ? schema.maximum : undefined;
-    this.exclusiveMinimum = typeof schema.exclusiveMinimum === 'number' ? schema.exclusiveMinimum : undefined;
-    this.exclusiveMaximum = typeof schema.exclusiveMaximum === 'number' ? schema.exclusiveMaximum : undefined;
-    this.multipleOf = typeof schema.multipleOf === 'number' ? schema.multipleOf : undefined;
+    this.hasConst = S.const !== undefined;
+    this.const = S.const;
+
+    this.minimum = typeof S.minimum === 'number' ? S.minimum : undefined;
+    this.maximum = typeof S.maximum === 'number' ? S.maximum : undefined;
+    this.exclusiveMinimum = typeof S.exclusiveMinimum === 'number' ? S.exclusiveMinimum : undefined;
+    this.exclusiveMaximum = typeof S.exclusiveMaximum === 'number' ? S.exclusiveMaximum : undefined;
+    this.multipleOf = typeof S.multipleOf === 'number' ? S.multipleOf : undefined;
     this.hasNumber = this.minimum !== undefined || this.maximum !== undefined || this.exclusiveMinimum !== undefined || this.exclusiveMaximum !== undefined || this.multipleOf !== undefined;
 
-    this.minLength = schema.minLength;
-    this.maxLength = schema.maxLength;
-    this.pattern = schema.pattern !== undefined ? interp.pattern(schema.pattern) : null;
-    this.patternSource = schema.pattern;
-    this.format = schema.format;
+    this.minLength = S.minLength;
+    this.maxLength = S.maxLength;
+    this.pattern = S.pattern !== undefined ? interp.pattern(S.pattern) : null;
+    this.patternSource = S.pattern;
+    this.format = S.format;
     this.formatFn = null;
-    if (schema.format !== undefined) {
+    if (S.format !== undefined) {
       // Own properties only, as the generated code reads them: an inherited
       // Object member ('hasOwnProperty', 'constructor') is not a check.
       const own = Object.prototype.hasOwnProperty;
       const uf = interp.userFormats;
-      const f = schema.format;
+      const f = S.format;
       const table = require('./formats').formatChecks();
       const fc = (uf && typeof f === 'string' && own.call(uf, f) && typeof uf[f] === 'function') ? uf[f]
         : (typeof f === 'string' && own.call(table, f) && typeof table[f] === 'function' ? table[f] : null);
@@ -443,31 +510,31 @@ class Plan {
     // A format compat registered for numbers (`type: 'number'`), checked on
     // numbers as the reference checks it.
     const nf = interp.numberFormats;
-    this.numFormatFn = schema.format !== undefined && nf !== null && typeof nf[schema.format] === 'function' ? nf[schema.format] : null;
+    this.numFormatFn = S.format !== undefined && nf !== null && typeof nf[S.format] === 'function' ? nf[S.format] : null;
     if (this.numFormatFn !== null) this.hasNumber = true;
 
-    this.minItems = schema.minItems;
-    this.maxItems = schema.maxItems;
-    this.uniqueItems = schema.uniqueItems === true;
-    this.prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems.map(child) : null;
-    this.items = schema.items !== undefined ? child(schema.items) : undefined;
-    this.contains = schema.contains !== undefined ? child(schema.contains) : undefined;
-    this.minContains = schema.minContains;
-    this.maxContains = schema.maxContains;
+    this.minItems = S.minItems;
+    this.maxItems = S.maxItems;
+    this.uniqueItems = S.uniqueItems === true;
+    this.prefixItems = Array.isArray(S.prefixItems) ? S.prefixItems.map(child) : null;
+    this.items = S.items !== undefined ? child(S.items) : undefined;
+    this.contains = S.contains !== undefined ? child(S.contains) : undefined;
+    this.minContains = S.minContains;
+    this.maxContains = S.maxContains;
     this.hasArray = this.minItems !== undefined || this.maxItems !== undefined || this.uniqueItems || this.prefixItems !== null || this.items !== undefined || this.contains !== undefined;
 
-    this.required = Array.isArray(schema.required) ? schema.required : null;
-    this.minProperties = schema.minProperties;
-    this.maxProperties = schema.maxProperties;
-    this.dependentRequired = isObjectMap(schema.dependentRequired) ? Object.entries(schema.dependentRequired) : null;
-    this.propertyNames = schema.propertyNames !== undefined ? child(schema.propertyNames) : undefined;
+    this.required = Array.isArray(S.required) ? S.required : null;
+    this.minProperties = S.minProperties;
+    this.maxProperties = S.maxProperties;
+    this.dependentRequired = isObjectMap(S.dependentRequired) ? Object.entries(S.dependentRequired) : null;
+    this.propertyNames = S.propertyNames !== undefined ? child(S.propertyNames) : undefined;
     this.properties = null;
-    if (isObjectMap(schema.properties)) {
+    if (isObjectMap(S.properties)) {
       this.properties = new Map();
-      for (const key of Object.keys(schema.properties)) {
+      for (const key of Object.keys(S.properties)) {
         const ek = escapePointer(key);
         // Escaped once here; the walk only concatenates.
-        this.properties.set(key, { node: child(schema.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
+        this.properties.set(key, { node: child(S.properties[key]), seg: '/' + ek, schemaSeg: '/properties/' + ek });
       }
     }
     // A required key holding undefined is missing. Where the key is also a
@@ -486,26 +553,26 @@ class Plan {
       }
     }
     this.patternProperties = null;
-    if (isObjectMap(schema.patternProperties)) {
-      this.patternProperties = Object.keys(schema.patternProperties).map((src) => ({ src, re: interp.pattern(src), node: child(schema.patternProperties[src]) }));
+    if (isObjectMap(S.patternProperties)) {
+      this.patternProperties = Object.keys(S.patternProperties).map((src) => ({ src, re: interp.pattern(src), node: child(S.patternProperties[src]) }));
     }
-    this.additionalProperties = schema.additionalProperties !== undefined ? child(schema.additionalProperties) : undefined;
-    this.dependentSchemas = isObjectMap(schema.dependentSchemas) ? Object.entries(schema.dependentSchemas).map(([k, v]) => [k, child(v)]) : null;
+    this.additionalProperties = S.additionalProperties !== undefined ? child(S.additionalProperties) : undefined;
+    this.dependentSchemas = isObjectMap(S.dependentSchemas) ? Object.entries(S.dependentSchemas).map(([k, v]) => [k, child(v)]) : null;
     this.propertyDependencies = null;
-    if (isObjectMap(schema.propertyDependencies)) {
-      this.propertyDependencies = Object.entries(schema.propertyDependencies)
+    if (isObjectMap(S.propertyDependencies)) {
+      this.propertyDependencies = Object.entries(S.propertyDependencies)
         .filter(([, choices]) => isObjectMap(choices))
         .map(([k, choices]) => [k, new Map(Object.keys(choices).map((v) => [v, child(choices[v])]))]);
     }
     this.hasObject = this.required !== null || this.minProperties !== undefined || this.maxProperties !== undefined || this.dependentRequired !== null || this.propertyNames !== undefined || this.properties !== null || this.patternProperties !== null || this.additionalProperties !== undefined || this.dependentSchemas !== null || this.propertyDependencies !== null;
 
-    this.allOf = Array.isArray(schema.allOf) ? schema.allOf.map(child) : null;
-    this.anyOf = Array.isArray(schema.anyOf) ? schema.anyOf.map(child) : null;
-    this.oneOf = Array.isArray(schema.oneOf) ? schema.oneOf.map(child) : null;
-    this.not = schema.not !== undefined ? child(schema.not) : undefined;
-    this.if = schema.if !== undefined ? child(schema.if) : undefined;
-    this.then = schema.then !== undefined ? child(schema.then) : undefined;
-    this.else = schema.else !== undefined ? child(schema.else) : undefined;
+    this.allOf = Array.isArray(S.allOf) ? S.allOf.map(child) : null;
+    this.anyOf = Array.isArray(S.anyOf) ? S.anyOf.map(child) : null;
+    this.oneOf = Array.isArray(S.oneOf) ? S.oneOf.map(child) : null;
+    this.not = S.not !== undefined ? child(S.not) : undefined;
+    this.if = S.if !== undefined ? child(S.if) : undefined;
+    this.then = S.then !== undefined ? child(S.then) : undefined;
+    this.else = S.else !== undefined ? child(S.else) : undefined;
     // Macro keywords: the schema the macro returns is applied in place, the
     // way the reference validator does it, so its errors carry the keyword's
     // path and the keyword adds an error of its own when that schema fails.
@@ -522,13 +589,13 @@ class Plan {
     }
     this.hasApplicators = this.allOf !== null || this.anyOf !== null || this.oneOf !== null || this.not !== undefined || this.if !== undefined || this.macros !== null;
 
-    this.unevaluatedProperties = schema.unevaluatedProperties !== undefined ? child(schema.unevaluatedProperties) : undefined;
-    this.unevaluatedItems = schema.unevaluatedItems !== undefined ? child(schema.unevaluatedItems) : undefined;
+    this.unevaluatedProperties = S.unevaluatedProperties !== undefined ? child(S.unevaluatedProperties) : undefined;
+    this.unevaluatedItems = S.unevaluatedItems !== undefined ? child(S.unevaluatedItems) : undefined;
     // A `false` here rejects the member outright, and the error belongs to this
     // keyword on this object, not to a boolean schema that happens to sit
     // under it. Recorded at compile time so the check below is one test.
-    this.unevaluatedPropertiesFalse = schema.unevaluatedProperties === false;
-    this.unevaluatedItemsFalse = schema.unevaluatedItems === false;
+    this.unevaluatedPropertiesFalse = S.unevaluatedProperties === false;
+    this.unevaluatedItemsFalse = S.unevaluatedItems === false;
     this.hasUnevaluated = this.unevaluatedProperties !== undefined || this.unevaluatedItems !== undefined;
 
     // Custom keywords present on this node, in schema order. Each op holds
@@ -847,7 +914,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 +987,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)) {
@@ -1244,9 +1313,15 @@ class Interpreter {
       }
     }
 
-    // objects
+    // objects. The object's own names, enumerable or not: a declared
+    // property is read by name, as the generated code reads it, so one
+    // hidden under its name is checked; patternProperties, propertyNames
+    // and additionalProperties see the names for-in sees, as there too, and
+    // minProperties and maxProperties count those.
     if (P.hasObject && bits === T_OBJECT) {
-      const keys = Object.keys(data);
+      const keys = Object.getOwnPropertyNames(data);
+      let hidden = 0;
+      if (P.minProperties !== undefined || P.maxProperties !== undefined) for (let k = 0; k < keys.length; k++) if (!propEnum.call(data, keys[k])) hidden++;
       if (P.required !== null) {
         const req = P.required;
         for (let i = 0; i < req.length; i++) {
@@ -1254,8 +1329,8 @@ class Interpreter {
           if (!Object.hasOwn(data, key) || (P.requiredUndef !== null && P.requiredUndef[i] && data[key] === undefined)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
         }
       }
-      if (P.minProperties !== undefined && keys.length < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
-      if (P.maxProperties !== undefined && keys.length > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
+      if (P.minProperties !== undefined && keys.length - hidden < P.minProperties) { errors === NOERRORS || errors.push(err('minProperties', 'minProperties', instancePath, schemaPath + '/minProperties', { limit: P.minProperties }, `must NOT have fewer than ${P.minProperties} properties`)); valid = false; }
+      if (P.maxProperties !== undefined && keys.length - hidden > P.maxProperties) { errors === NOERRORS || errors.push(err('maxProperties', 'maxProperties', instancePath, schemaPath + '/maxProperties', { limit: P.maxProperties }, `must NOT have more than ${P.maxProperties} properties`)); valid = false; }
       if (P.dependentRequired !== null) {
         for (const [key, deps] of P.dependentRequired) {
           if (Object.hasOwn(data, key)) {
@@ -1267,6 +1342,7 @@ class Interpreter {
       }
       if (P.propertyNames !== undefined) {
         for (const key of keys) {
+          if (!propEnum.call(data, key)) continue;
           if (!this.eval(P.propertyNames, key, base, dynScope, errors, instancePath, E ? schemaPath + '/propertyNames' : '', stack, DISCARD)) valid = false;
         }
       }
@@ -1276,6 +1352,7 @@ class Interpreter {
         const key = keys[k];
         let evaluated = false;
         const prop = props !== null ? props.get(key) : undefined;
+        const seen = prop !== undefined && patterns === null && P.additionalProperties === undefined || propEnum.call(data, key);
         if (prop !== undefined) {
           // A declared property whose value is undefined is not checked, as the
           // generated code does not check it: no JSON document carries one, and
@@ -1287,7 +1364,7 @@ class Interpreter {
           } else if (P.requiredInProps !== null && P.requiredInProps.has(key)) { errors === NOERRORS || errors.push(err('required', 'required', instancePath, schemaPath + '/required', { missingProperty: key }, `must have required property '${key}'`)); valid = false; }
           evaluated = true;
         }
-        if (patterns !== null) {
+        if (patterns !== null && seen) {
           for (let pi = 0; pi < patterns.length; pi++) {
             const pp = patterns[pi];
             if (pp.re.test(key)) {
@@ -1296,7 +1373,7 @@ class Interpreter {
             }
           }
         }
-        if (!evaluated && P.additionalProperties !== undefined) {
+        if (!evaluated && seen && P.additionalProperties !== undefined) {
           // `additionalProperties: false` keeps its own keyword and names the
           // property it turned away. Running it as a plain false subschema
           // reported `not` at the key's path, which drops both.
@@ -1549,7 +1626,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 };