@eslint-react/core 1.43.2-next.1 → 1.45.0-beta.3

package/dist/index.js

@@ -35,9 +35,13 @@ var JSX3__namespace = /*#__PURE__*/_interopNamespace(JSX3);
 var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
 var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 
-// src/component/component-collector.ts
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/core.js
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer) {
   class _6 {
@@ -78,6 +82,87 @@ 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();
@@ -94,11 +179,22 @@ 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() {
@@ -117,6 +213,30 @@ 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 = "";
@@ -139,9 +259,78 @@ 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)
@@ -158,11 +347,267 @@ 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)
@@ -194,8 +639,36 @@ 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.1.0/node_modules/@zod/core/dist/esm/errors.js
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/errors.js
 var ZOD_ERROR = Symbol.for("{{zod.error}}");
 var $ZodError = class {
   get message() {
@@ -212,7 +685,7 @@ var $ZodError = class {
   }
 };
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/parse.js
+// ../../node_modules/.pnpm/@zod+core@0.3.3/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);
@@ -264,7 +737,7 @@ var string = (params) => {
 };
 var boolean = /true|false/i;
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/doc.js
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/doc.js
 var Doc = class {
   constructor(args) {
     this.content = [];
@@ -296,13 +769,21 @@ var Doc = class {
   }
 };
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/schemas.js
+// ../../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
 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")) {
@@ -370,7 +851,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       return runChecks(result, checks, ctx);
     };
   }
-  defineLazy(inst, "~standard", () => ({
+  inst["~standard"] = {
     validate: (value) => {
       const result = inst._zod.run({ value, issues: [] }, {});
       if (result instanceof Promise) {
@@ -386,7 +867,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
     },
     vendor: "zod",
     version: 1
-  }));
+  };
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
@@ -591,7 +1072,9 @@ 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({
@@ -609,7 +1092,7 @@ var $ZodObjectLike = /* @__PURE__ */ $constructor("$ZodObjectLike", (inst, def)
       payload = fastpass(payload, ctx);
     } else {
       payload.value = {};
-      const { keys, shape, optionalKeys } = _normalized.value;
+      const { keys, shape, optionalKeys } = value;
       for (const key of keys) {
         const valueSchema = shape[key];
         const r = valueSchema._zod.run({ value: input[key], issues: [] }, ctx);
@@ -629,14 +1112,17 @@ 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 (_normalized.value.keySet.has(key))
+      if (keySet.has(key))
         continue;
-      if (catchall._zod.def.type === "never") {
+      if (t === "never") {
         unrecognized.push(key);
         continue;
       }
-      const r = catchall._zod.run({ value: input[key], issues: [] }, ctx);
+      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
         proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
       } else {
@@ -677,7 +1163,7 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
   };
 });
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/api.js
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/api.js
 function _string(Class, params) {
   return new Class({
     type: "string",
@@ -691,7 +1177,7 @@ function _boolean(Class, params) {
   });
 }
 
-// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/parse.js
+// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.20250411T005215_60e10b0f348e07070e4d24639ea7d4ee/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 });
@@ -699,7 +1185,7 @@ var safeParseAsync = /* @__PURE__ */ _safeParseAsync.bind({
   Error: $ZodError
 });
 
-// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/schemas.js
+// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.20250411T005215_60e10b0f348e07070e4d24639ea7d4ee/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.");
@@ -750,7 +1236,7 @@ function array(element, params) {
     // get element() {
     //   return element;
     // },
-    ...normalizeParams(params)
+    ...util_exports.normalizeParams(params)
   });
 }
 var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
@@ -762,9 +1248,9 @@ function object(shape, params) {
     type: "object",
     shape: shape ?? {},
     get optional() {
-      return optionalObjectKeys(shape ?? {});
+      return util_exports.optionalObjectKeys(shape ?? {});
     },
-    ...normalizeParams(params)
+    ...util_exports.normalizeParams(params)
   };
   return new ZodMiniObject(def);
 }
@@ -776,7 +1262,7 @@ function optional(innerType, params) {
   return new ZodMiniOptional({
     type: "optional",
     innerType,
-    ...normalizeParams(params)
+    ...util_exports.normalizeParams(params)
   });
 }
 
@@ -1034,6 +1520,7 @@ function isReactAPI(arg0, arg1) {
 function isReactAPICall(arg0, arg1) {
   return arg1 == null ? isCallFromReact(arg0) : isCallFromReactObject(arg0, arg1);
 }
+var isCaptureOwnerStack = isReactAPI("captureOwnerStack");
 var isChildrenCount = isReactAPI("Children", "count");
 var isChildrenForEach = isReactAPI("Children", "forEach");
 var isChildrenMap = isReactAPI("Children", "map");
@@ -1045,6 +1532,8 @@ var isCreateElement = isReactAPI("createElement");
 var isCreateRef = isReactAPI("createRef");
 var isForwardRef = isReactAPI("forwardRef");
 var isMemo = isReactAPI("memo");
+var isLazy = isReactAPI("lazy");
+var isCaptureOwnerStackCall = isReactAPICall("captureOwnerStack");
 var isChildrenCountCall = isReactAPICall("Children", "count");
 var isChildrenForEachCall = isReactAPICall("Children", "forEach");
 var isChildrenMapCall = isReactAPICall("Children", "map");
@@ -1056,6 +1545,7 @@ var isCreateElementCall = isReactAPICall("createElement");
 var isCreateRefCall = isReactAPICall("createRef");
 var isForwardRefCall = isReactAPICall("forwardRef");
 var isMemoCall = isReactAPICall("memo");
+var isLazyCall = isReactAPICall("lazy");
 
 // src/hook/hook-name.ts
 function isReactHookName(name) {
@@ -1405,7 +1895,7 @@ function isValidComponentDefinition(context, node, hint) {
   if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST6__namespace.isArrayMapCall(node.parent)) {
     return false;
   }
-  const boundaryNode = AST6__namespace.findParentNode(
+  const significantParent = AST6__namespace.findParentNode(
     node,
     AST6__namespace.isOneOf([
       types.AST_NODE_TYPES.JSXExpressionContainer,
@@ -1415,7 +1905,7 @@ function isValidComponentDefinition(context, node, hint) {
       types.AST_NODE_TYPES.ClassBody
     ])
   );
-  return boundaryNode == null || boundaryNode.type !== types.AST_NODE_TYPES.JSXExpressionContainer;
+  return significantParent == null || significantParent.type !== types.AST_NODE_TYPES.JSXExpressionContainer;
 }
 function isComponentWrapperCall(context, node) {
   if (node.type !== types.AST_NODE_TYPES.CallExpression) return false;
@@ -1682,6 +2172,8 @@ exports.hasNoneOrLooseComponentName = hasNoneOrLooseComponentName;
 exports.isAssignmentToThisState = isAssignmentToThisState;
 exports.isCallFromReact = isCallFromReact;
 exports.isCallFromReactObject = isCallFromReactObject;
+exports.isCaptureOwnerStack = isCaptureOwnerStack;
+exports.isCaptureOwnerStackCall = isCaptureOwnerStackCall;
 exports.isChildrenCount = isChildrenCount;
 exports.isChildrenCountCall = isChildrenCountCall;
 exports.isChildrenForEach = isChildrenForEach;
@@ -1737,6 +2229,8 @@ exports.isInitializedFromReact = isInitializedFromReact;
 exports.isInsideRenderMethod = isInsideRenderMethod;
 exports.isInstanceIdEqual = isInstanceIdEqual;
 exports.isInversePhase = isInversePhase;
+exports.isLazy = isLazy;
+exports.isLazyCall = isLazyCall;
 exports.isMemo = isMemo;
 exports.isMemoCall = isMemoCall;
 exports.isPureComponent = isPureComponent;