@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.1

package/lib/myLib/zod/src/v4/core/checks.js

@@ -0,0 +1,816 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+// import { $ZodType } from "./schemas.js";
+
+import * as core from "./core.js";
+import * as regexes from "./regexes.js";
+import * as util from "./util.js";
+
+//////////////////////////////   CHECKS   ///////////////////////////////////////
+
+export const $ZodCheck = /*@__PURE__*/core.$constructor("$ZodCheck", (inst, def) => {
+  inst._zod ??= {};
+  inst._zod.def = def;
+  inst._zod.onattach ??= [];
+});
+
+///////////////////////////////////////
+/////      $ZodCheckLessThan      /////
+///////////////////////////////////////
+
+const numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+export const $ZodCheckLessThan = /*@__PURE__*/core.$constructor("$ZodCheckLessThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push(inst => {
+    var _ref;
+    const bag = inst._zod.bag;
+    const curr = (_ref = def.inclusive ? bag.maximum : bag.exclusiveMaximum) !== null && _ref !== void 0 ? _ref : Number.POSITIVE_INFINITY;
+    if (def.value < curr) {
+      if (def.inclusive) bag.maximum = def.value;else bag.exclusiveMaximum = def.value;
+    }
+  });
+  inst._zod.check = payload => {
+    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckGreaterThan    /////
+/////////////////////////////////////
+
+export const $ZodCheckGreaterThan = /*@__PURE__*/core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push(inst => {
+    var _ref2;
+    const bag = inst._zod.bag;
+    const curr = (_ref2 = def.inclusive ? bag.minimum : bag.exclusiveMinimum) !== null && _ref2 !== void 0 ? _ref2 : Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive) bag.minimum = def.value;else bag.exclusiveMinimum = def.value;
+    }
+  });
+  inst._zod.check = payload => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckMultipleOf    /////
+/////////////////////////////////////
+// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
+
+export const $ZodCheckMultipleOf = /*@__PURE__*/core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push(inst => {
+    inst._zod.bag.multipleOf ??= def.value;
+  });
+  inst._zod.check = payload => {
+    if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
+    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : util.floatSafeRemainder(payload.value, def.value) === 0;
+    if (isMultiple) return;
+    payload.issues.push({
+      origin: typeof payload.value,
+      code: "not_multiple_of",
+      divisor: def.value,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckFinite    /////
+/////////////////////////////////////
+// interface $ZodCheckFiniteDef extends $ZodCheckDef {
+//   check: "finite";
+// }
+
+// export interface $ZodCheckFinite extends $ZodCheckInternals<number> {
+//   _def: $ZodCheckFiniteDef;
+//   _issc:
+//     | errors.$ZodIssueTooBig<"number", number>
+//     | errors.$ZodIssueTooSmall<"number", number>;
+// }
+
+// export const $ZodCheckFinite: core.$constructor<$ZodCheckFinite> =
+//   core.$constructor("$ZodCheckFinite", (inst, def) => {
+//     $ZodCheck.init(inst, def);
+
+//     inst._zod.onattach = (inst) => {
+//       inst["_bag"].finite = true;
+//     };
+
+//     inst._zod.check = (payload) => {
+//       if (Number.isFinite(payload.value)) return;
+//       payload.issues.push({
+//         origin: "number",
+//         ...(payload.value === Number.POSITIVE_INFINITY
+//           ? {
+//               code: "too_big",
+//               maximum: Number.POSITIVE_INFINITY,
+//             }
+//           : {
+//               code: "too_small",
+//               minimum: Number.NEGATIVE_INFINITY,
+//             }),
+//         // code: payload.value === Number.POSITIVE_INFINITY ? "too_big" : "too_big",
+//         // maximum: Number.POSITIVE_INFINITY,
+//         inclusive: false,
+//         input: payload.value,
+//         inst,
+//       });
+//     };
+//   });
+
+///////////////////////////////////////
+/////    $ZodCheckNumberFormat    /////
+///////////////////////////////////////
+
+export const $ZodCheckNumberFormat = /*@__PURE__*/core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
+  var _def$format;
+  $ZodCheck.init(inst, def); // no format checks
+  def.format = def.format || "float64";
+  const isInt = (_def$format = def.format) === null || _def$format === void 0 ? void 0 : _def$format.includes("int");
+  const origin = isInt ? "int" : "number";
+  const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    bag.minimum = minimum;
+    bag.maximum = maximum;
+    if (isInt) bag.pattern = regexes.integer;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    if (isInt) {
+      if (!Number.isInteger(input)) {
+        // invalid_format issue
+        // payload.issues.push({
+        //   expected: def.format,
+        //   format: def.format,
+        //   code: "invalid_format",
+        //   input,
+        //   inst,
+        // });
+        // invalid_type issue
+        payload.issues.push({
+          expected: origin,
+          format: def.format,
+          code: "invalid_type",
+          continue: false,
+          input,
+          inst
+        });
+        return;
+
+        // not_multiple_of issue
+        // payload.issues.push({
+        //   code: "not_multiple_of",
+        //   origin: "number",
+        //   input,
+        //   inst,
+        //   divisor: 1,
+        // });
+      }
+      if (!Number.isSafeInteger(input)) {
+        if (input > 0) {
+          // too_big
+          payload.issues.push({
+            input,
+            code: "too_big",
+            maximum: Number.MAX_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        } else {
+          // too_small
+          payload.issues.push({
+            input,
+            code: "too_small",
+            minimum: Number.MIN_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        }
+        return;
+      }
+    }
+    if (input < minimum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_small",
+        minimum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+    if (input > maximum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_big",
+        maximum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckBigIntFormat    /////
+/////////////////////////////////////
+
+export const $ZodCheckBigIntFormat = /*@__PURE__*/core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
+  $ZodCheck.init(inst, def); // no format checks
+
+  const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    bag.minimum = minimum;
+    bag.maximum = maximum;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    if (input < minimum) {
+      payload.issues.push({
+        origin: "bigint",
+        input,
+        code: "too_small",
+        minimum: minimum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+    if (input > maximum) {
+      payload.issues.push({
+        origin: "bigint",
+        input,
+        code: "too_big",
+        maximum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+
+//////////////////////////////////
+/////    $ZodCheckMaxSize    /////
+//////////////////////////////////
+
+export const $ZodCheckMaxSize = /*@__PURE__*/core.$constructor("$ZodCheckMaxSize", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.size !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    var _inst$_zod$bag$maximu;
+    const curr = (_inst$_zod$bag$maximu = inst._zod.bag.maximum) !== null && _inst$_zod$bag$maximu !== void 0 ? _inst$_zod$bag$maximu : Number.POSITIVE_INFINITY;
+    if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const size = input.size;
+    if (size <= def.maximum) return;
+    payload.issues.push({
+      origin: util.getSizableOrigin(input),
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+//////////////////////////////////
+/////    $ZodCheckMinSize    /////
+//////////////////////////////////
+
+export const $ZodCheckMinSize = /*@__PURE__*/core.$constructor("$ZodCheckMinSize", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.size !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    var _inst$_zod$bag$minimu;
+    const curr = (_inst$_zod$bag$minimu = inst._zod.bag.minimum) !== null && _inst$_zod$bag$minimu !== void 0 ? _inst$_zod$bag$minimu : Number.NEGATIVE_INFINITY;
+    if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const size = input.size;
+    if (size >= def.minimum) return;
+    payload.issues.push({
+      origin: util.getSizableOrigin(input),
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckSizeEquals    /////
+/////////////////////////////////////
+
+export const $ZodCheckSizeEquals = /*@__PURE__*/core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.size !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.minimum = def.size;
+    bag.maximum = def.size;
+    bag.size = def.size;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const size = input.size;
+    if (size === def.size) return;
+    const tooBig = size > def.size;
+    payload.issues.push(_objectSpread(_objectSpread({
+      origin: util.getSizableOrigin(input)
+    }, tooBig ? {
+      code: "too_big",
+      maximum: def.size
+    } : {
+      code: "too_small",
+      minimum: def.size
+    }), {}, {
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    }));
+  };
+});
+
+//////////////////////////////////
+/////    $ZodCheckMaxLength    /////
+//////////////////////////////////
+
+export const $ZodCheckMaxLength = /*@__PURE__*/core.$constructor("$ZodCheckMaxLength", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.length !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    var _inst$_zod$bag$maximu2;
+    const curr = (_inst$_zod$bag$maximu2 = inst._zod.bag.maximum) !== null && _inst$_zod$bag$maximu2 !== void 0 ? _inst$_zod$bag$maximu2 : Number.POSITIVE_INFINITY;
+    if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const length = input.length;
+    if (length <= def.maximum) return;
+    const origin = util.getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+//////////////////////////////////
+/////    $ZodCheckMinLength    /////
+//////////////////////////////////
+
+export const $ZodCheckMinLength = /*@__PURE__*/core.$constructor("$ZodCheckMinLength", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.length !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    var _inst$_zod$bag$minimu2;
+    const curr = (_inst$_zod$bag$minimu2 = inst._zod.bag.minimum) !== null && _inst$_zod$bag$minimu2 !== void 0 ? _inst$_zod$bag$minimu2 : Number.NEGATIVE_INFINITY;
+    if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const length = input.length;
+    if (length >= def.minimum) return;
+    const origin = util.getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckLengthEquals    /////
+/////////////////////////////////////
+
+export const $ZodCheckLengthEquals = /*@__PURE__*/core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.def.when ??= payload => {
+    const val = payload.value;
+    return !util.nullish(val) && val.length !== undefined;
+  };
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = payload => {
+    const input = payload.value;
+    const length = input.length;
+    if (length === def.length) return;
+    const origin = util.getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push(_objectSpread(_objectSpread({
+      origin
+    }, tooBig ? {
+      code: "too_big",
+      maximum: def.length
+    } : {
+      code: "too_small",
+      minimum: def.length
+    }), {}, {
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    }));
+  };
+});
+
+/////////////////////////////////////////////
+/////    $ZodCheckStringFormatRegex    /////
+/////////////////////////////////////////////
+
+export const $ZodCheckStringFormat = /*@__PURE__*/core.$constructor("$ZodCheckStringFormat", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    if (def.pattern) {
+      bag.patterns ??= new Set();
+      bag.patterns.add(def.pattern);
+    }
+  });
+  if (def.pattern) inst._zod.check ??= payload => {
+    def.pattern.lastIndex = 0;
+    if (def.pattern.test(payload.value)) return;
+    payload.issues.push(_objectSpread(_objectSpread({
+      origin: "string",
+      code: "invalid_format",
+      format: def.format,
+      input: payload.value
+    }, def.pattern ? {
+      pattern: def.pattern.toString()
+    } : {}), {}, {
+      inst,
+      continue: !def.abort
+    }));
+  };else inst._zod.check ??= () => {};
+});
+
+////////////////////////////////
+/////    $ZodCheckRegex    /////
+////////////////////////////////
+
+export const $ZodCheckRegex = /*@__PURE__*/core.$constructor("$ZodCheckRegex", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  inst._zod.check = payload => {
+    def.pattern.lastIndex = 0;
+    if (def.pattern.test(payload.value)) return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: payload.value,
+      pattern: def.pattern.toString(),
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+///////////////////////////////////
+/////    $ZodCheckJSONString    /////
+///////////////////////////////////
+// interface $ZodCheckJSONStringDef extends $ZodCheckStringFormatDef<"json_string"> {
+//   // check: "string_format";
+//   // format: "json_string";
+//   // error?: errors.$ZodErrorMap<errors.$ZodIssueInvalidStringFormat> | undefined;
+// }
+
+// export interface $ZodCheckJSONString extends $ZodCheckStringFormat {
+//   _def: $ZodCheckJSONStringDef;
+// }
+
+// export const $ZodCheckJSONString: core.$constructor<$ZodCheckJSONString> = /*@__PURE__*/ core.$constructor(
+//   "$ZodCheckJSONString",
+//   (inst, def) => {
+//     $ZodCheck.init(inst, def);
+
+//     inst._zod.check = (payload) => {
+//       try {
+//         JSON.parse(payload.value);
+//         return;
+//       } catch (_) {
+//         payload.issues.push({
+//           origin: "string",
+//           code: "invalid_format",
+//           format: def.format,
+//           input: payload.value,
+//           inst,
+//           continue: !def.abort,
+//         });
+//       }
+//     };
+//   }
+// );
+
+//////////////////////////////////////
+/////    $ZodCheckLowerCase    /////
+//////////////////////////////////////
+
+export const $ZodCheckLowerCase = /*@__PURE__*/core.$constructor("$ZodCheckLowerCase", (inst, def) => {
+  def.pattern ??= regexes.lowercase;
+  $ZodCheckStringFormat.init(inst, def);
+});
+
+//////////////////////////////////////
+/////    $ZodCheckUpperCase    /////
+//////////////////////////////////////
+
+export const $ZodCheckUpperCase = /*@__PURE__*/core.$constructor("$ZodCheckUpperCase", (inst, def) => {
+  def.pattern ??= regexes.uppercase;
+  $ZodCheckStringFormat.init(inst, def);
+});
+
+///////////////////////////////////
+/////    $ZodCheckIncludes    /////
+///////////////////////////////////
+
+export const $ZodCheckIncludes = /*@__PURE__*/core.$constructor("$ZodCheckIncludes", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const escapedRegex = util.escapeRegex(def.includes);
+  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+  def.pattern = pattern;
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.patterns ??= new Set();
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = payload => {
+    if (payload.value.includes(def.includes, def.position)) return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "includes",
+      includes: def.includes,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+/////////////////////////////////////
+/////    $ZodCheckStartsWith    /////
+/////////////////////////////////////
+
+export const $ZodCheckStartsWith = /*@__PURE__*/core.$constructor("$ZodCheckStartsWith", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);
+  def.pattern ??= pattern;
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.patterns ??= new Set();
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = payload => {
+    if (payload.value.startsWith(def.prefix)) return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "starts_with",
+      prefix: def.prefix,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+//////////////////////////////////
+/////   $ZodCheckEndsWith    /////
+//////////////////////////////////
+
+export const $ZodCheckEndsWith = /*@__PURE__*/core.$constructor("$ZodCheckEndsWith", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);
+  def.pattern ??= pattern;
+  inst._zod.onattach.push(inst => {
+    const bag = inst._zod.bag;
+    bag.patterns ??= new Set();
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = payload => {
+    if (payload.value.endsWith(def.suffix)) return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "ends_with",
+      suffix: def.suffix,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+///////////////////////////////////
+/////    $ZodCheckProperty    /////
+///////////////////////////////////
+function handleCheckPropertyResult(result, payload, property) {
+  if (result.issues.length) {
+    payload.issues.push(...util.prefixIssues(property, result.issues));
+  }
+}
+export const $ZodCheckProperty = /*@__PURE__*/core.$constructor("$ZodCheckProperty", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.check = payload => {
+    const result = def.schema._zod.run({
+      value: payload.value[def.property],
+      issues: []
+    }, {});
+    if (result instanceof Promise) {
+      return result.then(result => handleCheckPropertyResult(result, payload, def.property));
+    }
+    handleCheckPropertyResult(result, payload, def.property);
+  };
+});
+
+///////////////////////////////////
+/////    $ZodCheckMimeType    /////
+///////////////////////////////////
+
+export const $ZodCheckMimeType = /*@__PURE__*/core.$constructor("$ZodCheckMimeType", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const mimeSet = new Set(def.mime);
+  inst._zod.onattach.push(inst => {
+    inst._zod.bag.mime = def.mime;
+  });
+  inst._zod.check = payload => {
+    if (mimeSet.has(payload.value.type)) return;
+    payload.issues.push({
+      code: "invalid_value",
+      values: def.mime,
+      input: payload.value.type,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+///////////////////////////////////
+/////    $ZodCheckFileName    /////
+///////////////////////////////////
+// interface $ZodCheckFileNameDef extends $ZodCheckDef {
+//   check: "file_name";
+//   fileName: string;
+//   error?: errors.$ZodErrorMap<errors.$ZodIssueInvalidType> | undefined;
+// }
+// export interface $ZodCheckFileName<T extends File = File>
+//   extends $ZodCheckInternals<T> {
+//   _def: $ZodCheckFileNameDef;
+// }
+
+// export const $ZodCheckFileName: core.$constructor<$ZodCheckFileName> =
+//   core.$constructor("$ZodCheckFileName", (inst, def) => {
+//     $ZodCheck.init(inst, def);
+
+//     inst._zod.check = (payload) => {
+//       if (def.fileName === payload.value.name) return;
+//       payload.issues.push({
+//         origin: "file",
+//         code: "invalid_value",
+//         options: [def.fileName],
+//         input: payload.value,
+//         path: ["name"],
+//         inst,
+//       });
+//     };
+//   });
+
+///////////////////////////////////
+/////    $ZodCheckOverwrite    /////
+///////////////////////////////////
+
+export const $ZodCheckOverwrite = /*@__PURE__*/core.$constructor("$ZodCheckOverwrite", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.check = payload => {
+    payload.value = def.tx(payload.value);
+  };
+});
+
+// ///////////////////////////////
+// /////    $ZodCheckTrim    /////
+// ///////////////////////////////
+// export interface $ZodCheckTrimDef extends $ZodCheckDef {
+//   check: "trim";
+//   error?: errors.$ZodErrorMap<never> | undefined;
+// }
+// export interface $ZodCheckTrim extends $ZodCheckInternals<string> {
+//   _def: $ZodCheckTrimDef;
+// }
+
+// export const $ZodCheckTrim: core.$constructor<$ZodCheckTrim> =
+//   core.$constructor("$ZodCheckTrim", (inst, def) => {
+//     $ZodCheck.init(inst, def);
+
+//     inst._zod.check = (payload) => {
+//       payload.value = payload.value.trim();
+//     };
+//   });
+
+// //////////////////////////////////////
+// /////    $ZodCheckNormalize    /////
+// //////////////////////////////////////
+// interface $ZodCheckNormalizeDef extends $ZodCheckDef {
+//   check: "normalize";
+//   error?: errors.$ZodErrorMap<never> | undefined;
+// }
+
+// export interface $ZodCheckNormalize extends $ZodCheckInternals<string> {
+//   _def: $ZodCheckNormalizeDef;
+// }
+
+// export const $ZodCheckNormalize: core.$constructor<$ZodCheckNormalize> =
+//   core.$constructor("$ZodCheckNormalize", (inst, def) => {
+//     $ZodCheck.init(inst, def);
+
+//     inst._zod.check = (payload) => {
+//       payload.value = payload.value.normalize();
+//     };
+//   });
+
+// union of string format schema types