@eslint-react/core 1.43.1-next.0 → 1.43.2-beta.2

package/dist/index.js

@@ -35,343 +35,1235 @@ 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/valibot@1.0.0_typescript@5.8.3/node_modules/valibot/dist/index.js
-var store;
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/core.js
 // @__NO_SIDE_EFFECTS__
-function getGlobalConfig(config2) {
+function $constructor(name, initializer) {
+  class _6 {
+    constructor(def) {
+      var _a;
+      const th = this;
+      _6.init(th, def);
+      (_a = th._zod).deferred ?? (_a.deferred = []);
+      for (const fn of th._zod.deferred) {
+        fn();
+      }
+    }
+    static init(inst, def) {
+      var _a;
+      inst._zod ?? (inst._zod = {});
+      (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
+      inst._zod.traits.add(name);
+      initializer(inst, def);
+      for (const k in _6.prototype) {
+        Object.defineProperty(inst, k, { value: _6.prototype[k].bind(inst) });
+      }
+      inst._zod.constr = _6;
+      inst._zod.def = def;
+    }
+    static [Symbol.hasInstance](inst) {
+      return inst?._zod?.traits?.has(name);
+    }
+  }
+  Object.defineProperty(_6, "name", { value: name });
+  return _6;
+}
+var $ZodAsyncError = class extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+};
+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();
+  return value;
+}
+function cached(getter) {
   return {
-    lang: config2?.lang ?? store?.lang,
-    message: config2?.message,
-    abortEarly: config2?.abortEarly ?? store?.abortEarly,
-    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+    get value() {
+      {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+    }
   };
 }
-var store2;
-// @__NO_SIDE_EFFECTS__
-function getGlobalMessage(lang) {
-  return store2?.get(lang);
+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() {
+      {
+        const value = getter();
+        object2[key] = value;
+        return value;
+      }
+    },
+    set(v) {
+      Object.defineProperty(object2, key, {
+        value: v
+        // configurable: true,
+      });
+    },
+    configurable: true
+  });
 }
-var store3;
-// @__NO_SIDE_EFFECTS__
-function getSchemaMessage(lang) {
-  return store3?.get(lang);
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
 }
-var store4;
-// @__NO_SIDE_EFFECTS__
-function getSpecificMessage(reference, lang) {
-  return store4?.get(reference)?.get(lang);
+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;
+  });
 }
-// @__NO_SIDE_EFFECTS__
-function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") {
-    return `"${input}"`;
-  }
-  if (type === "number" || type === "bigint" || type === "boolean") {
-    return `${input}`;
-  }
-  if (type === "object" || type === "function") {
-    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  }
-  return type;
-}
-function _addIssue(context, label, dataset, config2, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
-    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-    requirement: context.requirement,
-    path: other?.path,
-    issues: other?.issues,
-    lang: config2.lang,
-    abortEarly: config2.abortEarly,
-    abortPipeEarly: config2.abortPipeEarly
-  };
-  const isSchema = context.kind === "schema";
-  const message = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-  if (message !== void 0) {
-    issue.message = typeof message === "function" ? (
-      // @ts-expect-error
-      message(issue)
-    ) : message;
-  }
-  if (isSchema) {
-    dataset.typed = false;
-  }
-  if (dataset.issues) {
-    dataset.issues.push(issue);
-  } else {
-    dataset.issues = [issue];
+function randomString(length = 10) {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
   }
+  return str;
 }
-// @__NO_SIDE_EFFECTS__
-function _getStandardProps(context) {
+function esc(str) {
+  return JSON.stringify(str);
+}
+function isObject(data) {
+  return typeof data === "object" && data !== null;
+}
+var allowsEval = cached(() => {
+  try {
+    new Function("");
+    return true;
+  } catch (_6) {
+    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 {
-    version: 1,
-    vendor: "valibot",
-    validate(value2) {
-      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    checks,
+    params
+  };
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== void 0) {
+    if (params?.error !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    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
+  });
 }
-var ValiError = class extends Error {
-  /**
-   * Creates a Valibot error with useful information.
-   *
-   * @param issues The error issues.
-   */
+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)
+      return true;
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config2) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  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
+var ZOD_ERROR = Symbol.for("{{zod.error}}");
+var $ZodError = class {
+  get message() {
+    return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
+  }
   constructor(issues) {
-    super(issues[0].message);
-    this.name = "ValiError";
+    Object.defineProperty(this, "_tag", { value: ZOD_ERROR, enumerable: false });
+    Object.defineProperty(this, "name", { value: "$ZodError", enumerable: false });
     this.issues = issues;
   }
+  // @ts-ignore
+  static [Symbol.hasInstance](inst) {
+    return inst?._tag === ZOD_ERROR;
+  }
 };
-// @__NO_SIDE_EFFECTS__
-function getFallback(schema, dataset, config2) {
-  return typeof schema.fallback === "function" ? (
-    // @ts-expect-error
-    schema.fallback(dataset, config2)
-  ) : (
-    // @ts-expect-error
-    schema.fallback
-  );
+
+// ../../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);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  if (result.issues.length) {
+    throw new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  }
+  return result.value;
 }
-// @__NO_SIDE_EFFECTS__
-function getDefault(schema, dataset, config2) {
-  return typeof schema.default === "function" ? (
-    // @ts-expect-error
-    schema.default(dataset, config2)
-  ) : (
-    // @ts-expect-error
-    schema.default
-  );
+function _safeParse(schema, value, _ctx) {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+}
+async function _parseAsync(schema, value, _ctx) {
+  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    throw new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  }
+  return result.value;
+}
+async function _safeParseAsync(schema, value, _ctx) {
+  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    return {
+      success: false,
+      error: new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    };
+  }
+  return { success: true, data: result.value };
 }
-// @__NO_SIDE_EFFECTS__
-function array(item, message) {
-  return {
-    kind: "schema",
-    type: "array",
-    reference: array,
-    expects: "Array",
-    async: false,
-    item,
-    message,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config2) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < input.length; key++) {
-          const value2 = input[key];
-          const itemDataset = this.item["~run"]({ value: value2 }, config2);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value2
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) {
-                issue.path.unshift(pathItem);
-              } else {
-                issue.path = [pathItem];
-              }
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) {
-              dataset.issues = itemDataset.issues;
-            }
-            if (config2.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) {
-            dataset.typed = false;
+var string = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+var boolean = /true|false/i;
+
+// ../../node_modules/.pnpm/@zod+core@0.3.3/node_modules/@zod/core/dist/esm/doc.js
+var Doc = class {
+  constructor(args) {
+    this.content = [];
+    this.indent = 0;
+    this.args = args;
+  }
+  indented(fn) {
+    this.indent += 1;
+    fn(this);
+    this.indent -= 1;
+  }
+  write(arg) {
+    if (typeof arg === "function") {
+      arg(this, { execution: "sync" });
+      arg(this, { execution: "async" });
+      return;
+    }
+    const content = arg;
+    const lines = content.split("\n").filter((x) => x);
+    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+    for (const line of dedented) {
+      this.content.push(line);
+    }
+  }
+  compile() {
+    const lines = [...this.content.map((x) => `  ${x}`)];
+    return new Function(...this.args, lines.join("\n"));
+  }
+};
+
+// ../../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")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    ch._zod.onattach?.(inst);
+  }
+  if (checks.length === 0) {
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    inst._zod.deferred?.push(() => {
+      inst._zod.run = inst._zod.parse;
+    });
+  } else {
+    const runChecks = (payload, checks2, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks2) {
+        if (ch._zod.when) {
+          const shouldRun = ch._zod.when(payload);
+          if (!shouldRun)
+            continue;
+        } else {
+          if (isAborted) {
+            continue;
           }
-          dataset.value.push(itemDataset.value);
         }
+        const currLen = payload.issues.length;
+        const _6 = ch._zod.check(payload);
+        if (_6 instanceof Promise && ctx?.async === false) {
+          throw new $ZodAsyncError();
+        }
+        if (asyncResult || _6 instanceof Promise) {
+          asyncResult = asyncResult ?? Promise.resolve();
+          asyncResult.then(async () => {
+            await _6;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    inst._zod.run = (payload, ctx) => {
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return result.then((result2) => runChecks(result2, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  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 };
+        });
+      }
+      if (result.issues.length === 0)
+        return { value: result.value };
+      return { issues: result.issues };
+    },
+    vendor: "zod",
+    version: 1
+  };
+});
+var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = inst?._zod.computed?.pattern ?? string(inst._zod.computed);
+  inst._zod.parse = (payload, _6) => {
+    if (def.coerce)
+      try {
+        payload.value = String(payload.value);
+      } catch (_7) {
+      }
+    if (typeof payload.value === "string")
+      return payload;
+    payload.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = boolean;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Boolean(payload.value);
+      } catch (_6) {
+      }
+    const input = payload.value;
+    if (typeof input === "boolean")
+      return payload;
+    payload.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
       } else {
-        _addIssue(this, "type", dataset, config2);
+        handleArrayResult(result, payload, i);
       }
-      return dataset;
     }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
   };
+});
+function handleObjectResult(result, final, key) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(key, result.issues));
+  } else {
+    final.value[key] = result.value;
+  }
 }
-// @__NO_SIDE_EFFECTS__
-function boolean(message) {
-  return {
-    kind: "schema",
-    type: "boolean",
-    reference: boolean,
-    expects: "boolean",
-    async: false,
-    message,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config2) {
-      if (typeof dataset.value === "boolean") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
+function handleOptionalObjectResult(result, final, key, input) {
+  if (result.issues.length) {
+    if (input[key] === void 0) {
+      if (key in input) {
+        final.value[key] = void 0;
       }
-      return dataset;
+    } else {
+      final.issues.push(...prefixIssues(key, result.issues));
     }
-  };
+  } else if (result.value === void 0) {
+    if (key in input)
+      final.value[key] = void 0;
+  } else {
+    final.value[key] = result.value;
+  }
 }
-// @__NO_SIDE_EFFECTS__
-function object(entries, message) {
-  return {
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
-    async: false,
-    entries,
-    message,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config2) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
-          valueSchema.default !== void 0) {
-            const value2 = key in input ? (
-              // @ts-expect-error
-              input[key]
-            ) : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value2
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) {
-                  issue.path.unshift(pathItem);
-                } else {
-                  issue.path = [pathItem];
-                }
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) {
-                dataset.issues = valueDataset.issues;
-              }
-              if (config2.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) {
-              dataset.typed = false;
-            }
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) {
-            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config2, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [
-                {
-                  type: "object",
-                  origin: "key",
-                  input,
-                  key,
-                  // @ts-expect-error
-                  value: input[key]
-                }
-              ]
-            });
-            if (config2.abortEarly) {
-              break;
+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 {
+      shape: def.shape,
+      keys,
+      keySet: new Set(keys),
+      numKeys: keys.length,
+      optionalKeys: new Set(def.optional)
+    };
+  });
+  defineLazy(inst._zod, "disc", () => {
+    const shape = def.shape;
+    const discMap = /* @__PURE__ */ new Map();
+    let hasDisc = false;
+    for (const key in shape) {
+      const field = shape[key]._zod;
+      if (field.values || field.disc) {
+        hasDisc = true;
+        const o = {
+          values: new Set(field.values ?? []),
+          maps: field.disc ? [field.disc] : []
+        };
+        discMap.set(key, o);
+      }
+    }
+    if (!hasDisc)
+      return void 0;
+    return discMap;
+  });
+  const generateFastpass = (shape) => {
+    const doc = new Doc(["shape", "payload", "ctx"]);
+    const { keys, optionalKeys } = _normalized.value;
+    const parseStr = (key) => {
+      const k = esc(key);
+      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+    };
+    doc.write(`const input = payload.value;`);
+    const ids = {};
+    for (const key of keys) {
+      ids[key] = randomString(15);
+    }
+    for (const key of keys) {
+      if (optionalKeys.has(key))
+        continue;
+      const id = ids[key];
+      doc.write(`const ${id} = ${parseStr(key)};`);
+      doc.write(`
+          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
+          })));`);
+    }
+    doc.write(`payload.value = {`);
+    doc.indented(() => {
+      for (const key of keys) {
+        if (optionalKeys.has(key))
+          continue;
+        const id = ids[key];
+        doc.write(`  ${esc(key)}: ${id}.value,`);
+      }
+    });
+    doc.write(`}`);
+    for (const key of keys) {
+      if (!optionalKeys.has(key))
+        continue;
+      const id = ids[key];
+      doc.write(`const ${id} = ${parseStr(key)};`);
+      const k = esc(key);
+      doc.write(`
+        if (${id}.issues.length) {
+          if (input[${k}] === undefined) {
+            if (${k} in input) {
+              payload.value[${k}] = undefined;
             }
+          } else {
+            payload.issues = payload.issues.concat(
+              ${id}.issues.map((iss) => ({
+                ...iss,
+                path: iss.path ? [${k}, ...iss.path] : [${k}],
+              }))
+            );
+          }
+        } else if (${id}.value === undefined) {
+          if (${k} in input) payload.value[${k}] = undefined;
+        } else {
+          payload.value[${k}] = ${id}.value;
+        }  
+        `);
+    }
+    doc.write(`return payload;`);
+    const fn = doc.compile();
+    return (payload, ctx) => fn(shape, payload, ctx);
+  };
+  let fastpass;
+  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({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    if (fastEnabled && ctx?.async === false && ctx.noPrecompilation !== true) {
+      if (!fastpass)
+        fastpass = generateFastpass(def.shape);
+      payload = fastpass(payload, ctx);
+    } else {
+      payload.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);
+        const isOptional = optionalKeys.has(key);
+        if (r instanceof Promise) {
+          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
+        } else {
+          if (isOptional) {
+            handleOptionalObjectResult(r, payload, key, input);
+          } else {
+            handleObjectResult(r, payload, key);
           }
         }
+      }
+    }
+    if (!catchall) {
+      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))
+        continue;
+      if (t === "never") {
+        unrecognized.push(key);
+        continue;
+      }
+      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
       } else {
-        _addIssue(this, "type", dataset, config2);
+        handleObjectResult(r, payload, key);
       }
-      return dataset;
     }
+    if (unrecognized.length) {
+      payload.issues.push({
+        code: "unrecognized_keys",
+        keys: unrecognized,
+        input,
+        inst
+      });
+    }
+    if (!proms.length)
+      return payload;
+    return Promise.all(proms).then(() => {
+      return payload;
+    });
   };
-}
-// @__NO_SIDE_EFFECTS__
-function optional(wrapped, default_) {
-  return {
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `(${wrapped.expects} | undefined)`,
-    async: false,
-    wrapped,
-    default: default_,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset, config2) {
-      if (dataset.value === void 0) {
-        if (this.default !== void 0) {
-          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
-        }
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config2);
+});
+var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+  $ZodObjectLike.init(inst, def);
+});
+var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.qout = "true";
+  if (def.innerType._zod.values)
+    inst._zod.values = /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]);
+  const pattern = def.innerType._zod.pattern;
+  if (pattern)
+    inst._zod.pattern = new RegExp(`^(${cleanRegex(pattern.source)})?$`);
+  inst._zod.parse = (payload, ctx) => {
+    if (payload.value === void 0) {
+      return payload;
     }
+    return def.innerType._zod.run(payload, ctx);
   };
-}
-// @__NO_SIDE_EFFECTS__
-function string(message) {
-  return {
-    kind: "schema",
+});
+
+// ../../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",
-    reference: string,
-    expects: "string",
-    async: false,
-    message,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
+    ...normalizeParams(params)
+  });
+}
+function _boolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
+
+// ../../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 });
+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
+var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+  if (!inst._zod)
+    throw new Error("Uninitialized schema in mixin ZodMiniType.");
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.parse = (data, params) => parse2(inst, data, params);
+  inst.safeParse = (data, params) => safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params);
+  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+  inst.check = (...checks) => {
+    return inst.clone({
+      ...def,
+      checks: [
+        ...def.checks ?? [],
+        ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" } } } : ch)
+      ]
+    });
+  };
+  inst.clone = (_def) => clone(inst, _def ?? def);
+  inst.brand = () => inst;
+  inst.register = (reg, meta) => {
+    reg.add(inst, meta);
+    return inst;
+  };
+});
+var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function string2(params) {
+  return _string(ZodMiniString, params);
+}
+var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+  $ZodBoolean.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function boolean2(params) {
+  return _boolean(ZodMiniBoolean, params);
+}
+var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function array(element, params) {
+  return new ZodMiniArray({
+    type: "array",
+    element,
+    // get element() {
+    //   return element;
+    // },
+    ...util_exports.normalizeParams(params)
+  });
+}
+var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+  $ZodObject.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    get optional() {
+      return util_exports.optionalObjectKeys(shape ?? {});
     },
-    "~run"(dataset, config2) {
-      if (typeof dataset.value === "string") {
-        dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
+    ...util_exports.normalizeParams(params)
   };
+  return new ZodMiniObject(def);
 }
-function parse(schema, input, config2) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
-  if (dataset.issues) {
-    throw new ValiError(dataset.issues);
-  }
-  return dataset.value;
+var ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+function optional(innerType, params) {
+  return new ZodMiniOptional({
+    type: "optional",
+    innerType,
+    ...util_exports.normalizeParams(params)
+  });
 }
 
 // ../shared/src/schemas.ts
@@ -381,26 +1273,26 @@ var CustomComponentPropSchema = object({
    * @example
    * "to"
    */
-  name: string(),
+  name: string2(),
   /**
    * The name of the prop in the host component.
    * @example
    * "href"
    */
-  as: optional(string()),
+  as: optional(string2()),
   /**
    * Whether the prop is controlled or not in the user-defined component.
    * @internal
    * @example
    * `true`
    */
-  controlled: optional(boolean()),
+  controlled: optional(boolean2()),
   /**
    * The default value of the prop in the user-defined component.
    * @example
    * `"/"`
    */
-  defaultValue: optional(string())
+  defaultValue: optional(string2())
 });
 var CustomComponentSchema = object({
   /**
@@ -408,13 +1300,13 @@ var CustomComponentSchema = object({
    * @example
    * "Link"
    */
-  name: string(),
+  name: string2(),
   /**
    * The name of the host component that the user-defined component represents.
    * @example
    * "a"
    */
-  as: optional(string()),
+  as: optional(string2()),
   /**
    * Attributes mapping between the user-defined component and the host component.
    * @example
@@ -427,28 +1319,28 @@ var CustomComponentSchema = object({
    * @example
    * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
    */
-  selector: optional(string())
+  selector: optional(string2())
 });
 var CustomHooksSchema = object({
-  use: optional(array(string())),
-  useActionState: optional(array(string())),
-  useCallback: optional(array(string())),
-  useContext: optional(array(string())),
-  useDebugValue: optional(array(string())),
-  useDeferredValue: optional(array(string())),
-  useEffect: optional(array(string())),
-  useFormStatus: optional(array(string())),
-  useId: optional(array(string())),
-  useImperativeHandle: optional(array(string())),
-  useInsertionEffect: optional(array(string())),
-  useLayoutEffect: optional(array(string())),
-  useMemo: optional(array(string())),
-  useOptimistic: optional(array(string())),
-  useReducer: optional(array(string())),
-  useRef: optional(array(string())),
-  useState: optional(array(string())),
-  useSyncExternalStore: optional(array(string())),
-  useTransition: optional(array(string()))
+  use: optional(array(string2())),
+  useActionState: optional(array(string2())),
+  useCallback: optional(array(string2())),
+  useContext: optional(array(string2())),
+  useDebugValue: optional(array(string2())),
+  useDeferredValue: optional(array(string2())),
+  useEffect: optional(array(string2())),
+  useFormStatus: optional(array(string2())),
+  useId: optional(array(string2())),
+  useImperativeHandle: optional(array(string2())),
+  useInsertionEffect: optional(array(string2())),
+  useLayoutEffect: optional(array(string2())),
+  useMemo: optional(array(string2())),
+  useOptimistic: optional(array(string2())),
+  useReducer: optional(array(string2())),
+  useRef: optional(array(string2())),
+  useState: optional(array(string2())),
+  useSyncExternalStore: optional(array(string2())),
+  useTransition: optional(array(string2()))
 });
 var ESLintReactSettingsSchema = object({
   /**
@@ -457,43 +1349,43 @@ var ESLintReactSettingsSchema = object({
    * @default `"react"`
    * @example `"@pika/react"`
    */
-  importSource: optional(string()),
+  importSource: optional(string2()),
   /**
    * The identifier that's used for JSX Element creation.
    * @default `"createElement"`
    * @deprecated
    */
-  jsxPragma: optional(string()),
+  jsxPragma: optional(string2()),
   /**
    * The identifier that's used for JSX fragment elements.
    * @description This should not be a member expression (i.e. use "Fragment" instead of "React.Fragment").
    * @default `"Fragment"`
    * @deprecated
    */
-  jsxPragmaFrag: optional(string()),
+  jsxPragmaFrag: optional(string2()),
   /**
    * The name of the prop that is used for polymorphic components.
    * @description This is used to determine the type of the component.
    * @example `"as"`
    */
-  polymorphicPropName: optional(string()),
+  polymorphicPropName: optional(string2()),
   /**
    * @internal
    */
-  strict: optional(boolean(), false),
+  strict: optional(boolean2()),
   /**
    * Check both the shape and the import to determine if an API is from React.
    * @description This can prevent false positives when using a irrelevant third-party library that has similar APIs to React.
    * @default `true`
    */
-  skipImportCheck: optional(boolean(), true),
+  skipImportCheck: optional(boolean2()),
   /**
    * React version to use, "detect" means auto detect React version from the project's dependencies.
    * If `importSource` is specified, an equivalent version of React should be provided here.
    * @example `"18.3.1"`
    * @default `"detect"`
    */
-  version: optional(string()),
+  version: optional(string2()),
   /**
    * A object to define additional hooks that are equivalent to the built-in React Hooks.
    * @description ESLint React will recognize these aliases as equivalent to the built-in hooks in all its rules.
@@ -507,8 +1399,16 @@ var ESLintReactSettingsSchema = object({
    */
   additionalComponents: optional(array(CustomComponentSchema))
 });
+optional(
+  object({
+    "react-x": optional(ESLintReactSettingsSchema),
+    /** @deprecated Use `react-x` instead */
+    reactOptions: optional(ESLintReactSettingsSchema)
+  }),
+  {}
+);
 var DEFAULT_ESLINT_REACT_SETTINGS = {
-  ...parse(ESLintReactSettingsSchema, {}),
+  ...parse2(ESLintReactSettingsSchema, {}),
   importSource: "react"};
 function getInstanceId(node, prev) {
   switch (true) {