canonize 0.1.0

package/dist/index.js

@@ -0,0 +1,1623 @@
+// src/index.ts
+import * as z2 from "zod";
+
+// src/utilities/circular.ts
+class CircularTracker {
+  seen = new WeakSet;
+  has(obj) {
+    return this.seen.has(obj);
+  }
+  add(obj) {
+    this.seen.add(obj);
+  }
+  child() {
+    const child = new CircularTracker;
+    return child;
+  }
+}
+function canBeCircular(value) {
+  return typeof value === "object" && value !== null;
+}
+function throwCircular() {
+  throw new Error("Circular reference detected");
+}
+
+// src/utilities/parsers.ts
+function tryParseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function tryParseCSV(value) {
+  if (value.includes(",")) {
+    return value.split(",").map((s) => s.trim());
+  }
+  if (value.includes(";")) {
+    return value.split(";").map((s) => s.trim());
+  }
+  if (value.includes("|")) {
+    return value.split("|").map((s) => s.trim());
+  }
+  return null;
+}
+function tryParseSpecialNumber(value) {
+  const trimmed = value.trim();
+  if (/^0x[0-9a-f]+$/i.test(trimmed)) {
+    return parseInt(trimmed, 16);
+  }
+  if (/^0o[0-7]+$/i.test(trimmed)) {
+    return parseInt(trimmed.slice(2), 8);
+  }
+  if (/^0b[01]+$/i.test(trimmed)) {
+    return parseInt(trimmed.slice(2), 2);
+  }
+  return null;
+}
+function tryParseNumber(value) {
+  const special = tryParseSpecialNumber(value);
+  if (special !== null)
+    return special;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  const num = Number(trimmed);
+  if (isNaN(num))
+    return null;
+  return num;
+}
+function normalizeString(value) {
+  return value.trim().toLowerCase();
+}
+function isFalsyForNull(value) {
+  if (value === null)
+    return true;
+  if (value === undefined)
+    return true;
+  if (value === false)
+    return true;
+  if (value === 0)
+    return true;
+  if (Object.is(value, -0))
+    return true;
+  if (value === "")
+    return true;
+  if (typeof value === "bigint" && value === 0n)
+    return true;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "null" || normalized === "undefined")
+      return true;
+  }
+  if (Array.isArray(value) && value.length === 0)
+    return true;
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const keys = Object.keys(value);
+    if (keys.length === 0)
+      return true;
+  }
+  return false;
+}
+
+// src/constants.ts
+var TRUTHY_STRINGS = ["true", "yes", "on", "y", "t", "enabled", "1"];
+var FALSY_STRINGS = ["false", "no", "off", "n", "f", "disabled", "0"];
+var ZodType = {
+  STRING: "string",
+  NUMBER: "number",
+  BOOLEAN: "boolean",
+  DATE: "date",
+  BIGINT: "bigint",
+  NULL: "null",
+  UNDEFINED: "undefined",
+  NAN: "nan",
+  ARRAY: "array",
+  OBJECT: "object",
+  TUPLE: "tuple",
+  RECORD: "record",
+  ENUM: "enum",
+  NATIVE_ENUM: "nativeEnum",
+  LITERAL: "literal",
+  UNION: "union",
+  DISCRIMINATED_UNION: "discriminatedUnion",
+  INTERSECTION: "intersection",
+  MAP: "map",
+  SET: "set",
+  OPTIONAL: "optional",
+  NULLABLE: "nullable",
+  DEFAULT: "default",
+  CATCH: "catch",
+  LAZY: "lazy",
+  READONLY: "readonly",
+  BRANDED: "branded",
+  ANY: "any",
+  UNKNOWN: "unknown",
+  NEVER: "never",
+  CUSTOM: "custom"
+};
+
+// src/utilities/type-detection.ts
+function getZodTypeName(schema) {
+  const candidates = [
+    schema._def.type,
+    schema._def.typeName,
+    schema.type
+  ];
+  const rawType = candidates.find((candidate) => typeof candidate === "string") ?? "";
+  const withoutPrefix = rawType.replace(/^Zod/i, "");
+  const lower = withoutPrefix.toLowerCase();
+  const mapped = {
+    nativeenum: ZodType.NATIVE_ENUM,
+    discriminatedunion: ZodType.DISCRIMINATED_UNION
+  };
+  return mapped[lower] ?? lower;
+}
+function unwrapSchema(schema) {
+  const typeName = getZodTypeName(schema);
+  if (typeName === ZodType.OPTIONAL || typeName === ZodType.NULLABLE) {
+    return unwrapSchema(schema._def.innerType);
+  }
+  if (typeName === ZodType.DEFAULT) {
+    return unwrapSchema(schema._def.innerType);
+  }
+  if (typeName === ZodType.CATCH) {
+    return unwrapSchema(schema._def.innerType);
+  }
+  if (typeName === ZodType.READONLY) {
+    return unwrapSchema(schema._def.innerType);
+  }
+  return schema;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (Array.isArray(value))
+    return false;
+  if (value instanceof Date)
+    return false;
+  if (value instanceof Map)
+    return false;
+  if (value instanceof Set)
+    return false;
+  if (value instanceof RegExp)
+    return false;
+  if (value instanceof Error)
+    return false;
+  if (ArrayBuffer.isView(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isArrayLike(value) {
+  if (!isPlainObject(value))
+    return false;
+  const obj = value;
+  return typeof obj["length"] === "number" && obj["length"] >= 0;
+}
+
+// src/coercers/array.ts
+function coerceToArray(value, _elementSchema, coerceElement, tracker = new CircularTracker) {
+  if (value === null)
+    return [];
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (Array.isArray(value)) {
+    tracker.add(value);
+    const result = [];
+    for (let i = 0;i < value.length; i++) {
+      if (i in value) {
+        if (canBeCircular(value[i]) && tracker.has(value[i])) {
+          throwCircular();
+        }
+        result[i] = coerceElement(value[i], tracker);
+      }
+    }
+    return result;
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return [];
+    const json = tryParseJSON(trimmed);
+    if (Array.isArray(json)) {
+      return json.map((v) => coerceElement(v, tracker));
+    }
+    const csv = tryParseCSV(trimmed);
+    if (csv) {
+      return csv.map((v) => coerceElement(v, tracker));
+    }
+    return [coerceElement(trimmed, tracker)];
+  }
+  if (value instanceof Set) {
+    return Array.from(value).map((v) => coerceElement(v, tracker));
+  }
+  if (value instanceof Map) {
+    return Array.from(value.values()).map((v) => coerceElement(v, tracker));
+  }
+  if (ArrayBuffer.isView(value)) {
+    return Array.from(value).map((v) => coerceElement(v, tracker));
+  }
+  if (isArrayLike(value)) {
+    const obj = value;
+    const length = obj.length;
+    const result = [];
+    for (let i = 0;i < length; i++) {
+      if (i in obj) {
+        result[i] = coerceElement(obj[i], tracker);
+      }
+    }
+    return result;
+  }
+  if (isPlainObject(value)) {
+    const values = Object.values(value);
+    return values.map((v) => coerceElement(v, tracker));
+  }
+  return [coerceElement(value, tracker)];
+}
+
+// src/utilities/special-methods.ts
+function extractPrimitiveValue(value, hint = "default") {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const obj = value;
+  if (value instanceof Date && typeof obj.toJSON === "function") {
+    try {
+      return obj.toJSON();
+    } catch {}
+  }
+  if (Symbol.toPrimitive in obj) {
+    try {
+      return obj[Symbol.toPrimitive](hint);
+    } catch {}
+  }
+  if (typeof obj.toJSON === "function") {
+    try {
+      return obj.toJSON();
+    } catch {}
+  }
+  if (hint === "string" && typeof obj.toString === "function") {
+    try {
+      const result = obj.toString();
+      if (result !== "[object Object]") {
+        return result;
+      }
+    } catch {}
+  }
+  if (typeof obj.valueOf === "function") {
+    try {
+      const result = obj.valueOf();
+      if (result !== obj) {
+        return result;
+      }
+    } catch {}
+  }
+  if (hint !== "string" && typeof obj.toString === "function") {
+    try {
+      const result = obj.toString();
+      if (result !== "[object Object]") {
+        return result;
+      }
+    } catch {}
+  }
+  return value;
+}
+function extractDateValue(value) {
+  if (value instanceof Date)
+    return value;
+  if (typeof value !== "object" || value === null)
+    return null;
+  const obj = value;
+  if (typeof obj.getTime === "function") {
+    try {
+      const time = obj.getTime();
+      if (typeof time === "number" && !isNaN(time)) {
+        return new Date(time);
+      }
+    } catch {}
+  }
+  if (typeof obj.toISOString === "function") {
+    try {
+      const iso = obj.toISOString();
+      const date = new Date(iso);
+      if (!isNaN(date.getTime())) {
+        return date;
+      }
+    } catch {}
+  }
+  return null;
+}
+
+// src/coercers/bigint.ts
+function coerceToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "function") {
+    throw new Error("Cannot convert function to BigInt");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot convert symbol to BigInt");
+  }
+  if (typeof value === "number") {
+    if (!isFinite(value)) {
+      throw new Error("Cannot convert NaN or Infinity to BigInt");
+    }
+    return BigInt(Math.trunc(value));
+  }
+  if (typeof value === "boolean")
+    return value ? 1n : 0n;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return 0n;
+    try {
+      return BigInt(trimmed);
+    } catch {
+      const json = tryParseJSON(trimmed);
+      if (json !== null) {
+        return coerceToBigInt(json);
+      }
+      throw new Error(`Cannot convert "${trimmed}" to BigInt`);
+    }
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return 0n;
+    return coerceToBigInt(value[0]);
+  }
+  if (value === null)
+    return 0n;
+  if (value === undefined) {
+    throw new Error("Cannot convert undefined to BigInt");
+  }
+  const extracted = extractPrimitiveValue(value, "number");
+  if (typeof extracted === "bigint")
+    return extracted;
+  if (typeof extracted !== "object" || extracted === null) {
+    return coerceToBigInt(extracted);
+  }
+  throw new Error("Cannot convert object to BigInt");
+}
+
+// src/coercers/boolean.ts
+function coerceToBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "function" || typeof value === "symbol") {
+    return true;
+  }
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (typeof value === "number") {
+    if (value === 0 || Object.is(value, -0) || isNaN(value)) {
+      return false;
+    }
+    return true;
+  }
+  if (typeof value === "bigint") {
+    return value !== 0n;
+  }
+  if (typeof value === "string") {
+    const normalized = normalizeString(value);
+    if (normalized === "") {
+      return false;
+    }
+    if (TRUTHY_STRINGS.includes(normalized)) {
+      return true;
+    }
+    if (FALSY_STRINGS.includes(normalized)) {
+      return false;
+    }
+    throw new Error(`Cannot coerce string "${value}" to boolean`);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return false;
+    }
+    if (value.length === 1) {
+      return coerceToBoolean(value[0]);
+    }
+    return true;
+  }
+  const extracted = extractPrimitiveValue(value, "default");
+  if (typeof extracted === "boolean") {
+    return extracted;
+  }
+  if (typeof extracted !== "object" || extracted === null) {
+    return coerceToBoolean(extracted);
+  }
+  return Object.keys(value).length > 0;
+}
+
+// src/coercers/number.ts
+function coerceToNumber(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "function")
+    return NaN;
+  if (typeof value === "symbol")
+    return NaN;
+  if (value === null)
+    return 0;
+  if (value === undefined)
+    return NaN;
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return 0;
+    if (trimmed.toLowerCase() === "nan")
+      return NaN;
+    if (trimmed === "Infinity")
+      return Infinity;
+    if (trimmed === "-Infinity")
+      return -Infinity;
+    const parsed = tryParseNumber(trimmed);
+    if (parsed !== null)
+      return parsed;
+    const json = tryParseJSON(trimmed);
+    if (typeof json === "number")
+      return json;
+    return NaN;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return 0;
+    if (value.length === 1)
+      return coerceToNumber(value[0]);
+    return coerceToNumber(value[0]);
+  }
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  const extracted = extractPrimitiveValue(value, "number");
+  if (typeof extracted === "number")
+    return extracted;
+  if (typeof extracted !== "object" || extracted === null) {
+    return coerceToNumber(extracted);
+  }
+  return NaN;
+}
+function coerceToInteger(value) {
+  const num = coerceToNumber(value);
+  if (!isFinite(num))
+    return num;
+  const truncated = Math.trunc(num);
+  if (truncated > Number.MAX_SAFE_INTEGER)
+    return Number.MAX_SAFE_INTEGER;
+  if (truncated < Number.MIN_SAFE_INTEGER)
+    return Number.MIN_SAFE_INTEGER;
+  if (Object.is(truncated, -0))
+    return 0;
+  return truncated;
+}
+function coerceToInt32(value) {
+  const num = coerceToNumber(value);
+  return num | 0;
+}
+
+// src/coercers/date.ts
+function coerceToDate(value) {
+  if (value instanceof Date)
+    return value;
+  const extracted = extractDateValue(value);
+  if (extracted)
+    return extracted;
+  if (typeof value === "number") {
+    return new Date(value);
+  }
+  if (typeof value === "bigint") {
+    return new Date(Number(value));
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return new Date(NaN);
+    const parsed = new Date(trimmed);
+    if (!isNaN(parsed.getTime()))
+      return parsed;
+    const num2 = Number(trimmed);
+    if (!isNaN(num2)) {
+      if (num2 < 10000000000 && num2 > 0) {
+        return new Date(num2 * 1000);
+      }
+      return new Date(num2);
+    }
+    const json = tryParseJSON(trimmed);
+    if (json !== null) {
+      return coerceToDate(json);
+    }
+    return new Date(NaN);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return new Date(NaN);
+    if (value.length === 1) {
+      if (Array.isArray(value[0])) {
+        return new Date(NaN);
+      }
+      return coerceToDate(value[0]);
+    }
+    const parts = value.map(coerceToNumber);
+    const [year, month = 0, day = 1, hour = 0, minute = 0, second = 0, ms = 0] = parts;
+    return new Date(year, month, day, hour, minute, second, ms);
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if ("timestamp" in obj) {
+      return coerceToDate(obj.timestamp);
+    }
+    if ("year" in obj) {
+      if (!("month" in obj)) {
+        return new Date(NaN);
+      }
+      const year = coerceToNumber(obj.year);
+      const month = coerceToNumber(obj.month) - 1;
+      const day = "day" in obj ? coerceToNumber(obj.day) : 1;
+      const hour = "hour" in obj ? coerceToNumber(obj.hour) : 0;
+      const minute = "minute" in obj ? coerceToNumber(obj.minute) : 0;
+      const second = "second" in obj ? coerceToNumber(obj.second) : 0;
+      const ms = "millisecond" in obj ? coerceToNumber(obj.millisecond) : 0;
+      return new Date(year, month, day, hour, minute, second, ms);
+    }
+    if ("date" in obj && typeof obj.date === "string") {
+      return coerceToDate(obj.date);
+    }
+  }
+  const num = coerceToNumber(value);
+  if (!isNaN(num)) {
+    return new Date(num);
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if (typeof obj.toString === "function") {
+      try {
+        const str = obj.toString();
+        if (str && str !== "[object Object]") {
+          return coerceToDate(str);
+        }
+      } catch {}
+    }
+  }
+  return new Date(NaN);
+}
+
+// src/coercers/discriminated-union.ts
+function coerceToDiscriminatedUnion(value, discriminatorKey, options, coerceOption, tracker = new CircularTracker) {
+  if (!isPlainObject(value)) {
+    throw new Error("Discriminated union requires an object");
+  }
+  const obj = value;
+  if (!(discriminatorKey in obj)) {
+    throw new Error(`Missing discriminator key: ${discriminatorKey}`);
+  }
+  const discriminatorValue = obj[discriminatorKey];
+  const optionDiscriminators = [];
+  for (const option of options) {
+    const optionType = option._def.type || option._def.typeName;
+    if (optionType === "object") {
+      const shape = typeof option._def.shape === "function" ? option._def.shape() : option._def.shape;
+      if (discriminatorKey in shape) {
+        const discriminatorSchema = shape[discriminatorKey];
+        const discriminatorType = discriminatorSchema._def.type || discriminatorSchema._def.typeName;
+        if (discriminatorType === "literal") {
+          const value2 = discriminatorSchema._def.values ? discriminatorSchema._def.values[0] : discriminatorSchema._def.value;
+          optionDiscriminators.push(value2);
+        }
+      }
+    }
+  }
+  for (let i = 0;i < optionDiscriminators.length; i++) {
+    const expected = optionDiscriminators[i];
+    if (discriminatorValue === expected) {
+      try {
+        return coerceOption(i, value, tracker);
+      } catch {}
+    }
+    if (typeof expected === "string" && typeof discriminatorValue === "string") {
+      if (normalizeString(expected) === normalizeString(discriminatorValue)) {
+        try {
+          const updated = { ...obj, [discriminatorKey]: expected };
+          return coerceOption(i, updated, tracker);
+        } catch {}
+      }
+    }
+    if (typeof expected === "number") {
+      const coerced = coerceToNumber(discriminatorValue);
+      if (coerced === expected) {
+        try {
+          const updated = { ...obj, [discriminatorKey]: expected };
+          return coerceOption(i, updated, tracker);
+        } catch {}
+      }
+    }
+  }
+  throw new Error(`No matching discriminated union option for discriminator: ${discriminatorValue}`);
+}
+
+// src/coercers/enum.ts
+function coerceToEnum(value, enumValues, enumEntries) {
+  if (value === null) {
+    for (const enumValue of enumValues) {
+      if (enumValue === "null" || enumValue === null) {
+        return enumValue;
+      }
+    }
+    throw new Error(`Cannot coerce null to enum`);
+  }
+  if (value === undefined) {
+    for (const enumValue of enumValues) {
+      if (enumValue === "undefined" || enumValue === undefined) {
+        return enumValue;
+      }
+    }
+    throw new Error(`Cannot coerce undefined to enum`);
+  }
+  const isValidEnumIndex = (input) => Number.isInteger(input) && input >= 0 && input < enumValues.length;
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error(`Cannot coerce empty array to enum`);
+    }
+    const first = value[0];
+    if (typeof first === "number" && isValidEnumIndex(first)) {
+      return enumValues[first];
+    }
+    if (value.length >= 1)
+      return coerceToEnum(first, enumValues, enumEntries);
+  }
+  if (enumEntries && typeof value === "string") {
+    if (value in enumEntries) {
+      const result = enumEntries[value];
+      if (enumValues.includes(result)) {
+        return result;
+      }
+    }
+    const normalized = normalizeString(value);
+    for (const key of Object.keys(enumEntries)) {
+      if (normalizeString(key) === normalized) {
+        const result = enumEntries[key];
+        if (enumValues.includes(result)) {
+          return result;
+        }
+      }
+    }
+  }
+  for (const enumValue of enumValues) {
+    if (typeof enumValue === "string" && typeof value === "string") {
+      if (normalizeString(enumValue) === normalizeString(value)) {
+        return enumValue;
+      }
+    } else if (enumValue === value) {
+      return enumValue;
+    }
+  }
+  const allNumeric = enumValues.every((v) => typeof v === "number");
+  if (!allNumeric && (typeof value === "number" || typeof value === "boolean")) {
+    const index = typeof value === "boolean" ? value ? 1 : 0 : value;
+    if (Number.isInteger(index) && index >= 0 && index < enumValues.length) {
+      return enumValues[index];
+    }
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const num = coerceToNumber(value);
+    if (!isNaN(num)) {
+      if (enumValues.includes(num)) {
+        return num;
+      }
+      if (!allNumeric && isValidEnumIndex(num))
+        return enumValues[num];
+    }
+  }
+  if (!allNumeric && typeof value === "bigint") {
+    const num = Number(value);
+    if (Number.isInteger(num) && num >= 0 && num < enumValues.length) {
+      return enumValues[num];
+    }
+  }
+  throw new Error(`Cannot coerce value to enum`);
+}
+
+// src/coercers/intersection.ts
+function coerceToIntersection(value, left, right, coerceLeft, coerceRight, tracker = new CircularTracker) {
+  const leftTypeName = left._def.type || left._def.typeName;
+  const rightTypeName = right._def.type || right._def.typeName;
+  const leftIsObjectLike = leftTypeName === "object" || leftTypeName === "intersection";
+  const rightIsObjectLike = rightTypeName === "object" || rightTypeName === "intersection";
+  if (leftIsObjectLike && rightIsObjectLike) {
+    const leftResult = coerceLeft(value, tracker);
+    return coerceRight(leftResult, tracker);
+  }
+  if (leftTypeName === "record" && rightTypeName === "object" || leftTypeName === "object" && rightTypeName === "record") {
+    const leftResult = coerceLeft(value, tracker);
+    return coerceRight(leftResult, tracker);
+  }
+  if (leftTypeName === "union" && rightTypeName === "union") {
+    const leftResult = coerceLeft(value, tracker);
+    const rightValidation = right.safeParse(leftResult);
+    if (rightValidation.success) {
+      return leftResult;
+    }
+    const rightResult = coerceRight(value, tracker);
+    const leftValidation = left.safeParse(rightResult);
+    if (leftValidation.success) {
+      return rightResult;
+    }
+    return value;
+  }
+  if (leftTypeName === "literal" && rightTypeName === "string" || leftTypeName === "string" && rightTypeName === "literal") {
+    const literalSchema = leftTypeName === "literal" ? left : right;
+    const literalValues = literalSchema._def.values;
+    const literalValue = Array.isArray(literalValues) ? literalValues[0] : literalValues;
+    if (typeof value === "string" && typeof literalValue === "string") {
+      if (value.toLowerCase() === literalValue.toLowerCase()) {
+        return literalValue;
+      }
+    }
+    return value;
+  }
+  if (leftTypeName === "string" && rightTypeName === "object" || leftTypeName === "object" && rightTypeName === "string") {
+    return value;
+  }
+  if (leftTypeName === "array" && rightTypeName === "object" || leftTypeName === "object" && rightTypeName === "array") {
+    return value;
+  }
+  return value;
+}
+
+// src/coercers/string.ts
+function coerceToString(value, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (typeof value === "string")
+    return value;
+  if (value === null)
+    return "";
+  if (value === undefined)
+    return "";
+  const skipExtract = Array.isArray(value) || value instanceof Set || value instanceof Map || ArrayBuffer.isView(value);
+  if (!skipExtract) {
+    const extracted = extractPrimitiveValue(value, "string");
+    if (typeof extracted === "string")
+      return extracted;
+    if (typeof extracted !== "object" || extracted === null) {
+      return String(extracted);
+    }
+    if (extracted !== value) {
+      return coerceToString(extracted, tracker);
+    }
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "symbol")
+    return value.toString();
+  if (typeof value === "function")
+    return value.toString();
+  if (value instanceof RegExp)
+    return value.toString();
+  if (value instanceof Error)
+    return value.message || value.toString();
+  if (Array.isArray(value)) {
+    if (value.toString !== Array.prototype.toString) {
+      return value.toString();
+    }
+    return value.map((v) => {
+      if (Array.isArray(v)) {
+        return JSON.stringify(v).replace(/,/g, ", ");
+      }
+      if (typeof v === "object" && v !== null && !(v instanceof Date) && !(v instanceof RegExp) && !(v instanceof Error)) {
+        return String(v);
+      }
+      return coerceToString(v, tracker);
+    }).join(", ");
+  }
+  if (value instanceof Map) {
+    const entries = Array.from(value.entries());
+    return entries.map(([k, v]) => `${coerceToString(k, tracker)}: ${coerceToString(v, tracker)}`).join(", ");
+  }
+  if (value instanceof Set) {
+    return Array.from(value).map((v) => coerceToString(v, tracker)).join(", ");
+  }
+  if (ArrayBuffer.isView(value)) {
+    return Array.from(value).join(", ");
+  }
+  return isPlainObject(value) ? formatPlainObject(value, tracker) : String(value);
+}
+function formatPlainObject(value, tracker) {
+  return Object.entries(value).filter(([_, v]) => v !== null && v !== undefined && v !== "").map(([k, v]) => {
+    if (typeof v === "object" && v !== null && tracker.has(v)) {
+      throwCircular();
+    }
+    if (typeof v === "object" && v !== null && !(v instanceof Date) && !(v instanceof RegExp) && !(v instanceof Error)) {
+      return `${k}: ${String(v)}`;
+    }
+    return `${k}: ${coerceToString(v, tracker)}`;
+  }).join(", ");
+}
+
+// src/coercers/literal.ts
+function coerceToLiteral(value, literalValue) {
+  if (value === literalValue)
+    return literalValue;
+  if (typeof literalValue === "string") {
+    if (literalValue === "" && value === null) {
+      return literalValue;
+    }
+    const coerced = coerceToString(value);
+    if (normalizeString(coerced) === normalizeString(literalValue)) {
+      return literalValue;
+    }
+  }
+  if (typeof literalValue === "number") {
+    const coerced = coerceToNumber(value);
+    const matchesNumber = coerced === literalValue || isNaN(coerced) && isNaN(literalValue);
+    const matchesSignedZero = Object.is(coerced, literalValue);
+    if (matchesNumber || matchesSignedZero) {
+      return literalValue;
+    }
+  }
+  if (typeof literalValue === "boolean") {
+    const coerced = coerceToBoolean(value);
+    if (coerced === literalValue) {
+      return literalValue;
+    }
+  }
+  if (typeof literalValue === "bigint") {
+    try {
+      const coerced = coerceToBigInt(value);
+      if (coerced === literalValue) {
+        return literalValue;
+      }
+    } catch {}
+  }
+  if (literalValue === null) {
+    if (isFalsyForNull(value)) {
+      return null;
+    }
+  }
+  throw new Error(`Cannot coerce value to literal ${literalValue}`);
+}
+
+// src/coercers/map-set.ts
+function coerceToMap(value, keySchema, valueSchema, coerceKey, coerceValue, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (value instanceof Map) {
+    const result = new Map;
+    for (const [k, v] of value.entries()) {
+      result.set(coerceKey(k, tracker), coerceValue(v, tracker));
+    }
+    return result;
+  }
+  if (isPlainObject(value)) {
+    const result = new Map;
+    for (const [k, v] of Object.entries(value)) {
+      result.set(coerceKey(k, tracker), coerceValue(v, tracker));
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    if (value.every((item) => Array.isArray(item) && item.length === 2)) {
+      const result = new Map;
+      for (const [k, v] of value) {
+        result.set(coerceKey(k, tracker), coerceValue(v, tracker));
+      }
+      return result;
+    }
+    throw new Error("Cannot convert non-pair array to Map");
+  }
+  if (typeof value === "string")
+    return coerceMapFromString(value, keySchema, valueSchema, coerceKey, coerceValue, tracker);
+  throw new Error("Cannot convert value to Map");
+}
+function coerceToSet(value, elementSchema, coerceElement, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (value instanceof Set) {
+    const result = new Set;
+    for (const item of value) {
+      result.add(coerceElement(item, tracker));
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    const result = new Set;
+    for (const item of value) {
+      result.add(coerceElement(item, tracker));
+    }
+    return result;
+  }
+  if (typeof value === "string")
+    return coerceSetFromString(value, elementSchema, coerceElement, tracker);
+  if (isPlainObject(value)) {
+    const result = new Set;
+    for (const val of Object.values(value)) {
+      result.add(coerceElement(val, tracker));
+    }
+    return result;
+  }
+  throw new Error("Cannot convert value to Set");
+}
+function coerceMapFromString(raw, keySchema, valueSchema, coerceKey, coerceValue, tracker) {
+  const json = tryParseJSON(raw);
+  if (json === null) {
+    throw new Error("Cannot convert string to Map");
+  }
+  return coerceToMap(json, keySchema, valueSchema, coerceKey, coerceValue, tracker);
+}
+function coerceSetFromString(raw, elementSchema, coerceElement, tracker) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const json = tryParseJSON(trimmed);
+    if (!Array.isArray(json)) {
+      throw new Error("Cannot convert string to Set");
+    }
+    return coerceToSet(json, elementSchema, coerceElement, tracker);
+  }
+  const csv = tryParseCSV(trimmed);
+  if (csv) {
+    const result = new Set;
+    for (const item of csv) {
+      result.add(coerceElement(item, tracker));
+    }
+    return result;
+  }
+  throw new Error("Cannot convert string to Set");
+}
+
+// src/coercers/nan.ts
+function coerceToNaN(value) {
+  if (typeof value === "number" && isNaN(value))
+    return NaN;
+  if (value === undefined)
+    return NaN;
+  if (typeof value === "function")
+    return NaN;
+  if (typeof value === "symbol")
+    return NaN;
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === "nan")
+      return NaN;
+    const num = Number(trimmed);
+    if (isNaN(num))
+      return NaN;
+    throw new Error("Cannot coerce valid number to NaN");
+  }
+  if (Array.isArray(value) || typeof value === "object") {
+    const num = Number(value);
+    if (isNaN(num))
+      return NaN;
+    throw new Error("Cannot coerce valid value to NaN");
+  }
+  throw new Error("Cannot coerce valid value to NaN");
+}
+
+// src/coercers/null.ts
+function coerceToNull(value) {
+  if (value === null)
+    return null;
+  if (isFalsyForNull(value))
+    return null;
+  throw new Error("Cannot coerce non-falsy value to null");
+}
+
+// src/coercers/object.ts
+function coerceToObject(value, shape, coerceProperty, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (isPlainObject(value)) {
+    const extracted = extractPrimitiveValue(value, "default");
+    if (extracted !== value) {
+      return coerceToObject(extracted, shape, coerceProperty, tracker);
+    }
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = coerceProperty(key, val, tracker);
+    }
+    return result;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return {};
+    const json = tryParseJSON(trimmed);
+    if (isPlainObject(json)) {
+      return coerceToObject(json, shape, coerceProperty, tracker);
+    }
+    throw new Error("Cannot convert string to object");
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return {};
+    if (value.every((item) => Array.isArray(item) && item.length === 2)) {
+      const result2 = {};
+      for (const [key, val] of value) {
+        const keyStr = String(key);
+        result2[keyStr] = coerceProperty(keyStr, val, tracker);
+      }
+      return result2;
+    }
+    const result = {};
+    value.forEach((val, i) => {
+      const key = String(i);
+      result[key] = coerceProperty(key, val, tracker);
+    });
+    return result;
+  }
+  if (value instanceof Map) {
+    const result = {};
+    for (const [key, val] of value.entries()) {
+      const keyStr = String(key);
+      result[keyStr] = coerceProperty(keyStr, val, tracker);
+    }
+    return result;
+  }
+  if (value instanceof Set) {
+    const result = {};
+    let index = 0;
+    for (const val of value) {
+      const key = String(index);
+      result[key] = coerceProperty(key, val, tracker);
+      index++;
+    }
+    return result;
+  }
+  if (value === null || value === undefined)
+    return {};
+  if (typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = coerceProperty(key, value[key], tracker);
+    }
+    return result;
+  }
+  throw new Error("Cannot convert primitive to object");
+}
+
+// src/coercers/record.ts
+function coerceToRecord(value, valueSchema, coerceValue, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (canBeCircular(val) && tracker.has(val)) {
+        throwCircular();
+      }
+      result[key] = coerceValue(val, tracker);
+    }
+    return result;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return {};
+    const json = tryParseJSON(trimmed);
+    if (isPlainObject(json)) {
+      return coerceToRecord(json, valueSchema, coerceValue, tracker);
+    }
+    throw new Error("Cannot convert string to record");
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return {};
+    if (value.every((item) => Array.isArray(item) && item.length === 2)) {
+      const result2 = {};
+      for (const [key, val] of value) {
+        if (canBeCircular(val) && tracker.has(val)) {
+          throwCircular();
+        }
+        result2[String(key)] = coerceValue(val, tracker);
+      }
+      return result2;
+    }
+    const result = {};
+    value.forEach((val, index) => {
+      if (canBeCircular(val) && tracker.has(val)) {
+        throwCircular();
+      }
+      result[String(index)] = coerceValue(val, tracker);
+    });
+    return result;
+  }
+  if (value instanceof Map) {
+    const result = {};
+    for (const [key, val] of value.entries()) {
+      if (canBeCircular(val) && tracker.has(val)) {
+        throwCircular();
+      }
+      result[String(key)] = coerceValue(val, tracker);
+    }
+    return result;
+  }
+  if (value instanceof Set) {
+    const result = {};
+    let index = 0;
+    for (const val of value) {
+      if (canBeCircular(val) && tracker.has(val)) {
+        throwCircular();
+      }
+      result[String(index)] = coerceValue(val, tracker);
+      index++;
+    }
+    return result;
+  }
+  if (value === null || value === undefined)
+    return {};
+  if (typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const val = value[key];
+      if (canBeCircular(val) && tracker.has(val)) {
+        throwCircular();
+      }
+      result[key] = coerceValue(val, tracker);
+    }
+    return result;
+  }
+  throw new Error("Cannot convert primitive to record");
+}
+
+// src/coercers/tuple.ts
+function coerceToTuple(value, items, coerceElement, tracker = new CircularTracker) {
+  if (canBeCircular(value) && tracker.has(value)) {
+    throwCircular();
+  }
+  if (Array.isArray(value)) {
+    tracker.add(value);
+    const result = [];
+    for (let i = 0;i < items.length; i++) {
+      if (i < value.length) {
+        result.push(coerceElement(i, value[i], tracker));
+      } else {
+        result.push(undefined);
+      }
+    }
+    return result;
+  }
+  if (canBeCircular(value)) {
+    tracker.add(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "" || trimmed === "null") {
+      const result = [];
+      for (let i = 0;i < items.length; i++) {
+        result.push(undefined);
+      }
+      return result;
+    }
+    const json = tryParseJSON(trimmed);
+    if (Array.isArray(json)) {
+      return coerceToTuple(json, items, coerceElement, tracker);
+    }
+    const csv = tryParseCSV(trimmed);
+    if (csv) {
+      return coerceToTuple(csv, items, coerceElement, tracker);
+    }
+    throw new Error("Cannot convert non-array string to tuple");
+  }
+  if (value === null) {
+    const result = [];
+    for (let i = 0;i < items.length; i++) {
+      result.push(undefined);
+    }
+    return result;
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const obj = value;
+    if (isArrayLike(value)) {
+      const result = [];
+      for (let i = 0;i < items.length; i++) {
+        if (i in obj) {
+          result.push(coerceElement(i, obj[i], tracker));
+        } else {
+          result.push(undefined);
+        }
+      }
+      return result;
+    }
+    let hasNumericKeys = false;
+    for (let i = 0;i < items.length; i++) {
+      if (i in obj) {
+        hasNumericKeys = true;
+        break;
+      }
+    }
+    if (hasNumericKeys)
+      return items.map((_, i) => (i in obj) ? coerceElement(i, obj[i], tracker) : undefined);
+  }
+  throw new Error("Cannot convert non-array to tuple");
+}
+
+// src/coercers/union.ts
+function coerceToUnion(value, options, coerceOption, tracker = new CircularTracker) {
+  const errors = [];
+  const isPrimitive = typeof value !== "object" || value === null;
+  const isString = typeof value === "string";
+  const isDate = value instanceof Date;
+  if (isPrimitive && !isString || isDate) {
+    for (let i = 0;i < options.length; i++) {
+      const directResult = options[i].safeParse(value);
+      if (directResult.success) {
+        return value;
+      }
+    }
+  }
+  const objectCandidate = tryObjectFirstCoercion(value, options, tracker, coerceOption);
+  if (objectCandidate !== undefined) {
+    return objectCandidate;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0;i < options.length; i++) {
+      const option = options[i];
+      const type = option._def?.type || option._def.typeName;
+      if (type === "array" || type === "ZodArray") {
+        try {
+          const coerced = coerceOption(i, value, tracker);
+          const coercedResult = options[i].safeParse(coerced);
+          if (coercedResult.success) {
+            return coerced;
+          }
+        } catch {}
+      }
+    }
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const trimmed = value.trim();
+    if (trimmed.includes(",") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      for (let i = 0;i < options.length; i++) {
+        const option = options[i];
+        const type = option._def?.type || option._def.typeName;
+        if (type === "array" || type === "ZodArray") {
+          try {
+            const coerced = coerceOption(i, value, tracker);
+            const coercedResult = options[i].safeParse(coerced);
+            if (coercedResult.success) {
+              return coerced;
+            }
+          } catch {}
+        }
+      }
+    }
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const trimmed = value.trim().toLowerCase();
+    const nonNumericBooleanStrings = [
+      "true",
+      "false",
+      "yes",
+      "no",
+      "on",
+      "off",
+      "y",
+      "n",
+      "t",
+      "f",
+      "enabled",
+      "disabled"
+    ];
+    if (nonNumericBooleanStrings.includes(trimmed)) {
+      for (let i = 0;i < options.length; i++) {
+        const option = options[i];
+        const type = option._def?.type || option._def.typeName;
+        if (type === "boolean") {
+          try {
+            const coerced = coerceOption(i, value, tracker);
+            const coercedResult = options[i].safeParse(coerced);
+            if (coercedResult.success) {
+              return coerced;
+            }
+          } catch {}
+        }
+      }
+    }
+  }
+  if (options.length > 0) {
+    const attempt = executeUnionAttempt(0, value, options, tracker, coerceOption);
+    if (attempt.status === "success") {
+      return attempt.value;
+    }
+    if (attempt.status === "validation") {
+      errors.push(new Error(`Coercion to first type failed validation`));
+    } else if (attempt.error) {
+      errors.push(attempt.error);
+    }
+  }
+  for (let i = 1;i < options.length; i++) {
+    const attempt = executeUnionAttempt(i, value, options, tracker, coerceOption);
+    if (attempt.status === "success") {
+      return attempt.value;
+    }
+    if (attempt.status === "validation") {
+      errors.push(new Error(`Coerced value does not match schema`));
+    } else if (attempt.error) {
+      errors.push(attempt.error);
+    }
+  }
+  throw new Error(`Cannot coerce value to any union type: ${errors.map((e) => e.message).join(", ")}`);
+}
+function tryObjectFirstCoercion(value, options, _tracker, coerceOption) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) {
+    return;
+  }
+  for (let i = 0;i < options.length; i++) {
+    const option = options[i];
+    const type = option._def?.type || option._def.typeName;
+    if (type === "object" || type === "ZodObject" || type === "record") {
+      try {
+        const attemptTracker = new CircularTracker;
+        const coerced = coerceOption(i, value, attemptTracker);
+        const coercedResult = options[i].safeParse(coerced);
+        if (coercedResult.success) {
+          return coerced;
+        }
+      } catch {}
+    }
+  }
+  return;
+}
+function executeUnionAttempt(index, value, options, tracker, coerceOption) {
+  try {
+    const coerced = coerceOption(index, value, tracker);
+    const coercedResult = options[index].safeParse(coerced);
+    if (coercedResult.success) {
+      return { status: "success", value: coerced };
+    }
+    return { status: "validation" };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Circular reference")) {
+      throw error;
+    }
+    return { status: "error", error };
+  }
+}
+// src/create-schema.ts
+import * as z from "zod";
+var primitiveFactories = {
+  string: () => z.coerce.string(),
+  number: () => z.coerce.number(),
+  boolean: () => getStringBool(),
+  null: () => getNullCoercion()
+};
+function createCanonizePrimitive(primitive) {
+  return primitiveFactories[primitive]();
+}
+function createCanonizeSchema(schema) {
+  const shape = Object.fromEntries(Object.entries(schema).map(([key, primitive]) => [
+    key,
+    createCanonizePrimitive(primitive)
+  ]));
+  return z.object(shape);
+}
+var coerceHelpers = z.coerce;
+var stringBoolFactory = typeof coerceHelpers.stringbool === "function" ? () => coerceHelpers.stringbool() : () => z.preprocess((value) => coerceToBoolean(value), z.boolean());
+var nullFactory = typeof coerceHelpers.null === "function" ? () => coerceHelpers.null() : () => z.preprocess((value) => coerceToNull(value), z.null());
+function getStringBool() {
+  return stringBoolFactory();
+}
+function getNullCoercion() {
+  return nullFactory();
+}
+
+// src/index.ts
+function coerceValue(schema, value, tracker = new CircularTracker) {
+  const typeName = getZodTypeName(schema);
+  if (typeName === ZodType.OPTIONAL) {
+    if (value === undefined)
+      return;
+    return coerceValue(schema._def.innerType, value, tracker);
+  }
+  if (typeName === ZodType.NULLABLE) {
+    if (value === null)
+      return null;
+    if (value === "") {
+      return null;
+    }
+    return coerceValue(schema._def.innerType, value, tracker);
+  }
+  if (typeName === ZodType.DEFAULT) {
+    if (value === undefined)
+      return schema._def.defaultValue();
+    return coerceValue(schema._def.innerType, value, tracker);
+  }
+  if (typeName === ZodType.CATCH) {
+    return coerceValue(schema._def.innerType, value, tracker);
+  }
+  if (typeName === ZodType.READONLY) {
+    const result = coerceValue(schema._def.innerType, value, tracker);
+    if (typeof result === "object" && result !== null) {
+      return Object.freeze(result);
+    }
+    return result;
+  }
+  if (typeName === ZodType.LAZY) {
+    const lazySchema = schema._def.getter();
+    return coerceValue(lazySchema, value, tracker);
+  }
+  if (typeName === ZodType.STRING) {
+    return coerceToString(value, tracker);
+  }
+  if (typeName === ZodType.NUMBER) {
+    const num = coerceToNumber(value);
+    const defData = schema._def;
+    if (defData.check === "number_format" && defData.format === "safeint") {
+      return coerceToInteger(num);
+    }
+    if (defData.check === "number_format" && defData.format === "int32") {
+      return coerceToInt32(num);
+    }
+    return num;
+  }
+  if (typeName === ZodType.BOOLEAN) {
+    return coerceToBoolean(value);
+  }
+  if (typeName === ZodType.DATE) {
+    return coerceToDate(value);
+  }
+  if (typeName === ZodType.BIGINT) {
+    return coerceToBigInt(value);
+  }
+  if (typeName === ZodType.NULL) {
+    return coerceToNull(value);
+  }
+  if (typeName === ZodType.NAN) {
+    return coerceToNaN(value);
+  }
+  if (typeName === ZodType.ANY || typeName === ZodType.UNKNOWN) {
+    return value;
+  }
+  if (typeName === ZodType.CUSTOM) {
+    return coerceCustomSchema(schema, value, tracker);
+  }
+  if (typeName === ZodType.NEVER) {
+    throw new Error("Cannot coerce to never type");
+  }
+  if (typeName === ZodType.ARRAY) {
+    const elementSchema = schema._def.element;
+    return coerceToArray(value, elementSchema, (v, t) => coerceValue(elementSchema, v, t), tracker);
+  }
+  if (typeName === ZodType.OBJECT) {
+    const shape = schema._def.shape;
+    return coerceToObject(value, shape, (key, v, t) => {
+      if (key in shape) {
+        return coerceValue(shape[key], v, t);
+      }
+      return v;
+    }, tracker);
+  }
+  if (typeName === ZodType.TUPLE) {
+    const items = schema._def.items;
+    return coerceToTuple(value, items, (index, v, t) => coerceValue(items[index], v, t), tracker);
+  }
+  if (typeName === ZodType.RECORD) {
+    const valueType = schema._def.valueType;
+    return coerceToRecord(value, valueType, (v, t) => coerceValue(valueType, v, t), tracker);
+  }
+  if (typeName === ZodType.ENUM) {
+    const defData = schema._def;
+    const entries = defData.entries;
+    const allValues = Object.values(entries);
+    const hasNumbers = allValues.some((v) => typeof v === "number");
+    const validValues = hasNumbers ? allValues.filter((v) => typeof v === "number") : Array.from(new Set(allValues));
+    return coerceToEnum(value, validValues, entries);
+  }
+  if (typeName === ZodType.LITERAL) {
+    const defData = schema._def;
+    const literalValue = defData.values[0];
+    return coerceToLiteral(value, literalValue);
+  }
+  if (typeName === ZodType.UNION && schema._def.discriminator) {
+    const discriminator = schema._def.discriminator;
+    const options = schema._def.options;
+    return coerceToDiscriminatedUnion(value, discriminator, options, (index, v, t) => coerceValue(options[index], v, t), tracker);
+  }
+  if (typeName === ZodType.UNION) {
+    const options = schema._def.options;
+    return coerceToUnion(value, options, (index, v, t) => coerceValue(options[index], v, t), tracker);
+  }
+  if (typeName === ZodType.INTERSECTION) {
+    const left = schema._def.left;
+    const right = schema._def.right;
+    return coerceToIntersection(value, left, right, (v, t) => coerceValue(left, v, t), (v, t) => coerceValue(right, v, t), tracker);
+  }
+  if (typeName === ZodType.MAP) {
+    const keyType = schema._def.keyType;
+    const valueType = schema._def.valueType;
+    return coerceToMap(value, keyType, valueType, (v, t) => coerceValue(keyType, v, t), (v, t) => coerceValue(valueType, v, t), tracker);
+  }
+  if (typeName === ZodType.SET) {
+    return coerceSetSchema(value, schema, tracker);
+  }
+  return value;
+}
+function coerceSetSchema(value, schema, tracker) {
+  const valueType = schema._def.valueType;
+  return coerceToSet(value, valueType, (v, t) => coerceValue(valueType, v, t), tracker);
+}
+function coerceCustomSchema(schema, value, tracker) {
+  const defData = schema._def;
+  const predicate = typeof defData?.fn === "function" ? defData.fn : null;
+  if (!predicate) {
+    return value;
+  }
+  const attempts = [
+    () => value,
+    () => coerceToDate(value),
+    () => coerceToNumber(value),
+    () => coerceToBigInt(value),
+    () => coerceToBoolean(value),
+    () => coerceToString(value, tracker)
+  ];
+  for (const attempt of attempts) {
+    let coerced;
+    try {
+      coerced = attempt();
+    } catch {
+      continue;
+    }
+    try {
+      if (predicate(coerced)) {
+        return coerced;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return value;
+}
+function canonize(schema) {
+  const preprocessed = z2.preprocess((value) => {
+    try {
+      return coerceValue(schema, value);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Circular reference")) {
+        throw error;
+      }
+      return value;
+    }
+  }, schema);
+  return preprocessed;
+}
+export {
+  unwrapSchema,
+  getZodTypeName,
+  createCanonizeSchema,
+  createCanonizePrimitive,
+  canonize,
+  ZodType,
+  CircularTracker
+};
+
+//# debugId=4135B5B30AC609E164756E2164756E21