@eslint-react/jsx 1.5.11-next.1 → 1.5.11-next.11

package/dist/index.mjs

@@ -1,8 +1,6 @@
-import { is, NodeType, isOneOf, traverseUp, isJSXTagNameExpression, getNestedReturnStatements, traverseUpGuard, isStringLiteral, isMultiLine, ESLintCommunityESLintUtils } from '@eslint-react/ast';
-import { parseSchema, ESLintSettingsSchema } from '@eslint-react/shared';
-import memo from 'micro-memoize';
-import { findVariable, getVariableInit } from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import { isOneOf, NodeType, isJSXTagNameExpression, getNestedReturnStatements, is, traverseUpGuard, isStringLiteral, isMultiLine, ESLintCommunityESLintUtils } from '@eslint-react/ast';
+import { findVariable, getVariableInit } from '@eslint-react/var';
 import '@typescript-eslint/utils';
 
 var __defProp = Object.defineProperty;
@@ -10,8 +8,37 @@ var __export = (target, all3) => {
   for (var name in all3)
     __defProp(target, name, { get: all3[name], enumerable: true });
 };
+function resolveMemberExpressions(object, property) {
+  if (object.type === AST_NODE_TYPES.JSXMemberExpression) {
+    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
+  }
+  if (object.type === AST_NODE_TYPES.JSXNamespacedName) {
+    return `${object.namespace.name}:${object.name.name}.${property.name}`;
+  }
+  return `${object.name}.${property.name}`;
+}
+function elementType(node) {
+  if (node.type === AST_NODE_TYPES.JSXOpeningFragment) {
+    return "<>";
+  }
+  const { name } = node;
+  if (name.type === AST_NODE_TYPES.JSXMemberExpression) {
+    const { object, property } = name;
+    return resolveMemberExpressions(object, property);
+  }
+  if (name.type === AST_NODE_TYPES.JSXNamespacedName) {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return name.name;
+}
+function isJSXElementOfUserDefinedComponent(node) {
+  return node.openingElement.name.type === NodeType.JSXIdentifier && /^[A-Z]/u.test(node.openingElement.name.name);
+}
+function isJSXElementOfBuiltinComponent(node) {
+  return node.openingElement.name.type === NodeType.JSXIdentifier && node.openingElement.name.name.toLowerCase() === node.openingElement.name.name && /^[a-z]/u.test(node.openingElement.name.name);
+}
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Function.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Function.js
 var Function_exports = {};
 __export(Function_exports, {
   SK: () => SK,
@@ -186,14 +213,164 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
 var hole = /* @__PURE__ */ unsafeCoerce(absurd);
 var SK = (_2, b2) => b2;
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Equivalence.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Array.js
+var Array_exports = {};
+__export(Array_exports, {
+  allocate: () => allocate,
+  append: () => append,
+  appendAll: () => appendAll,
+  cartesian: () => cartesian,
+  cartesianWith: () => cartesianWith,
+  chop: () => chop,
+  chunksOf: () => chunksOf,
+  contains: () => contains2,
+  containsWith: () => containsWith2,
+  copy: () => copy,
+  dedupe: () => dedupe,
+  dedupeAdjacent: () => dedupeAdjacent,
+  dedupeAdjacentWith: () => dedupeAdjacentWith,
+  dedupeWith: () => dedupeWith,
+  difference: () => difference,
+  differenceWith: () => differenceWith,
+  drop: () => drop,
+  dropRight: () => dropRight,
+  dropWhile: () => dropWhile,
+  empty: () => empty2,
+  every: () => every2,
+  extend: () => extend,
+  filter: () => filter2,
+  filterMap: () => filterMap2,
+  filterMapWhile: () => filterMapWhile,
+  findFirst: () => findFirst2,
+  findFirstIndex: () => findFirstIndex,
+  findLast: () => findLast,
+  findLastIndex: () => findLastIndex,
+  flatMap: () => flatMap2,
+  flatMapNullable: () => flatMapNullable2,
+  flatten: () => flatten2,
+  forEach: () => forEach,
+  fromIterable: () => fromIterable2,
+  fromNullable: () => fromNullable2,
+  fromOption: () => fromOption2,
+  fromRecord: () => fromRecord,
+  get: () => get,
+  getEquivalence: () => getEquivalence2,
+  getLefts: () => getLefts,
+  getOrder: () => getOrder2,
+  getRights: () => getRights,
+  getSomes: () => getSomes,
+  group: () => group,
+  groupBy: () => groupBy,
+  groupWith: () => groupWith,
+  head: () => head,
+  headNonEmpty: () => headNonEmpty,
+  init: () => init,
+  initNonEmpty: () => initNonEmpty,
+  insertAt: () => insertAt,
+  intersection: () => intersection,
+  intersectionWith: () => intersectionWith,
+  intersperse: () => intersperse,
+  isArray: () => isArray,
+  isEmptyArray: () => isEmptyArray,
+  isEmptyReadonlyArray: () => isEmptyReadonlyArray,
+  isNonEmptyArray: () => isNonEmptyArray2,
+  isNonEmptyReadonlyArray: () => isNonEmptyReadonlyArray,
+  join: () => join,
+  last: () => last,
+  lastNonEmpty: () => lastNonEmpty,
+  length: () => length,
+  liftEither: () => liftEither,
+  liftNullable: () => liftNullable2,
+  liftOption: () => liftOption,
+  liftPredicate: () => liftPredicate2,
+  make: () => make4,
+  makeBy: () => makeBy,
+  map: () => map2,
+  mapAccum: () => mapAccum,
+  match: () => match2,
+  matchLeft: () => matchLeft,
+  matchRight: () => matchRight,
+  max: () => max2,
+  min: () => min2,
+  modify: () => modify,
+  modifyNonEmptyHead: () => modifyNonEmptyHead,
+  modifyNonEmptyLast: () => modifyNonEmptyLast,
+  modifyOption: () => modifyOption,
+  of: () => of,
+  partition: () => partition,
+  partitionMap: () => partitionMap2,
+  prepend: () => prepend,
+  prependAll: () => prependAll,
+  range: () => range,
+  reduce: () => reduce,
+  reduceRight: () => reduceRight,
+  remove: () => remove,
+  replace: () => replace,
+  replaceOption: () => replaceOption,
+  replicate: () => replicate,
+  reverse: () => reverse,
+  rotate: () => rotate,
+  scan: () => scan,
+  scanRight: () => scanRight,
+  separate: () => separate,
+  setNonEmptyHead: () => setNonEmptyHead,
+  setNonEmptyLast: () => setNonEmptyLast,
+  some: () => some4,
+  sort: () => sort,
+  sortBy: () => sortBy,
+  sortWith: () => sortWith,
+  span: () => span,
+  split: () => split,
+  splitAt: () => splitAt,
+  splitNonEmptyAt: () => splitNonEmptyAt,
+  splitWhere: () => splitWhere,
+  tail: () => tail,
+  tailNonEmpty: () => tailNonEmpty,
+  take: () => take,
+  takeRight: () => takeRight,
+  takeWhile: () => takeWhile,
+  unappend: () => unappend,
+  unfold: () => unfold,
+  union: () => union,
+  unionWith: () => unionWith,
+  unprepend: () => unprepend,
+  unsafeGet: () => unsafeGet,
+  unzip: () => unzip,
+  zip: () => zip,
+  zipWith: () => zipWith2
+});
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+var array = (item) => make((self, that) => {
+  if (self.length !== that.length) {
+    return false;
+  }
+  for (let i2 = 0; i2 < self.length; i2++) {
+    const isEq = item(self[i2], that[i2]);
+    if (!isEq) {
+      return false;
+    }
+  }
+  return true;
+});
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.0.7";
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/doNotation.js
+var let_ = (map3) => dual(3, (self, name, f2) => map3(self, (a2) => Object.assign({}, a2, {
+  [name]: f2(a2)
+})));
+var bindTo = (map3) => dual(2, (self, name) => map3(self, (a2) => ({
+  [name]: a2
+})));
+var bind = (map3, flatMap3) => dual(3, (self, name, f2) => flatMap3(self, (a2) => map3(f2(a2), (b2) => Object.assign({}, a2, {
+  [name]: b2
+}))));
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.1.2";
 var getCurrentVersion = () => moduleVersion;
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/GlobalValue.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`);
 if (!(globalStoreId in globalThis)) {
   globalThis[globalStoreId] = /* @__PURE__ */ new Map();
@@ -206,7 +383,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Predicate.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Predicate.js
 var Predicate_exports = {};
 __export(Predicate_exports, {
   all: () => all,
@@ -304,13 +481,13 @@ var all = (collection) => {
 };
 var productMany = (self, collection) => {
   const rest = all(collection);
-  return ([head, ...tail]) => self(head) === false ? false : rest(tail);
+  return ([head2, ...tail2]) => self(head2) === false ? false : rest(tail2);
 };
 var tuple = (...elements) => all(elements);
 var struct = (fields) => {
-  const keys = Object.keys(fields);
+  const keys2 = Object.keys(fields);
   return (a2) => {
-    for (const key of keys) {
+    for (const key of keys2) {
       if (!fields[key](a2[key])) {
         return false;
       }
@@ -343,10 +520,10 @@ var some = (collection) => (a2) => {
   return false;
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/internal/errors.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Utils.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var isGenKind = (u2) => isObject(u2) && GenKindTypeId in u2;
 var GenKindImpl = class {
@@ -492,19 +669,19 @@ var PCGRandom = class {
    * @category getter
    * @since 2.0.0
    */
-  integer(max) {
-    if (!max) {
+  integer(max3) {
+    if (!max3) {
       return this._next();
     }
-    max = max >>> 0;
-    if ((max & max - 1) === 0) {
-      return this._next() & max - 1;
+    max3 = max3 >>> 0;
+    if ((max3 & max3 - 1) === 0) {
+      return this._next() & max3 - 1;
     }
     let num = 0;
-    const skew = (-max >>> 0) % max >>> 0;
+    const skew = (-max3 >>> 0) % max3 >>> 0;
     for (num = this._next(); num < skew; num = this._next()) {
     }
-    return num % max;
+    return num % max3;
   }
   /**
    * Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
@@ -585,8 +762,12 @@ function yieldWrapGet(self) {
   }
   throw new Error(getBugErrorMessage("yieldWrapGet"));
 }
+var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
+  enabled: false,
+  tester: void 0
+}));
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Hash.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var pcgr = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/pcgr"), () => new PCGRandom());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
@@ -620,6 +801,9 @@ var hash = (self) => {
   }
 };
 var random = (self) => {
+  if (structuralRegionState.enabled === true) {
+    return 0;
+  }
   if (!randomHashCache.has(self)) {
     randomHashCache.set(self, number(pcgr.integer(Number.MAX_SAFE_INTEGER)));
   }
@@ -652,27 +836,39 @@ var cached = function() {
   if (arguments.length === 1) {
     const self2 = arguments[0];
     return function(hash3) {
-      Object.defineProperty(self2, symbol, {
-        value() {
-          return hash3;
-        },
-        enumerable: false
-      });
+      const original2 = self2[symbol].bind(self2);
+      if (structuralRegionState.enabled === false) {
+        Object.defineProperty(self2, symbol, {
+          value() {
+            if (structuralRegionState.enabled === true) {
+              return original2();
+            }
+            return hash3;
+          },
+          enumerable: false
+        });
+      }
       return hash3;
     };
   }
   const self = arguments[0];
   const hash2 = arguments[1];
-  Object.defineProperty(self, symbol, {
-    value() {
-      return hash2;
-    },
-    enumerable: false
-  });
+  const original = self[symbol].bind(self);
+  if (structuralRegionState.enabled === false) {
+    Object.defineProperty(self, symbol, {
+      value() {
+        if (structuralRegionState.enabled === true) {
+          return original();
+        }
+        return hash2;
+      },
+      enumerable: false
+    });
+  }
   return hash2;
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Equal.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -688,17 +884,37 @@ function compareBoth(self, that) {
   if (selfType !== typeof that) {
     return false;
   }
-  if ((selfType === "object" || selfType === "function") && self !== null && that !== null) {
-    if (isEqual(self) && isEqual(that)) {
-      return hash(self) === hash(that) && self[symbol2](that);
+  if (selfType === "object" || selfType === "function") {
+    if (self !== null && that !== null) {
+      if (isEqual(self) && isEqual(that)) {
+        return hash(self) === hash(that) && self[symbol2](that);
+      }
+    }
+    if (structuralRegionState.enabled) {
+      if (Array.isArray(self) && Array.isArray(that)) {
+        return self.length === that.length && self.every((v2, i2) => compareBoth(v2, that[i2]));
+      }
+      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
+        const keysSelf = Object.keys(self);
+        const keysThat = Object.keys(that);
+        if (keysSelf.length === keysThat.length) {
+          for (const key of keysSelf) {
+            if (!(key in that && compareBoth(self[key], that[key]))) {
+              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+            }
+          }
+          return true;
+        }
+      }
+      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
     }
   }
-  return false;
+  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
 }
 var isEqual = (u2) => hasProperty(u2, symbol2);
 var equivalence = () => equals;
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Inspectable.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x2) => {
   if (hasProperty(x2, "toJSON") && isFunction2(x2["toJSON"]) && x2["toJSON"].length === 0) {
@@ -710,7 +926,7 @@ var toJSON = (x2) => {
 };
 var format = (x2) => JSON.stringify(x2, null, 2);
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Pipeable.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
     case 1:
@@ -741,7 +957,7 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/internal/effectable.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -802,7 +1018,7 @@ var EffectPrototype = {
   }
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/internal/option.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -860,7 +1076,7 @@ var some2 = (value) => {
   return a2;
 };
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/internal/either.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -924,7 +1140,14 @@ var right = (right2) => {
 var getLeft = (self) => isRight(self) ? none : some2(self.left);
 var getRight = (self) => isLeft(self) ? none : some2(self.right);
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Option.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Either.js
+var isLeft2 = isLeft;
+var isRight2 = isRight;
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Option.js
 var Option_exports = {};
 __export(Option_exports, {
   Do: () => Do,
@@ -934,8 +1157,8 @@ __export(Option_exports, {
   ap: () => ap,
   as: () => as,
   asVoid: () => asVoid,
-  bind: () => bind,
-  bindTo: () => bindTo,
+  bind: () => bind2,
+  bindTo: () => bindTo2,
   composeK: () => composeK,
   contains: () => contains,
   containsWith: () => containsWith,
@@ -961,7 +1184,7 @@ __export(Option_exports, {
   isNone: () => isNone2,
   isOption: () => isOption2,
   isSome: () => isSome2,
-  let: () => let_,
+  let: () => let_2,
   lift2: () => lift2,
   liftNullable: () => liftNullable,
   liftPredicate: () => liftPredicate,
@@ -986,10 +1209,41 @@ __export(Option_exports, {
   zipWith: () => zipWith
 });
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Order.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
+var combineMany = /* @__PURE__ */ dual(2, (self, collection) => make2((a1, a2) => {
+  let out = self(a1, a2);
+  if (out !== 0) {
+    return out;
+  }
+  for (const O2 of collection) {
+    out = O2(a1, a2);
+    if (out !== 0) {
+      return out;
+    }
+  }
+  return out;
+}));
+var empty = () => make2(() => 0);
+var combineAll = (collection) => combineMany(empty(), collection);
+var mapInput2 = /* @__PURE__ */ dual(2, (self, f2) => make2((b1, b2) => self(f2(b1), f2(b2))));
+var array2 = (O2) => make2((self, that) => {
+  const aLen = self.length;
+  const bLen = that.length;
+  const len = Math.min(aLen, bLen);
+  for (let i2 = 0; i2 < len; i2++) {
+    const o2 = O2(self[i2], that[i2]);
+    if (o2 !== 0) {
+      return o2;
+    }
+  }
+  return number2(aLen, bLen);
+});
+var min = (O2) => dual(2, (self, that) => self === that || O2(self, that) < 1 ? self : that);
+var max = (O2) => dual(2, (self, that) => self === that || O2(self, that) > -1 ? self : that);
 
-// ../../../node_modules/.pnpm/effect@3.0.7/node_modules/effect/dist/esm/Option.js
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Option.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Option");
 var none2 = () => none;
 var some3 = some2;
@@ -1119,15 +1373,9 @@ var containsWith = (isEquivalent) => dual(2, (self, a2) => isNone2(self) ? false
 var _equivalence = /* @__PURE__ */ equivalence();
 var contains = /* @__PURE__ */ containsWith(_equivalence);
 var exists = /* @__PURE__ */ dual(2, (self, refinement) => isNone2(self) ? false : refinement(self.value));
-var bindTo = /* @__PURE__ */ dual(2, (self, name) => map(self, (a2) => ({
-  [name]: a2
-})));
-var let_ = /* @__PURE__ */ dual(3, (self, name, f2) => map(self, (a2) => Object.assign({}, a2, {
-  [name]: f2(a2)
-})));
-var bind = /* @__PURE__ */ dual(3, (self, name, f2) => flatMap(self, (a2) => map(f2(a2), (b2) => Object.assign({}, a2, {
-  [name]: b2
-}))));
+var bindTo2 = /* @__PURE__ */ bindTo(map);
+var let_2 = /* @__PURE__ */ let_(map);
+var bind2 = /* @__PURE__ */ bind(map, flatMap);
 var Do = /* @__PURE__ */ some3({});
 var adapter2 = /* @__PURE__ */ adapter();
 var gen = (f2) => {
@@ -1162,32 +1410,585 @@ var gen = (f2) => {
     return some3(state.value);
   }
 };
-var RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
-var RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
-function getFragmentFromContext(context) {
-  const settings = parseSchema(ESLintSettingsSchema, context.settings);
-  const fragment = settings.reactOptions?.jsxPragmaFrag;
-  if (Predicate_exports.isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment))
-    return fragment;
-  return "Fragment";
-}
-var getPragmaFromContext = memo(
-  (context) => {
-    const settings = parseSchema(ESLintSettingsSchema, context.settings);
-    const pragma = settings.reactOptions?.jsxPragma;
-    const { sourceCode } = context;
-    const pragmaNode = sourceCode.getAllComments().find((node) => RE_JSX_ANNOTATION_REGEX.test(node.value));
-    return Function_exports.pipe(
-      Option_exports.orElse(Option_exports.fromNullable(pragma), () => Function_exports.pipe(
-        Option_exports.fromNullable(pragmaNode),
-        Option_exports.map(({ value }) => RE_JSX_ANNOTATION_REGEX.exec(value)),
-        Option_exports.flatMapNullable((matches) => matches?.[1]?.split(".")[0])
-      )),
-      Option_exports.flatMap(Option_exports.liftPredicate((x2) => RE_JS_IDENTIFIER_REGEX.test(x2))),
-      Option_exports.getOrElse(Function_exports.constant("React"))
-    );
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Tuple.js
+var make3 = (...elements) => elements;
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Iterable.js
+var findFirst = /* @__PURE__ */ dual(2, (self, f2) => {
+  let i2 = 0;
+  for (const a2 of self) {
+    const o2 = f2(a2, i2);
+    if (isBoolean(o2)) {
+      if (o2) {
+        return some3(a2);
+      }
+    } else {
+      if (isSome2(o2)) {
+        return o2;
+      }
+    }
+    i2++;
+  }
+  return none2();
+});
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Record.js
+var collect = /* @__PURE__ */ dual(2, (self, f2) => {
+  const out = [];
+  for (const key of keys(self)) {
+    out.push(f2(key, self[key]));
   }
-);
+  return out;
+});
+var toEntries = /* @__PURE__ */ collect((key, value) => [key, value]);
+var keys = (self) => Object.keys(self);
+
+// ../../../node_modules/.pnpm/effect@3.1.2/node_modules/effect/dist/esm/Array.js
+var make4 = (...elements) => elements;
+var allocate = (n2) => new Array(n2);
+var makeBy = (n2, f2) => {
+  const max3 = Math.max(1, Math.floor(n2));
+  const out = new Array(max3);
+  for (let i2 = 0; i2 < max3; i2++) {
+    out[i2] = f2(i2);
+  }
+  return out;
+};
+var range = (start, end) => start <= end ? makeBy(end - start + 1, (i2) => start + i2) : [start];
+var replicate = /* @__PURE__ */ dual(2, (a2, n2) => makeBy(n2, () => a2));
+var fromIterable2 = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+var fromRecord = toEntries;
+var fromOption2 = toArray;
+var match2 = /* @__PURE__ */ dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(self) : onEmpty());
+var matchLeft = /* @__PURE__ */ dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());
+var matchRight = /* @__PURE__ */ dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());
+var prepend = /* @__PURE__ */ dual(2, (self, head2) => [head2, ...self]);
+var prependAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable2(that).concat(fromIterable2(self)));
+var append = /* @__PURE__ */ dual(2, (self, last2) => [...self, last2]);
+var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable2(self).concat(fromIterable2(that)));
+var scan = /* @__PURE__ */ dual(3, (self, b2, f2) => {
+  const out = [b2];
+  let i2 = 0;
+  for (const a2 of self) {
+    out[i2 + 1] = f2(out[i2], a2);
+    i2++;
+  }
+  return out;
+});
+var scanRight = /* @__PURE__ */ dual(3, (self, b2, f2) => {
+  const input = fromIterable2(self);
+  const out = new Array(input.length + 1);
+  out[input.length] = b2;
+  for (let i2 = input.length - 1; i2 >= 0; i2--) {
+    out[i2] = f2(out[i2 + 1], input[i2]);
+  }
+  return out;
+});
+var isArray = Array.isArray;
+var isEmptyArray = (self) => self.length === 0;
+var isEmptyReadonlyArray = isEmptyArray;
+var isNonEmptyArray2 = isNonEmptyArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
+var length = (self) => self.length;
+var isOutOfBound = (i2, as2) => i2 < 0 || i2 >= as2.length;
+var clamp = (i2, as2) => Math.floor(Math.min(Math.max(0, i2), as2.length));
+var get = /* @__PURE__ */ dual(2, (self, index) => {
+  const i2 = Math.floor(index);
+  return isOutOfBound(i2, self) ? none2() : some3(self[i2]);
+});
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i2 = Math.floor(index);
+  if (isOutOfBound(i2, self)) {
+    throw new Error(`Index ${i2} out of bounds`);
+  }
+  return self[i2];
+});
+var unprepend = (self) => [headNonEmpty(self), tailNonEmpty(self)];
+var unappend = (self) => [initNonEmpty(self), lastNonEmpty(self)];
+var head = /* @__PURE__ */ get(0);
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var last = (self) => isNonEmptyReadonlyArray(self) ? some3(lastNonEmpty(self)) : none2();
+var lastNonEmpty = (self) => self[self.length - 1];
+var tail = (self) => {
+  const input = fromIterable2(self);
+  return isNonEmptyReadonlyArray(input) ? some3(tailNonEmpty(input)) : none2();
+};
+var tailNonEmpty = (self) => self.slice(1);
+var init = (self) => {
+  const input = fromIterable2(self);
+  return isNonEmptyReadonlyArray(input) ? some3(initNonEmpty(input)) : none2();
+};
+var initNonEmpty = (self) => self.slice(0, -1);
+var take = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  return input.slice(0, clamp(n2, input));
+});
+var takeRight = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  const i2 = clamp(n2, input);
+  return i2 === 0 ? [] : input.slice(-i2);
+});
+var takeWhile = /* @__PURE__ */ dual(2, (self, predicate) => {
+  let i2 = 0;
+  const out = [];
+  for (const a2 of self) {
+    if (!predicate(a2, i2)) {
+      break;
+    }
+    out.push(a2);
+    i2++;
+  }
+  return out;
+});
+var spanIndex = (self, predicate) => {
+  let i2 = 0;
+  for (const a2 of self) {
+    if (!predicate(a2, i2)) {
+      break;
+    }
+    i2++;
+  }
+  return i2;
+};
+var span = /* @__PURE__ */ dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
+var drop = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  return input.slice(clamp(n2, input), input.length);
+});
+var dropRight = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  return input.slice(0, input.length - clamp(n2, input));
+});
+var dropWhile = /* @__PURE__ */ dual(2, (self, predicate) => fromIterable2(self).slice(spanIndex(self, predicate)));
+var findFirstIndex = /* @__PURE__ */ dual(2, (self, predicate) => {
+  let i2 = 0;
+  for (const a2 of self) {
+    if (predicate(a2, i2)) {
+      return some3(i2);
+    }
+    i2++;
+  }
+  return none2();
+});
+var findLastIndex = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const input = fromIterable2(self);
+  for (let i2 = input.length - 1; i2 >= 0; i2--) {
+    if (predicate(input[i2], i2)) {
+      return some3(i2);
+    }
+  }
+  return none2();
+});
+var findFirst2 = findFirst;
+var findLast = /* @__PURE__ */ dual(2, (self, f2) => {
+  const input = fromIterable2(self);
+  for (let i2 = input.length - 1; i2 >= 0; i2--) {
+    const a2 = input[i2];
+    const o2 = f2(a2, i2);
+    if (isBoolean(o2)) {
+      if (o2) {
+        return some3(a2);
+      }
+    } else {
+      if (isSome2(o2)) {
+        return o2;
+      }
+    }
+  }
+  return none2();
+});
+var insertAt = /* @__PURE__ */ dual(3, (self, i2, b2) => {
+  const out = Array.from(self);
+  if (i2 < 0 || i2 > out.length) {
+    return none2();
+  }
+  out.splice(i2, 0, b2);
+  return some3(out);
+});
+var replace = /* @__PURE__ */ dual(3, (self, i2, b2) => modify(self, i2, () => b2));
+var replaceOption = /* @__PURE__ */ dual(3, (self, i2, b2) => modifyOption(self, i2, () => b2));
+var modify = /* @__PURE__ */ dual(3, (self, i2, f2) => getOrElse(modifyOption(self, i2, f2), () => Array.from(self)));
+var modifyOption = /* @__PURE__ */ dual(3, (self, i2, f2) => {
+  const out = Array.from(self);
+  if (isOutOfBound(i2, out)) {
+    return none2();
+  }
+  const next = f2(out[i2]);
+  out[i2] = next;
+  return some3(out);
+});
+var remove = /* @__PURE__ */ dual(2, (self, i2) => {
+  const out = Array.from(self);
+  if (isOutOfBound(i2, out)) {
+    return out;
+  }
+  out.splice(i2, 1);
+  return out;
+});
+var reverse = (self) => Array.from(self).reverse();
+var sort = /* @__PURE__ */ dual(2, (self, O2) => {
+  const out = Array.from(self);
+  out.sort(O2);
+  return out;
+});
+var sortWith = /* @__PURE__ */ dual(3, (self, f2, order) => sort(self, mapInput2(order, f2)));
+var sortBy = (...orders) => {
+  const sortByAll = sort(combineAll(orders));
+  return (self) => {
+    const input = fromIterable2(self);
+    if (isNonEmptyReadonlyArray(input)) {
+      return sortByAll(input);
+    }
+    return [];
+  };
+};
+var zip = /* @__PURE__ */ dual(2, (self, that) => zipWith2(self, that, make3));
+var zipWith2 = /* @__PURE__ */ dual(3, (self, that, f2) => {
+  const as2 = fromIterable2(self);
+  const bs = fromIterable2(that);
+  if (isNonEmptyReadonlyArray(as2) && isNonEmptyReadonlyArray(bs)) {
+    const out = [f2(headNonEmpty(as2), headNonEmpty(bs))];
+    const len = Math.min(as2.length, bs.length);
+    for (let i2 = 1; i2 < len; i2++) {
+      out[i2] = f2(as2[i2], bs[i2]);
+    }
+    return out;
+  }
+  return [];
+});
+var unzip = (self) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const fa = [input[0][0]];
+    const fb = [input[0][1]];
+    for (let i2 = 1; i2 < input.length; i2++) {
+      fa[i2] = input[i2][0];
+      fb[i2] = input[i2][1];
+    }
+    return [fa, fb];
+  }
+  return [[], []];
+};
+var intersperse = /* @__PURE__ */ dual(2, (self, middle) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const tail2 = tailNonEmpty(input);
+    for (let i2 = 0; i2 < tail2.length; i2++) {
+      if (i2 < tail2.length) {
+        out.push(middle);
+      }
+      out.push(tail2[i2]);
+    }
+    return out;
+  }
+  return [];
+});
+var modifyNonEmptyHead = /* @__PURE__ */ dual(2, (self, f2) => [f2(headNonEmpty(self)), ...tailNonEmpty(self)]);
+var setNonEmptyHead = /* @__PURE__ */ dual(2, (self, b2) => modifyNonEmptyHead(self, () => b2));
+var modifyNonEmptyLast = /* @__PURE__ */ dual(2, (self, f2) => append(initNonEmpty(self), f2(lastNonEmpty(self))));
+var setNonEmptyLast = /* @__PURE__ */ dual(2, (self, b2) => modifyNonEmptyLast(self, () => b2));
+var rotate = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const len = input.length;
+    const m2 = Math.round(n2) % len;
+    if (isOutOfBound(Math.abs(m2), input) || m2 === 0) {
+      return copy(input);
+    }
+    if (m2 < 0) {
+      const [f2, s2] = splitNonEmptyAt(input, -m2);
+      return appendAll(s2, f2);
+    } else {
+      return rotate(self, m2 - len);
+    }
+  }
+  return [];
+});
+var containsWith2 = (isEquivalent) => dual(2, (self, a2) => {
+  for (const i2 of self) {
+    if (isEquivalent(a2, i2)) {
+      return true;
+    }
+  }
+  return false;
+});
+var _equivalence2 = /* @__PURE__ */ equivalence();
+var contains2 = /* @__PURE__ */ containsWith2(_equivalence2);
+var chop = /* @__PURE__ */ dual(2, (self, f2) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const [b2, rest] = f2(input);
+    const out = [b2];
+    let next = rest;
+    while (isNonEmptyArray(next)) {
+      const [b3, rest2] = f2(next);
+      out.push(b3);
+      next = rest2;
+    }
+    return out;
+  }
+  return [];
+});
+var splitAt = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = Array.from(self);
+  const _n = Math.floor(n2);
+  if (isNonEmptyReadonlyArray(input)) {
+    if (_n >= 1) {
+      return splitNonEmptyAt(input, _n);
+    }
+    return [[], input];
+  }
+  return [input, []];
+});
+var splitNonEmptyAt = /* @__PURE__ */ dual(2, (self, n2) => {
+  const _n = Math.max(1, Math.floor(n2));
+  return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];
+});
+var split = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  return chunksOf(input, Math.ceil(input.length / Math.floor(n2)));
+});
+var splitWhere = /* @__PURE__ */ dual(2, (self, predicate) => span(self, (a2, i2) => !predicate(a2, i2)));
+var copy = (self) => self.slice();
+var chunksOf = /* @__PURE__ */ dual(2, (self, n2) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    return chop(input, splitNonEmptyAt(n2));
+  }
+  return [];
+});
+var groupWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => chop(self, (as2) => {
+  const h2 = headNonEmpty(as2);
+  const out = [h2];
+  let i2 = 1;
+  for (; i2 < as2.length; i2++) {
+    const a2 = as2[i2];
+    if (isEquivalent(a2, h2)) {
+      out.push(a2);
+    } else {
+      break;
+    }
+  }
+  return [out, as2.slice(i2)];
+}));
+var group = /* @__PURE__ */ groupWith(/* @__PURE__ */ equivalence());
+var groupBy = /* @__PURE__ */ dual(2, (self, f2) => {
+  const out = {};
+  for (const a2 of self) {
+    const k2 = f2(a2);
+    if (Object.prototype.hasOwnProperty.call(out, k2)) {
+      out[k2].push(a2);
+    } else {
+      out[k2] = [a2];
+    }
+  }
+  return out;
+});
+var unionWith = /* @__PURE__ */ dual(3, (self, that, isEquivalent) => {
+  const a2 = fromIterable2(self);
+  const b2 = fromIterable2(that);
+  if (isNonEmptyReadonlyArray(a2)) {
+    if (isNonEmptyReadonlyArray(b2)) {
+      const dedupe2 = dedupeWith(isEquivalent);
+      return dedupe2(appendAll(a2, b2));
+    }
+    return a2;
+  }
+  return b2;
+});
+var union = /* @__PURE__ */ dual(2, (self, that) => unionWith(self, that, _equivalence2));
+var intersectionWith = (isEquivalent) => {
+  const has = containsWith2(isEquivalent);
+  return dual(2, (self, that) => fromIterable2(self).filter((a2) => has(that, a2)));
+};
+var intersection = /* @__PURE__ */ intersectionWith(_equivalence2);
+var differenceWith = (isEquivalent) => {
+  const has = containsWith2(isEquivalent);
+  return dual(2, (self, that) => fromIterable2(self).filter((a2) => !has(that, a2)));
+};
+var difference = /* @__PURE__ */ differenceWith(_equivalence2);
+var empty2 = () => [];
+var of = (a2) => [a2];
+var map2 = /* @__PURE__ */ dual(2, (self, f2) => self.map(f2));
+var flatMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i2 = 0; i2 < self.length; i2++) {
+    const inner = f2(self[i2], i2);
+    for (let j2 = 0; j2 < inner.length; j2++) {
+      out.push(inner[j2]);
+    }
+  }
+  return out;
+});
+var flatten2 = /* @__PURE__ */ flatMap2(identity);
+var filterMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
+  const as2 = fromIterable2(self);
+  const out = [];
+  for (let i2 = 0; i2 < as2.length; i2++) {
+    const o2 = f2(as2[i2], i2);
+    if (isSome2(o2)) {
+      out.push(o2.value);
+    }
+  }
+  return out;
+});
+var filterMapWhile = /* @__PURE__ */ dual(2, (self, f2) => {
+  let i2 = 0;
+  const out = [];
+  for (const a2 of self) {
+    const b2 = f2(a2, i2);
+    if (isSome2(b2)) {
+      out.push(b2.value);
+    } else {
+      break;
+    }
+    i2++;
+  }
+  return out;
+});
+var partitionMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
+  const left2 = [];
+  const right2 = [];
+  const as2 = fromIterable2(self);
+  for (let i2 = 0; i2 < as2.length; i2++) {
+    const e2 = f2(as2[i2], i2);
+    if (isLeft2(e2)) {
+      left2.push(e2.left);
+    } else {
+      right2.push(e2.right);
+    }
+  }
+  return [left2, right2];
+});
+var getSomes = /* @__PURE__ */ filterMap2(identity);
+var getLefts = (self) => {
+  const out = [];
+  for (const a2 of self) {
+    if (isLeft2(a2)) {
+      out.push(a2.left);
+    }
+  }
+  return out;
+};
+var getRights = (self) => {
+  const out = [];
+  for (const a2 of self) {
+    if (isRight2(a2)) {
+      out.push(a2.right);
+    }
+  }
+  return out;
+};
+var filter2 = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const as2 = fromIterable2(self);
+  const out = [];
+  for (let i2 = 0; i2 < as2.length; i2++) {
+    if (predicate(as2[i2], i2)) {
+      out.push(as2[i2]);
+    }
+  }
+  return out;
+});
+var partition = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const left2 = [];
+  const right2 = [];
+  const as2 = fromIterable2(self);
+  for (let i2 = 0; i2 < as2.length; i2++) {
+    if (predicate(as2[i2], i2)) {
+      right2.push(as2[i2]);
+    } else {
+      left2.push(as2[i2]);
+    }
+  }
+  return [left2, right2];
+});
+var separate = /* @__PURE__ */ partitionMap2(identity);
+var reduce = /* @__PURE__ */ dual(3, (self, b2, f2) => fromIterable2(self).reduce((b3, a2, i2) => f2(b3, a2, i2), b2));
+var reduceRight = /* @__PURE__ */ dual(3, (self, b2, f2) => fromIterable2(self).reduceRight((b3, a2, i2) => f2(b3, a2, i2), b2));
+var liftPredicate2 = (predicate) => (b2) => predicate(b2) ? [b2] : [];
+var liftOption = (f2) => (...a2) => fromOption2(f2(...a2));
+var fromNullable2 = (a2) => a2 == null ? empty2() : [a2];
+var liftNullable2 = (f2) => (...a2) => fromNullable2(f2(...a2));
+var flatMapNullable2 = /* @__PURE__ */ dual(2, (self, f2) => isNonEmptyReadonlyArray(self) ? fromNullable2(f2(headNonEmpty(self))) : empty2());
+var liftEither = (f2) => (...a2) => {
+  const e2 = f2(...a2);
+  return isLeft2(e2) ? [] : [e2.right];
+};
+var every2 = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
+var some4 = /* @__PURE__ */ dual(2, (self, predicate) => self.some(predicate));
+var extend = /* @__PURE__ */ dual(2, (self, f2) => self.map((_2, i2, as2) => f2(as2.slice(i2))));
+var min2 = /* @__PURE__ */ dual(2, (self, O2) => self.reduce(min(O2)));
+var max2 = /* @__PURE__ */ dual(2, (self, O2) => self.reduce(max(O2)));
+var unfold = (b2, f2) => {
+  const out = [];
+  let next = b2;
+  let o2;
+  while (isSome2(o2 = f2(next))) {
+    const [a2, b3] = o2.value;
+    out.push(a2);
+    next = b3;
+  }
+  return out;
+};
+var getOrder2 = array2;
+var getEquivalence2 = array;
+var forEach = /* @__PURE__ */ dual(2, (self, f2) => fromIterable2(self).forEach((a2, i2) => f2(a2, i2)));
+var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const input = fromIterable2(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r2 of rest) {
+      if (out.every((a2) => !isEquivalent(r2, a2))) {
+        out.push(r2);
+      }
+    }
+    return out;
+  }
+  return [];
+});
+var dedupe = (self) => dedupeWith(self, equivalence());
+var dedupeAdjacentWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const out = [];
+  let lastA = none2();
+  for (const a2 of self) {
+    if (isNone2(lastA) || !isEquivalent(a2, lastA.value)) {
+      out.push(a2);
+      lastA = some3(a2);
+    }
+  }
+  return out;
+});
+var dedupeAdjacent = /* @__PURE__ */ dedupeAdjacentWith(/* @__PURE__ */ equivalence());
+var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable2(self).join(sep));
+var mapAccum = /* @__PURE__ */ dual(3, (self, s2, f2) => {
+  let i2 = 0;
+  let s1 = s2;
+  const out = [];
+  for (const a2 of self) {
+    const r2 = f2(s1, a2, i2);
+    s1 = r2[0];
+    out.push(r2[1]);
+    i2++;
+  }
+  return [s1, out];
+});
+var cartesianWith = /* @__PURE__ */ dual(3, (self, that, f2) => flatMap2(self, (a2) => map2(that, (b2) => f2(a2, b2))));
+var cartesian = /* @__PURE__ */ dual(2, (self, that) => cartesianWith(self, that, (a2, b2) => [a2, b2]));
 
 // ../../../node_modules/.pnpm/ts-pattern@5.1.1/node_modules/ts-pattern/dist/index.js
 var t = Symbol.for("@ts-pattern/matcher");
@@ -1464,177 +2265,7 @@ var z = class _z {
   }
 };
 
-// src/pragma/is-from-pragma.ts
-function isInitializedFromPragma(variableName, context, initialScope, pragma = getPragmaFromContext(context)) {
-  const maybeVariable = findVariable(variableName, initialScope);
-  const maybeLatestDef = Option_exports.flatMapNullable(maybeVariable, (variable) => variable.defs.at(-1));
-  if (Option_exports.isNone(maybeLatestDef))
-    return false;
-  const latestDef = maybeLatestDef.value;
-  const { node, parent } = latestDef;
-  if (node.type === NodeType.VariableDeclarator && node.init) {
-    const { init } = node;
-    if (a({ type: "MemberExpression", object: { type: "Identifier", name: pragma } }, init))
-      return true;
-    if (a({ type: "Identifier", name: pragma }, init))
-      return true;
-    const maybeRequireExpression = $(init).with({
-      type: NodeType.CallExpression,
-      callee: { type: NodeType.Identifier, name: "require" }
-    }, (exp) => Option_exports.some(exp)).with(
-      {
-        type: NodeType.MemberExpression,
-        object: {
-          type: NodeType.CallExpression,
-          callee: { type: NodeType.Identifier, name: "require" }
-        }
-      },
-      ({ object }) => Option_exports.some(object)
-    ).otherwise(Option_exports.none);
-    if (Option_exports.isNone(maybeRequireExpression))
-      return false;
-    const requireExpression = maybeRequireExpression.value;
-    const [firstArg] = requireExpression.arguments;
-    if (firstArg?.type !== NodeType.Literal)
-      return false;
-    return firstArg.value === pragma.toLowerCase();
-  }
-  return a({ type: "ImportDeclaration", source: { value: pragma.toLowerCase() } }, parent);
-}
-function isPropertyOfPragma(name, context, pragma = getPragmaFromContext(context)) {
-  const isMatch = a({
-    type: NodeType.MemberExpression,
-    object: {
-      type: NodeType.Identifier,
-      name: pragma
-    },
-    property: {
-      name
-    }
-  });
-  return isMatch;
-}
-function isFromPragma(name) {
-  return (node, context) => {
-    const initialScope = context.sourceCode.getScope(node);
-    if (node.type === NodeType.MemberExpression)
-      return isPropertyOfPragma(name, context)(node);
-    if (node.name === name)
-      return isInitializedFromPragma(name, context, initialScope);
-    return false;
-  };
-}
-function isFromPragmaMember(pragmaMemberName, name) {
-  return (node, context, pragma = getPragmaFromContext(context)) => {
-    const initialScope = context.sourceCode.getScope(node);
-    if (node.property.type !== NodeType.Identifier || node.property.name !== name)
-      return false;
-    if (node.object.type === NodeType.Identifier && node.object.name === pragmaMemberName) {
-      return isInitializedFromPragma(node.object.name, context, initialScope, pragma);
-    }
-    if (node.object.type === NodeType.MemberExpression && node.object.object.type === NodeType.Identifier && node.object.object.name === pragma && node.object.property.type === NodeType.Identifier) {
-      return node.object.property.name === pragmaMemberName;
-    }
-    return false;
-  };
-}
-function isCallFromPragma(name) {
-  return (node, context) => {
-    if (!isOneOf([NodeType.Identifier, NodeType.MemberExpression])(node.callee))
-      return false;
-    return isFromPragma(name)(node.callee, context);
-  };
-}
-function isCallFromPragmaMember(pragmaMemberName, name) {
-  return (node, context) => {
-    if (!is(NodeType.MemberExpression)(node.callee))
-      return false;
-    return isFromPragmaMember(pragmaMemberName, name)(node.callee, context);
-  };
-}
-
-// src/element/api.ts
-var isCreateElement = isFromPragma("createElement");
-var isCreateElementCall = (node, context) => {
-  if (!isOneOf([NodeType.Identifier, NodeType.MemberExpression])(node.callee))
-    return false;
-  return isCreateElement(node.callee, context);
-};
-var isCloneElement = isFromPragma("cloneElement");
-var isCloneElementCall = (node, context) => {
-  if (!isOneOf([NodeType.Identifier, NodeType.MemberExpression])(node.callee))
-    return false;
-  return isCloneElement(node.callee, context);
-};
-function resolveMemberExpressions(object, property) {
-  if (object.type === AST_NODE_TYPES.JSXMemberExpression) {
-    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
-  }
-  if (object.type === AST_NODE_TYPES.JSXNamespacedName) {
-    return `${object.namespace.name}:${object.name.name}.${property.name}`;
-  }
-  return `${object.name}.${property.name}`;
-}
-function elementType(node) {
-  if (node.type === AST_NODE_TYPES.JSXOpeningFragment) {
-    return "<>";
-  }
-  const { name } = node;
-  if (name.type === AST_NODE_TYPES.JSXMemberExpression) {
-    const { object, property } = name;
-    return resolveMemberExpressions(object, property);
-  }
-  if (name.type === AST_NODE_TYPES.JSXNamespacedName) {
-    return `${name.namespace.name}:${name.name.name}`;
-  }
-  return name.name;
-}
-function isInsideCreateElementProps(node, context) {
-  return Function_exports.pipe(
-    traverseUp(node, (n2) => is(NodeType.CallExpression)(n2) && isCreateElementCall(n2, context)),
-    Option_exports.filter(is(NodeType.CallExpression)),
-    Option_exports.flatMapNullable((c2) => c2.arguments.at(1)),
-    Option_exports.filter(is(NodeType.ObjectExpression)),
-    Option_exports.zipWith(traverseUp(node, is(NodeType.ObjectExpression)), (a2, b2) => a2 === b2),
-    Option_exports.getOrElse(Function_exports.constFalse)
-  );
-}
-function isChildrenOfCreateElement(node, context) {
-  return Function_exports.pipe(
-    Option_exports.fromNullable(node.parent),
-    Option_exports.filter(is(NodeType.CallExpression)),
-    Option_exports.filter((n2) => isCreateElementCall(n2, context)),
-    Option_exports.exists(
-      (n2) => n2.arguments.slice(2).some((arg) => arg === node)
-    )
-  );
-}
-function hasChildren(node, predicate) {
-  if (Predicate_exports.isFunction(predicate))
-    return node.children.some(predicate);
-  return node.children.length > 0;
-}
-function isChildOfJSXElement(node) {
-  return node.parent?.type === NodeType.JSXElement && node.parent.children.some((child) => child === node);
-}
-function isJSXElementOfUserDefinedComponent(node) {
-  return node.openingElement.name.type === NodeType.JSXIdentifier && /^[A-Z]/u.test(node.openingElement.name.name);
-}
-function isJSXElementOfBuiltinComponent(node) {
-  return node.openingElement.name.type === NodeType.JSXIdentifier && node.openingElement.name.name.toLowerCase() === node.openingElement.name.name && /^[a-z]/u.test(node.openingElement.name.name);
-}
-var isFragment = (node, pragma, fragment) => {
-  if (!isOneOf([NodeType.JSXElement, NodeType.JSXFragment])(node))
-    return false;
-  return isFragmentSyntax(node) || isFragmentElement(node, pragma, fragment);
-};
-var isFragmentSyntax = is(NodeType.JSXFragment);
-function isFragmentElement(node, pragma, fragment) {
-  const { name } = node.openingElement;
-  if (name.type === NodeType.JSXIdentifier && name.name === fragment)
-    return true;
-  return name.type === NodeType.JSXMemberExpression && name.object.type === NodeType.JSXIdentifier && name.object.name === pragma && name.property.name === fragment;
-}
+// src/value/is-jsx-value.ts
 var JSXValueHint = {
   None: 0n,
   SkipNullLiteral: 1n << 0n,
@@ -1682,7 +2313,7 @@ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
   }).with({ type: NodeType.CallExpression }, (node2) => {
     if (hint & JSXValueHint.SkipCreateElement)
       return false;
-    return isCreateElementCall(node2, context);
+    return $(node2.callee).with({ type: NodeType.Identifier, name: "createElement" }, Function_exports.constTrue).with({ type: NodeType.MemberExpression, property: { name: "createElement" } }, Function_exports.constTrue).otherwise(Function_exports.constFalse);
   }).with({ type: NodeType.Identifier }, (node2) => {
     const { name } = node2;
     if (name === "undefined")
@@ -1707,6 +2338,19 @@ function isFunctionReturningJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HIN
   const statements = getNestedReturnStatements(node.body);
   return statements.some((statement) => isJSXValue(statement.argument, context, hint));
 }
+
+// src/pragma.ts
+var RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
+var RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
+function getJSXPragmaFromContext(context) {
+  const { sourceCode } = context;
+  return Function_exports.pipe(
+    Array_exports.findFirst(sourceCode.getAllComments(), (node) => RE_JSX_ANNOTATION_REGEX.test(node.value)),
+    Option_exports.map(({ value }) => RE_JSX_ANNOTATION_REGEX.exec(value)),
+    Option_exports.flatMapNullable((matches) => matches?.[1]),
+    Option_exports.filter((pragma) => RE_JS_IDENTIFIER_REGEX.test(pragma))
+  );
+}
 var { getStaticValue } = ESLintCommunityESLintUtils;
 function getPropName(node) {
   return $(node.name).when(is(NodeType.JSXIdentifier), (n2) => n2.name).when(is(NodeType.JSXNamespacedName), (n2) => `${n2.namespace.name}:${n2.name.name}`).exhaustive();
@@ -1744,13 +2388,13 @@ function findPropInProperties(properties, context, initialScope, seenProps = [])
             );
             if (Option_exports.isNone(maybeInit))
               return false;
-            const init = maybeInit.value;
-            if (init.type !== NodeType.ObjectExpression)
+            const init2 = maybeInit.value;
+            if (init2.type !== NodeType.ObjectExpression)
               return false;
             if (seenProps.includes(name))
               return false;
             return Option_exports.isSome(
-              findPropInProperties(init.properties, context, initialScope, [...seenProps, name])(propName)
+              findPropInProperties(init2.properties, context, initialScope, [...seenProps, name])(propName)
             );
           }).when(is(NodeType.ObjectExpression), (argument) => {
             return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
@@ -1777,10 +2421,10 @@ function findPropInAttributes(attributes, context, initialScope) {
             );
             if (Option_exports.isNone(maybeInit))
               return false;
-            const init = maybeInit.value;
-            if (!("properties" in init))
+            const init2 = maybeInit.value;
+            if (!("properties" in init2))
               return false;
-            return Option_exports.isSome(findPropInProperties(init.properties, context, initialScope)(propName));
+            return Option_exports.isSome(findPropInProperties(init2.properties, context, initialScope)(propName));
           }).when(is(NodeType.ObjectExpression), (argument) => {
             return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
           }).when(is(NodeType.MemberExpression), () => {
@@ -1828,4 +2472,4 @@ function isPaddingSpaces(node) {
   return isLiteral(node) && isWhiteSpace(node) && node.raw.includes("\n");
 }
 
-export { DEFAULT_JSX_VALUE_HINT, JSXValueHint, elementType, findPropInAttributes, findPropInProperties, getFragmentFromContext, getPragmaFromContext, getProp, getPropName, getPropValue, hasAnyProp, hasChildren, hasEveryProp, hasProp, isCallFromPragma, isCallFromPragmaMember, isChildOfJSXElement, isChildrenOfCreateElement, isCloneElement, isCloneElementCall, isCreateElement, isCreateElementCall, isFragment, isFragmentElement, isFragmentSyntax, isFromPragma, isFromPragmaMember, isFunctionReturningJSXValue, isInitializedFromPragma, isInsideCreateElementProps, isInsidePropValue, isJSXElementOfBuiltinComponent, isJSXElementOfUserDefinedComponent, isJSXValue, isLineBreak, isLiteral, isPaddingSpaces, isPropertyOfPragma, isWhiteSpace, traverseUpProp };
+export { DEFAULT_JSX_VALUE_HINT, JSXValueHint, elementType, findPropInAttributes, findPropInProperties, getJSXPragmaFromContext, getProp, getPropName, getPropValue, hasAnyProp, hasEveryProp, hasProp, isFunctionReturningJSXValue, isInsidePropValue, isJSXElementOfBuiltinComponent, isJSXElementOfUserDefinedComponent, isJSXValue, isLineBreak, isLiteral, isPaddingSpaces, isWhiteSpace, traverseUpProp };