@rebilly/instruments 9.32.1 → 9.32.2

package/dist/index.js

@@ -5690,7 +5690,7 @@ function Jt(e2, t2) {
   return s;
 }
 var Gt = P$1;
-const Yt = /* @__PURE__ */ wt(Gt), Qt = "56.15.0";
+const Yt = /* @__PURE__ */ wt(Gt), Qt = "56.15.1";
 let Xt = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", Zt = (e2 = 21) => {
   let t2 = "", s = e2;
   for (; s--; )
@@ -11172,7 +11172,7 @@ async function U() {
       requestId: l.requestId
     };
   } catch (r2) {
-    return console.log(r2), {};
+    return console.error(r2), {};
   }
 }
 async function De() {
@@ -15481,6 +15481,7 @@ async function fetchData({
       availableInstruments
     });
   } catch (error2) {
+    console.error(error2);
   }
   return new DataInstance({});
 }
@@ -17405,29 +17406,29 @@ var util = {};
 })(util);
 var names$1 = {};
 Object.defineProperty(names$1, "__esModule", { value: true });
-const codegen_1$s = codegen;
+const codegen_1$x = codegen;
 const names = {
   // validation function arguments
-  data: new codegen_1$s.Name("data"),
+  data: new codegen_1$x.Name("data"),
   // args passed from referencing schema
-  valCxt: new codegen_1$s.Name("valCxt"),
-  instancePath: new codegen_1$s.Name("instancePath"),
-  parentData: new codegen_1$s.Name("parentData"),
-  parentDataProperty: new codegen_1$s.Name("parentDataProperty"),
-  rootData: new codegen_1$s.Name("rootData"),
-  dynamicAnchors: new codegen_1$s.Name("dynamicAnchors"),
+  valCxt: new codegen_1$x.Name("valCxt"),
+  instancePath: new codegen_1$x.Name("instancePath"),
+  parentData: new codegen_1$x.Name("parentData"),
+  parentDataProperty: new codegen_1$x.Name("parentDataProperty"),
+  rootData: new codegen_1$x.Name("rootData"),
+  dynamicAnchors: new codegen_1$x.Name("dynamicAnchors"),
   // function scoped variables
-  vErrors: new codegen_1$s.Name("vErrors"),
-  errors: new codegen_1$s.Name("errors"),
-  this: new codegen_1$s.Name("this"),
+  vErrors: new codegen_1$x.Name("vErrors"),
+  errors: new codegen_1$x.Name("errors"),
+  this: new codegen_1$x.Name("this"),
   // "globals"
-  self: new codegen_1$s.Name("self"),
-  scope: new codegen_1$s.Name("scope"),
+  self: new codegen_1$x.Name("self"),
+  scope: new codegen_1$x.Name("scope"),
   // JTD serialize/parse name for JSON string and position
-  json: new codegen_1$s.Name("json"),
-  jsonPos: new codegen_1$s.Name("jsonPos"),
-  jsonLen: new codegen_1$s.Name("jsonLen"),
-  jsonPart: new codegen_1$s.Name("jsonPart")
+  json: new codegen_1$x.Name("json"),
+  jsonPos: new codegen_1$x.Name("jsonPos"),
+  jsonLen: new codegen_1$x.Name("jsonLen"),
+  jsonPart: new codegen_1$x.Name("jsonPart")
 };
 names$1.default = names;
 (function(exports) {
@@ -17546,56 +17547,49 @@ names$1.default = names;
       keyValues.push([E.propertyName, propertyName]);
   }
 })(errors);
-var hasRequiredBoolSchema;
-function requireBoolSchema() {
-  if (hasRequiredBoolSchema)
-    return boolSchema;
-  hasRequiredBoolSchema = 1;
-  Object.defineProperty(boolSchema, "__esModule", { value: true });
-  boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
-  const errors_1 = errors;
-  const codegen_12 = codegen;
-  const names_12 = names$1;
-  const boolError = {
-    message: "boolean schema is false"
-  };
-  function topBoolOrEmptySchema(it2) {
-    const { gen, schema: schema2, validateName } = it2;
-    if (schema2 === false) {
-      falseSchemaError(it2, false);
-    } else if (typeof schema2 == "object" && schema2.$async === true) {
-      gen.return(names_12.default.data);
-    } else {
-      gen.assign((0, codegen_12._)`${validateName}.errors`, null);
-      gen.return(true);
-    }
-  }
-  boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema;
-  function boolOrEmptySchema(it2, valid) {
-    const { gen, schema: schema2 } = it2;
-    if (schema2 === false) {
-      gen.var(valid, false);
-      falseSchemaError(it2);
-    } else {
-      gen.var(valid, true);
-    }
+Object.defineProperty(boolSchema, "__esModule", { value: true });
+boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
+const errors_1$2 = errors;
+const codegen_1$w = codegen;
+const names_1$9 = names$1;
+const boolError = {
+  message: "boolean schema is false"
+};
+function topBoolOrEmptySchema(it2) {
+  const { gen, schema: schema2, validateName } = it2;
+  if (schema2 === false) {
+    falseSchemaError(it2, false);
+  } else if (typeof schema2 == "object" && schema2.$async === true) {
+    gen.return(names_1$9.default.data);
+  } else {
+    gen.assign((0, codegen_1$w._)`${validateName}.errors`, null);
+    gen.return(true);
   }
-  boolSchema.boolOrEmptySchema = boolOrEmptySchema;
-  function falseSchemaError(it2, overrideAllErrors) {
-    const { gen, data } = it2;
-    const cxt = {
-      gen,
-      keyword: "false schema",
-      data,
-      schema: false,
-      schemaCode: false,
-      schemaValue: false,
-      params: {},
-      it: it2
-    };
-    (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
+}
+boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema;
+function boolOrEmptySchema(it2, valid) {
+  const { gen, schema: schema2 } = it2;
+  if (schema2 === false) {
+    gen.var(valid, false);
+    falseSchemaError(it2);
+  } else {
+    gen.var(valid, true);
   }
-  return boolSchema;
+}
+boolSchema.boolOrEmptySchema = boolOrEmptySchema;
+function falseSchemaError(it2, overrideAllErrors) {
+  const { gen, data } = it2;
+  const cxt = {
+    gen,
+    keyword: "false schema",
+    data,
+    schema: false,
+    schemaCode: false,
+    schemaValue: false,
+    params: {},
+    it: it2
+  };
+  (0, errors_1$2.reportError)(cxt, boolError, void 0, overrideAllErrors);
 }
 var dataType = {};
 var rules = {};
@@ -17644,8 +17638,8 @@ applicability.shouldUseRule = shouldUseRule;
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
   const rules_1 = rules;
-  const applicability_1 = applicability;
-  const errors_1 = errors;
+  const applicability_12 = applicability;
+  const errors_12 = errors;
   const codegen_12 = codegen;
   const util_12 = util;
   var DataType;
@@ -17679,7 +17673,7 @@ applicability.shouldUseRule = shouldUseRule;
   function coerceAndCheckDataType(it2, types2) {
     const { gen, data, opts } = it2;
     const coerceTo = coerceToTypes(types2, opts.coerceTypes);
-    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1.schemaHasRulesForType)(it2, types2[0]));
+    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_12.schemaHasRulesForType)(it2, types2[0]));
     if (checkTypes) {
       const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
@@ -17800,7 +17794,7 @@ applicability.shouldUseRule = shouldUseRule;
   };
   function reportTypeError(it2) {
     const cxt = getTypeErrorContext(it2);
-    (0, errors_1.reportError)(cxt, typeError);
+    (0, errors_12.reportError)(cxt, typeError);
   }
   exports.reportTypeError = reportTypeError;
   function getTypeErrorContext(it2) {
@@ -17820,61 +17814,54 @@ applicability.shouldUseRule = shouldUseRule;
   }
 })(dataType);
 var defaults = {};
-var hasRequiredDefaults;
-function requireDefaults() {
-  if (hasRequiredDefaults)
-    return defaults;
-  hasRequiredDefaults = 1;
-  Object.defineProperty(defaults, "__esModule", { value: true });
-  defaults.assignDefaults = void 0;
-  const codegen_12 = codegen;
-  const util_12 = util;
-  function assignDefaults(it2, ty) {
-    const { properties: properties2, items: items2 } = it2.schema;
-    if (ty === "object" && properties2) {
-      for (const key in properties2) {
-        assignDefault(it2, key, properties2[key].default);
-      }
-    } else if (ty === "array" && Array.isArray(items2)) {
-      items2.forEach((sch, i) => assignDefault(it2, i, sch.default));
-    }
+Object.defineProperty(defaults, "__esModule", { value: true });
+defaults.assignDefaults = void 0;
+const codegen_1$v = codegen;
+const util_1$t = util;
+function assignDefaults(it2, ty) {
+  const { properties: properties2, items: items2 } = it2.schema;
+  if (ty === "object" && properties2) {
+    for (const key in properties2) {
+      assignDefault(it2, key, properties2[key].default);
+    }
+  } else if (ty === "array" && Array.isArray(items2)) {
+    items2.forEach((sch, i) => assignDefault(it2, i, sch.default));
+  }
+}
+defaults.assignDefaults = assignDefaults;
+function assignDefault(it2, prop, defaultValue) {
+  const { gen, compositeRule, data, opts } = it2;
+  if (defaultValue === void 0)
+    return;
+  const childData = (0, codegen_1$v._)`${data}${(0, codegen_1$v.getProperty)(prop)}`;
+  if (compositeRule) {
+    (0, util_1$t.checkStrictMode)(it2, `default is ignored for: ${childData}`);
+    return;
   }
-  defaults.assignDefaults = assignDefaults;
-  function assignDefault(it2, prop, defaultValue) {
-    const { gen, compositeRule, data, opts } = it2;
-    if (defaultValue === void 0)
-      return;
-    const childData = (0, codegen_12._)`${data}${(0, codegen_12.getProperty)(prop)}`;
-    if (compositeRule) {
-      (0, util_12.checkStrictMode)(it2, `default is ignored for: ${childData}`);
-      return;
-    }
-    let condition = (0, codegen_12._)`${childData} === undefined`;
-    if (opts.useDefaults === "empty") {
-      condition = (0, codegen_12._)`${condition} || ${childData} === null || ${childData} === ""`;
-    }
-    gen.if(condition, (0, codegen_12._)`${childData} = ${(0, codegen_12.stringify)(defaultValue)}`);
+  let condition = (0, codegen_1$v._)`${childData} === undefined`;
+  if (opts.useDefaults === "empty") {
+    condition = (0, codegen_1$v._)`${condition} || ${childData} === null || ${childData} === ""`;
   }
-  return defaults;
+  gen.if(condition, (0, codegen_1$v._)`${childData} = ${(0, codegen_1$v.stringify)(defaultValue)}`);
 }
 var keyword = {};
 var code = {};
 Object.defineProperty(code, "__esModule", { value: true });
 code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
-const codegen_1$r = codegen;
-const util_1$q = util;
-const names_1$6 = names$1;
+const codegen_1$u = codegen;
+const util_1$s = util;
+const names_1$8 = names$1;
 const util_2$1 = util;
 function checkReportMissingProp(cxt, prop) {
   const { gen, data, it: it2 } = cxt;
   gen.if(noPropertyInData(gen, data, prop, it2.opts.ownProperties), () => {
-    cxt.setParams({ missingProperty: (0, codegen_1$r._)`${prop}` }, true);
+    cxt.setParams({ missingProperty: (0, codegen_1$u._)`${prop}` }, true);
     cxt.error();
   });
 }
 code.checkReportMissingProp = checkReportMissingProp;
 function checkMissingProp({ gen, data, it: { opts } }, properties2, missing) {
-  return (0, codegen_1$r.or)(...properties2.map((prop) => (0, codegen_1$r.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1$r._)`${missing} = ${prop}`)));
+  return (0, codegen_1$u.or)(...properties2.map((prop) => (0, codegen_1$u.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1$u._)`${missing} = ${prop}`)));
 }
 code.checkMissingProp = checkMissingProp;
 function reportMissingProp(cxt, missing) {
@@ -17886,22 +17873,22 @@ function hasPropFunc(gen) {
   return gen.scopeValue("func", {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     ref: Object.prototype.hasOwnProperty,
-    code: (0, codegen_1$r._)`Object.prototype.hasOwnProperty`
+    code: (0, codegen_1$u._)`Object.prototype.hasOwnProperty`
   });
 }
 code.hasPropFunc = hasPropFunc;
 function isOwnProperty(gen, data, property) {
-  return (0, codegen_1$r._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
+  return (0, codegen_1$u._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
 }
 code.isOwnProperty = isOwnProperty;
 function propertyInData(gen, data, property, ownProperties) {
-  const cond = (0, codegen_1$r._)`${data}${(0, codegen_1$r.getProperty)(property)} !== undefined`;
-  return ownProperties ? (0, codegen_1$r._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
+  const cond = (0, codegen_1$u._)`${data}${(0, codegen_1$u.getProperty)(property)} !== undefined`;
+  return ownProperties ? (0, codegen_1$u._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
 }
 code.propertyInData = propertyInData;
 function noPropertyInData(gen, data, property, ownProperties) {
-  const cond = (0, codegen_1$r._)`${data}${(0, codegen_1$r.getProperty)(property)} === undefined`;
-  return ownProperties ? (0, codegen_1$r.or)(cond, (0, codegen_1$r.not)(isOwnProperty(gen, data, property))) : cond;
+  const cond = (0, codegen_1$u._)`${data}${(0, codegen_1$u.getProperty)(property)} === undefined`;
+  return ownProperties ? (0, codegen_1$u.or)(cond, (0, codegen_1$u.not)(isOwnProperty(gen, data, property))) : cond;
 }
 code.noPropertyInData = noPropertyInData;
 function allSchemaProperties(schemaMap) {
@@ -17909,24 +17896,24 @@ function allSchemaProperties(schemaMap) {
 }
 code.allSchemaProperties = allSchemaProperties;
 function schemaProperties(it2, schemaMap) {
-  return allSchemaProperties(schemaMap).filter((p2) => !(0, util_1$q.alwaysValidSchema)(it2, schemaMap[p2]));
+  return allSchemaProperties(schemaMap).filter((p2) => !(0, util_1$s.alwaysValidSchema)(it2, schemaMap[p2]));
 }
 code.schemaProperties = schemaProperties;
 function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it: it2 }, func, context, passSchema) {
-  const dataAndSchema = passSchema ? (0, codegen_1$r._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
+  const dataAndSchema = passSchema ? (0, codegen_1$u._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
   const valCxt = [
-    [names_1$6.default.instancePath, (0, codegen_1$r.strConcat)(names_1$6.default.instancePath, errorPath)],
-    [names_1$6.default.parentData, it2.parentData],
-    [names_1$6.default.parentDataProperty, it2.parentDataProperty],
-    [names_1$6.default.rootData, names_1$6.default.rootData]
+    [names_1$8.default.instancePath, (0, codegen_1$u.strConcat)(names_1$8.default.instancePath, errorPath)],
+    [names_1$8.default.parentData, it2.parentData],
+    [names_1$8.default.parentDataProperty, it2.parentDataProperty],
+    [names_1$8.default.rootData, names_1$8.default.rootData]
   ];
   if (it2.opts.dynamicRef)
-    valCxt.push([names_1$6.default.dynamicAnchors, names_1$6.default.dynamicAnchors]);
-  const args = (0, codegen_1$r._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
-  return context !== codegen_1$r.nil ? (0, codegen_1$r._)`${func}.call(${context}, ${args})` : (0, codegen_1$r._)`${func}(${args})`;
+    valCxt.push([names_1$8.default.dynamicAnchors, names_1$8.default.dynamicAnchors]);
+  const args = (0, codegen_1$u._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
+  return context !== codegen_1$u.nil ? (0, codegen_1$u._)`${func}.call(${context}, ${args})` : (0, codegen_1$u._)`${func}(${args})`;
 }
 code.callValidateCode = callValidateCode;
-const newRegExp = (0, codegen_1$r._)`new RegExp`;
+const newRegExp = (0, codegen_1$u._)`new RegExp`;
 function usePattern({ gen, it: { opts } }, pattern2) {
   const u = opts.unicodeRegExp ? "u" : "";
   const { regExp } = opts.code;
@@ -17934,7 +17921,7 @@ function usePattern({ gen, it: { opts } }, pattern2) {
   return gen.scopeValue("pattern", {
     key: rx.toString(),
     ref: rx,
-    code: (0, codegen_1$r._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern2}, ${u})`
+    code: (0, codegen_1$u._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern2}, ${u})`
   });
 }
 code.usePattern = usePattern;
@@ -17950,14 +17937,14 @@ function validateArray(cxt) {
   validateItems(() => gen.break());
   return valid;
   function validateItems(notValid) {
-    const len = gen.const("len", (0, codegen_1$r._)`${data}.length`);
+    const len = gen.const("len", (0, codegen_1$u._)`${data}.length`);
     gen.forRange("i", 0, len, (i) => {
       cxt.subschema({
         keyword: keyword2,
         dataProp: i,
-        dataPropType: util_1$q.Type.Num
+        dataPropType: util_1$s.Type.Num
       }, valid);
-      gen.if((0, codegen_1$r.not)(valid), notValid);
+      gen.if((0, codegen_1$u.not)(valid), notValid);
     });
   }
 }
@@ -17966,7 +17953,7 @@ function validateUnion(cxt) {
   const { gen, schema: schema2, keyword: keyword2, it: it2 } = cxt;
   if (!Array.isArray(schema2))
     throw new Error("ajv implementation error");
-  const alwaysValid = schema2.some((sch) => (0, util_1$q.alwaysValidSchema)(it2, sch));
+  const alwaysValid = schema2.some((sch) => (0, util_1$s.alwaysValidSchema)(it2, sch));
   if (alwaysValid && !it2.opts.unevaluated)
     return;
   const valid = gen.let("valid", false);
@@ -17977,216 +17964,202 @@ function validateUnion(cxt) {
       schemaProp: i,
       compositeRule: true
     }, schValid);
-    gen.assign(valid, (0, codegen_1$r._)`${valid} || ${schValid}`);
+    gen.assign(valid, (0, codegen_1$u._)`${valid} || ${schValid}`);
     const merged = cxt.mergeValidEvaluated(schCxt, schValid);
     if (!merged)
-      gen.if((0, codegen_1$r.not)(valid));
+      gen.if((0, codegen_1$u.not)(valid));
   }));
   cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
 }
 code.validateUnion = validateUnion;
-var hasRequiredKeyword;
-function requireKeyword() {
-  if (hasRequiredKeyword)
-    return keyword;
-  hasRequiredKeyword = 1;
-  Object.defineProperty(keyword, "__esModule", { value: true });
-  keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0;
-  const codegen_12 = codegen;
-  const names_12 = names$1;
-  const code_12 = code;
-  const errors_1 = errors;
-  function macroKeywordCode(cxt, def2) {
-    const { gen, keyword: keyword2, schema: schema2, parentSchema, it: it2 } = cxt;
-    const macroSchema = def2.macro.call(it2.self, schema2, parentSchema, it2);
-    const schemaRef = useKeyword(gen, keyword2, macroSchema);
-    if (it2.opts.validateSchema !== false)
-      it2.self.validateSchema(macroSchema, true);
-    const valid = gen.name("valid");
-    cxt.subschema({
-      schema: macroSchema,
-      schemaPath: codegen_12.nil,
-      errSchemaPath: `${it2.errSchemaPath}/${keyword2}`,
-      topSchemaRef: schemaRef,
-      compositeRule: true
-    }, valid);
-    cxt.pass(valid, () => cxt.error(true));
-  }
-  keyword.macroKeywordCode = macroKeywordCode;
-  function funcKeywordCode(cxt, def2) {
-    var _a;
-    const { gen, keyword: keyword2, schema: schema2, parentSchema, $data, it: it2 } = cxt;
-    checkAsyncKeyword(it2, def2);
-    const validate2 = !$data && def2.compile ? def2.compile.call(it2.self, schema2, parentSchema, it2) : def2.validate;
-    const validateRef = useKeyword(gen, keyword2, validate2);
-    const valid = gen.let("valid");
-    cxt.block$data(valid, validateKeyword);
-    cxt.ok((_a = def2.valid) !== null && _a !== void 0 ? _a : valid);
-    function validateKeyword() {
-      if (def2.errors === false) {
-        assignValid();
-        if (def2.modifying)
-          modifyData(cxt);
-        reportErrs(() => cxt.error());
-      } else {
-        const ruleErrs = def2.async ? validateAsync() : validateSync();
-        if (def2.modifying)
-          modifyData(cxt);
-        reportErrs(() => addErrs(cxt, ruleErrs));
-      }
-    }
-    function validateAsync() {
-      const ruleErrs = gen.let("ruleErrs", null);
-      gen.try(() => assignValid((0, codegen_12._)`await `), (e2) => gen.assign(valid, false).if((0, codegen_12._)`${e2} instanceof ${it2.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_12._)`${e2}.errors`), () => gen.throw(e2)));
-      return ruleErrs;
-    }
-    function validateSync() {
-      const validateErrs = (0, codegen_12._)`${validateRef}.errors`;
-      gen.assign(validateErrs, null);
-      assignValid(codegen_12.nil);
-      return validateErrs;
-    }
-    function assignValid(_await = def2.async ? (0, codegen_12._)`await ` : codegen_12.nil) {
-      const passCxt = it2.opts.passContext ? names_12.default.this : names_12.default.self;
-      const passSchema = !("compile" in def2 && !$data || def2.schema === false);
-      gen.assign(valid, (0, codegen_12._)`${_await}${(0, code_12.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def2.modifying);
-    }
-    function reportErrs(errors2) {
-      var _a2;
-      gen.if((0, codegen_12.not)((_a2 = def2.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors2);
+Object.defineProperty(keyword, "__esModule", { value: true });
+keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0;
+const codegen_1$t = codegen;
+const names_1$7 = names$1;
+const code_1$9 = code;
+const errors_1$1 = errors;
+function macroKeywordCode(cxt, def2) {
+  const { gen, keyword: keyword2, schema: schema2, parentSchema, it: it2 } = cxt;
+  const macroSchema = def2.macro.call(it2.self, schema2, parentSchema, it2);
+  const schemaRef = useKeyword(gen, keyword2, macroSchema);
+  if (it2.opts.validateSchema !== false)
+    it2.self.validateSchema(macroSchema, true);
+  const valid = gen.name("valid");
+  cxt.subschema({
+    schema: macroSchema,
+    schemaPath: codegen_1$t.nil,
+    errSchemaPath: `${it2.errSchemaPath}/${keyword2}`,
+    topSchemaRef: schemaRef,
+    compositeRule: true
+  }, valid);
+  cxt.pass(valid, () => cxt.error(true));
+}
+keyword.macroKeywordCode = macroKeywordCode;
+function funcKeywordCode(cxt, def2) {
+  var _a;
+  const { gen, keyword: keyword2, schema: schema2, parentSchema, $data, it: it2 } = cxt;
+  checkAsyncKeyword(it2, def2);
+  const validate2 = !$data && def2.compile ? def2.compile.call(it2.self, schema2, parentSchema, it2) : def2.validate;
+  const validateRef = useKeyword(gen, keyword2, validate2);
+  const valid = gen.let("valid");
+  cxt.block$data(valid, validateKeyword);
+  cxt.ok((_a = def2.valid) !== null && _a !== void 0 ? _a : valid);
+  function validateKeyword() {
+    if (def2.errors === false) {
+      assignValid();
+      if (def2.modifying)
+        modifyData(cxt);
+      reportErrs(() => cxt.error());
+    } else {
+      const ruleErrs = def2.async ? validateAsync() : validateSync();
+      if (def2.modifying)
+        modifyData(cxt);
+      reportErrs(() => addErrs(cxt, ruleErrs));
     }
   }
-  keyword.funcKeywordCode = funcKeywordCode;
-  function modifyData(cxt) {
-    const { gen, data, it: it2 } = cxt;
-    gen.if(it2.parentData, () => gen.assign(data, (0, codegen_12._)`${it2.parentData}[${it2.parentDataProperty}]`));
-  }
-  function addErrs(cxt, errs) {
-    const { gen } = cxt;
-    gen.if((0, codegen_12._)`Array.isArray(${errs})`, () => {
-      gen.assign(names_12.default.vErrors, (0, codegen_12._)`${names_12.default.vErrors} === null ? ${errs} : ${names_12.default.vErrors}.concat(${errs})`).assign(names_12.default.errors, (0, codegen_12._)`${names_12.default.vErrors}.length`);
-      (0, errors_1.extendErrors)(cxt);
-    }, () => cxt.error());
-  }
-  function checkAsyncKeyword({ schemaEnv }, def2) {
-    if (def2.async && !schemaEnv.$async)
-      throw new Error("async keyword in sync schema");
-  }
-  function useKeyword(gen, keyword2, result) {
-    if (result === void 0)
-      throw new Error(`keyword "${keyword2}" failed to compile`);
-    return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_12.stringify)(result) });
-  }
-  function validSchemaType(schema2, schemaType, allowUndefined = false) {
-    return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema2) : st === "object" ? schema2 && typeof schema2 == "object" && !Array.isArray(schema2) : typeof schema2 == st || allowUndefined && typeof schema2 == "undefined");
-  }
-  keyword.validSchemaType = validSchemaType;
-  function validateKeywordUsage({ schema: schema2, opts, self: self2, errSchemaPath }, def2, keyword2) {
-    if (Array.isArray(def2.keyword) ? !def2.keyword.includes(keyword2) : def2.keyword !== keyword2) {
-      throw new Error("ajv implementation error");
-    }
-    const deps = def2.dependencies;
-    if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema2, kwd))) {
-      throw new Error(`parent schema must have dependencies of ${keyword2}: ${deps.join(",")}`);
-    }
-    if (def2.validateSchema) {
-      const valid = def2.validateSchema(schema2[keyword2]);
-      if (!valid) {
-        const msg = `keyword "${keyword2}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def2.validateSchema.errors);
-        if (opts.validateSchema === "log")
-          self2.logger.error(msg);
-        else
-          throw new Error(msg);
-      }
+  function validateAsync() {
+    const ruleErrs = gen.let("ruleErrs", null);
+    gen.try(() => assignValid((0, codegen_1$t._)`await `), (e2) => gen.assign(valid, false).if((0, codegen_1$t._)`${e2} instanceof ${it2.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1$t._)`${e2}.errors`), () => gen.throw(e2)));
+    return ruleErrs;
+  }
+  function validateSync() {
+    const validateErrs = (0, codegen_1$t._)`${validateRef}.errors`;
+    gen.assign(validateErrs, null);
+    assignValid(codegen_1$t.nil);
+    return validateErrs;
+  }
+  function assignValid(_await = def2.async ? (0, codegen_1$t._)`await ` : codegen_1$t.nil) {
+    const passCxt = it2.opts.passContext ? names_1$7.default.this : names_1$7.default.self;
+    const passSchema = !("compile" in def2 && !$data || def2.schema === false);
+    gen.assign(valid, (0, codegen_1$t._)`${_await}${(0, code_1$9.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def2.modifying);
+  }
+  function reportErrs(errors2) {
+    var _a2;
+    gen.if((0, codegen_1$t.not)((_a2 = def2.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors2);
+  }
+}
+keyword.funcKeywordCode = funcKeywordCode;
+function modifyData(cxt) {
+  const { gen, data, it: it2 } = cxt;
+  gen.if(it2.parentData, () => gen.assign(data, (0, codegen_1$t._)`${it2.parentData}[${it2.parentDataProperty}]`));
+}
+function addErrs(cxt, errs) {
+  const { gen } = cxt;
+  gen.if((0, codegen_1$t._)`Array.isArray(${errs})`, () => {
+    gen.assign(names_1$7.default.vErrors, (0, codegen_1$t._)`${names_1$7.default.vErrors} === null ? ${errs} : ${names_1$7.default.vErrors}.concat(${errs})`).assign(names_1$7.default.errors, (0, codegen_1$t._)`${names_1$7.default.vErrors}.length`);
+    (0, errors_1$1.extendErrors)(cxt);
+  }, () => cxt.error());
+}
+function checkAsyncKeyword({ schemaEnv }, def2) {
+  if (def2.async && !schemaEnv.$async)
+    throw new Error("async keyword in sync schema");
+}
+function useKeyword(gen, keyword2, result) {
+  if (result === void 0)
+    throw new Error(`keyword "${keyword2}" failed to compile`);
+  return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1$t.stringify)(result) });
+}
+function validSchemaType(schema2, schemaType, allowUndefined = false) {
+  return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema2) : st === "object" ? schema2 && typeof schema2 == "object" && !Array.isArray(schema2) : typeof schema2 == st || allowUndefined && typeof schema2 == "undefined");
+}
+keyword.validSchemaType = validSchemaType;
+function validateKeywordUsage({ schema: schema2, opts, self: self2, errSchemaPath }, def2, keyword2) {
+  if (Array.isArray(def2.keyword) ? !def2.keyword.includes(keyword2) : def2.keyword !== keyword2) {
+    throw new Error("ajv implementation error");
+  }
+  const deps = def2.dependencies;
+  if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema2, kwd))) {
+    throw new Error(`parent schema must have dependencies of ${keyword2}: ${deps.join(",")}`);
+  }
+  if (def2.validateSchema) {
+    const valid = def2.validateSchema(schema2[keyword2]);
+    if (!valid) {
+      const msg = `keyword "${keyword2}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def2.validateSchema.errors);
+      if (opts.validateSchema === "log")
+        self2.logger.error(msg);
+      else
+        throw new Error(msg);
     }
   }
-  keyword.validateKeywordUsage = validateKeywordUsage;
-  return keyword;
 }
+keyword.validateKeywordUsage = validateKeywordUsage;
 var subschema = {};
-var hasRequiredSubschema;
-function requireSubschema() {
-  if (hasRequiredSubschema)
-    return subschema;
-  hasRequiredSubschema = 1;
-  Object.defineProperty(subschema, "__esModule", { value: true });
-  subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0;
-  const codegen_12 = codegen;
-  const util_12 = util;
-  function getSubschema(it2, { keyword: keyword2, schemaProp, schema: schema2, schemaPath, errSchemaPath, topSchemaRef }) {
-    if (keyword2 !== void 0 && schema2 !== void 0) {
-      throw new Error('both "keyword" and "schema" passed, only one allowed');
-    }
-    if (keyword2 !== void 0) {
-      const sch = it2.schema[keyword2];
-      return schemaProp === void 0 ? {
-        schema: sch,
-        schemaPath: (0, codegen_12._)`${it2.schemaPath}${(0, codegen_12.getProperty)(keyword2)}`,
-        errSchemaPath: `${it2.errSchemaPath}/${keyword2}`
-      } : {
-        schema: sch[schemaProp],
-        schemaPath: (0, codegen_12._)`${it2.schemaPath}${(0, codegen_12.getProperty)(keyword2)}${(0, codegen_12.getProperty)(schemaProp)}`,
-        errSchemaPath: `${it2.errSchemaPath}/${keyword2}/${(0, util_12.escapeFragment)(schemaProp)}`
-      };
-    }
-    if (schema2 !== void 0) {
-      if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
-        throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
-      }
-      return {
-        schema: schema2,
-        schemaPath,
-        topSchemaRef,
-        errSchemaPath
-      };
+Object.defineProperty(subschema, "__esModule", { value: true });
+subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0;
+const codegen_1$s = codegen;
+const util_1$r = util;
+function getSubschema(it2, { keyword: keyword2, schemaProp, schema: schema2, schemaPath, errSchemaPath, topSchemaRef }) {
+  if (keyword2 !== void 0 && schema2 !== void 0) {
+    throw new Error('both "keyword" and "schema" passed, only one allowed');
+  }
+  if (keyword2 !== void 0) {
+    const sch = it2.schema[keyword2];
+    return schemaProp === void 0 ? {
+      schema: sch,
+      schemaPath: (0, codegen_1$s._)`${it2.schemaPath}${(0, codegen_1$s.getProperty)(keyword2)}`,
+      errSchemaPath: `${it2.errSchemaPath}/${keyword2}`
+    } : {
+      schema: sch[schemaProp],
+      schemaPath: (0, codegen_1$s._)`${it2.schemaPath}${(0, codegen_1$s.getProperty)(keyword2)}${(0, codegen_1$s.getProperty)(schemaProp)}`,
+      errSchemaPath: `${it2.errSchemaPath}/${keyword2}/${(0, util_1$r.escapeFragment)(schemaProp)}`
+    };
+  }
+  if (schema2 !== void 0) {
+    if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
+      throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
     }
-    throw new Error('either "keyword" or "schema" must be passed');
-  }
-  subschema.getSubschema = getSubschema;
-  function extendSubschemaData(subschema2, it2, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
-    if (data !== void 0 && dataProp !== void 0) {
-      throw new Error('both "data" and "dataProp" passed, only one allowed');
-    }
-    const { gen } = it2;
-    if (dataProp !== void 0) {
-      const { errorPath, dataPathArr, opts } = it2;
-      const nextData = gen.let("data", (0, codegen_12._)`${it2.data}${(0, codegen_12.getProperty)(dataProp)}`, true);
-      dataContextProps(nextData);
-      subschema2.errorPath = (0, codegen_12.str)`${errorPath}${(0, util_12.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
-      subschema2.parentDataProperty = (0, codegen_12._)`${dataProp}`;
-      subschema2.dataPathArr = [...dataPathArr, subschema2.parentDataProperty];
-    }
-    if (data !== void 0) {
-      const nextData = data instanceof codegen_12.Name ? data : gen.let("data", data, true);
-      dataContextProps(nextData);
-      if (propertyName !== void 0)
-        subschema2.propertyName = propertyName;
-    }
-    if (dataTypes)
-      subschema2.dataTypes = dataTypes;
-    function dataContextProps(_nextData) {
-      subschema2.data = _nextData;
-      subschema2.dataLevel = it2.dataLevel + 1;
-      subschema2.dataTypes = [];
-      it2.definedProperties = /* @__PURE__ */ new Set();
-      subschema2.parentData = it2.data;
-      subschema2.dataNames = [...it2.dataNames, _nextData];
-    }
-  }
-  subschema.extendSubschemaData = extendSubschemaData;
-  function extendSubschemaMode(subschema2, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
-    if (compositeRule !== void 0)
-      subschema2.compositeRule = compositeRule;
-    if (createErrors !== void 0)
-      subschema2.createErrors = createErrors;
-    if (allErrors !== void 0)
-      subschema2.allErrors = allErrors;
-    subschema2.jtdDiscriminator = jtdDiscriminator;
-    subschema2.jtdMetadata = jtdMetadata;
-  }
-  subschema.extendSubschemaMode = extendSubschemaMode;
-  return subschema;
-}
+    return {
+      schema: schema2,
+      schemaPath,
+      topSchemaRef,
+      errSchemaPath
+    };
+  }
+  throw new Error('either "keyword" or "schema" must be passed');
+}
+subschema.getSubschema = getSubschema;
+function extendSubschemaData(subschema2, it2, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
+  if (data !== void 0 && dataProp !== void 0) {
+    throw new Error('both "data" and "dataProp" passed, only one allowed');
+  }
+  const { gen } = it2;
+  if (dataProp !== void 0) {
+    const { errorPath, dataPathArr, opts } = it2;
+    const nextData = gen.let("data", (0, codegen_1$s._)`${it2.data}${(0, codegen_1$s.getProperty)(dataProp)}`, true);
+    dataContextProps(nextData);
+    subschema2.errorPath = (0, codegen_1$s.str)`${errorPath}${(0, util_1$r.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+    subschema2.parentDataProperty = (0, codegen_1$s._)`${dataProp}`;
+    subschema2.dataPathArr = [...dataPathArr, subschema2.parentDataProperty];
+  }
+  if (data !== void 0) {
+    const nextData = data instanceof codegen_1$s.Name ? data : gen.let("data", data, true);
+    dataContextProps(nextData);
+    if (propertyName !== void 0)
+      subschema2.propertyName = propertyName;
+  }
+  if (dataTypes)
+    subschema2.dataTypes = dataTypes;
+  function dataContextProps(_nextData) {
+    subschema2.data = _nextData;
+    subschema2.dataLevel = it2.dataLevel + 1;
+    subschema2.dataTypes = [];
+    it2.definedProperties = /* @__PURE__ */ new Set();
+    subschema2.parentData = it2.data;
+    subschema2.dataNames = [...it2.dataNames, _nextData];
+  }
+}
+subschema.extendSubschemaData = extendSubschemaData;
+function extendSubschemaMode(subschema2, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
+  if (compositeRule !== void 0)
+    subschema2.compositeRule = compositeRule;
+  if (createErrors !== void 0)
+    subschema2.createErrors = createErrors;
+  if (allErrors !== void 0)
+    subschema2.allErrors = allErrors;
+  subschema2.jtdDiscriminator = jtdDiscriminator;
+  subschema2.jtdMetadata = jtdMetadata;
+}
+subschema.extendSubschemaMode = extendSubschemaMode;
 var resolve$1 = {};
 var fastDeepEqual = function equal(a, b2) {
   if (a === b2)
@@ -18311,7 +18284,7 @@ function escapeJsonPtr(str) {
 var jsonSchemaTraverseExports = jsonSchemaTraverse.exports;
 Object.defineProperty(resolve$1, "__esModule", { value: true });
 resolve$1.getSchemaRefs = resolve$1.resolveUrl = resolve$1.normalizeId = resolve$1._getFullPath = resolve$1.getFullPath = resolve$1.inlineRef = void 0;
-const util_1$p = util;
+const util_1$q = util;
 const equal$2 = fastDeepEqual;
 const traverse = jsonSchemaTraverseExports;
 const SIMPLE_INLINED = /* @__PURE__ */ new Set([
@@ -18370,7 +18343,7 @@ function countKeys(schema2) {
     if (SIMPLE_INLINED.has(key))
       continue;
     if (typeof schema2[key] == "object") {
-      (0, util_1$p.eachItem)(schema2[key], (sch) => count += countKeys(sch));
+      (0, util_1$q.eachItem)(schema2[key], (sch) => count += countKeys(sch));
     }
     if (count === Infinity)
       return Infinity;
@@ -18458,557 +18431,536 @@ function getSchemaRefs(schema2, baseId) {
   }
 }
 resolve$1.getSchemaRefs = getSchemaRefs;
-var hasRequiredValidate;
-function requireValidate() {
-  if (hasRequiredValidate)
-    return validate$1;
-  hasRequiredValidate = 1;
-  Object.defineProperty(validate$1, "__esModule", { value: true });
-  validate$1.getData = validate$1.KeywordCxt = validate$1.validateFunctionCode = void 0;
-  const boolSchema_1 = requireBoolSchema();
-  const dataType_12 = dataType;
-  const applicability_1 = applicability;
-  const dataType_2 = dataType;
-  const defaults_1 = requireDefaults();
-  const keyword_1 = requireKeyword();
-  const subschema_1 = requireSubschema();
-  const codegen_12 = codegen;
-  const names_12 = names$1;
-  const resolve_12 = resolve$1;
-  const util_12 = util;
-  const errors_1 = errors;
-  function validateFunctionCode(it2) {
-    if (isSchemaObj(it2)) {
-      checkKeywords(it2);
-      if (schemaCxtHasRules(it2)) {
-        topSchemaObjCode(it2);
-        return;
-      }
+Object.defineProperty(validate$1, "__esModule", { value: true });
+validate$1.getData = validate$1.KeywordCxt = validate$1.validateFunctionCode = void 0;
+const boolSchema_1 = boolSchema;
+const dataType_1$1 = dataType;
+const applicability_1 = applicability;
+const dataType_2 = dataType;
+const defaults_1 = defaults;
+const keyword_1 = keyword;
+const subschema_1 = subschema;
+const codegen_1$r = codegen;
+const names_1$6 = names$1;
+const resolve_1$2 = resolve$1;
+const util_1$p = util;
+const errors_1 = errors;
+function validateFunctionCode(it2) {
+  if (isSchemaObj(it2)) {
+    checkKeywords(it2);
+    if (schemaCxtHasRules(it2)) {
+      topSchemaObjCode(it2);
+      return;
     }
-    validateFunction(it2, () => (0, boolSchema_1.topBoolOrEmptySchema)(it2));
-  }
-  validate$1.validateFunctionCode = validateFunctionCode;
-  function validateFunction({ gen, validateName, schema: schema2, schemaEnv, opts }, body) {
-    if (opts.code.es5) {
-      gen.func(validateName, (0, codegen_12._)`${names_12.default.data}, ${names_12.default.valCxt}`, schemaEnv.$async, () => {
-        gen.code((0, codegen_12._)`"use strict"; ${funcSourceUrl(schema2, opts)}`);
-        destructureValCxtES5(gen, opts);
-        gen.code(body);
-      });
-    } else {
-      gen.func(validateName, (0, codegen_12._)`${names_12.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema2, opts)).code(body));
-    }
-  }
-  function destructureValCxt(opts) {
-    return (0, codegen_12._)`{${names_12.default.instancePath}="", ${names_12.default.parentData}, ${names_12.default.parentDataProperty}, ${names_12.default.rootData}=${names_12.default.data}${opts.dynamicRef ? (0, codegen_12._)`, ${names_12.default.dynamicAnchors}={}` : codegen_12.nil}}={}`;
-  }
-  function destructureValCxtES5(gen, opts) {
-    gen.if(names_12.default.valCxt, () => {
-      gen.var(names_12.default.instancePath, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.instancePath}`);
-      gen.var(names_12.default.parentData, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.parentData}`);
-      gen.var(names_12.default.parentDataProperty, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.parentDataProperty}`);
-      gen.var(names_12.default.rootData, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.rootData}`);
-      if (opts.dynamicRef)
-        gen.var(names_12.default.dynamicAnchors, (0, codegen_12._)`${names_12.default.valCxt}.${names_12.default.dynamicAnchors}`);
-    }, () => {
-      gen.var(names_12.default.instancePath, (0, codegen_12._)`""`);
-      gen.var(names_12.default.parentData, (0, codegen_12._)`undefined`);
-      gen.var(names_12.default.parentDataProperty, (0, codegen_12._)`undefined`);
-      gen.var(names_12.default.rootData, names_12.default.data);
-      if (opts.dynamicRef)
-        gen.var(names_12.default.dynamicAnchors, (0, codegen_12._)`{}`);
-    });
   }
-  function topSchemaObjCode(it2) {
-    const { schema: schema2, opts, gen } = it2;
-    validateFunction(it2, () => {
-      if (opts.$comment && schema2.$comment)
-        commentKeyword(it2);
-      checkNoDefault(it2);
-      gen.let(names_12.default.vErrors, null);
-      gen.let(names_12.default.errors, 0);
-      if (opts.unevaluated)
-        resetEvaluated(it2);
-      typeAndKeywords(it2);
-      returnResults(it2);
+  validateFunction(it2, () => (0, boolSchema_1.topBoolOrEmptySchema)(it2));
+}
+validate$1.validateFunctionCode = validateFunctionCode;
+function validateFunction({ gen, validateName, schema: schema2, schemaEnv, opts }, body) {
+  if (opts.code.es5) {
+    gen.func(validateName, (0, codegen_1$r._)`${names_1$6.default.data}, ${names_1$6.default.valCxt}`, schemaEnv.$async, () => {
+      gen.code((0, codegen_1$r._)`"use strict"; ${funcSourceUrl(schema2, opts)}`);
+      destructureValCxtES5(gen, opts);
+      gen.code(body);
     });
-    return;
-  }
-  function resetEvaluated(it2) {
-    const { gen, validateName } = it2;
-    it2.evaluated = gen.const("evaluated", (0, codegen_12._)`${validateName}.evaluated`);
-    gen.if((0, codegen_12._)`${it2.evaluated}.dynamicProps`, () => gen.assign((0, codegen_12._)`${it2.evaluated}.props`, (0, codegen_12._)`undefined`));
-    gen.if((0, codegen_12._)`${it2.evaluated}.dynamicItems`, () => gen.assign((0, codegen_12._)`${it2.evaluated}.items`, (0, codegen_12._)`undefined`));
-  }
-  function funcSourceUrl(schema2, opts) {
-    const schId = typeof schema2 == "object" && schema2[opts.schemaId];
-    return schId && (opts.code.source || opts.code.process) ? (0, codegen_12._)`/*# sourceURL=${schId} */` : codegen_12.nil;
-  }
-  function subschemaCode(it2, valid) {
-    if (isSchemaObj(it2)) {
-      checkKeywords(it2);
-      if (schemaCxtHasRules(it2)) {
-        subSchemaObjCode(it2, valid);
-        return;
-      }
-    }
-    (0, boolSchema_1.boolOrEmptySchema)(it2, valid);
-  }
-  function schemaCxtHasRules({ schema: schema2, self: self2 }) {
-    if (typeof schema2 == "boolean")
-      return !schema2;
-    for (const key in schema2)
-      if (self2.RULES.all[key])
-        return true;
-    return false;
-  }
-  function isSchemaObj(it2) {
-    return typeof it2.schema != "boolean";
-  }
-  function subSchemaObjCode(it2, valid) {
-    const { schema: schema2, gen, opts } = it2;
+  } else {
+    gen.func(validateName, (0, codegen_1$r._)`${names_1$6.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema2, opts)).code(body));
+  }
+}
+function destructureValCxt(opts) {
+  return (0, codegen_1$r._)`{${names_1$6.default.instancePath}="", ${names_1$6.default.parentData}, ${names_1$6.default.parentDataProperty}, ${names_1$6.default.rootData}=${names_1$6.default.data}${opts.dynamicRef ? (0, codegen_1$r._)`, ${names_1$6.default.dynamicAnchors}={}` : codegen_1$r.nil}}={}`;
+}
+function destructureValCxtES5(gen, opts) {
+  gen.if(names_1$6.default.valCxt, () => {
+    gen.var(names_1$6.default.instancePath, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.instancePath}`);
+    gen.var(names_1$6.default.parentData, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.parentData}`);
+    gen.var(names_1$6.default.parentDataProperty, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.parentDataProperty}`);
+    gen.var(names_1$6.default.rootData, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.rootData}`);
+    if (opts.dynamicRef)
+      gen.var(names_1$6.default.dynamicAnchors, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.dynamicAnchors}`);
+  }, () => {
+    gen.var(names_1$6.default.instancePath, (0, codegen_1$r._)`""`);
+    gen.var(names_1$6.default.parentData, (0, codegen_1$r._)`undefined`);
+    gen.var(names_1$6.default.parentDataProperty, (0, codegen_1$r._)`undefined`);
+    gen.var(names_1$6.default.rootData, names_1$6.default.data);
+    if (opts.dynamicRef)
+      gen.var(names_1$6.default.dynamicAnchors, (0, codegen_1$r._)`{}`);
+  });
+}
+function topSchemaObjCode(it2) {
+  const { schema: schema2, opts, gen } = it2;
+  validateFunction(it2, () => {
     if (opts.$comment && schema2.$comment)
       commentKeyword(it2);
-    updateContext(it2);
-    checkAsyncSchema(it2);
-    const errsCount = gen.const("_errs", names_12.default.errors);
-    typeAndKeywords(it2, errsCount);
-    gen.var(valid, (0, codegen_12._)`${errsCount} === ${names_12.default.errors}`);
-  }
-  function checkKeywords(it2) {
-    (0, util_12.checkUnknownRules)(it2);
-    checkRefsAndKeywords(it2);
-  }
-  function typeAndKeywords(it2, errsCount) {
-    if (it2.opts.jtd)
-      return schemaKeywords(it2, [], false, errsCount);
-    const types2 = (0, dataType_12.getSchemaTypes)(it2.schema);
-    const checkedTypes = (0, dataType_12.coerceAndCheckDataType)(it2, types2);
-    schemaKeywords(it2, types2, !checkedTypes, errsCount);
-  }
-  function checkRefsAndKeywords(it2) {
-    const { schema: schema2, errSchemaPath, opts, self: self2 } = it2;
-    if (schema2.$ref && opts.ignoreKeywordsWithRef && (0, util_12.schemaHasRulesButRef)(schema2, self2.RULES)) {
-      self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
-    }
-  }
-  function checkNoDefault(it2) {
-    const { schema: schema2, opts } = it2;
-    if (schema2.default !== void 0 && opts.useDefaults && opts.strictSchema) {
-      (0, util_12.checkStrictMode)(it2, "default is ignored in the schema root");
-    }
-  }
-  function updateContext(it2) {
-    const schId = it2.schema[it2.opts.schemaId];
-    if (schId)
-      it2.baseId = (0, resolve_12.resolveUrl)(it2.opts.uriResolver, it2.baseId, schId);
-  }
-  function checkAsyncSchema(it2) {
-    if (it2.schema.$async && !it2.schemaEnv.$async)
-      throw new Error("async schema in sync schema");
-  }
-  function commentKeyword({ gen, schemaEnv, schema: schema2, errSchemaPath, opts }) {
-    const msg = schema2.$comment;
-    if (opts.$comment === true) {
-      gen.code((0, codegen_12._)`${names_12.default.self}.logger.log(${msg})`);
-    } else if (typeof opts.$comment == "function") {
-      const schemaPath = (0, codegen_12.str)`${errSchemaPath}/$comment`;
-      const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
-      gen.code((0, codegen_12._)`${names_12.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
-    }
-  }
-  function returnResults(it2) {
-    const { gen, schemaEnv, validateName, ValidationError, opts } = it2;
-    if (schemaEnv.$async) {
-      gen.if((0, codegen_12._)`${names_12.default.errors} === 0`, () => gen.return(names_12.default.data), () => gen.throw((0, codegen_12._)`new ${ValidationError}(${names_12.default.vErrors})`));
-    } else {
-      gen.assign((0, codegen_12._)`${validateName}.errors`, names_12.default.vErrors);
-      if (opts.unevaluated)
-        assignEvaluated(it2);
-      gen.return((0, codegen_12._)`${names_12.default.errors} === 0`);
-    }
-  }
-  function assignEvaluated({ gen, evaluated, props, items: items2 }) {
-    if (props instanceof codegen_12.Name)
-      gen.assign((0, codegen_12._)`${evaluated}.props`, props);
-    if (items2 instanceof codegen_12.Name)
-      gen.assign((0, codegen_12._)`${evaluated}.items`, items2);
-  }
-  function schemaKeywords(it2, types2, typeErrors, errsCount) {
-    const { gen, schema: schema2, data, allErrors, opts, self: self2 } = it2;
-    const { RULES } = self2;
-    if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_12.schemaHasRulesButRef)(schema2, RULES))) {
-      gen.block(() => keywordCode(it2, "$ref", RULES.all.$ref.definition));
+    checkNoDefault(it2);
+    gen.let(names_1$6.default.vErrors, null);
+    gen.let(names_1$6.default.errors, 0);
+    if (opts.unevaluated)
+      resetEvaluated(it2);
+    typeAndKeywords(it2);
+    returnResults(it2);
+  });
+  return;
+}
+function resetEvaluated(it2) {
+  const { gen, validateName } = it2;
+  it2.evaluated = gen.const("evaluated", (0, codegen_1$r._)`${validateName}.evaluated`);
+  gen.if((0, codegen_1$r._)`${it2.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1$r._)`${it2.evaluated}.props`, (0, codegen_1$r._)`undefined`));
+  gen.if((0, codegen_1$r._)`${it2.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1$r._)`${it2.evaluated}.items`, (0, codegen_1$r._)`undefined`));
+}
+function funcSourceUrl(schema2, opts) {
+  const schId = typeof schema2 == "object" && schema2[opts.schemaId];
+  return schId && (opts.code.source || opts.code.process) ? (0, codegen_1$r._)`/*# sourceURL=${schId} */` : codegen_1$r.nil;
+}
+function subschemaCode(it2, valid) {
+  if (isSchemaObj(it2)) {
+    checkKeywords(it2);
+    if (schemaCxtHasRules(it2)) {
+      subSchemaObjCode(it2, valid);
       return;
     }
-    if (!opts.jtd)
-      checkStrictTypes(it2, types2);
-    gen.block(() => {
-      for (const group of RULES.rules)
-        groupKeywords(group);
-      groupKeywords(RULES.post);
-    });
-    function groupKeywords(group) {
-      if (!(0, applicability_1.shouldUseGroup)(schema2, group))
-        return;
-      if (group.type) {
-        gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
-        iterateKeywords(it2, group);
-        if (types2.length === 1 && types2[0] === group.type && typeErrors) {
-          gen.else();
-          (0, dataType_2.reportTypeError)(it2);
-        }
-        gen.endIf();
-      } else {
-        iterateKeywords(it2, group);
-      }
-      if (!allErrors)
-        gen.if((0, codegen_12._)`${names_12.default.errors} === ${errsCount || 0}`);
-    }
-  }
-  function iterateKeywords(it2, group) {
-    const { gen, schema: schema2, opts: { useDefaults } } = it2;
-    if (useDefaults)
-      (0, defaults_1.assignDefaults)(it2, group.type);
-    gen.block(() => {
-      for (const rule of group.rules) {
-        if ((0, applicability_1.shouldUseRule)(schema2, rule)) {
-          keywordCode(it2, rule.keyword, rule.definition, group.type);
-        }
-      }
-    });
   }
-  function checkStrictTypes(it2, types2) {
-    if (it2.schemaEnv.meta || !it2.opts.strictTypes)
-      return;
-    checkContextTypes(it2, types2);
-    if (!it2.opts.allowUnionTypes)
-      checkMultipleTypes(it2, types2);
-    checkKeywordTypes(it2, it2.dataTypes);
+  (0, boolSchema_1.boolOrEmptySchema)(it2, valid);
+}
+function schemaCxtHasRules({ schema: schema2, self: self2 }) {
+  if (typeof schema2 == "boolean")
+    return !schema2;
+  for (const key in schema2)
+    if (self2.RULES.all[key])
+      return true;
+  return false;
+}
+function isSchemaObj(it2) {
+  return typeof it2.schema != "boolean";
+}
+function subSchemaObjCode(it2, valid) {
+  const { schema: schema2, gen, opts } = it2;
+  if (opts.$comment && schema2.$comment)
+    commentKeyword(it2);
+  updateContext(it2);
+  checkAsyncSchema(it2);
+  const errsCount = gen.const("_errs", names_1$6.default.errors);
+  typeAndKeywords(it2, errsCount);
+  gen.var(valid, (0, codegen_1$r._)`${errsCount} === ${names_1$6.default.errors}`);
+}
+function checkKeywords(it2) {
+  (0, util_1$p.checkUnknownRules)(it2);
+  checkRefsAndKeywords(it2);
+}
+function typeAndKeywords(it2, errsCount) {
+  if (it2.opts.jtd)
+    return schemaKeywords(it2, [], false, errsCount);
+  const types2 = (0, dataType_1$1.getSchemaTypes)(it2.schema);
+  const checkedTypes = (0, dataType_1$1.coerceAndCheckDataType)(it2, types2);
+  schemaKeywords(it2, types2, !checkedTypes, errsCount);
+}
+function checkRefsAndKeywords(it2) {
+  const { schema: schema2, errSchemaPath, opts, self: self2 } = it2;
+  if (schema2.$ref && opts.ignoreKeywordsWithRef && (0, util_1$p.schemaHasRulesButRef)(schema2, self2.RULES)) {
+    self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+  }
+}
+function checkNoDefault(it2) {
+  const { schema: schema2, opts } = it2;
+  if (schema2.default !== void 0 && opts.useDefaults && opts.strictSchema) {
+    (0, util_1$p.checkStrictMode)(it2, "default is ignored in the schema root");
+  }
+}
+function updateContext(it2) {
+  const schId = it2.schema[it2.opts.schemaId];
+  if (schId)
+    it2.baseId = (0, resolve_1$2.resolveUrl)(it2.opts.uriResolver, it2.baseId, schId);
+}
+function checkAsyncSchema(it2) {
+  if (it2.schema.$async && !it2.schemaEnv.$async)
+    throw new Error("async schema in sync schema");
+}
+function commentKeyword({ gen, schemaEnv, schema: schema2, errSchemaPath, opts }) {
+  const msg = schema2.$comment;
+  if (opts.$comment === true) {
+    gen.code((0, codegen_1$r._)`${names_1$6.default.self}.logger.log(${msg})`);
+  } else if (typeof opts.$comment == "function") {
+    const schemaPath = (0, codegen_1$r.str)`${errSchemaPath}/$comment`;
+    const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
+    gen.code((0, codegen_1$r._)`${names_1$6.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
+  }
+}
+function returnResults(it2) {
+  const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it2;
+  if (schemaEnv.$async) {
+    gen.if((0, codegen_1$r._)`${names_1$6.default.errors} === 0`, () => gen.return(names_1$6.default.data), () => gen.throw((0, codegen_1$r._)`new ${ValidationError2}(${names_1$6.default.vErrors})`));
+  } else {
+    gen.assign((0, codegen_1$r._)`${validateName}.errors`, names_1$6.default.vErrors);
+    if (opts.unevaluated)
+      assignEvaluated(it2);
+    gen.return((0, codegen_1$r._)`${names_1$6.default.errors} === 0`);
+  }
+}
+function assignEvaluated({ gen, evaluated, props, items: items2 }) {
+  if (props instanceof codegen_1$r.Name)
+    gen.assign((0, codegen_1$r._)`${evaluated}.props`, props);
+  if (items2 instanceof codegen_1$r.Name)
+    gen.assign((0, codegen_1$r._)`${evaluated}.items`, items2);
+}
+function schemaKeywords(it2, types2, typeErrors, errsCount) {
+  const { gen, schema: schema2, data, allErrors, opts, self: self2 } = it2;
+  const { RULES } = self2;
+  if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$p.schemaHasRulesButRef)(schema2, RULES))) {
+    gen.block(() => keywordCode(it2, "$ref", RULES.all.$ref.definition));
+    return;
   }
-  function checkContextTypes(it2, types2) {
-    if (!types2.length)
-      return;
-    if (!it2.dataTypes.length) {
-      it2.dataTypes = types2;
+  if (!opts.jtd)
+    checkStrictTypes(it2, types2);
+  gen.block(() => {
+    for (const group of RULES.rules)
+      groupKeywords(group);
+    groupKeywords(RULES.post);
+  });
+  function groupKeywords(group) {
+    if (!(0, applicability_1.shouldUseGroup)(schema2, group))
       return;
-    }
-    types2.forEach((t2) => {
-      if (!includesType(it2.dataTypes, t2)) {
-        strictTypesError(it2, `type "${t2}" not allowed by context "${it2.dataTypes.join(",")}"`);
+    if (group.type) {
+      gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
+      iterateKeywords(it2, group);
+      if (types2.length === 1 && types2[0] === group.type && typeErrors) {
+        gen.else();
+        (0, dataType_2.reportTypeError)(it2);
       }
-    });
-    narrowSchemaTypes(it2, types2);
-  }
-  function checkMultipleTypes(it2, ts2) {
-    if (ts2.length > 1 && !(ts2.length === 2 && ts2.includes("null"))) {
-      strictTypesError(it2, "use allowUnionTypes to allow union type keyword");
+      gen.endIf();
+    } else {
+      iterateKeywords(it2, group);
     }
+    if (!allErrors)
+      gen.if((0, codegen_1$r._)`${names_1$6.default.errors} === ${errsCount || 0}`);
   }
-  function checkKeywordTypes(it2, ts2) {
-    const rules2 = it2.self.RULES.all;
-    for (const keyword2 in rules2) {
-      const rule = rules2[keyword2];
-      if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it2.schema, rule)) {
-        const { type: type2 } = rule.definition;
-        if (type2.length && !type2.some((t2) => hasApplicableType(ts2, t2))) {
-          strictTypesError(it2, `missing type "${type2.join(",")}" for keyword "${keyword2}"`);
-        }
+}
+function iterateKeywords(it2, group) {
+  const { gen, schema: schema2, opts: { useDefaults } } = it2;
+  if (useDefaults)
+    (0, defaults_1.assignDefaults)(it2, group.type);
+  gen.block(() => {
+    for (const rule of group.rules) {
+      if ((0, applicability_1.shouldUseRule)(schema2, rule)) {
+        keywordCode(it2, rule.keyword, rule.definition, group.type);
       }
     }
+  });
+}
+function checkStrictTypes(it2, types2) {
+  if (it2.schemaEnv.meta || !it2.opts.strictTypes)
+    return;
+  checkContextTypes(it2, types2);
+  if (!it2.opts.allowUnionTypes)
+    checkMultipleTypes(it2, types2);
+  checkKeywordTypes(it2, it2.dataTypes);
+}
+function checkContextTypes(it2, types2) {
+  if (!types2.length)
+    return;
+  if (!it2.dataTypes.length) {
+    it2.dataTypes = types2;
+    return;
   }
-  function hasApplicableType(schTs, kwdT) {
-    return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
-  }
-  function includesType(ts2, t2) {
-    return ts2.includes(t2) || t2 === "integer" && ts2.includes("number");
-  }
-  function narrowSchemaTypes(it2, withTypes) {
-    const ts2 = [];
-    for (const t2 of it2.dataTypes) {
-      if (includesType(withTypes, t2))
-        ts2.push(t2);
-      else if (withTypes.includes("integer") && t2 === "number")
-        ts2.push("integer");
-    }
-    it2.dataTypes = ts2;
-  }
-  function strictTypesError(it2, msg) {
-    const schemaPath = it2.schemaEnv.baseId + it2.errSchemaPath;
-    msg += ` at "${schemaPath}" (strictTypes)`;
-    (0, util_12.checkStrictMode)(it2, msg, it2.opts.strictTypes);
-  }
-  class KeywordCxt {
-    constructor(it2, def2, keyword2) {
-      (0, keyword_1.validateKeywordUsage)(it2, def2, keyword2);
-      this.gen = it2.gen;
-      this.allErrors = it2.allErrors;
-      this.keyword = keyword2;
-      this.data = it2.data;
-      this.schema = it2.schema[keyword2];
-      this.$data = def2.$data && it2.opts.$data && this.schema && this.schema.$data;
-      this.schemaValue = (0, util_12.schemaRefOrVal)(it2, this.schema, keyword2, this.$data);
-      this.schemaType = def2.schemaType;
-      this.parentSchema = it2.schema;
-      this.params = {};
-      this.it = it2;
-      this.def = def2;
-      if (this.$data) {
-        this.schemaCode = it2.gen.const("vSchema", getData(this.$data, it2));
-      } else {
-        this.schemaCode = this.schemaValue;
-        if (!(0, keyword_1.validSchemaType)(this.schema, def2.schemaType, def2.allowUndefined)) {
-          throw new Error(`${keyword2} value must be ${JSON.stringify(def2.schemaType)}`);
-        }
-      }
-      if ("code" in def2 ? def2.trackErrors : def2.errors !== false) {
-        this.errsCount = it2.gen.const("_errs", names_12.default.errors);
-      }
+  types2.forEach((t2) => {
+    if (!includesType(it2.dataTypes, t2)) {
+      strictTypesError(it2, `type "${t2}" not allowed by context "${it2.dataTypes.join(",")}"`);
     }
-    result(condition, successAction, failAction) {
-      this.failResult((0, codegen_12.not)(condition), successAction, failAction);
-    }
-    failResult(condition, successAction, failAction) {
-      this.gen.if(condition);
-      if (failAction)
-        failAction();
-      else
-        this.error();
-      if (successAction) {
-        this.gen.else();
-        successAction();
-        if (this.allErrors)
-          this.gen.endIf();
-      } else {
-        if (this.allErrors)
-          this.gen.endIf();
-        else
-          this.gen.else();
+  });
+  narrowSchemaTypes(it2, types2);
+}
+function checkMultipleTypes(it2, ts2) {
+  if (ts2.length > 1 && !(ts2.length === 2 && ts2.includes("null"))) {
+    strictTypesError(it2, "use allowUnionTypes to allow union type keyword");
+  }
+}
+function checkKeywordTypes(it2, ts2) {
+  const rules2 = it2.self.RULES.all;
+  for (const keyword2 in rules2) {
+    const rule = rules2[keyword2];
+    if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it2.schema, rule)) {
+      const { type: type2 } = rule.definition;
+      if (type2.length && !type2.some((t2) => hasApplicableType(ts2, t2))) {
+        strictTypesError(it2, `missing type "${type2.join(",")}" for keyword "${keyword2}"`);
+      }
+    }
+  }
+}
+function hasApplicableType(schTs, kwdT) {
+  return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
+}
+function includesType(ts2, t2) {
+  return ts2.includes(t2) || t2 === "integer" && ts2.includes("number");
+}
+function narrowSchemaTypes(it2, withTypes) {
+  const ts2 = [];
+  for (const t2 of it2.dataTypes) {
+    if (includesType(withTypes, t2))
+      ts2.push(t2);
+    else if (withTypes.includes("integer") && t2 === "number")
+      ts2.push("integer");
+  }
+  it2.dataTypes = ts2;
+}
+function strictTypesError(it2, msg) {
+  const schemaPath = it2.schemaEnv.baseId + it2.errSchemaPath;
+  msg += ` at "${schemaPath}" (strictTypes)`;
+  (0, util_1$p.checkStrictMode)(it2, msg, it2.opts.strictTypes);
+}
+class KeywordCxt {
+  constructor(it2, def2, keyword2) {
+    (0, keyword_1.validateKeywordUsage)(it2, def2, keyword2);
+    this.gen = it2.gen;
+    this.allErrors = it2.allErrors;
+    this.keyword = keyword2;
+    this.data = it2.data;
+    this.schema = it2.schema[keyword2];
+    this.$data = def2.$data && it2.opts.$data && this.schema && this.schema.$data;
+    this.schemaValue = (0, util_1$p.schemaRefOrVal)(it2, this.schema, keyword2, this.$data);
+    this.schemaType = def2.schemaType;
+    this.parentSchema = it2.schema;
+    this.params = {};
+    this.it = it2;
+    this.def = def2;
+    if (this.$data) {
+      this.schemaCode = it2.gen.const("vSchema", getData(this.$data, it2));
+    } else {
+      this.schemaCode = this.schemaValue;
+      if (!(0, keyword_1.validSchemaType)(this.schema, def2.schemaType, def2.allowUndefined)) {
+        throw new Error(`${keyword2} value must be ${JSON.stringify(def2.schemaType)}`);
       }
     }
-    pass(condition, failAction) {
-      this.failResult((0, codegen_12.not)(condition), void 0, failAction);
+    if ("code" in def2 ? def2.trackErrors : def2.errors !== false) {
+      this.errsCount = it2.gen.const("_errs", names_1$6.default.errors);
     }
-    fail(condition) {
-      if (condition === void 0) {
-        this.error();
-        if (!this.allErrors)
-          this.gen.if(false);
-        return;
-      }
-      this.gen.if(condition);
+  }
+  result(condition, successAction, failAction) {
+    this.failResult((0, codegen_1$r.not)(condition), successAction, failAction);
+  }
+  failResult(condition, successAction, failAction) {
+    this.gen.if(condition);
+    if (failAction)
+      failAction();
+    else
       this.error();
+    if (successAction) {
+      this.gen.else();
+      successAction();
+      if (this.allErrors)
+        this.gen.endIf();
+    } else {
       if (this.allErrors)
         this.gen.endIf();
       else
         this.gen.else();
     }
-    fail$data(condition) {
-      if (!this.$data)
-        return this.fail(condition);
-      const { schemaCode } = this;
-      this.fail((0, codegen_12._)`${schemaCode} !== undefined && (${(0, codegen_12.or)(this.invalid$data(), condition)})`);
-    }
-    error(append2, errorParams, errorPaths) {
-      if (errorParams) {
-        this.setParams(errorParams);
-        this._error(append2, errorPaths);
-        this.setParams({});
-        return;
-      }
-      this._error(append2, errorPaths);
-    }
-    _error(append2, errorPaths) {
-      (append2 ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
-    }
-    $dataError() {
-      (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
-    }
-    reset() {
-      if (this.errsCount === void 0)
-        throw new Error('add "trackErrors" to keyword definition');
-      (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
-    }
-    ok(cond) {
+  }
+  pass(condition, failAction) {
+    this.failResult((0, codegen_1$r.not)(condition), void 0, failAction);
+  }
+  fail(condition) {
+    if (condition === void 0) {
+      this.error();
       if (!this.allErrors)
-        this.gen.if(cond);
+        this.gen.if(false);
+      return;
     }
-    setParams(obj, assign) {
-      if (assign)
-        Object.assign(this.params, obj);
-      else
-        this.params = obj;
+    this.gen.if(condition);
+    this.error();
+    if (this.allErrors)
+      this.gen.endIf();
+    else
+      this.gen.else();
+  }
+  fail$data(condition) {
+    if (!this.$data)
+      return this.fail(condition);
+    const { schemaCode } = this;
+    this.fail((0, codegen_1$r._)`${schemaCode} !== undefined && (${(0, codegen_1$r.or)(this.invalid$data(), condition)})`);
+  }
+  error(append2, errorParams, errorPaths) {
+    if (errorParams) {
+      this.setParams(errorParams);
+      this._error(append2, errorPaths);
+      this.setParams({});
+      return;
     }
-    block$data(valid, codeBlock, $dataValid = codegen_12.nil) {
-      this.gen.block(() => {
-        this.check$data(valid, $dataValid);
-        codeBlock();
-      });
+    this._error(append2, errorPaths);
+  }
+  _error(append2, errorPaths) {
+    (append2 ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
+  }
+  $dataError() {
+    (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
+  }
+  reset() {
+    if (this.errsCount === void 0)
+      throw new Error('add "trackErrors" to keyword definition');
+    (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
+  }
+  ok(cond) {
+    if (!this.allErrors)
+      this.gen.if(cond);
+  }
+  setParams(obj, assign) {
+    if (assign)
+      Object.assign(this.params, obj);
+    else
+      this.params = obj;
+  }
+  block$data(valid, codeBlock, $dataValid = codegen_1$r.nil) {
+    this.gen.block(() => {
+      this.check$data(valid, $dataValid);
+      codeBlock();
+    });
+  }
+  check$data(valid = codegen_1$r.nil, $dataValid = codegen_1$r.nil) {
+    if (!this.$data)
+      return;
+    const { gen, schemaCode, schemaType, def: def2 } = this;
+    gen.if((0, codegen_1$r.or)((0, codegen_1$r._)`${schemaCode} === undefined`, $dataValid));
+    if (valid !== codegen_1$r.nil)
+      gen.assign(valid, true);
+    if (schemaType.length || def2.validateSchema) {
+      gen.elseIf(this.invalid$data());
+      this.$dataError();
+      if (valid !== codegen_1$r.nil)
+        gen.assign(valid, false);
     }
-    check$data(valid = codegen_12.nil, $dataValid = codegen_12.nil) {
-      if (!this.$data)
-        return;
-      const { gen, schemaCode, schemaType, def: def2 } = this;
-      gen.if((0, codegen_12.or)((0, codegen_12._)`${schemaCode} === undefined`, $dataValid));
-      if (valid !== codegen_12.nil)
-        gen.assign(valid, true);
-      if (schemaType.length || def2.validateSchema) {
-        gen.elseIf(this.invalid$data());
-        this.$dataError();
-        if (valid !== codegen_12.nil)
-          gen.assign(valid, false);
+    gen.else();
+  }
+  invalid$data() {
+    const { gen, schemaCode, schemaType, def: def2, it: it2 } = this;
+    return (0, codegen_1$r.or)(wrong$DataType(), invalid$DataSchema());
+    function wrong$DataType() {
+      if (schemaType.length) {
+        if (!(schemaCode instanceof codegen_1$r.Name))
+          throw new Error("ajv implementation error");
+        const st = Array.isArray(schemaType) ? schemaType : [schemaType];
+        return (0, codegen_1$r._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it2.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
       }
-      gen.else();
+      return codegen_1$r.nil;
     }
-    invalid$data() {
-      const { gen, schemaCode, schemaType, def: def2, it: it2 } = this;
-      return (0, codegen_12.or)(wrong$DataType(), invalid$DataSchema());
-      function wrong$DataType() {
-        if (schemaType.length) {
-          if (!(schemaCode instanceof codegen_12.Name))
-            throw new Error("ajv implementation error");
-          const st = Array.isArray(schemaType) ? schemaType : [schemaType];
-          return (0, codegen_12._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it2.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
-        }
-        return codegen_12.nil;
-      }
-      function invalid$DataSchema() {
-        if (def2.validateSchema) {
-          const validateSchemaRef = gen.scopeValue("validate$data", { ref: def2.validateSchema });
-          return (0, codegen_12._)`!${validateSchemaRef}(${schemaCode})`;
-        }
-        return codegen_12.nil;
+    function invalid$DataSchema() {
+      if (def2.validateSchema) {
+        const validateSchemaRef = gen.scopeValue("validate$data", { ref: def2.validateSchema });
+        return (0, codegen_1$r._)`!${validateSchemaRef}(${schemaCode})`;
       }
+      return codegen_1$r.nil;
     }
-    subschema(appl, valid) {
-      const subschema2 = (0, subschema_1.getSubschema)(this.it, appl);
-      (0, subschema_1.extendSubschemaData)(subschema2, this.it, appl);
-      (0, subschema_1.extendSubschemaMode)(subschema2, appl);
-      const nextContext = { ...this.it, ...subschema2, items: void 0, props: void 0 };
-      subschemaCode(nextContext, valid);
-      return nextContext;
+  }
+  subschema(appl, valid) {
+    const subschema2 = (0, subschema_1.getSubschema)(this.it, appl);
+    (0, subschema_1.extendSubschemaData)(subschema2, this.it, appl);
+    (0, subschema_1.extendSubschemaMode)(subschema2, appl);
+    const nextContext = { ...this.it, ...subschema2, items: void 0, props: void 0 };
+    subschemaCode(nextContext, valid);
+    return nextContext;
+  }
+  mergeEvaluated(schemaCxt, toName) {
+    const { it: it2, gen } = this;
+    if (!it2.opts.unevaluated)
+      return;
+    if (it2.props !== true && schemaCxt.props !== void 0) {
+      it2.props = util_1$p.mergeEvaluated.props(gen, schemaCxt.props, it2.props, toName);
     }
-    mergeEvaluated(schemaCxt, toName) {
-      const { it: it2, gen } = this;
-      if (!it2.opts.unevaluated)
-        return;
-      if (it2.props !== true && schemaCxt.props !== void 0) {
-        it2.props = util_12.mergeEvaluated.props(gen, schemaCxt.props, it2.props, toName);
-      }
-      if (it2.items !== true && schemaCxt.items !== void 0) {
-        it2.items = util_12.mergeEvaluated.items(gen, schemaCxt.items, it2.items, toName);
-      }
+    if (it2.items !== true && schemaCxt.items !== void 0) {
+      it2.items = util_1$p.mergeEvaluated.items(gen, schemaCxt.items, it2.items, toName);
     }
-    mergeValidEvaluated(schemaCxt, valid) {
-      const { it: it2, gen } = this;
-      if (it2.opts.unevaluated && (it2.props !== true || it2.items !== true)) {
-        gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_12.Name));
-        return true;
-      }
+  }
+  mergeValidEvaluated(schemaCxt, valid) {
+    const { it: it2, gen } = this;
+    if (it2.opts.unevaluated && (it2.props !== true || it2.items !== true)) {
+      gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1$r.Name));
+      return true;
     }
   }
-  validate$1.KeywordCxt = KeywordCxt;
-  function keywordCode(it2, keyword2, def2, ruleType) {
-    const cxt = new KeywordCxt(it2, def2, keyword2);
-    if ("code" in def2) {
-      def2.code(cxt, ruleType);
-    } else if (cxt.$data && def2.validate) {
-      (0, keyword_1.funcKeywordCode)(cxt, def2);
-    } else if ("macro" in def2) {
-      (0, keyword_1.macroKeywordCode)(cxt, def2);
-    } else if (def2.compile || def2.validate) {
-      (0, keyword_1.funcKeywordCode)(cxt, def2);
-    }
-  }
-  const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
-  const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
-  function getData($data, { dataLevel, dataNames, dataPathArr }) {
-    let jsonPointer;
-    let data;
-    if ($data === "")
-      return names_12.default.rootData;
-    if ($data[0] === "/") {
-      if (!JSON_POINTER.test($data))
-        throw new Error(`Invalid JSON-pointer: ${$data}`);
-      jsonPointer = $data;
-      data = names_12.default.rootData;
-    } else {
-      const matches = RELATIVE_JSON_POINTER.exec($data);
-      if (!matches)
-        throw new Error(`Invalid JSON-pointer: ${$data}`);
-      const up = +matches[1];
-      jsonPointer = matches[2];
-      if (jsonPointer === "#") {
-        if (up >= dataLevel)
-          throw new Error(errorMsg("property/index", up));
-        return dataPathArr[dataLevel - up];
-      }
-      if (up > dataLevel)
-        throw new Error(errorMsg("data", up));
-      data = dataNames[dataLevel - up];
-      if (!jsonPointer)
-        return data;
-    }
-    let expr = data;
-    const segments = jsonPointer.split("/");
-    for (const segment of segments) {
-      if (segment) {
-        data = (0, codegen_12._)`${data}${(0, codegen_12.getProperty)((0, util_12.unescapeJsonPointer)(segment))}`;
-        expr = (0, codegen_12._)`${expr} && ${data}`;
-      }
-    }
-    return expr;
-    function errorMsg(pointerType, up) {
-      return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
-    }
-  }
-  validate$1.getData = getData;
-  return validate$1;
 }
+validate$1.KeywordCxt = KeywordCxt;
+function keywordCode(it2, keyword2, def2, ruleType) {
+  const cxt = new KeywordCxt(it2, def2, keyword2);
+  if ("code" in def2) {
+    def2.code(cxt, ruleType);
+  } else if (cxt.$data && def2.validate) {
+    (0, keyword_1.funcKeywordCode)(cxt, def2);
+  } else if ("macro" in def2) {
+    (0, keyword_1.macroKeywordCode)(cxt, def2);
+  } else if (def2.compile || def2.validate) {
+    (0, keyword_1.funcKeywordCode)(cxt, def2);
+  }
+}
+const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
+const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+function getData($data, { dataLevel, dataNames, dataPathArr }) {
+  let jsonPointer;
+  let data;
+  if ($data === "")
+    return names_1$6.default.rootData;
+  if ($data[0] === "/") {
+    if (!JSON_POINTER.test($data))
+      throw new Error(`Invalid JSON-pointer: ${$data}`);
+    jsonPointer = $data;
+    data = names_1$6.default.rootData;
+  } else {
+    const matches = RELATIVE_JSON_POINTER.exec($data);
+    if (!matches)
+      throw new Error(`Invalid JSON-pointer: ${$data}`);
+    const up = +matches[1];
+    jsonPointer = matches[2];
+    if (jsonPointer === "#") {
+      if (up >= dataLevel)
+        throw new Error(errorMsg("property/index", up));
+      return dataPathArr[dataLevel - up];
+    }
+    if (up > dataLevel)
+      throw new Error(errorMsg("data", up));
+    data = dataNames[dataLevel - up];
+    if (!jsonPointer)
+      return data;
+  }
+  let expr = data;
+  const segments = jsonPointer.split("/");
+  for (const segment of segments) {
+    if (segment) {
+      data = (0, codegen_1$r._)`${data}${(0, codegen_1$r.getProperty)((0, util_1$p.unescapeJsonPointer)(segment))}`;
+      expr = (0, codegen_1$r._)`${expr} && ${data}`;
+    }
+  }
+  return expr;
+  function errorMsg(pointerType, up) {
+    return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
+  }
+}
+validate$1.getData = getData;
 var validation_error = {};
-var hasRequiredValidation_error;
-function requireValidation_error() {
-  if (hasRequiredValidation_error)
-    return validation_error;
-  hasRequiredValidation_error = 1;
-  Object.defineProperty(validation_error, "__esModule", { value: true });
-  class ValidationError extends Error {
-    constructor(errors2) {
-      super("validation failed");
-      this.errors = errors2;
-      this.ajv = this.validation = true;
-    }
-  }
-  validation_error.default = ValidationError;
-  return validation_error;
+Object.defineProperty(validation_error, "__esModule", { value: true });
+class ValidationError extends Error {
+  constructor(errors2) {
+    super("validation failed");
+    this.errors = errors2;
+    this.ajv = this.validation = true;
+  }
 }
+validation_error.default = ValidationError;
 var ref_error = {};
-var hasRequiredRef_error;
-function requireRef_error() {
-  if (hasRequiredRef_error)
-    return ref_error;
-  hasRequiredRef_error = 1;
-  Object.defineProperty(ref_error, "__esModule", { value: true });
-  const resolve_12 = resolve$1;
-  class MissingRefError extends Error {
-    constructor(resolver, baseId, ref2, msg) {
-      super(msg || `can't resolve reference ${ref2} from id ${baseId}`);
-      this.missingRef = (0, resolve_12.resolveUrl)(resolver, baseId, ref2);
-      this.missingSchema = (0, resolve_12.normalizeId)((0, resolve_12.getFullPath)(resolver, this.missingRef));
-    }
+Object.defineProperty(ref_error, "__esModule", { value: true });
+const resolve_1$1 = resolve$1;
+class MissingRefError extends Error {
+  constructor(resolver, baseId, ref2, msg) {
+    super(msg || `can't resolve reference ${ref2} from id ${baseId}`);
+    this.missingRef = (0, resolve_1$1.resolveUrl)(resolver, baseId, ref2);
+    this.missingSchema = (0, resolve_1$1.normalizeId)((0, resolve_1$1.getFullPath)(resolver, this.missingRef));
   }
-  ref_error.default = MissingRefError;
-  return ref_error;
 }
+ref_error.default = MissingRefError;
 var compile = {};
 Object.defineProperty(compile, "__esModule", { value: true });
 compile.resolveSchema = compile.getCompilingSchema = compile.resolveRef = compile.compileSchema = compile.SchemaEnv = void 0;
 const codegen_1$q = codegen;
-const validation_error_1 = requireValidation_error();
+const validation_error_1 = validation_error;
 const names_1$5 = names$1;
 const resolve_1 = resolve$1;
 const util_1$o = util;
-const validate_1$1 = requireValidate();
+const validate_1$1 = validate$1;
 class SchemaEnv {
   constructor(env) {
     var _a;
@@ -20295,7 +20247,7 @@ uri$1.default = uri;
 (function(exports) {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
-  var validate_12 = requireValidate();
+  var validate_12 = validate$1;
   Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
     return validate_12.KeywordCxt;
   } });
@@ -20318,8 +20270,8 @@ uri$1.default = uri;
   Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
     return codegen_12.CodeGen;
   } });
-  const validation_error_12 = requireValidation_error();
-  const ref_error_12 = requireRef_error();
+  const validation_error_12 = validation_error;
+  const ref_error_12 = ref_error;
   const rules_1 = rules;
   const compile_12 = compile;
   const codegen_2 = codegen;
@@ -20912,7 +20864,7 @@ id.default = def$B;
 var ref = {};
 Object.defineProperty(ref, "__esModule", { value: true });
 ref.callRef = ref.getValidate = void 0;
-const ref_error_1 = requireRef_error();
+const ref_error_1 = ref_error;
 const code_1$8 = code;
 const codegen_1$p = codegen;
 const names_1$4 = names$1;
@@ -21897,7 +21849,7 @@ const def$j = {
 additionalProperties.default = def$j;
 var properties$8 = {};
 Object.defineProperty(properties$8, "__esModule", { value: true });
-const validate_1 = requireValidate();
+const validate_1 = validate$1;
 const code_1$2 = code;
 const util_1$b = util;
 const additionalProperties_1$1 = additionalProperties;
@@ -23255,7 +23207,7 @@ jsonSchema201909.default = addMetaSchema2019;
   module.exports = exports = Ajv2019;
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = Ajv2019;
-  var validate_12 = requireValidate();
+  var validate_12 = validate$1;
   Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
     return validate_12.KeywordCxt;
   } });
@@ -23278,11 +23230,11 @@ jsonSchema201909.default = addMetaSchema2019;
   Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
     return codegen_12.CodeGen;
   } });
-  var validation_error_12 = requireValidation_error();
+  var validation_error_12 = validation_error;
   Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
     return validation_error_12.default;
   } });
-  var ref_error_12 = requireRef_error();
+  var ref_error_12 = ref_error;
   Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
     return ref_error_12.default;
   } });
@@ -24270,7 +24222,7 @@ function handleComputedProperty(options) {
   var _a;
   return Object.assign({}, options, {
     _computed: {
-      version: "9.32.0",
+      version: "9.32.1",
       paymentMethodsUrl: ((_a = options._dev) == null ? void 0 : _a.paymentMethodsUrl) ?? "https://forms.secure-payments.app"
     }
   });
@@ -27612,7 +27564,7 @@ class RebillyInstrumentsInstance {
     await show({ componentName, payload });
   }
   get version() {
-    return `RebillyInstruments Ver.${"9.32.0"}`;
+    return `RebillyInstruments Ver.${"9.32.1"}`;
   }
   on(eventName, callback) {
     on({ eventName, callback });