@eslint-react/jsx 0.5.7 → 0.5.9

package/dist/index.cjs

@@ -1,17 +1,9 @@
 'use strict';
 
-var memo = require('micro-memoize');
 require('@typescript-eslint/scope-manager');
 var types = require('@typescript-eslint/types');
 var utils = require('@typescript-eslint/utils');
-
-/**
- * Check if a JSXElement or JSXFragment has children
- * @param node The AST node to check
- * @returns `true` if the node has children
- */ function hasChildren(node) {
-    return node.children.length > 0;
-}
+var memo = require('micro-memoize');
 
 /**
  * @since 2.0.0
@@ -1287,7 +1279,6 @@ const LeftProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Common
 };
 /** @internal */ const getLeft$2 = (self)=>isRight$1(self) ? none$1 : some$4(self.left);
 /** @internal */ const getRight$2 = (self)=>isLeft$1(self) ? none$1 : some$4(self.right);
-/** @internal */ const fromOption$1 = /*#__PURE__*/ dual(2, (self, onNone)=>isNone$1(self) ? left$1(onNone()) : right$1(self.value));
 /**
  * @since 2.0.0
  */ /**
@@ -2227,15 +2218,6 @@ var effectOption_esm = /*#__PURE__*/ Object.freeze({
     zipRight: zipRight,
     zipWith: zipWith$3
 });
-/**
- * @since 2.0.0
- */ /**
- * @category models
- * @since 2.0.0
- */ /**
- * @category symbols
- * @since 2.0.0
- */ const TypeId$5 = TypeId$7;
 /**
  * @category symbols
  * @since 2.0.0
@@ -2268,366 +2250,6 @@ var effectOption_esm = /*#__PURE__*/ Object.freeze({
  * @category constructors
  * @since 2.0.0
  */ const left = left$1;
-/**
- * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use
- * the provided default as a `Left`.
- *
- * @example
- * import * as Either from 'effect/Either'
- *
- * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
- * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback'))
- *
- * @category constructors
- * @since 2.0.0
- */ const fromNullable = /*#__PURE__*/ dual(2, (self, onNullable)=>self == null ? left(onNullable(self)) : right(self));
-/**
- * @example
- * import * as Either from 'effect/Either'
- * import * as Option from 'effect/Option'
- *
- * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
- * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error'))
- *
- * @category constructors
- * @since 2.0.0
- */ const fromOption = fromOption$1;
-const try_ = (evaluate)=>{
-    if (isFunction(evaluate)) {
-        try {
-            return right(evaluate());
-        } catch (e) {
-            return left(e);
-        }
-    } else {
-        try {
-            return right(evaluate.try());
-        } catch (e) {
-            return left(evaluate.catch(e));
-        }
-    }
-};
-/**
- * Tests if a value is a `Either`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isEither, left, right } from 'effect/Either'
- *
- * assert.deepStrictEqual(isEither(right(1)), true)
- * assert.deepStrictEqual(isEither(left("a")), true)
- * assert.deepStrictEqual(isEither({ right: 1 }), false)
- *
- * @category guards
- * @since 2.0.0
- */ const isEither = isEither$1;
-/**
- * Determine if a `Either` is a `Left`.
- *
- * @param self - The `Either` to check.
- *
- * @example
- * import { isLeft, left, right } from 'effect/Either'
- *
- * assert.deepStrictEqual(isLeft(right(1)), false)
- * assert.deepStrictEqual(isLeft(left("a")), true)
- *
- * @category guards
- * @since 2.0.0
- */ const isLeft = isLeft$1;
-/**
- * Determine if a `Either` is a `Right`.
- *
- * @param self - The `Either` to check.
- *
- * @example
- * import { isRight, left, right } from 'effect/Either'
- *
- * assert.deepStrictEqual(isRight(right(1)), true)
- * assert.deepStrictEqual(isRight(left("a")), false)
- *
- * @category guards
- * @since 2.0.0
- */ const isRight = isRight$1;
-/**
- * Converts a `Either` to an `Option` discarding the `Left`.
- *
- * Alias of {@link toOption}.
- *
- * @example
- * import * as O from 'effect/Option'
- * import * as E from 'effect/Either'
- *
- * assert.deepStrictEqual(E.getRight(E.right('ok')), O.some('ok'))
- * assert.deepStrictEqual(E.getRight(E.left('err')), O.none())
- *
- * @category getters
- * @since 2.0.0
- */ const getRight = getRight$2;
-/**
- * Converts a `Either` to an `Option` discarding the value.
- *
- * @example
- * import * as O from 'effect/Option'
- * import * as E from 'effect/Either'
- *
- * assert.deepStrictEqual(E.getLeft(E.right('ok')), O.none())
- * assert.deepStrictEqual(E.getLeft(E.left('err')), O.some('err'))
- *
- * @category getters
- * @since 2.0.0
- */ const getLeft = getLeft$2;
-/**
- * @category equivalence
- * @since 2.0.0
- */ const getEquivalence$4 = (EE, EA)=>make$7((x, y)=>x === y || (isLeft(x) ? isLeft(y) && EE(x.left, y.left) : isRight(y) && EA(x.right, y.right)));
-/**
- * @category mapping
- * @since 2.0.0
- */ const mapBoth = /*#__PURE__*/ dual(2, (self, { onLeft, onRight })=>isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right)));
-/**
- * Maps the `Left` side of an `Either` value to a new `Either` value.
- *
- * @param self - The input `Either` value to map.
- * @param f - A transformation function to apply to the `Left` value of the input `Either`.
- *
- * @category mapping
- * @since 2.0.0
- */ const mapLeft = /*#__PURE__*/ dual(2, (self, f)=>isLeft(self) ? left(f(self.left)) : right(self.right));
-/**
- * Maps the `Right` side of an `Either` value to a new `Either` value.
- *
- * @param self - An `Either` to map
- * @param f - The function to map over the value of the `Either`
- *
- * @category mapping
- * @since 2.0.0
- */ const map$4 = /*#__PURE__*/ dual(2, (self, f)=>isRight(self) ? right(f(self.right)) : left(self.left));
-/**
- * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function,
- * if the value is a `Right` the inner value is applied to the `onRight` function.
- *
- * @example
- * import * as E from 'effect/Either'
- * import { pipe } from 'effect/Function'
- *
- * const onLeft  = (strings: ReadonlyArray<string>): string => `strings: ${strings.join(', ')}`
- *
- * const onRight = (value: number): string => `Ok: ${value}`
- *
- * assert.deepStrictEqual(pipe(E.right(1), E.match({ onLeft, onRight })), 'Ok: 1')
- * assert.deepStrictEqual(
- *   pipe(E.left(['string 1', 'string 2']), E.match({ onLeft, onRight })),
- *   'strings: string 1, string 2'
- * )
- *
- * @category pattern matching
- * @since 2.0.0
- */ const match = /*#__PURE__*/ dual(2, (self, { onLeft, onRight })=>isLeft(self) ? onLeft(self.left) : onRight(self.right));
-/**
- * @category getters
- * @since 2.0.0
- */ const merge = /*#__PURE__*/ match({
-    onLeft: identity$1,
-    onRight: identity$1
-});
-/**
- * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.
- *
- * @example
- * import * as Either from 'effect/Either'
- *
- * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
- * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!")
- *
- * @category getters
- * @since 2.0.0
- */ const getOrElse = /*#__PURE__*/ dual(2, (self, onLeft)=>isLeft(self) ? onLeft(self.left) : self.right);
-/**
- * @example
- * import * as Either from 'effect/Either'
- *
- * assert.deepStrictEqual(Either.getOrNull(Either.right(1)), 1)
- * assert.deepStrictEqual(Either.getOrNull(Either.left("a")), null)
- *
- * @category getters
- * @since 2.0.0
- */ const getOrNull = /*#__PURE__*/ getOrElse(constNull);
-/**
- * @example
- * import * as Either from 'effect/Either'
- *
- * assert.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1)
- * assert.deepStrictEqual(Either.getOrUndefined(Either.left("a")), undefined)
- *
- * @category getters
- * @since 2.0.0
- */ const getOrUndefined = /*#__PURE__*/ getOrElse(constUndefined);
-/**
- * Extracts the value of an `Either` or throws if the `Either` is `Left`.
- *
- * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
- *
- * @param self - The `Either` to extract the value from.
- * @param onLeft - A function that will be called if the `Either` is `Left`. It returns the error to be thrown.
- *
- * @example
- * import * as E from "effect/Either"
- *
- * assert.deepStrictEqual(
- *   E.getOrThrowWith(E.right(1), () => new Error('Unexpected Left')),
- *   1
- * )
- * assert.throws(() => E.getOrThrowWith(E.left("error"), () => new Error('Unexpected Left')))
- *
- * @category getters
- * @since 2.0.0
- */ const getOrThrowWith = /*#__PURE__*/ dual(2, (self, onLeft)=>{
-    if (isRight(self)) {
-        return self.right;
-    }
-    throw onLeft(self.left);
-});
-/**
- * Extracts the value of an `Either` or throws if the `Either` is `Left`.
- *
- * The thrown error is a default error. To configure the error thrown, see  {@link getOrThrowWith}.
- *
- * @param self - The `Either` to extract the value from.
- * @throws `Error("getOrThrow called on a Left")`
- *
- * @example
- * import * as E from "effect/Either"
- *
- * assert.deepStrictEqual(E.getOrThrow(E.right(1)), 1)
- * assert.throws(() => E.getOrThrow(E.left("error")))
- *
- * @category getters
- * @since 2.0.0
- */ const getOrThrow = /*#__PURE__*/ getOrThrowWith(()=>new Error("getOrThrow called on a Left"));
-/**
- * Returns `self` if it is a `Right` or `that` otherwise.
- *
- * @param self - The input `Either` value to check and potentially return.
- * @param that - A function that takes the error value from `self` (if it's a `Left`) and returns a new `Either` value.
- *
- * @category error handling
- * @since 2.0.0
- */ const orElse = /*#__PURE__*/ dual(2, (self, that)=>isLeft(self) ? that(self.left) : right(self.right));
-/**
- * @category combining
- * @since 2.0.0
- */ const flatMap$2 = /*#__PURE__*/ dual(2, (self, f)=>isLeft(self) ? left(self.left) : f(self.right));
-/**
- * @since 2.0.0
- * @category combining
- */ const zipWith$2 = /*#__PURE__*/ dual(3, (self, that, f)=>flatMap$2(self, (a)=>map$4(that, (b)=>f(a, b))));
-/**
- * @category combining
- * @since 2.0.0
- */ const ap = /*#__PURE__*/ dual(2, (self, that)=>zipWith$2(self, that, (f, a)=>f(a)));
-/**
- * Takes a structure of `Option`s and returns an `Option` of values with the same structure.
- *
- * - If a tuple is supplied, then the returned `Option` will contain a tuple with the same length.
- * - If a struct is supplied, then the returned `Option` will contain a struct with the same keys.
- * - If an iterable is supplied, then the returned `Option` will contain an array.
- *
- * @param fields - the struct of `Option`s to be sequenced.
- *
- * @example
- * import * as Either from "effect/Either"
- *
- * assert.deepStrictEqual(Either.all([Either.right(1), Either.right(2)]), Either.right([1, 2]))
- * assert.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.right("hello") }), Either.right({ a: 1, b: "hello" }))
- * assert.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.left("error") }), Either.left("error"))
- *
- * @category combining
- * @since 2.0.0
- */ // @ts-expect-error
-const all = (input)=>{
-    if (Symbol.iterator in input) {
-        const out = [];
-        for (const e of input){
-            if (isLeft(e)) {
-                return e;
-            }
-            out.push(e.right);
-        }
-        return right(out);
-    }
-    const out = {};
-    for (const key of Object.keys(input)){
-        const e = input[key];
-        if (isLeft(e)) {
-            return e;
-        }
-        out[key] = e.right;
-    }
-    return right(out);
-};
-/**
- * @since 2.0.0
- */ const reverse$3 = (self)=>isLeft(self) ? right(self.left) : left(self.right);
-const adapter = /*#__PURE__*/ adapter$2();
-/**
- * @category generators
- * @since 2.0.0
- */ const gen = (f)=>{
-    const iterator = f(adapter);
-    let state = iterator.next();
-    if (state.done) {
-        return right(state.value);
-    } else {
-        let current = state.value.value;
-        if (isLeft(current)) {
-            return current;
-        }
-        while(!state.done){
-            state = iterator.next(current.right);
-            if (!state.done) {
-                current = state.value.value;
-                if (isLeft(current)) {
-                    return current;
-                }
-            }
-        }
-        return right(state.value);
-    }
-};
-var effectEither_esm = /*#__PURE__*/ Object.freeze({
-    __proto__: null,
-    TypeId: TypeId$5,
-    all: all,
-    ap: ap,
-    flatMap: flatMap$2,
-    fromNullable: fromNullable,
-    fromOption: fromOption,
-    gen: gen,
-    getEquivalence: getEquivalence$4,
-    getLeft: getLeft,
-    getOrElse: getOrElse,
-    getOrNull: getOrNull,
-    getOrThrow: getOrThrow,
-    getOrThrowWith: getOrThrowWith,
-    getOrUndefined: getOrUndefined,
-    getRight: getRight,
-    isEither: isEither,
-    isLeft: isLeft,
-    isRight: isRight,
-    left: left,
-    map: map$4,
-    mapBoth: mapBoth,
-    mapLeft: mapLeft,
-    match: match,
-    merge: merge,
-    orElse: orElse,
-    reverse: reverse$3,
-    right: right,
-    try: try_,
-    zipWith: zipWith$2
-});
 /**
  * @category conversions
  * @since 2.0.0
@@ -5130,30 +4752,6 @@ var effectData_esm = /*#__PURE__*/ Object.freeze({
     unsafeStruct: unsafeStruct
 });
 
-const RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
-// Does not check for reserved keywords or unicode characters
-const RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
-function getFragmentFromContext(context) {
-    // eslint-disable-next-line prefer-destructuring
-    const settings = context.settings;
-    const pragma = settings.react?.fragment ?? "Fragment";
-    if (!RE_JS_IDENTIFIER_REGEX.test(pragma)) {
-        return effectEither_esm.left(new Error(`Fragment pragma ${pragma} is not a valid identifier`));
-    }
-    return effectEither_esm.right(pragma);
-}
-const getPragmaFromContext = memo((context)=>{
-    // eslint-disable-next-line prefer-destructuring
-    const settings = context.settings;
-    const sourceCode = context.getSourceCode();
-    const pragmaNode = sourceCode.getAllComments().find((node)=>RE_JSX_ANNOTATION_REGEX.test(node.value));
-    const pragma = settings.react?.pragma ?? effectFunction_esm.pipe(effectOption_esm.fromNullable(pragmaNode), effectOption_esm.map((node)=>RE_JSX_ANNOTATION_REGEX.exec(node.value)), effectOption_esm.flatMap((matches)=>effectOption_esm.fromNullable(matches?.[1]?.split(".")[0])), effectOption_esm.getOrElse(()=>"React"));
-    if (!RE_JS_IDENTIFIER_REGEX.test(pragma)) {
-        return effectEither_esm.left(new Error(`React pragma ${pragma} is not a valid identifier`));
-    }
-    return effectEither_esm.right(pragma);
-});
-
 function isNil(x){
   return x === undefined || x === null
 }
@@ -5440,6 +5038,51 @@ isOneOf([
     NodeType.TSInterfaceDeclaration,
     NodeType.TSTypeAliasDeclaration
 ]);
+isOneOf([
+    NodeType.ArrayExpression,
+    NodeType.ArrayPattern,
+    NodeType.ArrowFunctionExpression,
+    NodeType.CallExpression,
+    NodeType.ClassExpression,
+    NodeType.FunctionExpression,
+    NodeType.Identifier,
+    NodeType.JSXElement,
+    NodeType.JSXFragment,
+    NodeType.Literal,
+    NodeType.TemplateLiteral,
+    NodeType.MemberExpression,
+    NodeType.MetaProperty,
+    NodeType.ObjectExpression,
+    NodeType.ObjectPattern,
+    NodeType.SequenceExpression,
+    NodeType.Super,
+    NodeType.TaggedTemplateExpression,
+    NodeType.ThisExpression
+]);
+isOneOf([
+    NodeType.ArrayExpression,
+    NodeType.ArrayPattern,
+    NodeType.ArrowFunctionExpression,
+    NodeType.CallExpression,
+    NodeType.ClassExpression,
+    NodeType.FunctionExpression,
+    NodeType.Identifier,
+    NodeType.JSXElement,
+    NodeType.JSXFragment,
+    NodeType.Literal,
+    NodeType.TemplateLiteral,
+    NodeType.MemberExpression,
+    NodeType.MetaProperty,
+    NodeType.ObjectExpression,
+    NodeType.ObjectPattern,
+    NodeType.SequenceExpression,
+    NodeType.Super,
+    NodeType.TaggedTemplateExpression,
+    NodeType.ThisExpression,
+    NodeType.TSAsExpression,
+    NodeType.TSNonNullExpression,
+    NodeType.TSTypeAssertion
+]);
 const Construction = effectData_esm.taggedEnum();
 Construction.None();
 [
@@ -6864,16 +6507,82 @@ function isStringLiteral(node) {
     };
 }
 
+/**
+ * Check if a `JSXElement` or `JSXFragment` has children
+ * @param node The AST node to check
+ * @param predicate A predicate to filter the children
+ * @returns `true` if the node has children
+ */ function hasChildren(node, predicate) {
+    if (typeof predicate === "function") {
+        return node.children.some(predicate);
+    }
+    return node.children.length > 0;
+}
+/**
+ * Check if a node is a child of a `JSXElement`
+ * @param node The AST node to check
+ * @returns `true` if the node is a child of a `JSXElement`
+ */ function isChildOfJSXElement(node) {
+    return node.parent?.type === NodeType.JSXElement && node.parent.children.some((child)=>child === node);
+}
+
+/**
+ * Tests if a value is a `string`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isString } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isString("a"), true)
+ *
+ * assert.deepStrictEqual(isString(1), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isString = input => typeof input === "string";
+
+const RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
+// Does not check for reserved keywords or unicode characters
+const RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
+function getFragmentFromContext(context) {
+    // eslint-disable-next-line prefer-destructuring
+    const settings = context.settings;
+    const fragment = settings.react?.fragment;
+    if (isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment)) {
+        return fragment;
+    }
+    return "Fragment";
+}
+const getPragmaFromContext = memo((context)=>{
+    // eslint-disable-next-line prefer-destructuring
+    const settings = context.settings;
+    const sourceCode = context.getSourceCode();
+    const pragmaNode = sourceCode.getAllComments().find((node)=>RE_JSX_ANNOTATION_REGEX.test(node.value));
+    return effectFunction_esm.pipe(effectOption_esm.orElse(effectOption_esm.fromNullable(settings.react?.pragma), ()=>effectFunction_esm.pipe(effectOption_esm.fromNullable(pragmaNode), effectOption_esm.map(({ value })=>RE_JSX_ANNOTATION_REGEX.exec(value)), effectOption_esm.flatMapNullable((matches)=>matches?.[1]?.split(".")[0]))), effectOption_esm.flatMap(effectOption_esm.liftPredicate((x)=>RE_JS_IDENTIFIER_REGEX.test(x))), effectOption_esm.getOrElse(effectFunction_esm.constant("React")));
+});
+
 const t=Symbol.for("@ts-pattern/matcher"),e=Symbol.for("@ts-pattern/isVariadic"),n="@ts-pattern/anonymous-select-key",r=t=>Boolean(t&&"object"==typeof t),i=e=>e&&!!e[t],s=(n,o,c)=>{if(i(n)){const e=n[t](),{matched:r,selections:i}=e.match(o);return r&&i&&Object.keys(i).forEach(t=>c(t,i[t])),r}if(r(n)){if(!r(o))return !1;if(Array.isArray(n)){if(!Array.isArray(o))return !1;let t=[],r=[],a=[];for(const s of n.keys()){const o=n[s];i(o)&&o[e]?a.push(o):a.length?r.push(o):t.push(o);}if(a.length){if(a.length>1)throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");if(o.length<t.length+r.length)return !1;const e=o.slice(0,t.length),n=0===r.length?[]:o.slice(-r.length),i=o.slice(t.length,0===r.length?Infinity:-r.length);return t.every((t,n)=>s(t,e[n],c))&&r.every((t,e)=>s(t,n[e],c))&&(0===a.length||s(a[0],i,c))}return n.length===o.length&&n.every((t,e)=>s(t,o[e],c))}return Object.keys(n).every(e=>{const r=n[e];return (e in o||i(a=r)&&"optional"===a[t]().matcherType)&&s(r,o[e],c);var a;})}return Object.is(o,n)},o=e=>{var n,s,a;return r(e)?i(e)?null!=(n=null==(s=(a=e[t]()).getSelectionKeys)?void 0:s.call(a))?n:[]:Array.isArray(e)?c(e,o):c(Object.values(e),o):[]},c=(t,e)=>t.reduce((t,n)=>t.concat(e(n)),[]);function a(...t){if(1===t.length){const[e]=t;return t=>s(e,t,()=>{})}if(2===t.length){const[e,n]=t;return s(e,n,()=>{})}throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`)}function u(t){return Object.assign(t,{optional:()=>l(t),and:e=>m(t,e),or:e=>y(t,e),select:e=>void 0===e?p(t):p(e,t)})}function h(t){return Object.assign((t=>Object.assign(t,{*[Symbol.iterator](){yield Object.assign(t,{[e]:!0});}}))(t),{optional:()=>h(l(t)),select:e=>h(void 0===e?p(t):p(e,t))})}function l(e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return void 0===t?(o(e).forEach(t=>r(t,void 0)),{matched:!0,selections:n}):{matched:s(e,t,r),selections:n}},getSelectionKeys:()=>o(e),matcherType:"optional"})})}const f=(t,e)=>{for(const n of t)if(!e(n))return !1;return !0},g=(t,e)=>{for(const[n,r]of t.entries())if(!e(r,n))return !1;return !0};function m(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return {matched:e.every(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"and"})})}function y(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return c(e,o).forEach(t=>r(t,void 0)),{matched:e.some(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"or"})})}function d(e){return {[t]:()=>({match:t=>({matched:Boolean(e(t))})})}}function p(...e){const r="string"==typeof e[0]?e[0]:void 0,i=2===e.length?e[1]:"string"==typeof e[0]?void 0:e[0];return u({[t]:()=>({match:t=>{let e={[null!=r?r:n]:t};return {matched:void 0===i||s(i,t,(t,n)=>{e[t]=n;}),selections:e}},getSelectionKeys:()=>[null!=r?r:n].concat(void 0===i?[]:o(i))})})}function v(t){return "number"==typeof t}function b(t){return "string"==typeof t}function w(t){return "bigint"==typeof t}const S=u(d(function(t){return !0})),O=S,j=t=>Object.assign(u(t),{startsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.startsWith(n)))));var n;},endsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.endsWith(n)))));var n;},minLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length>=t))(e))),maxLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length<=t))(e))),includes:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.includes(n)))));var n;},regex:e=>{return j(m(t,(n=e,d(t=>b(t)&&Boolean(t.match(n))))));var n;}}),E=j(d(b)),K=t=>Object.assign(u(t),{between:(e,n)=>K(m(t,((t,e)=>d(n=>v(n)&&t<=n&&e>=n))(e,n))),lt:e=>K(m(t,(t=>d(e=>v(e)&&e<t))(e))),gt:e=>K(m(t,(t=>d(e=>v(e)&&e>t))(e))),lte:e=>K(m(t,(t=>d(e=>v(e)&&e<=t))(e))),gte:e=>K(m(t,(t=>d(e=>v(e)&&e>=t))(e))),int:()=>K(m(t,d(t=>v(t)&&Number.isInteger(t)))),finite:()=>K(m(t,d(t=>v(t)&&Number.isFinite(t)))),positive:()=>K(m(t,d(t=>v(t)&&t>0))),negative:()=>K(m(t,d(t=>v(t)&&t<0)))}),A=K(d(v)),x=t=>Object.assign(u(t),{between:(e,n)=>x(m(t,((t,e)=>d(n=>w(n)&&t<=n&&e>=n))(e,n))),lt:e=>x(m(t,(t=>d(e=>w(e)&&e<t))(e))),gt:e=>x(m(t,(t=>d(e=>w(e)&&e>t))(e))),lte:e=>x(m(t,(t=>d(e=>w(e)&&e<=t))(e))),gte:e=>x(m(t,(t=>d(e=>w(e)&&e>=t))(e))),positive:()=>x(m(t,d(t=>w(t)&&t>0))),negative:()=>x(m(t,d(t=>w(t)&&t<0)))}),P=x(d(w)),T=u(d(function(t){return "boolean"==typeof t})),k=u(d(function(t){return "symbol"==typeof t})),B=u(d(function(t){return null==t}));var _={__proto__:null,matcher:t,optional:l,array:function(...e){return h({[t]:()=>({match:t=>{if(!Array.isArray(t))return {matched:!1};if(0===e.length)return {matched:!0};const n=e[0];let r={};if(0===t.length)return o(n).forEach(t=>{r[t]=[];}),{matched:!0,selections:r};const i=(t,e)=>{r[t]=(r[t]||[]).concat([e]);};return {matched:t.every(t=>s(n,t,i)),selections:r}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},set:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Set))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};if(0===e.length)return {matched:!0};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);},i=e[0];return {matched:f(t,t=>s(i,t,r)),selections:n}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},map:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Map))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);};if(0===e.length)return {matched:!0};var i;if(1===e.length)throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null==(i=e[0])?void 0:i.toString()}`);const[o,c]=e;return {matched:g(t,(t,e)=>{const n=s(o,e,r),i=s(c,t,r);return n&&i}),selections:n}},getSelectionKeys:()=>0===e.length?[]:[...o(e[0]),...o(e[1])]})})},intersection:m,union:y,not:function(e){return u({[t]:()=>({match:t=>({matched:!s(e,t,()=>{})}),getSelectionKeys:()=>[],matcherType:"not"})})},when:d,select:p,any:S,_:O,string:E,number:A,bigint:P,boolean:T,symbol:k,nullish:B,instanceOf:function(t){return u(d(function(t){return e=>e instanceof t}(t)))},shape:function(t){return u(d(a(t)))}};const W={matched:!1,value:void 0};function N(t){return new $(t,W)}class ${constructor(t,e){this.input=void 0,this.state=void 0,this.input=t,this.state=e;}with(...t){if(this.state.matched)return this;const e=t[t.length-1],r=[t[0]];let i;3===t.length&&"function"==typeof t[1]?(r.push(t[0]),i=t[1]):t.length>2&&r.push(...t.slice(1,t.length-1));let o=!1,c={};const a=(t,e)=>{o=!0,c[t]=e;},u=!r.some(t=>s(t,this.input,a))||i&&!Boolean(i(this.input))?W:{matched:!0,value:e(o?n in c?c[n]:c:this.input,this.input)};return new $(this.input,u)}when(t,e){if(this.state.matched)return this;const n=Boolean(t(this.input));return new $(this.input,n?{matched:!0,value:e(this.input,this.input)}:W)}otherwise(t){return this.state.matched?this.state.value:t(this.input)}exhaustive(){return this.run()}run(){if(this.state.matched)return this.state.value;let t;try{t=JSON.stringify(this.input);}catch(e){t=this.input;}throw new Error(`Pattern matching error: no pattern matches value ${t}`)}returnType(){return this}}
 
-function isDestructuredFromPragma(variableName, context) {
-    const maybePragma = getPragmaFromContext(context);
+function isPropertyOfPragma(name, context, pragma = getPragmaFromContext(context)) {
+    const isMatch = a({
+        type: NodeType.MemberExpression,
+        object: {
+            type: NodeType.Identifier,
+            name: pragma
+        },
+        property: {
+            name
+        }
+    });
+    return isMatch;
+}
+
+function isInitializedFromPragma(variableName, context, pragma = getPragmaFromContext(context)) {
     const variables = getVariablesUpToGlobal(context.getScope());
-    if (effectEither_esm.isLeft(maybePragma)) {
-        return false;
-    }
-    const pragma = maybePragma.right;
-    const maybeLatestDef = effectFunction_esm.pipe(findVariableByName(variableName)(variables), effectOption_esm.flatMapNullable((variable)=>variable.defs.at(-1)));
+    const maybeVariable = findVariableByName(variableName)(variables);
+    const maybeLatestDef = effectOption_esm.flatMapNullable(maybeVariable, (variable)=>variable.defs.at(-1));
     if (effectOption_esm.isNone(maybeLatestDef)) {
         return false;
     }
@@ -6929,32 +6638,24 @@ function isDestructuredFromPragma(variableName, context) {
         }
     }, parent);
 }
-
 /**
  * Checks if the given node is a call expression to the given function or method of the pragma
  * @param name The name of the function or method to check
  * @returns A predicate that checks if the given node is a call expression to the given function or method
- */ const isCallFromPragma = (name)=>(node, context)=>{
+ */ function isCallFromPragma(name) {
+    return (node, context)=>{
         if (node.type !== NodeType.CallExpression || !("callee" in node)) {
             return false;
         }
-        const maybePragma = getPragmaFromContext(context);
-        if (effectEither_esm.isLeft(maybePragma)) {
-            return false;
+        if (node.callee.type === NodeType.MemberExpression) {
+            return isPropertyOfPragma(name, context)(node.callee);
         }
-        const pragma = maybePragma.right;
-        return N(node.callee).with({
-            type: NodeType.MemberExpression,
-            object: {
-                name: pragma
-            },
-            property: {
-                name
-            }
-        }, effectFunction_esm.constTrue).with({
-            name
-        }, ({ name })=>isDestructuredFromPragma(name, context)).otherwise(effectFunction_esm.constFalse);
+        if ("name" in node.callee && node.callee.name === name) {
+            return isInitializedFromPragma(name, context);
+        }
+        return false;
     };
+}
 
 /**
  * Checks if the given node is a call expression to `createElement`
@@ -6977,6 +6678,21 @@ function isChildrenOfCreateElement(node, context) {
     return maybeCallExpression.arguments.slice(2).some((child)=>child === node);
 }
 
+/**
+ * Check if a node is a `JSXElement` of `User-Defined Component` type
+ * @param node The AST node to check
+ * @returns `true` if the node is a `JSXElement` of `User-Defined Component` type
+ */ function isJSXElementOfUserDefinedComponent(node) {
+    return node.type === NodeType.JSXElement && node.openingElement.name.type === NodeType.JSXIdentifier && /^[A-Z]/u.test(node.openingElement.name.name);
+}
+/**
+ * Check if a node is a `JSXFragment` of `Built-in Component` type
+ * @param node The AST node to check
+ * @returns `true` if the node is a `JSXFragment` of `Built-in Component` type
+ */ function isJSXElementOfBuiltinComponent(node) {
+    return node.type === NodeType.JSXElement && node.openingElement.name.type === NodeType.JSXIdentifier && node.openingElement.name.name.toLowerCase() === node.openingElement.name.name && /^[a-z]/u.test(node.openingElement.name.name);
+}
+
 /**
  * Determines whether inside createElement's props.
  * @param node The AST node to check
@@ -7133,21 +6849,87 @@ const hdlWheel = [
 ];
 
 /**
- * Tests if a value is a `string`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isString } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isString("a"), true)
- *
- * assert.deepStrictEqual(isString(1), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isString = input => typeof input === "string";
+ * Check if a node is a Literal or JSXText
+ * @param node The AST node to check
+ * @returns boolean `true` if the node is a Literal or JSXText
+ */ const isLiteral = isOneOf([
+    NodeType.Literal,
+    NodeType.JSXText
+]);
+/**
+ * Check if a Literal or JSXText node is whitespace
+ * @param node The AST node to check
+ * @returns boolean `true` if the node is whitespace
+ */ function isWhiteSpace(node) {
+    return isString(node.value) && node.value.trim() === "";
+}
+/**
+ * Check if a Literal or JSXText node is a line break
+ * @param node The AST node to check
+ * @returns boolean
+ */ function isLineBreak(node) {
+    return isLiteral(node) && isWhiteSpace(node) && isMultiLine(node);
+}
+/**
+ * Check if a Literal or JSXText node is padding spaces
+ * @param node The AST node to check
+ * @returns boolean
+ */ function isPaddingSpaces(node) {
+    return isLiteral(node) && isWhiteSpace(node) && node.raw.includes("\n");
+}
+
+const isFragment = (node, pragma, fragment)=>{
+    if (!isOneOf([
+        NodeType.JSXElement,
+        NodeType.JSXFragment
+    ])(node)) {
+        return false;
+    }
+    return isFragmentSyntax(node) || isFragmentElement(node, pragma, fragment);
+};
+/**
+ * Check if a node is `<></>`
+ */ const isFragmentSyntax = is(NodeType.JSXFragment);
+/**
+ * Check if a node is `<Fragment></Fragment>` or `<Pragma.Fragment></Pragma.Fragment>`
+ * @param node
+ * @param pragma
+ * @param fragment
+ */ function isFragmentElement(node, pragma, fragment) {
+    const { name } = node.openingElement;
+    // <Fragment>
+    if (name.type === NodeType.JSXIdentifier && name.name === fragment) {
+        return true;
+    }
+    // <Pragma.Fragment>
+    return name.type === NodeType.JSXMemberExpression && name.object.type === NodeType.JSXIdentifier && name.object.name === pragma && name.property.name === fragment;
+}
+/**
+ * Check if a JSXElement or JSXFragment has only one literal child and is not a child
+ * @param node The AST node to check
+ * @returns `true` if the node has only one literal child and is not a child
+ * @example Somehow fragment like this is useful: <Foo content={<>ee eeee eeee ...</>} />
+ */ function isFragmentWithOnlyTextAndIsNotChild(node) {
+    return node.children.length === 1 && isLiteral(node.children[0]) && !(node.parent.type === NodeType.JSXElement || node.parent.type === NodeType.JSXFragment);
+}
+function containsCallExpression(node) {
+    return node.type === NodeType.JSXExpressionContainer && node.expression.type === NodeType.CallExpression;
+}
+/**
+ * Check if a JSXElement or JSXFragment has less than two non-padding children and the first child is not a call expression
+ * @param node The AST node to check
+ * @returns boolean
+ */ function isFragmentHasLessThanTwoChildren(node) {
+    const nonPaddingChildren = node.children.filter((child)=>!isPaddingSpaces(child));
+    if (nonPaddingChildren.length === 1) {
+        return !containsCallExpression(nonPaddingChildren[0]);
+    }
+    return nonPaddingChildren.length === 0;
+}
+function isFragmentWithSingleExpression(node) {
+    const children = node.children.filter((child)=>!isPaddingSpaces(child));
+    return children.length === 1 && children[0]?.type === NodeType.JSXExpressionContainer;
+}
 
 const defaultJSXValueCheckOptions = {
     ignoreNull: false,
@@ -7356,45 +7138,28 @@ const defaultJSXValueCheckOptions = {
         }));
     };
 }
-function getPropValue(attribute, context) {
+/**
+ * Gets and resolves the static value of a JSX attribute
+ * @param attribute The JSX attribute to get the value of
+ * @param context The rule context
+ * @returns  The static value of the given JSX attribute
+ */ function getPropValue(attribute, context) {
+    const scope = context.getScope();
     if (attribute.type === NodeType.JSXAttribute && "value" in attribute) {
         const { value } = attribute;
         if (value === null) {
             return effectOption_esm.none();
         }
         if (value.type === NodeType.Literal) {
-            return effectOption_esm.some(getStaticValue(value, context.getScope()));
+            return effectOption_esm.some(getStaticValue(value, scope));
         }
         if (value.type === NodeType.JSXExpressionContainer) {
-            return effectOption_esm.some(getStaticValue(value.expression, context.getScope()));
+            return effectOption_esm.some(getStaticValue(value.expression, scope));
         }
         return effectOption_esm.none();
     }
     const { argument } = attribute;
-    return effectOption_esm.some(getStaticValue(argument, context.getScope()));
-}
-
-/**
- * Check if a node is a Literal or JSXText
- * @param node The AST node to check
- * @returns boolean `true` if the node is a Literal or JSXText
- */ const isLiteral = isOneOf([
-    NodeType.Literal,
-    NodeType.JSXText
-]);
-/**
- * Check if a Literal or JSXText node is whitespace
- * @param node The AST node to check
- * @returns boolean `true` if the node is whitespace
- */ function isWhiteSpace(node) {
-    return isString(node.value) && node.value.trim() === "";
-}
-/**
- * Check if a Literal or JSXText node is a line break
- * @param node The AST node to check
- * @returns boolean
- */ function isLineBreak(node) {
-    return isLiteral(node) && isWhiteSpace(node) && isMultiLine(node);
+    return effectOption_esm.some(getStaticValue(argument, scope));
 }
 
 exports.defaultJSXValueCheckOptions = defaultJSXValueCheckOptions;
@@ -7425,15 +7190,26 @@ exports.hdlTouch = hdlTouch;
 exports.hdlTransition = hdlTransition;
 exports.hdlWheel = hdlWheel;
 exports.isCallFromPragma = isCallFromPragma;
+exports.isChildOfJSXElement = isChildOfJSXElement;
 exports.isChildrenOfCreateElement = isChildrenOfCreateElement;
 exports.isCloneElementCall = isCloneElementCall;
 exports.isCreateElementCall = isCreateElementCall;
-exports.isDestructuredFromPragma = isDestructuredFromPragma;
+exports.isFragment = isFragment;
+exports.isFragmentElement = isFragmentElement;
+exports.isFragmentHasLessThanTwoChildren = isFragmentHasLessThanTwoChildren;
+exports.isFragmentSyntax = isFragmentSyntax;
+exports.isFragmentWithOnlyTextAndIsNotChild = isFragmentWithOnlyTextAndIsNotChild;
+exports.isFragmentWithSingleExpression = isFragmentWithSingleExpression;
 exports.isFunctionReturningJSXValue = isFunctionReturningJSXValue;
+exports.isInitializedFromPragma = isInitializedFromPragma;
 exports.isInsideCreateElementProps = isInsideCreateElementProps;
 exports.isInsidePropValue = isInsidePropValue;
+exports.isJSXElementOfBuiltinComponent = isJSXElementOfBuiltinComponent;
+exports.isJSXElementOfUserDefinedComponent = isJSXElementOfUserDefinedComponent;
 exports.isJSXValue = isJSXValue;
 exports.isLineBreak = isLineBreak;
 exports.isLiteral = isLiteral;
+exports.isPaddingSpaces = isPaddingSpaces;
+exports.isPropertyOfPragma = isPropertyOfPragma;
 exports.isWhiteSpace = isWhiteSpace;
 exports.traverseUpProp = traverseUpProp;