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

package/dist/index.mjs

@@ -1,1403 +1,13 @@
 import * as AST9 from '@eslint-react/ast';
 import { flip, dual, constFalse, identity, constTrue, _ } from '@eslint-react/eff';
-import { RegExp as RegExp$1, Selector } from '@eslint-react/kit';
-import { coerceSettings, getId } from '@eslint-react/shared';
+import { RegExp, Selector } from '@eslint-react/kit';
+import { coerceSettings, DEFAULT_ESLINT_REACT_SETTINGS, getId } from '@eslint-react/shared';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import * as VAR3 from '@eslint-react/var';
 import { isMatching, P, match } from 'ts-pattern';
 import birecord from 'birecord';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// ../../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 {
-    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.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();
-  return value;
-}
-function cached(getter) {
-  return {
-    get value() {
-      {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-    }
-  };
-}
-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
-  });
-}
-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 = "";
-  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 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)
-    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
-  });
-}
-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.5.1/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.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);
-  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.5.1/node_modules/@zod/core/dist/esm/doc.js
-var Doc = class {
-  constructor(args = []) {
-    this.content = [];
-    this.indent = 0;
-    if (this)
-      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 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.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")) {
-    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()).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: issues.map((iss) => finalizeIssue(iss, {}, config())) };
-        });
-      }
-      if (result.issues.length === 0)
-        return { value: result.value };
-      return { issues: result.issues.map((iss) => finalizeIssue(iss, {}, config())) };
-    },
-    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);
-  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 {
-        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.5.1/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.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 });
-var safeParseAsync = /* @__PURE__ */ _safeParseAsync.bind({
-  Error: $ZodError
-});
-
-// ../../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.");
-  $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;
-    // },
-    ...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 ?? {});
-    },
-    ...util_exports.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,
-    ...util_exports.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"};
+// src/component/component-collector.ts
 function getInstanceId(node, prev) {
   switch (true) {
     case (node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev):
@@ -2129,10 +739,10 @@ function getComponentFlagFromInitPath(initPath) {
   return flag;
 }
 function isComponentName(name) {
-  return RegExp$1.COMPONENT_NAME.test(name);
+  return RegExp.COMPONENT_NAME.test(name);
 }
 function isComponentNameLoose(name) {
-  return RegExp$1.COMPONENT_NAME_LOOSE.test(name);
+  return RegExp.COMPONENT_NAME_LOOSE.test(name);
 }
 function getComponentNameFromId(id) {
   if (id == null) return _;