@amritk/generate-parsers 0.24.0 → 0.25.0

package/dist/generators/generate-parser-function.js

@@ -1,1973 +0,0 @@
-import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
-import { quoteJsString } from "@amritk/helpers/quote-js-string";
-import { declaresKey, readKey } from "@amritk/helpers/read-key";
-import { refToName } from "@amritk/helpers/ref-to-name";
-import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { hasOwnCheck, missingCheck, safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasMaxItems, hasMaxProperties, hasMinItems, hasMinProperties, hasOneOf, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
-import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
-import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
-import { findDiscriminator } from "../helpers/find-discriminator.js";
-import { getDefaultValue } from "../helpers/get-default-value.js";
-import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
-import { assertNoUnsupportedKeywords } from "./assert-supported-keywords.js";
-import { generateEnumCaseInsensitiveCoercion } from "./generate-enum-check.js";
-import { generateBackstopAssertion, generateCompositionChecks, generateContainsCheck, generateKeyedValueChecks, generateObjectKeywordChecks, generateObjectSizeChecks, generateObjectStrictAssertion, generateScalarStrictAssertion, inlineAllOfMembers } from "./generate-strict-assertion.js";
-import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, hasFastPathBlockingKeyword, isExclusiveUnion, isInlineObjectArrayProperty, isInlineObjectProperty, isInlineUnionProperty, isUnionArrayProperty, shapeValidatorName } from "./generate-type-checks.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { generatePrefixItemsMap, generateValidationExpression, getPrefixItems, isCoercibleItemSchema, prefixItemsCapsLength } from "./generate-validation-expression.js";
-const generateParserName = (typeName) => {
-  return `parse${typeName}`;
-};
-const safeLiteralKey = (key) => key === "__proto__" ? '["__proto__"]' : safeKey(key);
-const isPropertyRequired = (key, schema) => {
-  if (!isSchemaObject(schema)) {
-    return false;
-  }
-  if (!("required" in schema) || !Array.isArray(schema.required)) {
-    return false;
-  }
-  return schema.required.includes(key);
-};
-const generateRequiredRefCall = (key, ref, suffix) => {
-  const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref, suffix));
-  return `${parserName}(${acc})`;
-};
-const generateOptionalRefCall = (key, ref, suffix) => {
-  const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref, suffix));
-  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${acc}) })`;
-};
-const generateRequiredArrayRefCall = (key, ref, suffix) => {
-  const parserName = generateParserName(refToName(ref, suffix));
-  return `validateArray(${safeAccessor("input", key)}, ${parserName})`;
-};
-const generateOptionalArrayRefCall = (key, ref, suffix) => {
-  const parserName = generateParserName(refToName(ref, suffix));
-  const acc = safeAccessor("input", key);
-  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateArray(${acc}, ${parserName}) })`;
-};
-const generateRequiredRecordRefCall = (key, ref, suffix) => {
-  const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref, suffix));
-  return `validateRecord(${acc}, ${parserName})`;
-};
-const generateOptionalRecordRefCall = (key, ref, suffix) => {
-  const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref, suffix));
-  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${acc}, ${parserName}) })`;
-};
-const generateOptionalInlineProperty = (key, valueExpression) => {
-  return `...((value => value === undefined ? {} : { ${safeLiteralKey(key)}: value })(${valueExpression}))`;
-};
-const shouldUseRefImport = (propSchema, useRefImports) => {
-  if (!useRefImports || !hasRef(propSchema)) {
-    return false;
-  }
-  const ref = propSchema.$ref;
-  const isUri = ref.startsWith("http://") || ref.startsWith("https://");
-  if (isUri && (ref.includes("#/properties/") || ref.includes("#/definitions/"))) {
-    return false;
-  }
-  return true;
-};
-const shouldUseArrayRefImport = (propSchema, useRefImports) => {
-  if (!useRefImports) {
-    return false;
-  }
-  if (!isSchemaObject(propSchema)) {
-    return false;
-  }
-  if (!("type" in propSchema) || propSchema.type !== "array") {
-    return false;
-  }
-  return hasItems(propSchema) && hasRef(propSchema.items);
-};
-const shouldUseRecordRefImport = (propSchema, useRefImports) => {
-  if (!useRefImports) {
-    return false;
-  }
-  if (!isSchemaObject(propSchema)) {
-    return false;
-  }
-  if (!("type" in propSchema) || propSchema.type !== "object") {
-    return false;
-  }
-  if (!("additionalProperties" in propSchema)) {
-    return false;
-  }
-  const additionalProps = propSchema.additionalProperties;
-  return isSchemaObject(additionalProps) && hasRef(additionalProps);
-};
-const generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix, caseInsensitive = false) => {
-  if (shouldUseRefImport(propSchema, useRefImports)) {
-    const ref = propSchema.$ref;
-    return isRequired ? generateRequiredRefCall(key, ref, suffix) : generateOptionalRefCall(key, ref, suffix);
-  }
-  if (shouldUseArrayRefImport(propSchema, useRefImports)) {
-    const items = propSchema.items;
-    const ref = items.$ref;
-    return isRequired ? generateRequiredArrayRefCall(key, ref, suffix) : generateOptionalArrayRefCall(key, ref, suffix);
-  }
-  if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-    const additionalProps = propSchema.additionalProperties;
-    const ref = additionalProps.$ref;
-    return isRequired ? generateRequiredRecordRefCall(key, ref, suffix) : generateOptionalRecordRefCall(key, ref, suffix);
-  }
-  if (!isSchemaObject(propSchema)) {
-    return isRequired ? "undefined" : generateOptionalInlineProperty(key, "undefined");
-  }
-  const defaultValue = getDefaultValue(propSchema);
-  const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired, void 0, void 0, void 0, void 0, caseInsensitive);
-  return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
-};
-const generatePropertyEntries = (schema, useRefImports, suffix, caseInsensitive = false) => {
-  if (!hasProperties(schema)) {
-    return [];
-  }
-  const entries = [];
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    const isRequired = isPropertyRequired(key, schema);
-    const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix, caseInsensitive);
-    const isOptional = value.startsWith("...");
-    entries.push({ key, value, isOptional });
-  }
-  return entries;
-};
-const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
-  if (useRefImports && hasRef(propSchema)) {
-    const ref = propSchema.$ref;
-    const parserName = generateParserName(refToName(ref, suffix));
-    return `${parserName}(undefined)`;
-  }
-  if (useRefImports && isSchemaObject(propSchema) && propSchema.type === "array" && hasItems(propSchema) && hasRef(propSchema.items)) {
-    return "[]";
-  }
-  if (useRefImports && isSchemaObject(propSchema) && propSchema.type === "object" && "additionalProperties" in propSchema) {
-    const additionalProps = propSchema.additionalProperties;
-    if (isSchemaObject(additionalProps) && hasRef(additionalProps)) {
-      return "{}";
-    }
-  }
-  return getDefaultValue(propSchema);
-};
-const PROTOTYPE_MEMBER_NAMES = new Set(Object.getOwnPropertyNames(Object.prototype));
-const declaresPrototypeMemberProperty = (schema, depth = 4) => {
-  if (!isSchemaObject(schema) || depth < 0)
-    return false;
-  if (hasProperties(schema) && Object.keys(schema.properties).some((key) => PROTOTYPE_MEMBER_NAMES.has(key)))
-    return true;
-  const record = schema;
-  const children = [];
-  if (hasProperties(schema))
-    children.push(...Object.values(schema.properties));
-  const items = record["items"];
-  if (Array.isArray(items))
-    children.push(...items);
-  else if (items !== void 0)
-    children.push(items);
-  const prefixItems = record["prefixItems"];
-  if (Array.isArray(prefixItems))
-    children.push(...prefixItems);
-  return children.some((child) => declaresPrototypeMemberProperty(child, depth - 1));
-};
-const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
-  if (!hasProperties(schema)) {
-    return `{} as ${typeName}`;
-  }
-  if (isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
-    return `{} as ${typeName}`;
-  }
-  if (isSchemaObject(schema) && hasAllOf(schema)) {
-    const composesConditional = schema.allOf.some((member) => isSchemaObject(member) && (hasRef(member) || "if" in member || "then" in member || "else" in member));
-    if (composesConditional)
-      return `{} as ${typeName}`;
-  }
-  const requiredProps = [];
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    const isRequired = isPropertyRequired(key, schema);
-    if (isRequired) {
-      const subName = subTypeNames?.get(key);
-      const fallbackValue = subName ? `${generateParserName(subName)}(undefined)` : generateFallbackValue(key, propSchema, useRefImports, suffix);
-      if (fallbackValue === "undefined") {
-        return `{} as ${typeName}`;
-      }
-      const partialFallback = fallbackValue === "{}" || isSchemaObject(propSchema) && (hasAllOf(propSchema) || hasOneOf(propSchema) || hasAnyOf(propSchema));
-      requiredProps.push(`        ${safeLiteralKey(key)}: ${partialFallback ? `${fallbackValue} as NonNullable<${typeName}>[${JSON.stringify(key)}]` : fallbackValue},`);
-    }
-  }
-  if (requiredProps.length === 0) {
-    return `{} as ${typeName}`;
-  }
-  let result = "{\n";
-  for (let i = 0; i < requiredProps.length; i++) {
-    result += requiredProps[i];
-    if (i < requiredProps.length - 1) {
-      result += "\n";
-    }
-  }
-  result += "\n      }";
-  if (declaresPrototypeMemberProperty(schema))
-    return `${result} as unknown as ${typeName}`;
-  const composesUnion = isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema));
-  return composesUnion ? `${result} as ${typeName}` : result;
-};
-const SCALAR_ROOT_CONSTRAINTS = [
-  "pattern",
-  "minLength",
-  "maxLength",
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf"
-];
-const isConstrainedScalarRoot = (schema) => {
-  if (!isSchemaObject(schema) || !hasType(schema))
-    return false;
-  if (schema.type !== "string" && schema.type !== "number" && schema.type !== "integer")
-    return false;
-  const record = schema;
-  return SCALAR_ROOT_CONSTRAINTS.some((keyword) => keyword in record);
-};
-const scalarDefaultLiteral = (schema) => {
-  const value = getDefaultValue(schema);
-  return value === "undefined" ? "{}" : value;
-};
-const generateRefUnionDispatch = (functionName, typeName, schema, branches, strict, ctx) => {
-  const rootSchema = ctx.rootSchema;
-  if (!ctx.useRefImports || rootSchema === void 0)
-    return null;
-  if (branches.length === 0 || !branches.every((b) => isSchemaObject(b) && hasRef(b)))
-    return null;
-  const resolved = branches.map((b) => {
-    const ref = b.$ref;
-    return { parser: generateParserName(refToName(ref, ctx.suffix)), schema: resolveRef(ref, rootSchema) };
-  });
-  if (resolved.some((r) => !isSchemaObject(r.schema)))
-    return null;
-  const discriminator = findDiscriminator(resolved.map((r) => r.schema));
-  if (discriminator === null)
-    return null;
-  const cases = [];
-  for (const r of resolved) {
-    const value = getDiscriminatorValue(r.schema, discriminator);
-    if (value === null)
-      return null;
-    cases.push({ value, parser: r.parser });
-  }
-  const access = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(discriminator) ? `.${discriminator}` : `[${JSON.stringify(discriminator)}]`;
-  const discExpr = `input == null ? undefined : (input as Record<string, unknown>)${access}`;
-  const fallback = strict ? `(() => { throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)}); })()` : `${cases[0]?.parser}(input)`;
-  let expr = fallback;
-  for (let i = cases.length - 1; i >= 0; i--) {
-    const c = cases[i];
-    if (c)
-      expr = `_disc === ${JSON.stringify(c.value)} ? ${c.parser}(input) : ${expr}`;
-  }
-  const backstop = strict ? generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(ctx)) : [];
-  const prelude = backstop.length > 0 ? `${backstop.join("\n")}
-` : "";
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-${prelude}  const _disc = ${discExpr};
-  return ${expr};
-};`;
-};
-const SCORE_TAG_MATCH = 100;
-const SCORE_TAG_MISMATCH = -100;
-const SCORE_REQUIRED_PRESENT = 4;
-const SCORE_REQUIRED_MISSING = -4;
-const SCORE_DECLARED_PRESENT = 1;
-const SCORE_DECLARED_WELL_TYPED = 2;
-const resolveForScoring = (schema, rootSchema) => {
-  if (!isSchemaObject(schema) || !hasRef(schema) || rootSchema === void 0)
-    return schema;
-  const target = resolveRef(schema.$ref, rootSchema);
-  return target !== void 0 && isSchemaObject(target) ? target : schema;
-};
-const tagValueOf = (schema) => {
-  if (!isSchemaObject(schema))
-    return void 0;
-  if (hasConst(schema))
-    return schema.const;
-  if (hasEnum(schema) && schema.enum.length === 1)
-    return schema.enum[0];
-  return void 0;
-};
-const branchScoreExpression = (branch, ctx) => {
-  const resolved = resolveForScoring(branch, ctx.rootSchema);
-  if (!isSchemaObject(resolved) || !hasProperties(resolved))
-    return "0";
-  const properties = resolved.properties;
-  const required = new Set(hasRequired(resolved) ? resolved.required : []);
-  const terms = [];
-  for (const key of Object.keys(properties)) {
-    const propertySchema = resolveForScoring(properties[key], ctx.rootSchema);
-    const accessor = safeAccessor("input", key);
-    const present = hasOwnCheck("input", key);
-    const tag = tagValueOf(propertySchema);
-    if (tag !== void 0) {
-      terms.push(`(${accessor} === ${JSON.stringify(tag)} ? ${SCORE_TAG_MATCH} : ${present} ? ${SCORE_TAG_MISMATCH} : 0)`);
-      continue;
-    }
-    if (required.has(key)) {
-      terms.push(`(${present} ? ${SCORE_REQUIRED_PRESENT} : ${SCORE_REQUIRED_MISSING})`);
-    } else {
-      terms.push(`(${present} ? ${SCORE_DECLARED_PRESENT} : 0)`);
-    }
-    const typeCheck = generatePropertyTypeCheck(accessor, properties[key], ctx.useRefImports, ctx.suffix);
-    if (typeCheck !== null)
-      terms.push(`(${typeCheck} ? ${SCORE_DECLARED_WELL_TYPED} : 0)`);
-  }
-  return terms.length === 0 ? "0" : terms.join(" + ");
-};
-const generateScoredUnionParser = (functionName, typeName, branches, ctx, exported = true) => {
-  if (branches.length < 2)
-    return null;
-  const preamble = [];
-  const dispatch = [];
-  const reserved = new Set(ctx.reservedNames ?? []);
-  const needsUnnarrowedAlias = branches.some((branch) => isSchemaObject(branch) && !(hasRef(branch) && ctx.useRefImports) && !(isObjectSchema(branch) && hasProperties(branch)));
-  const valueRef = needsUnnarrowedAlias ? "_u" : "input";
-  for (const [index, branch] of branches.entries()) {
-    if (!isSchemaObject(branch))
-      return null;
-    if (hasRef(branch) && ctx.useRefImports) {
-      const refName = refToName(branch.$ref, ctx.suffix);
-      if (refName === typeName)
-        return null;
-      dispatch.push({
-        predicate: `${shapeValidatorName(refName)}(input)`,
-        result: `${generateParserName(refName)}(${valueRef}) as ${typeName}`
-      });
-      continue;
-    }
-    if (hasRef(branch))
-      return null;
-    if (hasOneOf(branch) || hasAnyOf(branch) || hasAllOf(branch) || "not" in branch)
-      return null;
-    if ("if" in branch || "then" in branch || "else" in branch || "patternProperties" in branch)
-      return null;
-    if (!isObjectSchema(branch) || !hasProperties(branch)) {
-      const predicate = generatePropertyTypeCheck("input", branch, ctx.useRefImports, ctx.suffix);
-      if (predicate === null)
-        return null;
-      const coerced = generateValidationExpression("", branch, scalarDefaultLiteral(branch), true, ctx.rootSchema, void 0, valueRef, false, ctx.caseInsensitive);
-      dispatch.push({ predicate, result: `(${coerced}) as ${typeName}` });
-      continue;
-    }
-    let subName = `${typeName}_B${index}`;
-    while (reserved.has(subName))
-      subName = `${subName}_`;
-    reserved.add(subName);
-    const shapeValidator = generateShapeValidator(branch, subName, ctx.useRefImports, ctx.suffix, false, ctx.stripUnknown ?? false, reserved, ctx.unknownKeys ?? DEFAULT_UNKNOWN_KEYS);
-    if (shapeValidator.includes("(_input: unknown): boolean => false"))
-      return null;
-    preamble.push(generateTypeDefinition(branch, subName, {
-      ...ctx.suffix ? { typeSuffix: ctx.suffix } : {},
-      ...ctx.rootSchema ? { rootSchema: ctx.rootSchema } : {}
-    }).replace(/^export /, ""));
-    preamble.push(shapeValidator);
-    preamble.push(generateObjectParser(
-      branch,
-      subName,
-      ctx.useRefImports,
-      ctx.suffix,
-      ctx.logWarnings,
-      // Always the coercing parser: this whole path exists to repair.
-      false,
-      false,
-      ctx.stripUnknown ?? false,
-      ctx.rootSchema,
-      reserved,
-      ctx.caseInsensitive ?? false,
-      shapeValidator,
-      ctx.unknownKeys ?? DEFAULT_UNKNOWN_KEYS
-    ));
-    dispatch.push({
-      predicate: `${shapeValidatorName(subName)}(input)`,
-      result: `${generateParserName(subName)}(${valueRef}) as ${typeName}`
-    });
-  }
-  const first = dispatch[0];
-  if (first === void 0)
-    return null;
-  const lines = [];
-  if (needsUnnarrowedAlias)
-    lines.push("  const _u: unknown = input;");
-  for (const { predicate, result } of dispatch) {
-    lines.push(`  if (${predicate}) return ${result};`);
-  }
-  lines.push(`  if (!isObject(input)) return ${first.result};`);
-  const scores = branches.map((branch, index) => `  const _s${index} = ${branchScoreExpression(branch, ctx)};`);
-  lines.push(...scores);
-  const last = dispatch[dispatch.length - 1];
-  let best = `${last?.result}`;
-  for (let index = dispatch.length - 2; index >= 0; index--) {
-    const atLeastAsGood = dispatch.slice(index + 1).map((_, offset) => `_s${index} >= _s${index + 1 + offset}`).join(" && ");
-    best = `${atLeastAsGood} ? ${dispatch[index]?.result} : ${best}`;
-  }
-  lines.push(`  return ${best};`);
-  const head = preamble.length > 0 ? `${preamble.join("\n\n")}
-
-` : "";
-  const exportPrefix = exported ? "export " : "";
-  return `${head}${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {
-${lines.join("\n")}
-};`;
-};
-const strictContext = (ctx) => ({
-  useRefImports: ctx?.useRefImports ?? false,
-  suffix: ctx?.suffix ?? "",
-  ...ctx?.rootSchema !== void 0 ? { rootSchema: ctx.rootSchema } : {},
-  ...ctx?.stripUnknown !== void 0 ? { stripUnknown: ctx.stripUnknown } : {},
-  ...ctx?.unknownKeys !== void 0 ? { unknownKeys: ctx.unknownKeys } : {}
-});
-const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
-  const functionName = generateParserName(typeName);
-  if (unionCtx && isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema))) {
-    const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
-    if (branches.length > 0 && branches.every((b) => isSchemaObject(b) && hasRef(b))) {
-      const dispatch = generateRefUnionDispatch(functionName, typeName, schema, branches, strict, unionCtx);
-      if (dispatch !== null)
-        return dispatch;
-    }
-  }
-  if (unionCtx?.useRefImports && isSchemaObject(schema) && hasRef(schema) && !hasProperties(schema)) {
-    const refName = refToName(schema.$ref, unionCtx.suffix);
-    if (refName !== typeName) {
-      const assertion = strict ? generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx)) : [];
-      if (assertion.length === 0) {
-        return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
-      }
-      return `export const ${functionName} = (input: unknown): ${typeName} => {
-${assertion.join("\n")}
-  return ${generateParserName(refName)}(input) as ${typeName};
-};`;
-    }
-  }
-  if (strict && unionCtx && isSchemaObject(schema)) {
-    const branches = getUnionBranches(schema);
-    if (branches && !unionCtx.stripUnknown && canEnforceUnion(branches, unionCtx.rootSchema)) {
-      const check = generateUnionCheck("input", branches, unionCtx.useRefImports, unionCtx.suffix, isExclusiveUnion(schema));
-      if (check !== null) {
-        const backstop = generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx));
-        const assertions = [
-          `  if (!(${check})) throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)});`,
-          ...backstop
-        ].join("\n");
-        return `export const ${functionName} = (input: unknown): ${typeName} => {
-${assertions}
-  return input as ${typeName};
-};`;
-      }
-    }
-  }
-  if (!strict && isSchemaObject(schema)) {
-    if (hasConst(schema)) {
-      const literal = JSON.stringify(schema.const);
-      const isPrimitive = schema.const === null || typeof schema.const !== "object";
-      return isPrimitive ? `export const ${functionName} = (input: unknown): ${typeName} => input === ${literal} ? input as ${typeName} : ${literal} as ${typeName};` : `export const ${functionName} = (input: unknown): ${typeName} => ${literal} as ${typeName};`;
-    }
-    if (hasEnum(schema) && schema.enum.length > 0) {
-      const values = JSON.stringify(schema.enum);
-      const fallback = JSON.stringify(schema.enum[0]);
-      const ci = unionCtx?.caseInsensitive ? generateEnumCaseInsensitiveCoercion("input", schema.enum, fallback) : null;
-      const coerced = ci ? `(${ci})` : fallback;
-      return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${coerced} as ${typeName};`;
-    }
-    if (hasOneOf(schema) || hasAnyOf(schema)) {
-      const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
-      const scored = unionCtx ? generateScoredUnionParser(functionName, typeName, branches, unionCtx) : null;
-      if (scored !== null)
-        return scored;
-      const hasRefBranch = branches.some((b) => isSchemaObject(b) && hasRef(b));
-      if (branches.length > 0 && !hasRefBranch) {
-        const fallback = scalarDefaultLiteral(branches[0]);
-        const expr = generateValidationExpression("", schema, fallback, true, void 0, void 0, "input", true);
-        return `export const ${functionName} = (input: unknown): ${typeName} => (${expr}) as ${typeName};`;
-      }
-      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-    }
-  }
-  if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema) || hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || "not" in schema || "if" in schema)) {
-    const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
-    if (assertion !== null) {
-      return `export const ${functionName} = (input: unknown): ${typeName} => {
-${assertion}
-  return input as ${typeName};
-};`;
-    }
-  }
-  if (isSchemaObject(schema) && hasType(schema) && schema.type === "array" && hasItems(schema) && !Array.isArray(schema.items)) {
-    const items = schema.items;
-    const notArrayThrow = `if (!Array.isArray(input)) throw new Error(\`[${typeName}] expected array, got \${input === null ? "null" : typeof input}\`);`;
-    const strictArrayChecks = strict ? [
-      // `minItems`/`maxItems` were dropped on this path entirely: a root
-      // array of objects or `$ref`s bypasses generateScalarStrictAssertion,
-      // so `{ type: 'array', minItems: 2, items: { type: 'object' } }`
-      // accepted a one-element array.
-      ...hasMinItems(schema) ? [
-        `  if (input.length < ${schema.minItems}) throw new Error(${quoteJsString(`[${typeName}] must have at least ${schema.minItems} items`)});`
-      ] : [],
-      ...hasMaxItems(schema) ? [
-        `  if (input.length > ${schema.maxItems}) throw new Error(${quoteJsString(`[${typeName}] must have at most ${schema.maxItems} items`)});`
-      ] : [],
-      ...generateContainsCheck("input", schema, `[${typeName}]`),
-      ...hasUniqueItems(schema) && schema.uniqueItems === true ? [
-        `  if (!(${generateUniqueItemsCheck("input", schema)})) throw new Error(${quoteJsString(`[${typeName}] must NOT have duplicate items`)});`
-      ] : [],
-      // This path delegates elements to another parser and so never reaches
-      // generateScalarStrictAssertion — `unevaluatedItems` and friends would
-      // be lost with it.
-      ...generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx))
-    ].join("\n") : "";
-    const delegatedBody = (itemParserName) => `  const _parsed = validateArray(input, ${itemParserName});
-  return (_parsed === input ? [..._parsed] : _parsed) as ${typeName};`;
-    const delegated = (itemParserName) => strict ? `export const ${functionName} = (input: unknown): ${typeName} => {
-  ${notArrayThrow}${strictArrayChecks ? `
-${strictArrayChecks}` : ""}
-${delegatedBody(itemParserName)}
-};` : `export const ${functionName} = (input: unknown): ${typeName} => {
-${delegatedBody(itemParserName)}
-};`;
-    if (unionCtx?.useRefImports && isSchemaObject(items) && hasRef(items)) {
-      return delegated(generateParserName(refToName(items.$ref, unionCtx.suffix)));
-    }
-    if (isInlineObjectProperty(items)) {
-      const reserved = unionCtx?.reservedNames ?? NO_RESERVED_NAMES;
-      let itemName = `${typeName}_Item`;
-      while (reserved.has(itemName))
-        itemName = `${itemName}_`;
-      const useRefImports = unionCtx?.useRefImports ?? false;
-      const suffix = unionCtx?.suffix ?? "";
-      const stripUnknown = unionCtx?.stripUnknown ?? false;
-      const unknownKeys = unionCtx?.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
-      const itemShapeValidator = generateShapeValidator(items, itemName, useRefImports, suffix, false, stripUnknown, reserved, unknownKeys);
-      const preamble = [
-        `type ${itemName} = NonNullable<${typeName}>[number];`,
-        itemShapeValidator,
-        generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false, itemShapeValidator, unknownKeys)
-      ].join("\n\n");
-      return `${preamble}
-
-${delegated(generateParserName(itemName))}`;
-    }
-  }
-  const isMultiType = isSchemaObject(schema) && Array.isArray(schema.type);
-  if (!isSchemaObject(schema) || !hasType(schema) && !isMultiType) {
-    if (strict) {
-      const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
-      if (assertion !== null) {
-        return `export const ${functionName} = (input: unknown): ${typeName} => {
-${assertion}
-  return input as ${typeName};
-};`;
-      }
-    }
-    return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-  }
-  if (!strict && schema.type === "null") {
-    return `export const ${functionName} = (input: unknown): ${typeName} => null as ${typeName};`;
-  }
-  if (strict) {
-    const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
-    if (assertion === null) {
-      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-    }
-    const arrayCast = getPrefixItems(schema) ? `[...(input as readonly unknown[])] as unknown as ${typeName}` : `[...(input as readonly unknown[])] as ${typeName}`;
-    const returnExpr = !isMultiType && schema.type === "array" ? arrayCast : `input as ${typeName}`;
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
-${assertion}
-  return ${returnExpr};
-};`;
-  }
-  if (isConstrainedScalarRoot(schema)) {
-    const expr = generateValidationExpression("", schema, getDefaultValue(schema), true, unionCtx?.rootSchema, void 0, "input", true, unionCtx?.caseInsensitive);
-    return `export const ${functionName} = (input: unknown): ${typeName} => (${expr}) as ${typeName};`;
-  }
-  switch (schema.type) {
-    case "string":
-      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
-    case "number":
-      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" ? input as ${typeName} : 0 as ${typeName};`;
-    case "integer":
-      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" && Number.isInteger(input) ? input as ${typeName} : 0 as ${typeName};`;
-    case "boolean":
-      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "boolean" ? input as ${typeName} : false as ${typeName};`;
-    case "array": {
-      const prefixItems = getPrefixItems(schema);
-      if (prefixItems) {
-        const mapped = generatePrefixItemsMap("input", prefixItems, prefixItemsCapsLength(schema), unionCtx?.rootSchema, void 0, unionCtx?.caseInsensitive);
-        return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? ${mapped} as unknown as ${typeName} : [] as unknown as ${typeName};`;
-      }
-      if (hasItems(schema) && !Array.isArray(schema.items) && isCoercibleItemSchema(schema.items)) {
-        const item = schema.items;
-        const itemExpr = generateValidationExpression("", item, getDefaultValue(item), true, void 0, void 0, "_it", true, unionCtx?.caseInsensitive);
-        return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? (input as unknown[]).map((_it) => ${itemExpr}) as ${typeName} : [] as ${typeName};`;
-      }
-      return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? [...input] as ${typeName} : [] as ${typeName};`;
-    }
-    default:
-      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-  }
-};
-const strictObjectKeywordPrelude = (schema, typeName, context = {}) => {
-  if (!isSchemaObject(schema))
-    return "";
-  const lines = [
-    ...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false, context),
-    // `required` and the size bounds are the object-level constraints these
-    // specialized parsers never had a place for: `{ type: 'object', required:
-    // ['a'] }` and `{ type: 'object', minProperties: 2 }` carry no `properties`,
-    // so they land on the empty-object / record paths, which asserted only
-    // `isObject`. Keys that *are* declared are skipped — the per-property
-    // assertions of the combined parser already demand them.
-    ...requiredWithoutPropertyLines(schema, typeName),
-    ...generateObjectSizeChecks("input", schema, `[${typeName}]`, false),
-    // Values behind `patternProperties` / a schema-valued `additionalProperties`:
-    // these parsers build their result by copying or coercing, so nothing
-    // rejected a wrongly-typed pattern-matched value before this.
-    ...generateKeyedValueChecks("input", schema, `[${typeName}]`, context),
-    // Composition on a property-less object: these parsers delegate nothing, so
-    // `{ type: 'object', allOf: [{ $ref: … }] }` had no check at all.
-    ...generateCompositionChecks("input", schema, `[${typeName}]`, context),
-    // Whatever no specialized check above reaches (`unevaluated*`, a `$ref` with
-    // constraining siblings): these parsers never run generateObjectStrictAssertion,
-    // so the backstop has to be spliced in here too.
-    ...generateBackstopAssertion("input", schema, `[${typeName}]`, context)
-  ];
-  return lines.length > 0 ? `
-${lines.join("\n")}` : "";
-};
-const requiredWithoutPropertyLines = (schema, typeName) => {
-  if (!isSchemaObject(schema) || !hasRequired(schema))
-    return [];
-  const declared = hasProperties(schema) ? schema.properties : {};
-  const lines = [];
-  for (const key of new Set(schema.required)) {
-    if (key in declared)
-      continue;
-    lines.push(`  if (${missingCheck("input", key)}) throw new Error(${quoteJsString(`[${typeName}] missing required property '${key}'`)});`);
-  }
-  return lines;
-};
-const generateEmptyObjectParser = (typeName, strict, schema, context = {}) => {
-  const functionName = generateParserName(typeName);
-  if (strict) {
-    const prelude = schema !== void 0 ? strictObjectKeywordPrelude(schema, typeName, context) : "";
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${prelude}
-  return { ...input } as ${typeName};
-};`;
-  }
-  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
-};
-const toVarName = (key) => {
-  const safe = key.replace(/[^a-zA-Z0-9_$]/g, "_");
-  return `_${safe}`;
-};
-const pascalCaseKey = (key) => key.replace(/[^a-zA-Z0-9_$]/g, "_").split("_").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-const NO_RESERVED_NAMES = /* @__PURE__ */ new Set();
-const EMPTY_SUB_TYPES = { objects: /* @__PURE__ */ new Map(), arrayItems: /* @__PURE__ */ new Map() };
-const collectInlineSubTypes = (schema, typeName, reservedNames = NO_RESERVED_NAMES) => {
-  if (!hasProperties(schema))
-    return EMPTY_SUB_TYPES;
-  const props = schema.properties;
-  let objects = null;
-  let arrayItems = null;
-  let used = null;
-  const claim = (base) => {
-    used ??= /* @__PURE__ */ new Set();
-    let subName = base;
-    while (used.has(subName) || reservedNames.has(subName))
-      subName = `${subName}_`;
-    used.add(subName);
-    return subName;
-  };
-  for (const key in props) {
-    const propSchema = props[key];
-    if (isInlineObjectProperty(propSchema)) {
-      objects ??= /* @__PURE__ */ new Map();
-      objects.set(key, claim(`${typeName}_${pascalCaseKey(key) || "Value"}`));
-    } else if (isInlineObjectArrayProperty(propSchema) || isUnionArrayProperty(propSchema)) {
-      arrayItems ??= /* @__PURE__ */ new Map();
-      arrayItems.set(key, claim(`${typeName}_${pascalCaseKey(key) || "Value"}Item`));
-    }
-  }
-  if (objects === null && arrayItems === null)
-    return EMPTY_SUB_TYPES;
-  return { objects: objects ?? EMPTY_SUB_TYPES.objects, arrayItems: arrayItems ?? EMPTY_SUB_TYPES.arrayItems };
-};
-const hasStrictKeys = (schema) => {
-  if (!isSchemaObject(schema) || !hasProperties(schema))
-    return false;
-  if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
-    return false;
-  if ("patternProperties" in schema)
-    return false;
-  if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema))
-    return false;
-  return true;
-};
-const exactKeyCountOf = (schema) => {
-  if (!isSchemaObject(schema) || !hasProperties(schema) || !hasRequired(schema))
-    return null;
-  const props = schema.properties;
-  const required = schema.required;
-  const requiredLookup = required.length > 16 ? new Set(required) : null;
-  let declaredCount = 0;
-  for (const key in props) {
-    declaredCount++;
-    const isRequired = requiredLookup !== null ? requiredLookup.has(key) : required.includes(key);
-    if (!isRequired || !isSchemaObject(props[key]))
-      return null;
-  }
-  if (declaredCount === 0 || required.length !== declaredCount)
-    return null;
-  return declaredCount;
-};
-const KEY_COUNT_VAR = "_keyCount";
-const keyCountCheck = (unknownKeys, count, indent, obj = "input") => unknownKeys === "count-keys" ? {
-  statements: [],
-  verdict: `Object.getPrototypeOf(${obj}) === Object.prototype && Object.keys(${obj}).length === ${count}`
-} : {
-  statements: [`${indent}let ${KEY_COUNT_VAR} = 0;`, `${indent}for (const _k in ${obj}) ${KEY_COUNT_VAR}++;`],
-  verdict: `${KEY_COUNT_VAR} === ${count}`
-};
-const shouldCacheVariable = (propSchema) => {
-  return isSchemaObject(propSchema);
-};
-const INLINE_NESTED_MAX_PROPERTIES = 12;
-const INLINE_NESTED_MAX_SITES = 4;
-const INLINE_NESTED_MAX_TOTAL_PROPERTIES = 24;
-const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImports, suffix, stripUnknown, reservedNames, claimVarName) => {
-  if (!isSchemaObject(childSchema) || !hasProperties(childSchema))
-    return null;
-  if (!stripUnknown)
-    return null;
-  if (hasAdditionalProperties(childSchema) && childSchema.additionalProperties === false)
-    return null;
-  if (hasAllOf(childSchema) || hasOneOf(childSchema) || hasAnyOf(childSchema))
-    return null;
-  if (hasFastPathBlockingKeyword(childSchema))
-    return null;
-  if (hasMinProperties(childSchema) || hasMaxProperties(childSchema))
-    return null;
-  if (exactKeyCountOf(childSchema) === null)
-    return null;
-  const { objects, arrayItems } = collectInlineSubTypes(childSchema, childTypeName, reservedNames);
-  if (objects.size > 0 || arrayItems.size > 0)
-    return null;
-  const props = childSchema.properties;
-  const keys = Object.keys(props);
-  if (keys.length === 0 || keys.length > INLINE_NESTED_MAX_PROPERTIES)
-    return null;
-  const declarations = [];
-  const checks = [];
-  const fields = [];
-  const readRoot = `(${objectExpr} as Record<string, any>)`;
-  for (const key of keys) {
-    const propSchema = props[key];
-    if (shouldUseRefImport(propSchema, useRefImports) || shouldUseArrayRefImport(propSchema, useRefImports) || shouldUseRecordRefImport(propSchema, useRefImports)) {
-      return null;
-    }
-    const accessor = claimVarName(`${objectExpr}_${toVarName(key).slice(1)}`);
-    declarations.push(`  const ${accessor} = ${safeAccessor(readRoot, key)};`);
-    const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
-    if (check === null)
-      return null;
-    checks.push(check);
-    fields.push(`${safeLiteralKey(key)}: ${accessor}`);
-  }
-  const condition = checks.join(" && ");
-  return { declarations, condition, literal: `{ ${fields.join(", ")} }`, propertyCount: keys.length };
-};
-const RESULT_VARIABLE = "out";
-const PROTOTYPE_MEMBERS = new Set(Object.getOwnPropertyNames(Object.prototype));
-const resultMember = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? `${RESULT_VARIABLE}.${key}` : `${RESULT_VARIABLE}[${JSON.stringify(key)}]`;
-const renderLiteralEntry = (entry, indent) => {
-  if (entry.kind === "field")
-    return `${indent}${safeLiteralKey(entry.key)}: ${entry.value},`;
-  if (entry.kind === "spread")
-    return `${indent}...${entry.expression},`;
-  return `${indent}...(${entry.read} !== undefined && { ${safeLiteralKey(entry.key)}: ${entry.value} }),`;
-};
-const renderResultObject = (entries, typeName, guard) => {
-  const firstOptional = entries.findIndex((entry) => entry.kind === "optional");
-  const assignable = entries.every((entry, index) => index < firstOptional || entry.kind === "spread" || !PROTOTYPE_MEMBERS.has(entry.key));
-  if (firstOptional === -1 || !assignable) {
-    const open = guard === void 0 ? "  return {" : `  if (${guard}) return {`;
-    return [
-      open,
-      entries.map((entry) => renderLiteralEntry(entry, "    ")).join("\n"),
-      `  } as unknown as ${typeName};`
-    ];
-  }
-  const indent = guard === void 0 ? "  " : "    ";
-  const lines = [];
-  if (guard !== void 0)
-    lines.push(`  if (${guard}) {`);
-  const literal = entries.slice(0, firstOptional);
-  if (literal.length === 0) {
-    lines.push(`${indent}const ${RESULT_VARIABLE}: Record<string, unknown> = {};`);
-  } else {
-    lines.push(`${indent}const ${RESULT_VARIABLE}: Record<string, unknown> = {`);
-    lines.push(literal.map((entry) => renderLiteralEntry(entry, `${indent}  `)).join("\n"));
-    lines.push(`${indent}};`);
-  }
-  for (const entry of entries.slice(firstOptional)) {
-    if (entry.kind === "field")
-      lines.push(`${indent}${resultMember(entry.key)} = ${entry.value};`);
-    else if (entry.kind === "optional") {
-      lines.push(`${indent}if (${entry.read} !== undefined) ${resultMember(entry.key)} = ${entry.value};`);
-    } else
-      lines.push(`${indent}Object.assign(${RESULT_VARIABLE}, ${entry.expression});`);
-  }
-  lines.push(`${indent}return ${RESULT_VARIABLE} as unknown as ${typeName};`);
-  if (guard !== void 0)
-    lines.push("  }");
-  return lines;
-};
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
-  const functionName = generateParserName(typeName);
-  const exportPrefix = exported ? "export " : "";
-  if (!hasProperties(schema)) {
-    if (strict) {
-      return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${strictObjectKeywordPrelude(schema, typeName, { useRefImports, suffix, stripUnknown, ...rootSchema !== void 0 ? { rootSchema } : {} })}
-  return input as ${typeName};
-};`;
-    }
-    return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
-  }
-  const schemaProps = schema.properties;
-  const propertyKeys = Object.keys(schemaProps);
-  const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
-  const preamble = [];
-  for (const [key, subName] of subTypeNames) {
-    const propSchema = schemaProps[key];
-    preamble.push(`type ${subName} = NonNullable<${typeName}>[${JSON.stringify(key)}];`);
-    const subShapeValidator = generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames, unknownKeys);
-    preamble.push(subShapeValidator);
-    preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, subShapeValidator, unknownKeys));
-  }
-  for (const [key, subName] of subItemNames) {
-    const propSchema = schemaProps[key];
-    const itemSchema = propSchema.items;
-    preamble.push(`type ${subName} = NonNullable<NonNullable<${typeName}>[${JSON.stringify(key)}]>[number];`);
-    const itemShapeValidator = generateShapeValidator(itemSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames, unknownKeys);
-    preamble.push(itemShapeValidator);
-    preamble.push(`const _every${subName} = (arr: readonly unknown[]): boolean => {
-  for (let i = 0; i < arr.length; i++) if (!${shapeValidatorName(subName)}(arr[i])) return false;
-  return true;
-};`);
-    const unionBranches = strict ? null : getUnionBranches(itemSchema);
-    const scoredItemParser = unionBranches === null ? null : generateScoredUnionParser(generateParserName(subName), subName, unionBranches, {
-      useRefImports,
-      suffix,
-      ...rootSchema !== void 0 ? { rootSchema } : {},
-      ...logWarnings !== void 0 ? { logWarnings } : {},
-      reservedNames,
-      stripUnknown,
-      unknownKeys,
-      caseInsensitive
-    }, false);
-    preamble.push(scoredItemParser ?? generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, itemShapeValidator, unknownKeys));
-  }
-  const unionSubNames = /* @__PURE__ */ new Map();
-  if (!strict) {
-    const claimedUnionNames = /* @__PURE__ */ new Set([...reservedNames, ...subTypeNames.values(), ...subItemNames.values()]);
-    for (const key of Object.keys(schemaProps)) {
-      if (subTypeNames.has(key) || subItemNames.has(key))
-        continue;
-      const propSchema = schemaProps[key];
-      if (!isInlineUnionProperty(propSchema))
-        continue;
-      const branches = getUnionBranches(propSchema);
-      if (branches === null)
-        continue;
-      let unionSubName = `${typeName}_${pascalCaseKey(key) || "Value"}Union`;
-      while (claimedUnionNames.has(unionSubName))
-        unionSubName = `${unionSubName}_`;
-      claimedUnionNames.add(unionSubName);
-      const unionParser = generateScoredUnionParser(generateParserName(unionSubName), unionSubName, branches, {
-        useRefImports,
-        suffix,
-        ...rootSchema !== void 0 ? { rootSchema } : {},
-        ...logWarnings !== void 0 ? { logWarnings } : {},
-        reservedNames: claimedUnionNames,
-        stripUnknown,
-        unknownKeys,
-        caseInsensitive
-      }, false);
-      if (unionParser === null)
-        continue;
-      preamble.push(`type ${unionSubName} = NonNullable<${typeName}>[${JSON.stringify(key)}];`);
-      preamble.push(unionParser);
-      unionSubNames.set(key, unionSubName);
-    }
-  }
-  const strictKeys = hasStrictKeys(schema);
-  const stripKeys = strictKeys || stripUnknown;
-  const rejectsUnknownKeys = strict && isSchemaObject(schema) && hasAdditionalProperties(schema) && schema.additionalProperties === false && !("patternProperties" in schema) || false;
-  const guardKeys = stripKeys || rejectsUnknownKeys;
-  const fastPathBuildsDeclaredLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
-  const fastPathNeedsKnownKeys = guardKeys && (rejectsUnknownKeys || !fastPathBuildsDeclaredLiteral);
-  const droppedKnownKeysTerm = guardKeys && !fastPathNeedsKnownKeys;
-  const exactKeyCount = guardKeys ? exactKeyCountOf(schema) : null;
-  const strictKeyCheck = unknownKeyCheck(propertyKeys, `_knownKeys${typeName}`);
-  const shapeValidatorNeedsKnownKeys = shapeValidatorSource?.includes(`_hasOnlyKnownKeys${typeName}(`) ?? false;
-  if ((fastPathNeedsKnownKeys || shapeValidatorNeedsKnownKeys) && exactKeyCount === null) {
-    for (const declaration of strictKeyCheck.declarations) {
-      preamble.push(`${declaration};`);
-    }
-    preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {
-  for (const _k in input) if (${strictKeyCheck.isUnknown("_k")}) return false;
-  return true;
-};`);
-  } else if (rejectsUnknownKeys) {
-    for (const declaration of strictKeyCheck.declarations) {
-      preamble.push(`${declaration};`);
-    }
-  }
-  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
-  const propInfo = [];
-  const hasAllOfRefParsers = useRefImports && isSchemaObject(schema) && hasAllOf(schema) && schema.allOf.some((entry) => isSchemaObject(entry) && hasRef(entry));
-  let canFastPath = !hasAllOfRefParsers && !hasFastPathBlockingKeyword(schema) && !(strict && inlineAllOfMembers(schema).length > 0);
-  const fastPathChecks = [];
-  const fastPathAccessorChecks = [];
-  const usedVarNames = /* @__PURE__ */ new Set([KEY_COUNT_VAR]);
-  let inlinedGuardSites = 0;
-  let inlinedGuardProperties = 0;
-  for (const key of propertyKeys) {
-    const propSchema = schemaProps[key];
-    const isRequired = isPropertyRequired(key, schema);
-    let varName = toVarName(key);
-    while (usedVarNames.has(varName))
-      varName = `${varName}_`;
-    usedVarNames.add(varName);
-    propInfo.push({ key, varName, isRequired, propSchema });
-    if (!canFastPath)
-      continue;
-    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-      canFastPath = false;
-      continue;
-    }
-    const subName = subTypeNames.get(key);
-    const inlined = subName !== void 0 && inlinedGuardSites < INLINE_NESTED_MAX_SITES ? inlineNestedShapeCheck(propSchema, subName, varName, useRefImports, suffix, stripUnknown, reservedNames, unknownKeys) : null;
-    const withinBudget = inlined !== null && inlinedGuardProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES;
-    if (withinBudget) {
-      inlinedGuardSites++;
-      inlinedGuardProperties += inlined.propertyCount;
-    }
-    let check = withinBudget ? inlined.check : subName ? `${shapeValidatorName(subName)}(${varName})` : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
-    const itemSubName = subItemNames.get(key);
-    if (check !== null && itemSubName) {
-      check = `${check} && _every${itemSubName}(${varName})`;
-    }
-    if (check === null) {
-      canFastPath = false;
-      continue;
-    }
-    const accessor = safeAccessor("input", key);
-    let accessorCheck = subName ? `${shapeValidatorName(subName)}(${accessor})` : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
-    if (itemSubName) {
-      accessorCheck = `${accessorCheck} && _every${itemSubName}(${accessor})`;
-    }
-    if (isRequired) {
-      fastPathChecks.push(check);
-      fastPathAccessorChecks.push(accessorCheck);
-    } else {
-      fastPathChecks.push(`(${varName} === undefined || ${check})`);
-      fastPathAccessorChecks.push(`(${accessor} === undefined || ${accessorCheck})`);
-    }
-  }
-  if (canFastPath) {
-    if (hasMinProperties(schema)) {
-      fastPathChecks.push(`Object.keys(input).length >= ${schema.minProperties}`);
-      fastPathAccessorChecks.push(`Object.keys(input).length >= ${schema.minProperties}`);
-    }
-    if (hasMaxProperties(schema)) {
-      fastPathChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
-      fastPathAccessorChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
-    }
-  }
-  const fastPathKeyCount = fastPathNeedsKnownKeys ? exactKeyCount : null;
-  if (fastPathNeedsKnownKeys && exactKeyCount === null) {
-    fastPathChecks.push(`_hasOnlyKnownKeys${typeName}(input)`);
-  }
-  const deepGuard = canFastPath && (fastPathChecks.length > 0 || fastPathKeyCount !== null) ? fastPathChecks.join(" && ") : null;
-  const literalReturnUsesVars = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema)) && exported;
-  let deepGuardExpr = deepGuard;
-  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars && !droppedKnownKeysTerm) {
-    const shapeFnName = shapeValidatorName(typeName);
-    const shapeStrictKeysGuard = stripKeys && exactKeyCount === null ? `
-  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
-    const expectedShapeValidator = renderShapeValidator(exportPrefix, shapeFnName, fastPathAccessorChecks, stripKeys ? exactKeyCount : null, shapeStrictKeysGuard, unknownKeys);
-    if (shapeValidatorSource === expectedShapeValidator) {
-      deepGuardExpr = `${shapeFnName}(input)`;
-    }
-  }
-  const deepGuardCallsShape = deepGuardExpr !== deepGuard;
-  const inlineKeyCount = deepGuardCallsShape ? null : fastPathKeyCount;
-  let canShallowGuard = strict && stripUnknown && !strictKeys && !hasFastPathBlockingKeyword(schema);
-  const shallowChecks = [];
-  if (canShallowGuard) {
-    for (const { key, varName, isRequired, propSchema } of propInfo) {
-      const subName = subTypeNames.get(key);
-      let check;
-      if (subName) {
-        check = `isObject(${varName})`;
-      } else if (isSchemaObject(propSchema) && !hasEnum(propSchema) && !hasRef(propSchema) && !hasOneOf(propSchema) && !hasAnyOf(propSchema) && !hasAllOf(propSchema) && !("not" in propSchema) && !shouldUseRefImport(propSchema, useRefImports) && !shouldUseArrayRefImport(propSchema, useRefImports) && !shouldUseRecordRefImport(propSchema, useRefImports)) {
-        check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
-      } else {
-        check = null;
-      }
-      if (check === null) {
-        canShallowGuard = false;
-        break;
-      }
-      shallowChecks.push(isRequired ? check : `(${varName} === undefined || ${check})`);
-    }
-  }
-  const shallowGuard = canShallowGuard && shallowChecks.length > 0 ? shallowChecks.join(" && ") : null;
-  const varDeclLines = [];
-  for (const { key, varName, propSchema } of propInfo) {
-    if (shouldCacheVariable(propSchema)) {
-      varDeclLines.push(`  const ${varName} = ${safeAccessor("input", key)};`);
-    }
-  }
-  const warnLines = [];
-  if (logWarnings && propInfo.length > 0) {
-    const warnKeyCheck = unknownKeyCheck(propInfo.map(({ key }) => key), "_knownKeys");
-    for (const declaration of warnKeyCheck.declarations) {
-      warnLines.push(`  ${declaration};`);
-    }
-    warnLines.push(`  for (const _k in input) {`);
-    warnLines.push(`    if (${warnKeyCheck.isUnknown("_k")}) {`);
-    warnLines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
-    warnLines.push(`    }`);
-    warnLines.push(`  }`);
-  }
-  const claimNestedVarName = (base) => {
-    let name = base;
-    while (usedVarNames.has(name))
-      name = `${name}_`;
-    usedVarNames.add(name);
-    return name;
-  };
-  const buildObjectLines = (directAssign, hoistLines) => {
-    const entries = [];
-    let inlinedSites = 0;
-    let inlinedProperties = 0;
-    if (!stripKeys) {
-      entries.push({ kind: "spread", expression: "input" });
-    }
-    if (useRefImports && isSchemaObject(schema) && hasAllOf(schema)) {
-      for (const entry of schema.allOf) {
-        if (isSchemaObject(entry) && hasRef(entry)) {
-          const parserName = generateParserName(refToName(entry.$ref, suffix));
-          entries.push({ kind: "spread", expression: `(${parserName}(input) as Record<string, unknown>)` });
-        }
-      }
-    }
-    for (const { key, varName, isRequired, propSchema } of propInfo) {
-      const shouldCache = shouldCacheVariable(propSchema);
-      const accessor = shouldCache ? varName : safeAccessor("input", key);
-      const unionSubName = unionSubNames.get(key);
-      if (unionSubName) {
-        const unionParserName = generateParserName(unionSubName);
-        if (isRequired) {
-          entries.push({ kind: "field", key, value: `${unionParserName}(${accessor})` });
-        } else {
-          entries.push({ kind: "optional", key, read: accessor, value: `${unionParserName}(${accessor})` });
-        }
-        continue;
-      }
-      const subName = subTypeNames.get(key);
-      if (subName) {
-        const subParserName = generateParserName(subName);
-        if (isRequired) {
-          const inlined = hoistLines !== void 0 && directAssign && !logWarnings && inlinedSites < INLINE_NESTED_MAX_SITES ? inlineNestedFastPath(propSchema, subName, accessor, useRefImports, suffix, stripUnknown, reservedNames, claimNestedVarName) : null;
-          if (inlined !== null && inlinedProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES) {
-            inlinedSites++;
-            inlinedProperties += inlined.propertyCount;
-            hoistLines?.push(...inlined.declarations);
-            entries.push({
-              kind: "field",
-              key,
-              value: `(${inlined.condition})
-      ? ${inlined.literal}
-      : ${subParserName}(${accessor})`
-            });
-            continue;
-          }
-          entries.push({ kind: "field", key, value: `${subParserName}(${accessor})` });
-        } else {
-          entries.push({ kind: "optional", key, read: accessor, value: `${subParserName}(${accessor})` });
-        }
-        continue;
-      }
-      const itemSubName = subItemNames.get(key);
-      if (itemSubName) {
-        const itemParserName = generateParserName(itemSubName);
-        if (isRequired) {
-          entries.push({ kind: "field", key, value: `validateArray(${accessor}, ${itemParserName})` });
-        } else {
-          entries.push({
-            kind: "optional",
-            key,
-            read: accessor,
-            value: `validateArray(${accessor}, ${itemParserName})`
-          });
-        }
-        continue;
-      }
-      if (shouldUseRefImport(propSchema, useRefImports)) {
-        const ref = propSchema.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        if (isRequired) {
-          entries.push({ kind: "field", key, value: `${parserName}(${accessor})` });
-        } else {
-          entries.push({ kind: "optional", key, read: accessor, value: `${parserName}(${accessor})` });
-        }
-        continue;
-      }
-      if (shouldUseArrayRefImport(propSchema, useRefImports)) {
-        const items = propSchema.items;
-        const ref = items.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        if (isRequired) {
-          entries.push({ kind: "field", key, value: `validateArray(${accessor}, ${parserName})` });
-        } else {
-          entries.push({ kind: "optional", key, read: accessor, value: `validateArray(${accessor}, ${parserName})` });
-        }
-        continue;
-      }
-      if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-        const additionalProps = propSchema.additionalProperties;
-        const ref = additionalProps.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        if (isRequired) {
-          entries.push({ kind: "field", key, value: `validateRecord(${accessor}, ${parserName})` });
-        } else {
-          entries.push({ kind: "optional", key, read: accessor, value: `validateRecord(${accessor}, ${parserName})` });
-        }
-        continue;
-      }
-      if (!isSchemaObject(propSchema)) {
-        if (propSchema === true) {
-          if (isRequired) {
-            entries.push({ kind: "field", key, value: accessor });
-          } else if (stripKeys) {
-            entries.push({ kind: "optional", key, read: accessor, value: accessor });
-          }
-        } else if (isRequired) {
-          entries.push({ kind: "field", key, value: "undefined" });
-        }
-        continue;
-      }
-      let valueExpr;
-      if (directAssign) {
-        valueExpr = accessor;
-      } else {
-        const defaultValue = getDefaultValue(propSchema);
-        const knownNotUndefined = !isRequired;
-        valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, void 0, void 0, shouldCache ? varName : void 0, knownNotUndefined, caseInsensitive);
-      }
-      if (isRequired) {
-        entries.push({ kind: "field", key, value: valueExpr });
-      } else {
-        entries.push({ kind: "optional", key, read: accessor, value: valueExpr });
-      }
-    }
-    return entries;
-  };
-  const emitReturn = (lines2, entries) => {
-    lines2.push(...renderResultObject(entries, typeName));
-  };
-  const withKeyCount = (lines2, guarded) => {
-    if (inlineKeyCount === null) {
-      lines2.push(...guarded(deepGuardExpr));
-      return;
-    }
-    const count = keyCountCheck(unknownKeys, inlineKeyCount, "    ");
-    if (count.statements.length === 0) {
-      lines2.push(...guarded(deepGuardExpr === "" ? count.verdict : `${deepGuardExpr} && ${count.verdict}`));
-      return;
-    }
-    const counted = guarded(count.verdict);
-    if (deepGuardExpr === "") {
-      lines2.push(...keyCountCheck(unknownKeys, inlineKeyCount, "  ").statements, ...counted);
-      return;
-    }
-    const nested = counted.map((line) => line.split("\n").map((part) => `  ${part}`).join("\n"));
-    lines2.push(`  if (${deepGuardExpr}) {`, ...count.statements, ...nested, `  }`);
-  };
-  const emitGuardedReturn = (lines2, statement) => {
-    withKeyCount(lines2, (guard) => [`  if (${guard}) ${statement}`]);
-  };
-  const emitGuardedResult = (lines2, fields) => {
-    withKeyCount(lines2, (guard) => renderResultObject(fields, typeName, guard));
-  };
-  const emitDeepGuardReturn = (lines2) => {
-    if (!fastPathBuildsDeclaredLiteral) {
-      emitGuardedReturn(lines2, `return { ...input } as ${typeName};`);
-      return;
-    }
-    if (!exported && fastPathNeedsKnownKeys) {
-      emitGuardedReturn(lines2, `return input as ${typeName};`);
-      return;
-    }
-    const fields = [];
-    for (const { key, varName, isRequired, propSchema } of propInfo) {
-      if (!isSchemaObject(propSchema)) {
-        if (propSchema === true) {
-          const acc = safeAccessor("input", key);
-          fields.push(isRequired ? { kind: "field", key, value: acc } : { kind: "optional", key, read: acc, value: acc });
-        } else if (isRequired) {
-          fields.push({ kind: "field", key, value: "undefined" });
-        }
-        continue;
-      }
-      const accessor = shouldCacheVariable(propSchema) ? varName : safeAccessor("input", key);
-      fields.push(isRequired ? { kind: "field", key, value: accessor } : { kind: "optional", key, read: accessor, value: accessor });
-    }
-    emitGuardedResult(lines2, fields);
-  };
-  const assertionLines = strict ? generateObjectStrictAssertion(schema, typeName, {
-    useRefImports,
-    suffix,
-    stripUnknown,
-    ...rootSchema !== void 0 ? { rootSchema } : {}
-  }) : [];
-  const unknownKeyThrowLines = () => rejectsUnknownKeys ? [
-    `  for (const _k in input) {`,
-    `    if (${strictKeyCheck.isUnknown("_k")}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`,
-    `  }`
-  ] : [];
-  const varsAfterGuard = deepGuardCallsShape && shallowGuard === null;
-  const assertBodyLines = [...assertionLines.slice(1), ...shallowGuard === null ? unknownKeyThrowLines() : []];
-  const canSplit = !logWarnings && strict === true && (deepGuard !== null || shallowGuard !== null) && assertBodyLines.length > 0;
-  const assertName = `_assert${typeName}`;
-  const assertObjectName = `_assert${typeName}Object`;
-  const emitAssertObjectFunction = () => `const ${assertObjectName}: (input: unknown) => asserts input is Record<string, unknown> = (input) => {
-${assertionLines[0]}
-};`;
-  const emitAssertFunction = () => `const ${assertName} = (input: Record<string, unknown>): void => {
-${assertBodyLines.join("\n")}
-};`;
-  const lines = [];
-  lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
-  if (canSplit) {
-    preamble.push(emitAssertObjectFunction());
-    preamble.push(emitAssertFunction());
-    lines.push(`  if (!isObject(input)) ${assertObjectName}(input);`);
-    if (!varsAfterGuard)
-      lines.push(...varDeclLines);
-    if (shallowGuard) {
-      lines.push(`  if (!(${shallowGuard})) ${assertName}(input);`);
-      if (!exported && deepGuard !== null && fastPathNeedsKnownKeys) {
-        const residual = [];
-        for (let i = 0; i < fastPathChecks.length; i++) {
-          const deep = fastPathChecks[i];
-          const shallow = shallowChecks[i];
-          if (deep === shallow)
-            continue;
-          residual.push(shallow !== void 0 && deep.startsWith(`${shallow} && `) ? deep.slice(shallow.length + 4) : deep);
-        }
-        const returnInput = `return input as ${typeName};`;
-        if (fastPathKeyCount === null) {
-          lines.push(residual.length > 0 ? `  if (${residual.join(" && ")}) ${returnInput}` : `  ${returnInput}`);
-        } else {
-          const count = keyCountCheck(unknownKeys, fastPathKeyCount, residual.length === 0 ? "  " : "    ");
-          if (count.statements.length === 0) {
-            lines.push(`  if (${[...residual, count.verdict].join(" && ")}) ${returnInput}`);
-          } else if (residual.length === 0) {
-            lines.push(...count.statements, `  if (${count.verdict}) ${returnInput}`);
-          } else {
-            lines.push(`  if (${residual.join(" && ")}) {`);
-            lines.push(...count.statements, `    if (${count.verdict}) ${returnInput}`);
-            lines.push(`  }`);
-          }
-        }
-      }
-      const hoisted = [];
-      const objectLines = buildObjectLines(true, hoisted);
-      lines.push(...hoisted);
-      emitReturn(lines, objectLines);
-    } else {
-      emitDeepGuardReturn(lines);
-      if (varsAfterGuard)
-        lines.push(...varDeclLines);
-      lines.push(`  ${assertName}(input);`);
-      emitReturn(lines, buildObjectLines(true));
-    }
-  } else if (strict) {
-    lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
-    if (!varsAfterGuard)
-      lines.push(...varDeclLines);
-    lines.push(...warnLines);
-    if (shallowGuard) {
-      if (!exported && deepGuard && fastPathNeedsKnownKeys) {
-        const residual = [];
-        for (let i = 0; i < fastPathChecks.length; i++) {
-          const deep = fastPathChecks[i];
-          const shallow = shallowChecks[i];
-          if (deep === shallow)
-            continue;
-          residual.push(shallow !== void 0 && deep.startsWith(`${shallow} && `) ? deep.slice(shallow.length + 4) : deep);
-        }
-        lines.push(`  if (${shallowGuard}) {`);
-        const returnInput = `return input as ${typeName};`;
-        if (fastPathKeyCount === null) {
-          lines.push(residual.length > 0 ? `    if (${residual.join(" && ")}) ${returnInput}` : `    ${returnInput}`);
-        } else {
-          const count = keyCountCheck(unknownKeys, fastPathKeyCount, residual.length === 0 ? "    " : "      ");
-          if (count.statements.length === 0) {
-            lines.push(`    if (${[...residual, count.verdict].join(" && ")}) ${returnInput}`);
-          } else if (residual.length === 0) {
-            lines.push(...count.statements, `    if (${count.verdict}) ${returnInput}`);
-          } else {
-            lines.push(`    if (${residual.join(" && ")}) {`);
-            lines.push(...count.statements, `      if (${count.verdict}) ${returnInput}`);
-            lines.push(`    }`);
-          }
-        }
-        lines.push(`  } else {`);
-        for (const assertionLine of assertionLines.slice(1))
-          lines.push(`  ${assertionLine}`);
-        lines.push(`  }`);
-      } else {
-        lines.push(`  if (!(${shallowGuard})) {`);
-        for (const assertionLine of assertionLines.slice(1))
-          lines.push(`  ${assertionLine}`);
-        lines.push(`  }`);
-      }
-      emitReturn(lines, buildObjectLines(true));
-    } else {
-      if (deepGuard !== null) {
-        emitDeepGuardReturn(lines);
-      }
-      if (varsAfterGuard)
-        lines.push(...varDeclLines);
-      for (const assertionLine of assertionLines.slice(1))
-        lines.push(assertionLine);
-      lines.push(...unknownKeyThrowLines());
-      emitReturn(lines, buildObjectLines(true));
-    }
-  } else {
-    lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
-    if (!varsAfterGuard)
-      lines.push(...varDeclLines);
-    lines.push(...warnLines);
-    if (deepGuard !== null) {
-      emitDeepGuardReturn(lines);
-    }
-    if (varsAfterGuard)
-      lines.push(...varDeclLines);
-    emitReturn(lines, buildObjectLines(false));
-  }
-  lines.push(`}`);
-  const fn = lines.join("\n");
-  if (preamble.length === 0)
-    return fn;
-  return `${preamble.join("\n\n")}
-
-${fn}`;
-};
-const safeResultAssign = (keyVar, valueExpr) => `if (${keyVar} === "__proto__") { Object.defineProperty(result, ${keyVar}, { value: ${valueExpr}, writable: true, enumerable: true, configurable: true }); } else { (result as Record<string, unknown>)[${keyVar}] = ${valueExpr}; }`;
-const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict, context = {}) => {
-  const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
-  const knownKeyCheck = unknownKeyCheck(declaredKeys, "_knownKeys");
-  const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : void 0;
-  const loopLines = [`    if (${knownKeyCheck.isKnown("key")}) continue;`];
-  if (refPattern) {
-    const parserName = generateParserName(refToName(refPattern[1].$ref, suffix));
-    loopLines.push(`    if (${regexLiteral(refPattern[0])}.test(key)) {`);
-    loopLines.push(`      ${safeResultAssign("key", `${parserName}(input[key])`)}`);
-    loopLines.push(`      continue;`);
-    loopLines.push(`    }`);
-  }
-  const keepConditions = patterns.filter(([p]) => !(refPattern && p === refPattern[0])).map(([p]) => `${regexLiteral(p)}.test(key)`);
-  if (keepConditions.length > 0) {
-    loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
-    loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
-    loopLines.push(`      continue;`);
-    loopLines.push(`    }`);
-  }
-  if (strict)
-    loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
-  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
-  const resultBody = propertyLines.length > 0 ? `{
-${propertyLines.join("\n")}
-  }` : "{}";
-  const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};
-`).join("");
-  const assertionPrelude = strict ? generateObjectStrictAssertion(schema, typeName, context).slice(1) : [];
-  const keywordPrelude = assertionPrelude.length > 0 ? `
-${assertionPrelude.join("\n")}` : "";
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) {
-${notObjectBranch}
-  }${keywordPrelude}
-${knownKeysDeclaration}  const result = ${resultBody} as unknown as ${typeName};
-  for (const key in input) {
-${loopLines.join("\n")}
-  }
-  return result;
-};`;
-};
-const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false, context = {}) => {
-  const functionName = generateParserName(typeName);
-  const unknownKeys = context.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
-  const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
-  const propertyLines = entries.map((entry) => {
-    if (entry.isOptional) {
-      return `    ${entry.value},`;
-    }
-    return `    ${safeLiteralKey(entry.key)}: ${entry.value},`;
-  });
-  if (!isSchemaObject(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
-  }
-  const patternProps = schema.patternProperties;
-  const patterns = Object.entries(patternProps);
-  const refPattern = patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps));
-  const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
-  if (strictKeys) {
-    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict, context);
-  }
-  if (stripUnknown && !strict) {
-    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false, context);
-  }
-  if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
-  }
-  const [pattern, patternSchema] = refPattern;
-  const ref = patternSchema.$ref;
-  const parserName = generateParserName(refToName(ref, suffix));
-  const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-  const patternLiteral = regexLiteral(pattern);
-  const inputSpread = "    ...input,";
-  let objectProperties = inputSpread;
-  if (propertyLines.length > 0) {
-    for (const line of propertyLines) {
-      objectProperties += "\n" + line;
-    }
-  }
-  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) {
-${notObjectBranch}
-  }${keywordPrelude}
-  const result = {
-${objectProperties}
-  } as unknown as ${typeName};
-  for (const key in input) {
-    if (${patternLiteral}.test(key)) {
-      const value = input[key];
-      ${assignmentCode}
-    }
-  }
-  return result;
-};`;
-};
-const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict, context = {}) => {
-  const functionName = generateParserName(typeName);
-  const additionalProps = schema.additionalProperties;
-  if (!additionalProps) {
-    return generateEmptyObjectParser(typeName, strict, schema, context);
-  }
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
-  if (useRefImports && isSchemaObject(additionalProps) && hasRef(additionalProps)) {
-    const ref = additionalProps.$ref;
-    const parserName = generateParserName(refToName(ref, suffix));
-    if (strict) {
-      return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
-  return validateRecord(input, ${parserName}) as ${typeName};
-};`;
-    }
-    return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
-  }
-  if (isSchemaObject(additionalProps) && hasType(additionalProps)) {
-    const inlineParser = generateInlineValueParser(additionalProps, strict, `[${typeName}]`);
-    if (inlineParser) {
-      if (strict) {
-        return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
-  return validateRecord(input, ${inlineParser}) as ${typeName};
-};`;
-      }
-      return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
-    }
-  }
-  if (strict) {
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
-  return { ...input } as ${typeName};
-};`;
-  }
-  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
-};
-const generateInlineValueParser = (schema, strict = false, label = "") => {
-  if (!isSchemaObject(schema) || !hasType(schema)) {
-    return null;
-  }
-  if (strict) {
-    const err = (t) => `throw new Error(${JSON.stringify(`${label} record value must be ${t}`)})`;
-    switch (schema.type) {
-      case "string":
-        return `(value: unknown) => { if (typeof value !== "string") ${err("string")}; return value; }`;
-      case "number":
-        return `(value: unknown) => { if (typeof value !== "number") ${err("number")}; return value; }`;
-      case "integer":
-        return `(value: unknown) => { if (typeof value !== "number" || !Number.isInteger(value)) ${err("integer")}; return value; }`;
-      case "boolean":
-        return `(value: unknown) => { if (typeof value !== "boolean") ${err("boolean")}; return value; }`;
-      case "array":
-        return `(value: unknown) => { if (!Array.isArray(value)) ${err("array")}; return value; }`;
-      default:
-        return null;
-    }
-  }
-  switch (schema.type) {
-    case "string":
-      return '(value: unknown) => typeof value === "string" ? value : ""';
-    case "number":
-      return '(value: unknown) => typeof value === "number" ? value : 0';
-    case "integer":
-      return '(value: unknown) => typeof value === "number" && Number.isInteger(value) ? value : 0';
-    case "boolean":
-      return '(value: unknown) => typeof value === "boolean" ? value : false';
-    case "array":
-      return "(value: unknown) => Array.isArray(value) ? value : []";
-    default:
-      return null;
-  }
-};
-const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict, context = {}) => {
-  const functionName = generateParserName(typeName);
-  if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
-    return generateEmptyObjectParser(typeName, strict, schema, context);
-  }
-  const patternProps = schema.patternProperties;
-  const patterns = Object.entries(patternProps);
-  if (patterns.length === 0) {
-    return generateEmptyObjectParser(typeName, strict, schema, context);
-  }
-  const [pattern, patternSchema] = patterns[0];
-  let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
-  let patternValueExpr = "value";
-  if (useRefImports && isSchemaObject(patternSchema) && hasRef(patternSchema)) {
-    const ref = patternSchema.$ref;
-    const parserName = generateParserName(refToName(ref, suffix));
-    patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-    patternValueExpr = `${parserName}(value)`;
-  } else if (patternSchema === false) {
-    patternAssignment = "";
-    patternValueExpr = null;
-  }
-  const patternLiteral = regexLiteral(pattern);
-  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
-  const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
-  if (strictKeys) {
-    const loopLines = [`    if (${patternLiteral}.test(key)) {`];
-    if (patternValueExpr) {
-      loopLines.push(`      const value = input[key];`);
-      loopLines.push(`      ${safeResultAssign("key", patternValueExpr)}`);
-    }
-    loopLines.push(`      continue;`);
-    loopLines.push(`    }`);
-    const keepConditions = patterns.slice(1).map(([p]) => `${regexLiteral(p)}.test(key)`);
-    if (keepConditions.length > 0) {
-      loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
-      loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
-      loopLines.push(`      continue;`);
-      loopLines.push(`    }`);
-    }
-    if (strict)
-      loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) {
-${notObjectBranch}
-  }${keywordPrelude}
-  const result = {} as unknown as ${typeName};
-  for (const key in input) {
-${loopLines.join("\n")}
-  }
-  return result;
-};`;
-  }
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) {
-${notObjectBranch}
-  }${keywordPrelude}
-  const result = {
-    ...input,
-  } as unknown as ${typeName};
-  for (const key in input) {
-    if (${patternLiteral}.test(key)) {
-      const value = input[key];
-      ${patternAssignment}
-    }
-  }
-  return result;
-};`;
-};
-const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false, caseInsensitive = false, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
-  const functionName = generateParserName(typeName);
-  const ifSchema = schema.if;
-  const thenSchema = schema.then;
-  const elseSchema = schema.else;
-  const thenHasRef = thenSchema && isSchemaObject(thenSchema) && hasRef(thenSchema);
-  const elseHasRef = elseSchema && isSchemaObject(elseSchema) && hasRef(elseSchema);
-  if (!thenHasRef || !elseHasRef) {
-    const mergedSchema = getConditionalObjectSchema(schema);
-    if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
-    }
-    return generateEmptyObjectParser(typeName);
-  }
-  const isRefCondition = ifSchema && isSchemaObject(ifSchema) && "required" in ifSchema && Array.isArray(ifSchema.required) && ifSchema.required.includes("$ref");
-  if (!isRefCondition) {
-    const mergedSchema = getConditionalObjectSchema(schema);
-    if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
-    }
-    return generateEmptyObjectParser(typeName);
-  }
-  const thenRef = thenSchema.$ref;
-  const elseRef = elseSchema.$ref;
-  const thenParserName = generateParserName(refToName(thenRef, suffix));
-  const elseParserName = generateParserName(refToName(elseRef, suffix));
-  const thenTypeName = refToName(thenRef, suffix);
-  return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
-  hasRef(input) ? ${thenParserName}(input) : ${elseParserName}(input)
-      `;
-};
-const getConditionalObjectSchema = (schema) => {
-  if (!isSchemaObject(schema)) {
-    return null;
-  }
-  if (!("if" in schema) || !("then" in schema)) {
-    return null;
-  }
-  const ifSchema = schema.if;
-  const thenSchema = schema.then;
-  const elseSchema = "else" in schema ? schema.else : void 0;
-  if (!isSchemaObject(ifSchema) || !isSchemaObject(thenSchema)) {
-    return null;
-  }
-  const ifProperties = ifSchema.properties;
-  const thenProperties = thenSchema.properties;
-  const elseProperties = elseSchema && isSchemaObject(elseSchema) ? elseSchema.properties : void 0;
-  const hasIfProperties = ifProperties && typeof ifProperties === "object";
-  const hasThenProperties = thenProperties && typeof thenProperties === "object";
-  const hasElseProperties = elseProperties && typeof elseProperties === "object";
-  if (!hasIfProperties && !hasThenProperties && !hasElseProperties) {
-    return null;
-  }
-  const required = /* @__PURE__ */ new Set();
-  if (Array.isArray(ifSchema.required)) {
-    for (const key of ifSchema.required) {
-      required.add(key);
-    }
-  }
-  if (hasIfProperties && ifProperties && typeof ifProperties === "object") {
-    for (const [key, propSchema] of Object.entries(ifProperties)) {
-      if (isSchemaObject(propSchema) && hasConst(propSchema)) {
-        required.add(key);
-      }
-    }
-  }
-  if (Array.isArray(thenSchema.required)) {
-    for (const key of thenSchema.required) {
-      required.add(key);
-    }
-  }
-  return {
-    type: "object",
-    properties: {
-      // else properties first so then properties take precedence on overlap
-      ...hasElseProperties ? elseProperties : {},
-      ...hasIfProperties ? ifProperties : {},
-      ...hasThenProperties ? thenProperties : {}
-    },
-    ...required.size > 0 ? { required: Array.from(required) } : {}
-  };
-};
-const OBJECT_SHAPE_KEYWORDS = ["properties", "patternProperties", "additionalProperties", "required"];
-const DELEGATING_KEYWORDS = ["$ref", "$dynamicRef", "allOf", "anyOf", "oneOf", "if", "not"];
-const admitsBooleanSchema = (schema) => {
-  if (typeof schema === "boolean")
-    return true;
-  if (!isSchemaObject(schema))
-    return false;
-  const record = schema;
-  const type = readKey(record, "type");
-  if (type !== void 0)
-    return Array.isArray(type) ? type.includes("boolean") : type === "boolean";
-  return ![...OBJECT_SHAPE_KEYWORDS, ...DELEGATING_KEYWORDS].some((keyword) => declaresKey(record, keyword));
-};
-const generateSchemaObjectParser = (typeName, schema) => {
-  const functionName = generateParserName(typeName);
-  const booleanBranch = admitsBooleanSchema(schema) ? `  if (typeof input === 'boolean') {
-    return input as ${typeName};
-  }
-  
-` : "";
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-${booleanBranch}  if (!isObject(input)) {
-    return {} as ${typeName};
-  }
-  
-  return input as ${typeName};
-};`;
-};
-const selectParserStrategy = (schema, typeName, options) => {
-  const useRefImports = options?.useRefImports ?? false;
-  const logWarnings = options?.logWarnings ?? false;
-  const strict = options?.strict ?? false;
-  const stripUnknown = options?.stripUnknown ?? false;
-  const caseInsensitive = options?.caseInsensitive ?? false;
-  const unknownKeys = options?.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
-  const suffix = options?.typeSuffix ?? "";
-  const context = {
-    useRefImports,
-    suffix,
-    stripUnknown,
-    unknownKeys,
-    ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {}
-  };
-  const copyLoopContext = { ...context, subParsers: false };
-  if (!options?.isRoot && typeName === `Schema${suffix}`) {
-    return generateSchemaObjectParser(typeName, schema);
-  }
-  const isObjectLikeSchema = isObjectSchema(schema) || isSchemaObject(schema) && ("patternProperties" in schema || "additionalProperties" in schema);
-  if (!isObjectLikeSchema && !isSchemaObject(schema)) {
-    return generateNonObjectParser(typeName, schema, strict, {
-      useRefImports,
-      suffix,
-      stripUnknown,
-      caseInsensitive,
-      logWarnings,
-      unknownKeys,
-      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
-    });
-  }
-  if (hasProperties(schema) && isSchemaObject(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive, copyLoopContext);
-  }
-  if (strict && isSchemaObject(schema) && Array.isArray(schema.type) && schema.type.includes("null")) {
-    return generateNonObjectParser(typeName, schema, strict, {
-      useRefImports,
-      suffix,
-      stripUnknown,
-      caseInsensitive,
-      logWarnings,
-      unknownKeys,
-      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
-    });
-  }
-  if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive, options?.shapeValidatorSource, unknownKeys);
-  }
-  if (strict && isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
-    return generateNonObjectParser(typeName, schema, strict, {
-      useRefImports,
-      suffix,
-      stripUnknown,
-      caseInsensitive,
-      logWarnings,
-      unknownKeys,
-      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
-    });
-  }
-  if (isSchemaObject(schema) && "if" in schema && "then" in schema && "else" in schema) {
-    return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive, unknownKeys);
-  }
-  const conditionalObjectSchema = getConditionalObjectSchema(schema);
-  if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
-  }
-  if (!isObjectLikeSchema) {
-    return generateNonObjectParser(typeName, schema, strict, {
-      useRefImports,
-      suffix,
-      stripUnknown,
-      caseInsensitive,
-      logWarnings,
-      unknownKeys,
-      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
-    });
-  }
-  if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict, copyLoopContext);
-  }
-  if ("additionalProperties" in schema && !hasProperties(schema)) {
-    const additionalProps = schema.additionalProperties;
-    if (additionalProps === true || additionalProps === false) {
-      return generateEmptyObjectParser(typeName, strict, schema, context);
-    }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict, copyLoopContext);
-  }
-  if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
-    return generateEmptyObjectParser(typeName, strict, schema, context);
-  }
-  return generateEmptyObjectParser(typeName, strict, schema, context);
-};
-const generateParserFunction = (schema, typeName, rawOptions) => {
-  const options = rawOptions?.strict && rawOptions.rootSchema === void 0 && isSchemaObject(schema) ? { ...rawOptions, rootSchema: schema } : rawOptions;
-  if (options?.strict) {
-    assertNoUnsupportedKeywords(schema, typeName, {
-      useRefImports: options.useRefImports ?? false,
-      suffix: options.typeSuffix ?? "",
-      ...options.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-      ...options.stripUnknown !== void 0 ? { stripUnknown: options.stripUnknown } : {}
-    });
-  }
-  return selectParserStrategy(schema, typeName, options);
-};
-const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeName);
-const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", exported = true, stripUnknown = false, reservedNames = NO_RESERVED_NAMES, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
-  const fnName = shapeValidatorName(typeName);
-  const exportPrefix = exported ? "export " : "";
-  const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
-  if (!isSchemaObject(schema))
-    return stub;
-  if (hasFastPathBlockingKeyword(schema))
-    return stub;
-  if (useRefImports && hasRef(schema) && !hasProperties(schema)) {
-    const refName = refToName(schema.$ref, suffix);
-    if (refName !== typeName) {
-      return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${shapeValidatorName(refName)}(input);`;
-    }
-    return stub;
-  }
-  if (!hasProperties(schema) && !("patternProperties" in schema) && !("if" in schema) && !stripUnknown) {
-    const branches = getUnionBranches(schema);
-    if (branches) {
-      const check = generateUnionCheck("input", branches, useRefImports, suffix, isExclusiveUnion(schema));
-      if (check !== null) {
-        return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${check};`;
-      }
-      return stub;
-    }
-    const direct = generatePropertyTypeCheck("input", schema, useRefImports, suffix);
-    if (direct !== null) {
-      return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${direct};`;
-    }
-    return stub;
-  }
-  const shape = shapeChecksOf(schema, typeName, "input", useRefImports, suffix, stripUnknown, reservedNames);
-  if (shape === null)
-    return stub;
-  const strictKeysGuard = shape.walksKeys ? `
-  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
-  return renderShapeValidator(exportPrefix, fnName, shape.checks, shape.keyCount, strictKeysGuard, unknownKeys);
-};
-const shapeChecksOf = (schema, typeName, root, useRefImports, suffix, stripUnknown, reservedNames) => {
-  if (!isSchemaObject(schema))
-    return null;
-  if (hasFastPathBlockingKeyword(schema))
-    return null;
-  if (!hasProperties(schema))
-    return null;
-  if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema || "patternProperties" in schema || "if" in schema || "then" in schema || "else" in schema) {
-    return null;
-  }
-  const schemaProps = schema.properties;
-  const propertyKeys = Object.keys(schemaProps);
-  const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
-  const validatorStripKeys = hasStrictKeys(schema) || stripUnknown;
-  const keyCount = validatorStripKeys ? exactKeyCountOf(schema) : null;
-  const checks = [];
-  for (const key of propertyKeys) {
-    const propSchema = schemaProps[key];
-    if (shouldUseRecordRefImport(propSchema, useRefImports))
-      return null;
-    const accessor = safeAccessor(root, key);
-    const isRequired = isPropertyRequired(key, schema);
-    const subName = subTypeNames.get(key);
-    let check = subName ? `${shapeValidatorName(subName)}(${accessor})` : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
-    const itemSubName = subItemNames.get(key);
-    if (check !== null && itemSubName) {
-      check = `${check} && _every${itemSubName}(${accessor})`;
-    }
-    if (check === null)
-      return null;
-    if (isRequired) {
-      checks.push(check);
-    } else {
-      checks.push(`(${accessor} === undefined || ${check})`);
-    }
-  }
-  if (hasMinProperties(schema))
-    checks.push(`Object.keys(${root}).length >= ${schema.minProperties}`);
-  if (hasMaxProperties(schema))
-    checks.push(`Object.keys(${root}).length <= ${schema.maxProperties}`);
-  return { checks, keyCount, walksKeys: validatorStripKeys && keyCount === null, propertyCount: propertyKeys.length };
-};
-const inlineNestedShapeCheck = (childSchema, childTypeName, local, useRefImports, suffix, stripUnknown, reservedNames, unknownKeys) => {
-  const readRoot = `(${local} as Record<string, any>)`;
-  const shape = shapeChecksOf(childSchema, childTypeName, readRoot, useRefImports, suffix, stripUnknown, reservedNames);
-  if (shape === null || shape.walksKeys)
-    return null;
-  if (shape.propertyCount === 0 || shape.propertyCount > INLINE_NESTED_MAX_PROPERTIES)
-    return null;
-  const count = shape.keyCount === null ? null : keyCountCheck(unknownKeys, shape.keyCount, "", local);
-  if (count !== null && count.statements.length > 0)
-    return null;
-  const parts = [
-    `typeof ${local} === "object"`,
-    `${local} !== null`,
-    `!Array.isArray(${local})`,
-    ...shape.checks,
-    ...count === null ? [] : [count.verdict]
-  ];
-  return { check: `(${parts.join(" && ")})`, propertyCount: shape.propertyCount };
-};
-const renderShapeValidator = (exportPrefix, fnName, checks, keyCount, strictKeysGuard, unknownKeys) => {
-  const head = `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
-  if (!isObject(input)) return false;${strictKeysGuard}`;
-  const chain = checks.join("\n    && ");
-  if (keyCount === null) {
-    if (checks.length === 0) {
-      return strictKeysGuard ? `${head}
-  return true;
-};` : `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
-    }
-    return `${head}
-  return ${chain};
-};`;
-  }
-  const count = keyCountCheck(unknownKeys, keyCount, "  ");
-  if (count.statements.length === 0) {
-    return `${head}
-  return ${checks.length === 0 ? count.verdict : `${chain}
-    && ${count.verdict}`};
-};`;
-  }
-  const gate = checks.length === 0 ? "" : `
-  if (!(${chain})) return false;`;
-  return `${head}${gate}
-${count.statements.join("\n")}
-  return ${count.verdict};
-};`;
-};
-export {
-  generateParserFunction,
-  generateShapeValidator,
-  shapeValidatorFunctionName
-};