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

package/dist/index.js

@@ -34,909 +34,6 @@ var VAR3__namespace = /*#__PURE__*/_interopNamespace(VAR3);
 var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 
 // src/component/component-collector.ts
-
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/core.js
-// @__NO_SIDE_EFFECTS__
-function $constructor(name, initializer) {
-  class _6 {
-    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;
-}
-function jsonStringifyReplacer(_6, value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  return value;
-}
-function cached(getter) {
-  return {
-    get value() {
-      {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-    }
-  };
-}
-function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
-  const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
-}
-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
-  });
-}
-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;
-}
-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 clone(inst, def) {
-  return new inst._zod.constr(def);
-}
-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 optionalObjectKeys(shape) {
-  return Object.keys(shape).filter((k) => {
-    return shape[k]._zod.qout === "true";
-  });
-}
-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;
-}
-
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/errors.js
-var ZOD_ERROR = Symbol.for("{{zod.error}}");
-var $ZodError = class {
-  get message() {
-    return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
-  }
-  constructor(issues) {
-    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;
-  }
-};
-
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/parse.js
-function _parse(schema, value, _ctx) {
-  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  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;
-}
-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 };
-}
-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.1.0/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.1.0/node_modules/@zod/core/dist/esm/schemas.js
-var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
-  var _a;
-  inst ?? (inst = {});
-  inst._zod.id = def.type + "_" + randomString(10);
-  inst._zod.def = def;
-  inst._zod.computed = inst._zod.computed || {};
-  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;
-          }
-        }
-        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);
-    };
-  }
-  defineLazy(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;
-  };
-});
-var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload) => 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 {
-        handleArrayResult(result, payload, i);
-      }
-    }
-    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;
-  }
-}
-function handleOptionalObjectResult(result, final, key, input) {
-  if (result.issues.length) {
-    if (input[key] === void 0) {
-      if (key in input) {
-        final.value[key] = void 0;
-      }
-    } 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;
-  }
-}
-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;
-  inst._zod.parse = (payload, ctx) => {
-    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 } = _normalized.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 = [];
-    for (const key of Object.keys(input)) {
-      if (_normalized.value.keySet.has(key))
-        continue;
-      if (catchall._zod.def.type === "never") {
-        unrecognized.push(key);
-        continue;
-      }
-      const r = catchall._zod.run({ value: input[key], issues: [] }, ctx);
-      if (r instanceof Promise) {
-        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
-      } else {
-        handleObjectResult(r, payload, key);
-      }
-    }
-    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;
-    });
-  };
-});
-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);
-  };
-});
-
-// ../../node_modules/.pnpm/@zod+core@0.1.0/node_modules/@zod/core/dist/esm/api.js
-function _string(Class, params) {
-  return new Class({
-    type: "string",
-    ...normalizeParams(params)
-  });
-}
-function _boolean(Class, params) {
-  return new Class({
-    type: "boolean",
-    ...normalizeParams(params)
-  });
-}
-function _unknown(Class, params) {
-  return new Class({
-    type: "unknown",
-    ...normalizeParams(params)
-  });
-}
-
-// ../../node_modules/.pnpm/@zod+mini@4.0.0-beta.0/node_modules/@zod/mini/dist/esm/parse.js
-var parse2 = /* @__PURE__ */ _parse.bind({ Error: $ZodError });
-var safeParse = /* @__PURE__ */ _safeParse.bind({ Error: $ZodError });
-var parseAsync2 = /* @__PURE__ */ _parseAsync.bind({ Error: $ZodError });
-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
-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 ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
-  $ZodUnknown.init(inst, def);
-  ZodMiniType.init(inst, def);
-});
-function unknown(params) {
-  return _unknown(ZodMiniUnknown, 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;
-    // },
-    ...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 optionalObjectKeys(shape ?? {});
-    },
-    ...normalizeParams(params)
-  };
-  return new ZodMiniObject(def);
-}
-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,
-    ...normalizeParams(params)
-  });
-}
-
-// ../shared/src/schemas.ts
-var CustomComponentPropSchema = object({
-  /**
-   * The name of the prop in the user-defined component.
-   * @example
-   * "to"
-   */
-  name: string2(),
-  /**
-   * The name of the prop in the host component.
-   * @example
-   * "href"
-   */
-  as: optional(string2()),
-  /**
-   * Whether the prop is controlled or not in the user-defined component.
-   * @internal
-   * @example
-   * `true`
-   */
-  controlled: optional(boolean2()),
-  /**
-   * The default value of the prop in the user-defined component.
-   * @example
-   * `"/"`
-   */
-  defaultValue: optional(string2())
-});
-var CustomComponentSchema = object({
-  /**
-   * The name of the user-defined component.
-   * @example
-   * "Link"
-   */
-  name: string2(),
-  /**
-   * The name of the host component that the user-defined component represents.
-   * @example
-   * "a"
-   */
-  as: optional(string2()),
-  /**
-   * Attributes mapping between the user-defined component and the host component.
-   * @example
-   * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
-   */
-  attributes: optional(array(CustomComponentPropSchema)),
-  /**
-   * The ESQuery selector to select the component precisely.
-   * @internal
-   * @example
-   * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
-   */
-  selector: optional(string2())
-});
-var CustomHooksSchema = object({
-  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()))
-});
-object({
-  /**
-   * The source where React is imported from.
-   * @description This allows to specify a custom import location for React when not using the official distribution.
-   * @default `"react"`
-   * @example `"@pika/react"`
-   */
-  importSource: optional(string2()),
-  /**
-   * The identifier that's used for JSX Element creation.
-   * @default `"createElement"`
-   * @deprecated
-   */
-  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(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(string2()),
-  /**
-   * @default `true`
-   * @internal
-   */
-  strict: optional(boolean2()),
-  /**
-   * Check both the shape and the import to determine if an API is from React.
-   * @default `true`
-   * @internal
-   */
-  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(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.
-   * @example `{ useEffect: ["useIsomorphicLayoutEffect"] }`
-   */
-  additionalHooks: optional(CustomHooksSchema),
-  /**
-   * An array of user-defined components
-   * @description This is used to inform the ESLint React plugins how to treat these components during checks.
-   * @example `[{ name: "Link", as: "a", attributes: [{ name: "to", as: "href" }, { name: "rel", defaultValue: "noopener noreferrer" }] }]`
-   */
-  additionalComponents: optional(array(CustomComponentSchema))
-});
-optional(
-  object({
-    "react-x": optional(unknown())
-  }),
-  {}
-);
-var DEFAULT_ESLINT_REACT_SETTINGS = {
-  importSource: "react"};
 function getInstanceId(node, prev) {
   switch (true) {
     case (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init === prev):
@@ -1055,7 +152,7 @@ function isReactHookCall(node) {
 function isReactHookCallWithName(context, node) {
   if (node == null || node.type !== types.AST_NODE_TYPES.CallExpression) return eff.constFalse;
   const {
-    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    importSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
   } = shared.coerceSettings(context.settings);
   const initialScope = context.sourceCode.getScope(node);
@@ -1085,7 +182,7 @@ function isReactHookCallWithNameLoose(node) {
 }
 function isReactHookCallWithNameAlias(context, name, alias = []) {
   const {
-    importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource,
+    importSource = shared.DEFAULT_ESLINT_REACT_SETTINGS.importSource,
     skipImportCheck = true
   } = shared.coerceSettings(context.settings);
   return (node) => {
@@ -1194,10 +291,10 @@ function isFunctionOfUseEffectSetup(node) {
 function isFunctionOfUseEffectCleanup(node) {
   if (node == null) return false;
   const pReturn = AST9__namespace.findParentNode(node, AST9__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
-  const pFaunction = AST9__namespace.findParentNode(node, AST9__namespace.isFunction);
+  const pFunction = AST9__namespace.findParentNode(node, AST9__namespace.isFunction);
   const pFunctionOfReturn = AST9__namespace.findParentNode(pReturn, AST9__namespace.isFunction);
-  if (pFaunction !== pFunctionOfReturn) return false;
-  return isFunctionOfUseEffectSetup(pFaunction);
+  if (pFunction !== pFunctionOfReturn) return false;
+  return isFunctionOfUseEffectSetup(pFunction);
 }
 function stringifyJsx(node) {
   switch (node.type) {