@eslint-react/core 1.47.2-next.0 → 1.47.3-beta.0

package/dist/index.mjs

@@ -7,13 +7,9 @@ import * as VAR3 from '@eslint-react/var';
 import { isMatching, P, match } from 'ts-pattern';
 import birecord from 'birecord';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+// src/component/component-collector.ts
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/core.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer) {
   class _6 {
@@ -54,87 +50,6 @@ var globalConfig = {};
 function config(config2) {
   return globalConfig;
 }
-
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/util.js
-var util_exports = {};
-__export(util_exports, {
-  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
-  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
-  aborted: () => aborted,
-  allowsEval: () => allowsEval,
-  assert: () => assert,
-  assertEqual: () => assertEqual,
-  assertIs: () => assertIs,
-  assertNever: () => assertNever,
-  assertNotEqual: () => assertNotEqual,
-  assignProp: () => assignProp,
-  cached: () => cached,
-  cleanInterfaceKey: () => cleanInterfaceKey,
-  cleanInterfaceShape: () => cleanInterfaceShape,
-  cleanRegex: () => cleanRegex,
-  clone: () => clone,
-  createTransparentProxy: () => createTransparentProxy,
-  defineLazy: () => defineLazy,
-  esc: () => esc,
-  escapeRegex: () => escapeRegex,
-  extend: () => extend,
-  extendObjectLike: () => extendObjectLike,
-  finalizeIssue: () => finalizeIssue,
-  floatSafeRemainder: () => floatSafeRemainder,
-  getElementAtPath: () => getElementAtPath,
-  getLengthableOrigin: () => getLengthableOrigin,
-  getParsedType: () => getParsedType,
-  getSizableOrigin: () => getSizableOrigin,
-  getValidEnumValues: () => getValidEnumValues,
-  isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
-  issue: () => issue,
-  joinValues: () => joinValues,
-  jsonStringifyReplacer: () => jsonStringifyReplacer,
-  mergeObjectLike: () => mergeObjectLike,
-  normalizeObjectLikeDef: () => normalizeObjectLikeDef,
-  normalizeParams: () => normalizeParams,
-  nullish: () => nullish,
-  numKeys: () => numKeys,
-  omit: () => omit,
-  optionalInterfaceKeys: () => optionalInterfaceKeys,
-  optionalObjectKeys: () => optionalObjectKeys,
-  partialObjectLike: () => partialObjectLike,
-  pick: () => pick,
-  prefixIssues: () => prefixIssues,
-  primitiveTypes: () => primitiveTypes,
-  promiseAllObject: () => promiseAllObject,
-  propertyKeyTypes: () => propertyKeyTypes,
-  randomString: () => randomString,
-  requiredObjectLike: () => requiredObjectLike,
-  splitChecksAndParams: () => splitChecksAndParams,
-  stringifyPrimitive: () => stringifyPrimitive,
-  unwrapMessage: () => unwrapMessage
-});
-function assertEqual(val) {
-  return val;
-}
-function assertNotEqual(val) {
-  return val;
-}
-function assertIs(_arg) {
-}
-function assertNever(_x) {
-  throw new Error();
-}
-function assert(_6) {
-}
-function getValidEnumValues(obj) {
-  const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-  const filtered = {};
-  for (const k of validKeys) {
-    filtered[k] = obj[k];
-  }
-  return Object.values(filtered);
-}
-function joinValues(array2, separator = "|") {
-  return array2.map((val) => stringifyPrimitive(val)).join(separator);
-}
 function jsonStringifyReplacer(_6, value) {
   if (typeof value === "bigint")
     return value.toString();
@@ -151,22 +66,11 @@ function cached(getter) {
     }
   };
 }
-function nullish(input) {
-  return input === null || input === void 0;
-}
 function cleanRegex(source) {
   const start = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
   return source.slice(start, end);
 }
-function floatSafeRemainder(val, step) {
-  const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepDecCount = (step.toString().split(".")[1] || "").length;
-  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
-  return valInt % stepInt / 10 ** decCount;
-}
 function defineLazy(object2, key, getter) {
   Object.defineProperty(object2, key, {
     get() {
@@ -185,30 +89,6 @@ function defineLazy(object2, key, getter) {
     configurable: true
   });
 }
-function assignProp(target, prop, value) {
-  Object.defineProperty(target, prop, {
-    value,
-    writable: true,
-    enumerable: true,
-    configurable: true
-  });
-}
-function getElementAtPath(obj, path) {
-  if (!path)
-    return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
-}
-function promiseAllObject(promisesObj) {
-  const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
-    const resolvedObj = {};
-    for (let i = 0; i < keys.length; i++) {
-      resolvedObj[keys[i]] = results[i];
-    }
-    return resolvedObj;
-  });
-}
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
   let str = "";
@@ -231,78 +111,9 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject(data) {
-  return typeof data === "object" && data !== null && Object.getPrototypeOf(data) === Object.prototype;
-}
-function numKeys(data) {
-  let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
-      keyCount++;
-    }
-  }
-  return keyCount;
-}
-var getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
-    case "undefined":
-      return "undefined";
-    case "string":
-      return "string";
-    case "number":
-      return Number.isNaN(data) ? "nan" : "number";
-    case "boolean":
-      return "boolean";
-    case "function":
-      return "function";
-    case "bigint":
-      return "bigint";
-    case "symbol":
-      return "symbol";
-    case "object":
-      if (Array.isArray(data)) {
-        return "array";
-      }
-      if (data === null) {
-        return "null";
-      }
-      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
-        return "promise";
-      }
-      if (typeof Map !== "undefined" && data instanceof Map) {
-        return "map";
-      }
-      if (typeof Set !== "undefined" && data instanceof Set) {
-        return "set";
-      }
-      if (typeof Date !== "undefined" && data instanceof Date) {
-        return "date";
-      }
-      if (typeof File !== "undefined" && data instanceof File) {
-        return "file";
-      }
-      return "object";
-    default:
-      throw new Error(`Unknown data type: ${t}`);
-  }
-};
-var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function clone(inst, def) {
   return new inst._zod.constr(def);
 }
-function splitChecksAndParams(_paramsOrChecks, _checks) {
-  const params = Array.isArray(_paramsOrChecks) ? {} : _paramsOrChecks ?? {};
-  const checks = Array.isArray(_paramsOrChecks) ? _paramsOrChecks : _checks ?? [];
-  return {
-    checks,
-    params
-  };
-}
 function normalizeParams(_params) {
   const params = _params;
   if (!params)
@@ -319,267 +130,11 @@ function normalizeParams(_params) {
     return { ...params, error: () => params.error };
   return params;
 }
-function createTransparentProxy(getter) {
-  let target;
-  return new Proxy({}, {
-    get(_6, prop, receiver) {
-      target ?? (target = getter());
-      return Reflect.get(target, prop, receiver);
-    },
-    set(_6, prop, value, receiver) {
-      target ?? (target = getter());
-      return Reflect.set(target, prop, value, receiver);
-    },
-    has(_6, prop) {
-      target ?? (target = getter());
-      return Reflect.has(target, prop);
-    },
-    deleteProperty(_6, prop) {
-      target ?? (target = getter());
-      return Reflect.deleteProperty(target, prop);
-    },
-    ownKeys(_6) {
-      target ?? (target = getter());
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(_6, prop) {
-      target ?? (target = getter());
-      return Reflect.getOwnPropertyDescriptor(target, prop);
-    },
-    defineProperty(_6, prop, descriptor) {
-      target ?? (target = getter());
-      return Reflect.defineProperty(target, prop, descriptor);
-    }
-    // apply(target, thisArg, args) {
-    //   return Reflect.apply(target, thisArg, args);
-    // },
-    // construct(target, args, newTarget) {
-    //   return Reflect.construct(target, args, newTarget);
-    // },
-  });
-}
-function stringifyPrimitive(value) {
-  if (typeof value === "bigint")
-    return value.toString() + "n";
-  if (typeof value === "string")
-    return `"${value}"`;
-  return `${value}`;
-}
 function optionalObjectKeys(shape) {
   return Object.keys(shape).filter((k) => {
     return shape[k]._zod.qout === "true";
   });
 }
-function optionalInterfaceKeys(shape) {
-  return Object.keys(shape).filter((k) => {
-    return k.endsWith("?");
-  }).map((k) => k.replace(/\?$/, ""));
-}
-function cleanInterfaceKey(key) {
-  return key.replace(/^\?/, "").replace(/\?$/, "");
-}
-function cleanInterfaceShape(_shape) {
-  const keyMap = {};
-  const shape = {};
-  const optional2 = [];
-  const defaulted = [];
-  for (const [key, value] of Object.entries(_shape)) {
-    if (key.endsWith("?"))
-      optional2.push(key.slice(0, -1));
-    if (key.startsWith("?"))
-      defaulted.push(key.slice(1));
-    const cleanKey = cleanInterfaceKey(key);
-    shape[cleanKey] = value;
-    keyMap[cleanKey] = key;
-  }
-  return { shape, keyMap, optional: optional2, defaulted };
-}
-var NUMBER_FORMAT_RANGES = {
-  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-  int32: [-2147483648, 2147483647],
-  uint32: [0, 4294967295],
-  float32: [-34028234663852886e22, 34028234663852886e22],
-  float64: [-17976931348623157e292, 17976931348623157e292]
-};
-var BIGINT_FORMAT_RANGES = {
-  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
-  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
-};
-function pick(schema, mask) {
-  const newShape = {};
-  const newOptional = [];
-  const currShape = schema._zod.def.shape;
-  const currOptional = new Set(schema._zod.def.optional);
-  for (const key in mask) {
-    if (!(key in currShape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
-    }
-    if (!mask[key])
-      continue;
-    newShape[key] = currShape[key];
-    if (currOptional.has(key)) {
-      newOptional.push(key);
-    }
-  }
-  return clone(schema, {
-    ...schema._zod.def,
-    shape: newShape,
-    optional: newOptional,
-    checks: []
-  });
-}
-function omit(schema, mask) {
-  const newShape = { ...schema._zod.def.shape };
-  const newOptional = new Set(schema._zod.def.optional);
-  for (const key in mask) {
-    if (!(key in schema._zod.def.shape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
-    }
-    if (!mask[key])
-      continue;
-    delete newShape[key];
-    newOptional.delete(key);
-  }
-  return clone(schema, {
-    ...schema._zod.def,
-    shape: newShape,
-    optional: [...newOptional],
-    checks: []
-  });
-}
-function extend(schema, shape) {
-  const def = {
-    ...schema._zod.def,
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
-    },
-    checks: []
-    // delete existing checks
-  };
-  defineLazy(def, "shape", () => ({ ...schema._zod.def.shape, ...shape }));
-  return clone(schema, def);
-}
-function mergeObjectLike(a, b) {
-  const bKeys = new Set(Object.keys(b._zod.def.shape));
-  const optional2 = [...a._zod.def.optional.filter((k) => !bKeys.has(k)), ...b._zod.def.optional];
-  return clone(a, {
-    ...a._zod.def,
-    get shape() {
-      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
-    },
-    optional: optional2,
-    catchall: b._zod.def.catchall,
-    checks: []
-    // delete existing checks
-  });
-}
-function extendObjectLike(a, b) {
-  const bKeys = new Set(Object.keys(b._zod.def.shape));
-  const optional2 = [...a._zod.def.optional.filter((k) => !bKeys.has(k)), ...b._zod.def.optional];
-  return clone(a, {
-    ...a._zod.def,
-    get shape() {
-      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
-    },
-    optional: optional2,
-    checks: []
-    // delete existent checks
-  });
-}
-function partialObjectLike(Class, schema, mask) {
-  const shape = { ...schema._zod.def.shape };
-  const optional2 = new Set(schema._zod.def.optional);
-  if (mask) {
-    for (const key in mask) {
-      if (!(key in shape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
-      }
-      if (!mask[key])
-        continue;
-      shape[key] = new Class({
-        type: "optional",
-        innerType: schema._zod.def.shape[key]
-      });
-      optional2.add(key);
-    }
-  } else {
-    for (const key in schema._zod.def.shape) {
-      shape[key] = new Class({
-        type: "optional",
-        innerType: schema._zod.def.shape[key]
-      });
-      optional2.add(key);
-    }
-  }
-  return clone(schema, {
-    ...schema._zod.def,
-    shape,
-    optional: [...optional2],
-    checks: []
-  });
-}
-function requiredObjectLike(Class, schema, mask) {
-  const shape = { ...schema._zod.def.shape };
-  if (mask) {
-    for (const key in mask) {
-      if (!(key in shape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
-      }
-      if (!mask[key])
-        continue;
-      shape[key] = new Class({
-        type: "nonoptional",
-        innerType: schema._zod.def.shape[key]
-      });
-    }
-  } else {
-    for (const key in schema._zod.def.shape) {
-      shape[key] = new Class({
-        type: "nonoptional",
-        innerType: schema._zod.def.shape[key]
-      });
-    }
-  }
-  return clone(schema, {
-    ...schema._zod.def,
-    shape,
-    optional: [],
-    checks: []
-  });
-}
-function normalizeObjectLikeDef(def) {
-  if (def.type === "interface") {
-    const keys = Object.keys(def.shape);
-    const keySet = new Set(Object.keys(def.shape));
-    return {
-      shape: { ...def.shape },
-      // resolve getters
-      keys,
-      keySet,
-      numKeys: keys.length,
-      optionalKeys: new Set(def.optional)
-    };
-  }
-  if (def.type === "object") {
-    const keys = Object.keys(def.shape);
-    const keySet = new Set(Object.keys(def.shape));
-    return {
-      shape: { ...def.shape },
-      // resolve getters
-      keys,
-      keySet,
-      numKeys: keys.length,
-      optionalKeys: new Set(def.optional)
-    };
-  }
-  throw new Error("Invalid object-like type");
-}
 function aborted(x, startIndex = 0) {
   for (let i = startIndex; i < x.issues.length; i++) {
     if (x.issues[i].continue !== true)
@@ -611,36 +166,8 @@ function finalizeIssue(iss, ctx, config2) {
   }
   return full;
 }
-function getSizableOrigin(input) {
-  if (input instanceof Set)
-    return "set";
-  if (input instanceof Map)
-    return "map";
-  if (input instanceof File)
-    return "file";
-  return "unknown";
-}
-function getLengthableOrigin(input) {
-  if (Array.isArray(input))
-    return "array";
-  if (typeof input === "string")
-    return "string";
-  return "unknown";
-}
-function issue(...args) {
-  const [iss, input, inst] = args;
-  if (typeof iss === "string") {
-    return {
-      message: iss,
-      code: "custom",
-      input,
-      inst
-    };
-  }
-  return { ...iss };
-}
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/errors.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/errors.js
 var ZOD_ERROR = Symbol.for("{{zod.error}}");
 var $ZodError = class {
   get message() {
@@ -657,7 +184,7 @@ var $ZodError = class {
   }
 };
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/parse.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/parse.js
 function _parse(schema, value, _ctx) {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx);
@@ -709,7 +236,7 @@ var string = (params) => {
 };
 var boolean = /true|false/i;
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/doc.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/doc.js
 var Doc = class {
   constructor(args) {
     this.content = [];
@@ -741,21 +268,13 @@ var Doc = class {
   }
 };
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/versions.js
-var version = {
-  major: 0,
-  minor: 3,
-  patch: 3
-};
-
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/schemas.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/schemas.js
 var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   var _a;
   inst ?? (inst = {});
   inst._zod.id = def.type + "_" + randomString(10);
   inst._zod.def = def;
   inst._zod.computed = inst._zod.computed || {};
-  inst._zod.version = version;
   const checks = [...inst._zod.def.checks ?? []];
   def.type;
   if (inst._zod.traits.has("$ZodCheck")) {
@@ -823,7 +342,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       return runChecks(result, checks, ctx);
     };
   }
-  inst["~standard"] = {
+  defineLazy(inst, "~standard", () => ({
     validate: (value) => {
       const result = inst._zod.run({ value, issues: [] }, {});
       if (result instanceof Promise) {
@@ -839,7 +358,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
     },
     vendor: "zod",
     version: 1
-  };
+  }));
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
@@ -1044,9 +563,7 @@ var $ZodObjectLike = /* @__PURE__ */ $constructor("$ZodObjectLike", (inst, def)
   const fastEnabled = allowsEval.value;
   const isObject2 = isObject;
   const { catchall } = def;
-  let value;
   inst._zod.parse = (payload, ctx) => {
-    value ?? (value = _normalized.value);
     const input = payload.value;
     if (!isObject2(input)) {
       payload.issues.push({
@@ -1064,7 +581,7 @@ var $ZodObjectLike = /* @__PURE__ */ $constructor("$ZodObjectLike", (inst, def)
       payload = fastpass(payload, ctx);
     } else {
       payload.value = {};
-      const { keys, shape, optionalKeys } = value;
+      const { keys, shape, optionalKeys } = _normalized.value;
       for (const key of keys) {
         const valueSchema = shape[key];
         const r = valueSchema._zod.run({ value: input[key], issues: [] }, ctx);
@@ -1084,17 +601,14 @@ var $ZodObjectLike = /* @__PURE__ */ $constructor("$ZodObjectLike", (inst, def)
       return proms.length ? Promise.all(proms).then(() => payload) : payload;
     }
     const unrecognized = [];
-    const keySet = value.keySet;
-    const _catchall = catchall._zod;
-    const t = _catchall.def.type;
     for (const key of Object.keys(input)) {
-      if (keySet.has(key))
+      if (_normalized.value.keySet.has(key))
         continue;
-      if (t === "never") {
+      if (catchall._zod.def.type === "never") {
         unrecognized.push(key);
         continue;
       }
-      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+      const r = catchall._zod.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
         proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
       } else {
@@ -1135,7 +649,7 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
   };
 });
 
-// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/api.js
+// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/api.js
 function _string(Class, params) {
   return new Class({
     type: "string",
@@ -1149,7 +663,7 @@ function _boolean(Class, params) {
   });
 }
 
-// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.20250411T005215_60e10b0f348e07070e4d24639ea7d4ee/node_modules/@zod/mini/dist/esm/parse.js
+// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/parse.js
 var parse2 = /* @__PURE__ */ _parse.bind({ Error: $ZodError });
 var safeParse = /* @__PURE__ */ _safeParse.bind({ Error: $ZodError });
 var parseAsync2 = /* @__PURE__ */ _parseAsync.bind({ Error: $ZodError });
@@ -1157,7 +671,7 @@ var safeParseAsync = /* @__PURE__ */ _safeParseAsync.bind({
   Error: $ZodError
 });
 
-// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.20250411T005215_60e10b0f348e07070e4d24639ea7d4ee/node_modules/@zod/mini/dist/esm/schemas.js
+// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/schemas.js
 var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
   if (!inst._zod)
     throw new Error("Uninitialized schema in mixin ZodMiniType.");
@@ -1208,7 +722,7 @@ function array(element, params) {
     // get element() {
     //   return element;
     // },
-    ...util_exports.normalizeParams(params)
+    ...normalizeParams(params)
   });
 }
 var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
@@ -1220,9 +734,9 @@ function object(shape, params) {
     type: "object",
     shape: shape ?? {},
     get optional() {
-      return util_exports.optionalObjectKeys(shape ?? {});
+      return optionalObjectKeys(shape ?? {});
     },
-    ...util_exports.normalizeParams(params)
+    ...normalizeParams(params)
   };
   return new ZodMiniObject(def);
 }
@@ -1234,7 +748,7 @@ function optional(innerType, params) {
   return new ZodMiniOptional({
     type: "optional",
     innerType,
-    ...util_exports.normalizeParams(params)
+    ...normalizeParams(params)
   });
 }