@eslint-react/core 1.48.2 → 1.48.3-next.0

package/dist/index.mjs

@@ -7,9 +7,13 @@ import * as VAR3 from '@eslint-react/var';
 import { isMatching, P, match } from 'ts-pattern';
 import birecord from '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.5.1/node_modules/@zod/core/dist/esm/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer) {
   class _6 {
@@ -50,6 +54,87 @@ var globalConfig = {};
 function config(config2) {
   return globalConfig;
 }
+
+// ../../node_modules/.pnpm/@zod+core@0.5.1/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();
@@ -66,11 +151,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() {
@@ -89,6 +185,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 = "";
@@ -111,9 +231,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)
@@ -130,11 +319,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)
@@ -166,8 +611,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.5.1/node_modules/@zod/core/dist/esm/errors.js
 var ZOD_ERROR = Symbol.for("{{zod.error}}");
 var $ZodError = class {
   get message() {
@@ -184,7 +657,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.5.1/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);
@@ -236,12 +709,13 @@ 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.5.1/node_modules/@zod/core/dist/esm/doc.js
 var Doc = class {
-  constructor(args) {
+  constructor(args = []) {
     this.content = [];
     this.indent = 0;
-    this.args = args;
+    if (this)
+      this.args = args;
   }
   indented(fn) {
     this.indent += 1;
@@ -263,18 +737,28 @@ var Doc = class {
     }
   }
   compile() {
-    const lines = [...this.content.map((x) => `  ${x}`)];
-    return new Function(...this.args, lines.join("\n"));
+    const args = this?.args;
+    const content = this?.content ?? [``];
+    const lines = [...content.map((x) => `  ${x}`)];
+    return new Function(...args, lines.join("\n"));
   }
 };
 
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/schemas.js
+// ../../node_modules/.pnpm/@zod+core@0.5.1/node_modules/@zod/core/dist/esm/versions.js
+var version = {
+  major: 0,
+  minor: 5,
+  patch: 1
+};
+
+// ../../node_modules/.pnpm/@zod+core@0.5.1/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")) {
@@ -308,8 +792,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
           throw new $ZodAsyncError();
         }
         if (asyncResult || _6 instanceof Promise) {
-          asyncResult = asyncResult ?? Promise.resolve();
-          asyncResult.then(async () => {
+          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
             await _6;
             const nextLen = payload.issues.length;
             if (nextLen === currLen)
@@ -342,23 +825,23 @@ 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) {
         return result.then(({ issues, value: value2 }) => {
           if (issues.length === 0)
             return { value: value2 };
-          return { issues };
+          return { issues: issues.map((iss) => finalizeIssue(iss, {}, config())) };
         });
       }
       if (result.issues.length === 0)
         return { value: result.value };
-      return { issues: result.issues };
+      return { issues: result.issues.map((iss) => finalizeIssue(iss, {}, config())) };
     },
     vendor: "zod",
     version: 1
-  }));
+  };
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   $ZodType.init(inst, def);
@@ -469,7 +952,6 @@ function handleOptionalObjectResult(result, final, key, input) {
 }
 var $ZodObjectLike = /* @__PURE__ */ $constructor("$ZodObjectLike", (inst, def) => {
   $ZodType.init(inst, def);
-  defineLazy(inst._zod, "shape", () => def.shape);
   const _normalized = cached(() => {
     const keys = Object.keys(def.shape);
     return {
@@ -567,7 +1049,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({
@@ -585,7 +1069,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);
@@ -605,14 +1089,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 {
@@ -653,7 +1140,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.5.1/node_modules/@zod/core/dist/esm/api.js
 function _string(Class, params) {
   return new Class({
     type: "string",
@@ -673,7 +1160,7 @@ function _unknown(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.20250415T232143_a6e9e9ac6408e2c9467a9c53ed9f86b4/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 });
@@ -681,7 +1168,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.20250415T232143_a6e9e9ac6408e2c9467a9c53ed9f86b4/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.");
@@ -739,7 +1226,7 @@ function array(element, params) {
     // get element() {
     //   return element;
     // },
-    ...normalizeParams(params)
+    ...util_exports.normalizeParams(params)
   });
 }
 var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
@@ -751,9 +1238,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);
 }
@@ -765,7 +1252,7 @@ function optional(innerType, params) {
   return new ZodMiniOptional({
     type: "optional",
     innerType,
-    ...normalizeParams(params)
+    ...util_exports.normalizeParams(params)
   });
 }
 
@@ -1168,10 +1655,10 @@ function isFunctionOfUseEffectSetup(node) {
 function isFunctionOfUseEffectCleanup(node) {
   if (node == null) return false;
   const pReturn = AST9.findParentNode(node, AST9.is(AST_NODE_TYPES.ReturnStatement));
-  const pFaunction = AST9.findParentNode(node, AST9.isFunction);
+  const pFunction = AST9.findParentNode(node, AST9.isFunction);
   const pFunctionOfReturn = AST9.findParentNode(pReturn, AST9.isFunction);
-  if (pFaunction !== pFunctionOfReturn) return false;
-  return isFunctionOfUseEffectSetup(pFaunction);
+  if (pFunction !== pFunctionOfReturn) return false;
+  return isFunctionOfUseEffectSetup(pFunction);
 }
 function stringifyJsx(node) {
   switch (node.type) {