@ray-js/robot-data-stream 0.0.16-beta.2 → 0.0.16-beta.4

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

@@ -1,816 +0,0 @@
-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