@amritk/generate-parsers 0.24.0 → 0.25.0

package/dist/generators/generate-strict-assertion.js

@@ -1,759 +0,0 @@
-import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
-import { multipleOfFailExpr } from "@amritk/helpers/multiple-of-check";
-import { boundFailExpr } from "@amritk/helpers/numeric-bound-check";
-import { quoteJsString } from "@amritk/helpers/quote-js-string";
-import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { hasOwnCheck, missingCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
-import { maxLengthFailExpr, minLengthFailExpr } from "@amritk/helpers/string-length-check";
-import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
-import { generateEnumCheck } from "./generate-enum-check.js";
-import { canEnforceUnion, generateUnionCheck, getUnionBranches, isExclusiveUnion, isInlineObjectProperty, multiTypeCheck } from "./generate-type-checks.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { everyTailItem, getPrefixItems, plainScalarItemCheck, prefixItemsCapsLength } from "./generate-validation-expression.js";
-import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
-const shapeIsDelegated = (schema, context) => (context.subParsers ?? true) && isInlineObjectProperty(schema);
-const matchContext = (context) => context.rootSchema ? { rootSchema: context.rootSchema } : {};
-const TYPELESS_CONSTRAINT_KEYWORDS = [
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf",
-  "minLength",
-  "maxLength",
-  "pattern",
-  "minItems",
-  "maxItems",
-  "uniqueItems",
-  "items",
-  "prefixItems",
-  "contains"
-];
-const TYPELESS_OBJECT_KEYWORDS = [
-  "required",
-  "minProperties",
-  "maxProperties",
-  "propertyNames",
-  "patternProperties",
-  "additionalProperties",
-  "dependentRequired",
-  "dependentSchemas"
-];
-const backstopReason = (schema, context) => {
-  if (!isSchemaObject(schema))
-    return null;
-  const record = schema;
-  if ("unevaluatedProperties" in record && record["unevaluatedProperties"] !== true)
-    return "unevaluatedProperties";
-  if ("unevaluatedItems" in record && record["unevaluatedItems"] !== true)
-    return "unevaluatedItems";
-  if (hasRef(schema) && (!context.useRefImports || hasConstrainingRefSibling(schema)))
-    return "$ref";
-  if (record["items"] === false && !Array.isArray(record["prefixItems"]))
-    return "items";
-  if (!("type" in record)) {
-    if (TYPELESS_CONSTRAINT_KEYWORDS.some((keyword) => keyword in record))
-      return "constraints";
-    if (!("properties" in record) && TYPELESS_OBJECT_KEYWORDS.some((keyword) => keyword in record))
-      return "constraints";
-    return null;
-  }
-  if (Array.isArray(record["type"])) {
-    const nonNull = record["type"].filter((type) => type !== "null");
-    const constrains = TYPELESS_CONSTRAINT_KEYWORDS.some((keyword) => keyword in record) || TYPELESS_OBJECT_KEYWORDS.some((keyword) => keyword in record);
-    if (nonNull.length > 1 && constrains)
-      return "constraints";
-  }
-  return null;
-};
-const backstopSchema = (schema, reason) => {
-  if (reason !== "constraints" && reason !== "items")
-    return schema;
-  const record = schema;
-  const residual = {};
-  for (const keyword of [
-    "type",
-    ...TYPELESS_CONSTRAINT_KEYWORDS,
-    ...TYPELESS_OBJECT_KEYWORDS,
-    "minContains",
-    "maxContains"
-  ]) {
-    if (keyword in record)
-      residual[keyword] = record[keyword];
-  }
-  if ("additionalProperties" in residual && "properties" in record) {
-    const properties = record["properties"];
-    if (typeof properties === "object" && properties !== null && !Array.isArray(properties)) {
-      residual["properties"] = Object.fromEntries(Object.keys(properties).map((k) => [k, true]));
-    }
-  }
-  return residual;
-};
-const backstopMessage = (reason, label) => {
-  switch (reason) {
-    case "unevaluatedProperties":
-      return `${label} must NOT have unevaluated properties`;
-    case "unevaluatedItems":
-      return `${label} must NOT have unevaluated items`;
-    case "$ref":
-      return `${label} does not satisfy the referenced schema`;
-    default:
-      return `${label} does not satisfy the schema`;
-  }
-};
-const generateBackstopAssertion = (acc, schema, label, context, optional = false) => {
-  const reason = backstopReason(schema, context);
-  if (reason === null)
-    return [];
-  const match = subschemaMatchExpr(acc, backstopSchema(schema, reason), matchContext(context));
-  if (match === null || match === "true")
-    return [];
-  const failure = throwError(backstopMessage(reason, label));
-  return [optional ? `  if (${acc} !== undefined && !(${match})) ${failure};` : `  if (!(${match})) ${failure};`];
-};
-const wrongTypeCondition = (accessor, type) => {
-  switch (type) {
-    case "string":
-      return `typeof ${accessor} !== "string"`;
-    case "number":
-      return `typeof ${accessor} !== "number"`;
-    case "integer":
-      return `(typeof ${accessor} !== "number" || !Number.isInteger(${accessor}))`;
-    case "boolean":
-      return `typeof ${accessor} !== "boolean"`;
-    case "null":
-      return `${accessor} !== null`;
-    case "array":
-      return `!Array.isArray(${accessor})`;
-    case "object":
-      return `!isObject(${accessor})`;
-    default:
-      return null;
-  }
-};
-const typeLabel = (type) => type === "integer" ? "number" : type;
-const throwError = (message, suffixExpr) => {
-  const literal = quoteJsString(message);
-  return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
-};
-const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
-  if (!isSchemaObject(propSchema) || !hasType(propSchema))
-    return [];
-  const t = propSchema.type;
-  const lines = [];
-  if (t === "string") {
-    if (hasPattern(propSchema)) {
-      const patternLiteral = regexLiteral(propSchema.pattern);
-      lines.push(`  if (typeof ${acc} === "string" && !${patternLiteral}.test(${acc})) ${throwError(`${field} must match pattern ${propSchema.pattern}`)};`);
-    }
-    if (hasMinLength(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "string" && ${minLengthFailExpr(acc, propSchema.minLength)}) ${throwError(`${field} must have at least ${propSchema.minLength} characters`)};`);
-    }
-    if (hasMaxLength(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "string" && ${maxLengthFailExpr(acc, propSchema.maxLength)}) ${throwError(`${field} must have at most ${propSchema.maxLength} characters`)};`);
-    }
-  }
-  if (t === "number" || t === "integer") {
-    if (hasMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "minimum", propSchema.minimum)}) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
-    }
-    if (hasMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "maximum", propSchema.maximum)}) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
-    }
-    if (hasExclusiveMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "minimum", propSchema.exclusiveMinimum, true)}) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
-    }
-    if (hasExclusiveMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "maximum", propSchema.exclusiveMaximum, true)}) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
-    }
-    if (hasMultipleOf(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
-    }
-  }
-  if (t === "array") {
-    if (hasMinItems(propSchema)) {
-      lines.push(`  if (Array.isArray(${acc}) && ${acc}.length < ${propSchema.minItems}) ${throwError(`${field} must have at least ${propSchema.minItems} items`)};`);
-    }
-    if (hasMaxItems(propSchema)) {
-      lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${propSchema.maxItems}) ${throwError(`${field} must have at most ${propSchema.maxItems} items`)};`);
-    }
-    if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
-      lines.push(`  if (Array.isArray(${acc}) && !(${generateUniqueItemsCheck(acc, propSchema)})) ${throwError(`${field} must NOT have duplicate items`)};`);
-    }
-    const itemCheck = generateItemCheck(propSchema, context);
-    if (itemCheck) {
-      lines.push(`  if (Array.isArray(${acc}) && !${everyTailItem(acc, itemCheck.check, propSchema)}) ${throwError(`${field} ${itemCheck.message}`)};`);
-    }
-    lines.push(...generatePrefixItemsAssertion(acc, field, propSchema, context));
-  }
-  if (t === "object") {
-    lines.push(...generateObjectSizeChecks(acc, propSchema, field, true));
-  }
-  return lines;
-};
-const generateObjectSizeChecks = (acc, schema, label, guard) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const lines = [];
-  const prefix = guard ? `isObject(${acc}) && ` : "";
-  if (hasMinProperties(schema)) {
-    lines.push(`  if (${prefix}Object.keys(${acc}).length < ${schema.minProperties}) ${throwError(`${label} must have at least ${schema.minProperties} properties`)};`);
-  }
-  if (hasMaxProperties(schema)) {
-    lines.push(`  if (${prefix}Object.keys(${acc}).length > ${schema.maxProperties}) ${throwError(`${label} must have at most ${schema.maxProperties} properties`)};`);
-  }
-  return lines;
-};
-const generateItemCheck = (schema, context) => {
-  if (!isSchemaObject(schema) || !hasItems(schema) || Array.isArray(schema.items))
-    return null;
-  const items = schema.items;
-  if (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0) {
-    const label = items.enum.map((v) => JSON.stringify(v)).join(", ");
-    return { check: generateEnumCheck("_it", items.enum), message: `items must be one of: ${label}` };
-  }
-  const scalarCheck = plainScalarItemCheck(items, "_it");
-  if (scalarCheck !== null && isSchemaObject(items) && hasType(items)) {
-    return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
-  }
-  if (hasRef(items) && context.useRefImports === true || shapeIsDelegated(items, context))
-    return null;
-  const match = subschemaMatchExpr("_it", items, matchContext(context));
-  if (match !== null)
-    return match === "true" ? null : { check: match, message: "items do not match the item schema" };
-  const branches = getUnionBranches(items);
-  if (branches === null || context.stripUnknown === true)
-    return null;
-  if (!canEnforceUnion(branches, context.rootSchema))
-    return null;
-  const union = generateUnionCheck("_it", branches, context.useRefImports ?? false, context.suffix ?? "", isExclusiveUnion(items));
-  return union === null ? null : { check: union, message: "items do not match the item schema" };
-};
-const nullableObjectShapeChecks = (acc, schema, type, label, optional, context) => {
-  if (type !== "object")
-    return [];
-  const match = subschemaMatchExpr(acc, { ...schema, type: "object" }, matchContext(context));
-  if (match === null || match === "true")
-    return [];
-  const presence = optional ? `${acc} !== undefined && ${acc} !== null` : `${acc} !== null`;
-  return [`  if (${presence} && !(${match})) ${throwError(`${label} does not match the declared object shape`)};`];
-};
-const objectShapeResidual = (schema, context) => {
-  if (!isSchemaObject(schema) || !hasType(schema) || schema.type !== "object")
-    return null;
-  if (shapeIsDelegated(schema, context))
-    return null;
-  const record = schema;
-  const residual = { type: "object" };
-  if (hasProperties(schema))
-    residual["properties"] = record["properties"];
-  if (hasRequired(schema))
-    residual["required"] = record["required"];
-  if (record["additionalProperties"] === false) {
-    residual["additionalProperties"] = false;
-    if ("patternProperties" in record)
-      residual["patternProperties"] = record["patternProperties"];
-  }
-  return "properties" in residual || "required" in residual || "additionalProperties" in residual ? residual : null;
-};
-const declaredObjectShapeChecks = (acc, schema, label, optional, context) => {
-  const residual = objectShapeResidual(schema, context);
-  if (residual === null)
-    return [];
-  const match = subschemaMatchExpr(acc, residual, matchContext(context));
-  if (match === null || match === "true")
-    return [];
-  const presence = optional ? `${acc} !== undefined && ` : "";
-  return [`  if (${presence}!(${match})) ${throwError(`${label} does not match the declared object shape`)};`];
-};
-const generateNotCheck = (acc, schema, label, optional, context) => {
-  if (!isSchemaObject(schema) || !("not" in schema))
-    return [];
-  const match = subschemaMatchExpr(acc, schema["not"], matchContext(context));
-  if (match === null || match === "false")
-    return [];
-  const failure = throwError(`${label} must NOT match the excluded schema`);
-  return [optional ? `  if (${acc} !== undefined && (${match})) ${failure};` : `  if (${match}) ${failure};`];
-};
-const generateAllOfChecks = (acc, schema, label, optional, context, skipInlineMembers = false) => {
-  if (!isSchemaObject(schema) || !Array.isArray(schema.allOf))
-    return [];
-  const handledInline = new Set(skipInlineMembers ? inlineAllOfMembers(schema) : []);
-  const lines = [];
-  for (const member of schema.allOf) {
-    if (handledInline.has(member))
-      continue;
-    const delegated = context.useRefImports === true && hasProperties(schema) && !hasConstrainingRefSibling(member);
-    if (isSchemaObject(member) && hasRef(member) && delegated)
-      continue;
-    const match = subschemaMatchExpr(acc, member, matchContext(context));
-    if (match === null || match === "true")
-      continue;
-    const failure = throwError(`${label} does not satisfy all of the declared schemas`);
-    lines.push(optional ? `  if (${acc} !== undefined && !(${match})) ${failure};` : `  if (!(${match})) ${failure};`);
-  }
-  return lines;
-};
-const flatUnionCheck = (acc, schema, context) => {
-  const branches = getUnionBranches(schema);
-  if (branches === null || context.stripUnknown === true)
-    return null;
-  if (!canEnforceUnion(branches, context.rootSchema))
-    return null;
-  return generateUnionCheck(acc, branches, context.useRefImports ?? false, context.suffix ?? "", isExclusiveUnion(schema));
-};
-const generateUnionMatchChecks = (acc, schema, label, optional, context) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const record = schema;
-  const covered = flatUnionCheck(acc, schema, context) === null ? void 0 : isExclusiveUnion(schema) ? "oneOf" : "anyOf";
-  const lines = [];
-  for (const keyword of ["anyOf", "oneOf"]) {
-    if (keyword === covered)
-      continue;
-    const members = record[keyword];
-    if (!Array.isArray(members) || members.length === 0)
-      continue;
-    const matches = [];
-    for (const member of members) {
-      const match = subschemaMatchExpr(acc, member, matchContext(context));
-      if (match === null)
-        break;
-      matches.push(match);
-    }
-    if (matches.length !== members.length)
-      continue;
-    const check = unionMatchExpr(keyword, matches);
-    if (check === null || check === "true")
-      continue;
-    const failure = throwError(`${label} does not match ${keyword === "anyOf" ? "any of" : "exactly one of"} the declared schemas`);
-    lines.push(optional ? `  if (${acc} !== undefined && !(${check})) ${failure};` : `  if (!(${check})) ${failure};`);
-  }
-  return lines;
-};
-const unionMatchExpr = (keyword, matches) => {
-  if (keyword === "anyOf") {
-    if (matches.includes("true"))
-      return null;
-    return matches.length === 1 ? matches[0] : `(${matches.join(" || ")})`;
-  }
-  if (matches.length === 1)
-    return matches[0];
-  return `((${matches.map((match) => `(${match} ? 1 : 0)`).join(" + ")}) === 1)`;
-};
-const generateConditionalChecks = (acc, schema, label, context) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const record = schema;
-  if (!("if" in record) || !("then" in record) && !("else" in record))
-    return [];
-  const ifMatch = subschemaMatchExpr(acc, record["if"], matchContext(context));
-  if (ifMatch === null)
-    return [];
-  const lines = [];
-  if ("then" in record) {
-    const thenMatch = subschemaMatchExpr(acc, record["then"], matchContext(context));
-    if (thenMatch === null)
-      return [];
-    if (thenMatch !== "true") {
-      lines.push(`  if ((${ifMatch}) && !(${thenMatch})) ${throwError(`${label} does not satisfy the 'then' schema`)};`);
-    }
-  }
-  if ("else" in record) {
-    const elseMatch = subschemaMatchExpr(acc, record["else"], matchContext(context));
-    if (elseMatch === null)
-      return [];
-    if (elseMatch !== "true") {
-      lines.push(`  if (!(${ifMatch}) && !(${elseMatch})) ${throwError(`${label} does not satisfy the 'else' schema`)};`);
-    }
-  }
-  return lines;
-};
-const generateKeyedValueChecks = (obj, schema, label, context = {}) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const record = schema;
-  const patternEntries = [];
-  const patternSource = record["patternProperties"];
-  if (typeof patternSource === "object" && patternSource !== null && !Array.isArray(patternSource)) {
-    for (const [pattern, sub] of Object.entries(patternSource)) {
-      const match = subschemaMatchExpr("_v", sub, matchContext(context));
-      if (match === null || match === "true")
-        continue;
-      patternEntries.push([pattern, match]);
-    }
-  }
-  const allPatterns = typeof patternSource === "object" && patternSource !== null && !Array.isArray(patternSource) ? Object.keys(patternSource) : [];
-  const additional = record["additionalProperties"];
-  const additionalMatch = additional !== void 0 && typeof additional !== "boolean" ? subschemaMatchExpr("_v", additional, matchContext(context)) : null;
-  const lines = [];
-  for (const [pattern, match] of patternEntries) {
-    lines.push(`    if (${regexLiteral(pattern)}.test(_k) && !(${match})) ${throwError(`${label} invalid value for property `, "_k")};`);
-  }
-  if (additionalMatch !== null && additionalMatch !== "true") {
-    const declared = hasProperties(schema) ? Object.keys(schema.properties) : [];
-    const guards = [];
-    if (declared.length > 0)
-      guards.push(`!${JSON.stringify(declared)}.includes(_k)`);
-    for (const pattern of allPatterns)
-      guards.push(`!${regexLiteral(pattern)}.test(_k)`);
-    const prefix = guards.length > 0 ? `${guards.join(" && ")} && ` : "";
-    lines.push(`    if (${prefix}!(${additionalMatch})) ${throwError(`${label} invalid value for property `, "_k")};`);
-  }
-  if (lines.length === 0)
-    return [];
-  return [
-    `  for (const _k of Object.keys(${obj})) {`,
-    `    const _v = (${obj} as Record<string, unknown>)[_k];`,
-    ...lines,
-    `  }`
-  ];
-};
-const generateContainsCheck = (acc, schema, label, context = {}) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const sp = schema;
-  if (!("contains" in sp))
-    return [];
-  const match = subschemaMatchExpr("_c", sp["contains"], matchContext(context));
-  if (match === null)
-    return [];
-  const min = typeof sp["minContains"] === "number" ? sp["minContains"] : 1;
-  const max = typeof sp["maxContains"] === "number" ? sp["maxContains"] : void 0;
-  const bound = max !== void 0 ? `_cn < ${min} || _cn > ${max}` : `_cn < ${min}`;
-  return [
-    `  if (Array.isArray(${acc})) {`,
-    `    const _cn = (${acc} as unknown[]).filter((_c) => ${match}).length;`,
-    `    if (${bound}) ${throwError(`${label} array does not contain the required matching items`)};`,
-    `  }`
-  ];
-};
-const generateDependentRequiredChecks = (obj, schema, label) => {
-  if (!hasDependentRequired(schema))
-    return [];
-  const lines = [];
-  for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
-    if (!Array.isArray(deps))
-      continue;
-    for (const dep of deps) {
-      lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, dep)}) ${throwError(`${label} must have property '${dep}' when '${trigger}' is present`)};`);
-    }
-  }
-  return lines;
-};
-const generateDependentSchemasChecks = (obj, schema, label, context) => {
-  const dep = schema["dependentSchemas"];
-  if (typeof dep !== "object" || dep === null || Array.isArray(dep))
-    return [];
-  const lines = [];
-  for (const [trigger, sub] of Object.entries(dep)) {
-    if (sub === true)
-      continue;
-    if (sub === false) {
-      lines.push(`  if (${hasOwnCheck(obj, trigger)}) ${throwError(`${label} must NOT have property '${trigger}'`)};`);
-      continue;
-    }
-    const match = subschemaMatchExpr(obj, sub, matchContext(context));
-    if (match === null || match === "true")
-      continue;
-    lines.push(`  if (${hasOwnCheck(obj, trigger)} && !(${match})) ${throwError(`${label} does not satisfy the schema required when '${trigger}' is present`)};`);
-  }
-  return lines;
-};
-const resolvePositionSchema = (pos, rootSchema) => {
-  if (isSchemaObject(pos) && hasRef(pos) && rootSchema) {
-    const resolved = resolveRef(pos.$ref, rootSchema);
-    if (resolved)
-      return resolved;
-  }
-  return pos;
-};
-const generatePrefixItemsAssertion = (acc, field, schema, context) => {
-  const rootSchema = context.rootSchema;
-  const prefix = getPrefixItems(schema);
-  if (!prefix)
-    return [];
-  const lines = [];
-  for (let i = 0; i < prefix.length; i++) {
-    const pos = resolvePositionSchema(prefix[i], rootSchema);
-    const el = `${acc}[${i}]`;
-    const present = `Array.isArray(${acc}) && ${acc}.length > ${i}`;
-    if (isSchemaObject(pos) && hasEnum(pos) && pos.enum.length > 0) {
-      const label = pos.enum.map((v) => JSON.stringify(v)).join(", ");
-      lines.push(`  if (${present} && !${generateEnumCheck(el, pos.enum)}) ${throwError(`${field}[${i}] must be one of: ${label}`)};`);
-      continue;
-    }
-    if (isSchemaObject(pos) && hasType(pos)) {
-      const pt = pos.type;
-      const wrong = wrongTypeCondition(el, pt);
-      if (wrong) {
-        lines.push(`  if (${present} && (${wrong})) ${throwError(`${field}[${i}] expected ${typeLabel(pt)}, got `, `typeof ${el}`)};`);
-      }
-    }
-    const match = subschemaMatchExpr(el, prefix[i], matchContext(context));
-    if (match !== null && match !== "true") {
-      lines.push(`  if (${present} && !(${match})) ${throwError(`${field}[${i}] does not match the tuple schema`)};`);
-    }
-  }
-  if (prefixItemsCapsLength(schema)) {
-    lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${prefix.length}) ${throwError(`${field} must NOT have more than ${prefix.length} items`)};`);
-  }
-  return lines;
-};
-const generatePropertyNameChecks = (obj, schema, label, context) => {
-  if (!hasPropertyNames(schema) || !isSchemaObject(schema.propertyNames))
-    return [];
-  const match = subschemaMatchExpr("_name", schema.propertyNames, matchContext(context));
-  if (match === null || match === "true")
-    return [];
-  return [
-    `  for (const _name of Object.keys(${obj})) {`,
-    `    if (!(${match})) ${throwError(`${label} invalid property name: `, "_name")};`,
-    `  }`
-  ];
-};
-const generateCompositionChecks = (acc, schema, label, context = {}) => [
-  ...generateNotCheck(acc, schema, label, false, context),
-  ...generateAllOfChecks(acc, schema, label, false, context),
-  ...generateUnionMatchChecks(acc, schema, label, false, context),
-  ...generateConditionalChecks(acc, schema, label, context)
-];
-const generateObjectKeywordChecks = (obj, schema, label, guard, context = {}) => {
-  if (!isSchemaObject(schema))
-    return [];
-  const inner = [
-    ...generateDependentRequiredChecks(obj, schema, label),
-    ...generateDependentSchemasChecks(obj, schema, label, context),
-    ...generatePropertyNameChecks(obj, schema, label, context)
-  ];
-  if (inner.length === 0)
-    return [];
-  if (!guard)
-    return inner;
-  return [`  if (isObject(${obj})) {`, ...inner.map((line) => `  ${line}`), `  }`];
-};
-const generatePropertyAssertion = (key, propSchema, isRequired, typeName, context = {}) => {
-  const acc = safeAccessor("input", key);
-  const field = `[${typeName}] field '${key}'`;
-  const lines = [];
-  if (isRequired) {
-    lines.push(`  if (${missingCheck("input", key)}) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
-  }
-  if (propSchema === false) {
-    lines.push(`  if (${hasOwnCheck("input", key)}) ${throwError(`[${typeName}] must NOT have property '${key}'`)};`);
-    return lines;
-  }
-  if (!isSchemaObject(propSchema))
-    return lines;
-  lines.push(...generateBackstopAssertion(acc, propSchema, field, context, !isRequired));
-  if (hasRef(propSchema))
-    return lines;
-  lines.push(...generateNotCheck(acc, propSchema, field, !isRequired, context));
-  lines.push(...generateAllOfChecks(acc, propSchema, field, !isRequired, context));
-  lines.push(...generateUnionMatchChecks(acc, propSchema, field, !isRequired, context));
-  lines.push(...generateConditionalChecks(acc, propSchema, field, context));
-  lines.push(...declaredObjectShapeChecks(acc, propSchema, field, !isRequired, context));
-  const unionBranches = getUnionBranches(propSchema);
-  if (unionBranches) {
-    if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {
-      const check = generateUnionCheck(acc, unionBranches, context.useRefImports ?? false, context.suffix ?? "", isExclusiveUnion(propSchema));
-      if (check !== null) {
-        const failure = throwError(`${field} does not match any allowed variant`);
-        lines.push(isRequired ? `  if (!(${check})) ${failure};` : `  if (${acc} !== undefined && !(${check})) ${failure};`);
-      }
-    }
-    return lines;
-  }
-  const instanceOf = getMjstInstanceOf(propSchema);
-  if (instanceOf) {
-    if (isRequired) {
-      lines.push(`  if (!(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
-    } else {
-      lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
-    }
-    return lines;
-  }
-  const primitive = getMjstPrimitive(propSchema);
-  if (primitive) {
-    if (isRequired) {
-      lines.push(`  if (typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
-    } else {
-      lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
-    }
-    return lines;
-  }
-  if (hasConst(propSchema)) {
-    const equal = generateDeepEqualCheck(acc, propSchema.const);
-    const failure = throwError(`${field} must be ${JSON.stringify(propSchema.const)}`);
-    lines.push(isRequired ? `  if (!(${equal})) ${failure};` : `  if (${acc} !== undefined && !(${equal})) ${failure};`);
-    return lines;
-  }
-  if (hasEnum(propSchema)) {
-    const member = generateEnumCheck(acc, propSchema.enum);
-    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
-    if (isRequired) {
-      lines.push(`  if (!${member}) ${throwError(`${field} must be one of: ${label}`)};`);
-    } else {
-      lines.push(`  if (${acc} !== undefined && !${member}) ${throwError(`${field} must be one of: ${label}`)};`);
-    }
-    return lines;
-  }
-  const multiType = multiTypeCheck(acc, propSchema, { ignoreConstraints: true });
-  if (multiType !== void 0) {
-    const types = propSchema.type;
-    if (multiType !== null) {
-      const expected = throwError(`${field} expected ${types.map(typeLabel).join(" | ")}, got `, `typeof ${acc}`);
-      lines.push(isRequired ? `  if (!${multiType}) ${expected};` : `  if (${acc} !== undefined && !${multiType}) ${expected};`);
-    }
-    const nonNull = types.filter((type) => type !== "null");
-    if (nonNull.length === 1) {
-      lines.push(...generateConstraintChecks(acc, { ...propSchema, type: nonNull[0] }, field, context));
-      lines.push(...nullableObjectShapeChecks(acc, propSchema, nonNull[0], field, !isRequired, context));
-    }
-    return lines;
-  }
-  if (hasType(propSchema)) {
-    const t = propSchema.type;
-    const wrongType = wrongTypeCondition(acc, t);
-    if (wrongType) {
-      const expected = throwError(`${field} expected ${typeLabel(t)}, got `, `typeof ${acc}`);
-      if (isRequired) {
-        lines.push(`  if (${wrongType}) ${expected};`);
-      } else {
-        lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
-      }
-    }
-    lines.push(...generateConstraintChecks(acc, propSchema, field, context));
-  }
-  if (isSchemaObject(propSchema)) {
-    const r = propSchema;
-    if ("contains" in r)
-      lines.push(...generateContainsCheck(acc, propSchema, field, context));
-    if (("dependentRequired" in r || "dependentSchemas" in r || "propertyNames" in r) && !isInlineObjectProperty(propSchema)) {
-      lines.push(...generateObjectKeywordChecks(acc, propSchema, field, true, context));
-    }
-    if ("patternProperties" in r || isSchemaObject(propSchema) && typeof r["additionalProperties"] === "object") {
-      const keyed = generateKeyedValueChecks(acc, propSchema, field, context);
-      if (keyed.length > 0) {
-        lines.push(`  if (isObject(${acc})) {`, ...keyed.map((line) => `  ${line}`), `  }`);
-      }
-    }
-  }
-  return lines;
-};
-const inlineAllOfMembers = (schema) => {
-  if (!isSchemaObject(schema) || !Array.isArray(schema.allOf))
-    return [];
-  return schema.allOf.filter((member) => {
-    if (!isSchemaObject(member) || hasRef(member))
-      return false;
-    const record = member;
-    if ("allOf" in record || "oneOf" in record || "anyOf" in record || "not" in record)
-      return false;
-    if ("if" in record || "then" in record || "else" in record)
-      return false;
-    return hasProperties(member) || hasRequired(member);
-  });
-};
-const generateObjectStrictAssertion = (schema, typeName, context = {}) => {
-  const lines = [];
-  lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
-  if (!isSchemaObject(schema))
-    return lines;
-  const required = new Set(hasRequired(schema) ? schema.required : []);
-  if (hasProperties(schema)) {
-    const props = schema.properties;
-    for (const key in props) {
-      lines.push(...generatePropertyAssertion(key, props[key], required.has(key), typeName, context));
-    }
-    for (const key in props)
-      required.delete(key);
-  }
-  for (const key of required) {
-    lines.push(`  if (${missingCheck("input", key)}) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
-  }
-  for (const member of inlineAllOfMembers(schema)) {
-    lines.push(...generateObjectStrictAssertion(member, typeName, context).slice(1));
-  }
-  const sr = schema;
-  if ("dependentRequired" in sr || "dependentSchemas" in sr || "propertyNames" in sr) {
-    lines.push(...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false, context));
-  }
-  lines.push(...generateObjectSizeChecks("input", schema, `[${typeName}]`, false));
-  lines.push(...generateNotCheck("input", schema, `[${typeName}]`, false, context));
-  lines.push(...generateAllOfChecks("input", schema, `[${typeName}]`, false, context, true));
-  lines.push(...generateUnionMatchChecks("input", schema, `[${typeName}]`, false, context));
-  lines.push(...generateConditionalChecks("input", schema, `[${typeName}]`, context));
-  lines.push(...generateKeyedValueChecks("input", schema, `[${typeName}]`, context));
-  lines.push(...generateBackstopAssertion("input", schema, `[${typeName}]`, context));
-  return lines;
-};
-const generateScalarStrictAssertion = (schema, typeName, context = {}) => {
-  if (schema === false)
-    return `  ${throwError(`[${typeName}] schema is false: no value is valid`)};`;
-  const got = 'input === null ? "null" : typeof input';
-  const instanceOf = getMjstInstanceOf(schema);
-  if (instanceOf) {
-    return `  if (!(input instanceof ${instanceOf})) ${throwError(`[${typeName}] expected ${instanceOf}, got `, got)};`;
-  }
-  const primitive = getMjstPrimitive(schema);
-  if (primitive) {
-    return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
-  }
-  if (!isSchemaObject(schema))
-    return null;
-  const label = `[${typeName}]`;
-  const lines = [];
-  if (hasConst(schema)) {
-    lines.push(`  if (!(${generateDeepEqualCheck("input", schema.const)})) ${throwError(`${label} must be ${JSON.stringify(schema.const)}`)};`);
-  } else if (hasEnum(schema)) {
-    const enumLabel = schema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (!${generateEnumCheck("input", schema.enum)}) ${throwError(`${label} must be one of: ${enumLabel}`)};`);
-  }
-  lines.push(...generateNotCheck("input", schema, label, false, context));
-  lines.push(...generateAllOfChecks("input", schema, label, false, context));
-  lines.push(...generateUnionMatchChecks("input", schema, label, false, context));
-  lines.push(...generateConditionalChecks("input", schema, label, context));
-  const rootMultiType = multiTypeCheck("input", schema, { ignoreConstraints: true });
-  if (rootMultiType !== void 0) {
-    const types = schema.type;
-    if (rootMultiType !== null) {
-      lines.push(`  if (!${rootMultiType}) ${throwError(`${label} expected ${types.map(typeLabel).join(" | ")}, got `, got)};`);
-    }
-    const nonNull = types.filter((type) => type !== "null");
-    if (nonNull.length === 1) {
-      lines.push(...generateConstraintChecks("input", { ...schema, type: nonNull[0] }, label, context));
-      lines.push(...nullableObjectShapeChecks("input", schema, nonNull[0], label, false, context));
-    }
-    lines.push(...generateBackstopAssertion("input", schema, label, context));
-    return lines.length > 0 ? lines.join("\n") : null;
-  }
-  if (hasType(schema)) {
-    const t = schema.type;
-    const wrongType = wrongTypeCondition("input", t);
-    if (wrongType) {
-      lines.push(`  if (${wrongType}) ${throwError(`${label} expected ${typeLabel(t)}, got `, got)};`);
-    }
-    if (t === "array") {
-      lines.push(...generateContainsCheck("input", schema, label, context));
-    }
-    lines.push(...generateConstraintChecks("input", schema, label, context));
-  }
-  lines.push(...generateBackstopAssertion("input", schema, label, context));
-  return lines.length > 0 ? lines.join("\n") : null;
-};
-export {
-  backstopReason,
-  backstopSchema,
-  generateBackstopAssertion,
-  generateCompositionChecks,
-  generateContainsCheck,
-  generateKeyedValueChecks,
-  generateObjectKeywordChecks,
-  generateObjectSizeChecks,
-  generateObjectStrictAssertion,
-  generateScalarStrictAssertion,
-  inlineAllOfMembers
-};