npm - @eslint-react/jsx - Versions diffs - 1.5.3 → 1.5.4-beta.1 - Mend

@eslint-react/jsx 1.5.3 → 1.5.4-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,73 +1,48 @@
-import { NodeType, isOneOf, is, traverseUp, isJSXTagNameExpression, getNestedReturnStatements, ESLintCommunityESLintUtils, traverseUpGuard, isStringLiteral, isMultiLine } from '@eslint-react/ast';
+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 '@typescript-eslint/utils';
-/**
- * Tests if a value is a `function`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isFunction } from 'effect/Predicate'
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- * assert.deepStrictEqual(isFunction("function"), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction$1 = input => typeof input === "function";
-/**
- * Creates a function that can be used in a data-last (aka `pipe`able) or
- * data-first style.
- *
- * The first parameter to `dual` is either the arity of the uncurried function
- * or a predicate that determines if the function is being used in a data-first
- * or data-last style.
- *
- * Using the arity is the most common use case, but there are some cases where
- * you may want to use a predicate. For example, if you have a function that
- * takes an optional argument, you can use a predicate to determine if the
- * function is being used in a data-first or data-last style.
- *
- * @param arity - Either the arity of the uncurried function or a predicate
- *                which determines if the function is being used in a data-first
- *                or data-last style.
- * @param body - The definition of the uncurried function.
- *
- * @example
- * import { dual, pipe } from "effect/Function"
- *
- * // Exampe using arity to determine data-first or data-last style
- * const sum: {
- *   (that: number): (self: number) => number
- *   (self: number, that: number): number
- * } = dual(2, (self: number, that: number): number => self + that)
- *
- * assert.deepStrictEqual(sum(2, 3), 5)
- * assert.deepStrictEqual(pipe(2, sum(3)), 5)
- *
- * // Example using a predicate to determine data-first or data-last style
- * const sum2: {
- *   (that: number): (self: number) => number
- *   (self: number, that: number): number
- * } = dual((args) => args.length === 1, (self: number, that: number): number => self + that)
- *
- * assert.deepStrictEqual(sum(2, 3), 5)
- * assert.deepStrictEqual(pipe(2, sum(3)), 5)
- *
- * @since 2.0.0
- */
-const dual = function (arity, body) {
+var __defProp = Object.defineProperty;
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
+};
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Function.js
+var Function_exports = {};
+__export(Function_exports, {
+  SK: () => SK,
+  absurd: () => absurd,
+  apply: () => apply,
+  compose: () => compose,
+  constFalse: () => constFalse,
+  constNull: () => constNull,
+  constTrue: () => constTrue,
+  constUndefined: () => constUndefined,
+  constVoid: () => constVoid,
+  constant: () => constant,
+  dual: () => dual,
+  flip: () => flip,
+  flow: () => flow,
+  hole: () => hole,
+  identity: () => identity,
+  isFunction: () => isFunction,
+  pipe: () => pipe,
+  tupled: () => tupled,
+  unsafeCoerce: () => unsafeCoerce,
+  untupled: () => untupled
+});
+var isFunction = (input) => typeof input === "function";
+var dual = function(arity, body) {
   if (typeof arity === "function") {
-    return function () {
+    return function() {
       if (arity(arguments)) {
-        // @ts-expect-error
         return body.apply(this, arguments);
       }
-      return self => body(self, ...arguments);
+      return (self) => body(self, ...arguments);
     };
   }
   switch (arity) {
@@ -75,251 +50,388 @@ const dual = function (arity, body) {
     case 1:
       throw new RangeError(`Invalid arity ${arity}`);
     case 2:
-      return function (a, b) {
+      return function(a2, b2) {
         if (arguments.length >= 2) {
-          return body(a, b);
+          return body(a2, b2);
         }
-        return function (self) {
-          return body(self, a);
+        return function(self) {
+          return body(self, a2);
         };
       };
     case 3:
-      return function (a, b, c) {
+      return function(a2, b2, c2) {
         if (arguments.length >= 3) {
-          return body(a, b, c);
+          return body(a2, b2, c2);
         }
-        return function (self) {
-          return body(self, a, b);
+        return function(self) {
+          return body(self, a2, b2);
         };
       };
     case 4:
-      return function (a, b, c, d) {
+      return function(a2, b2, c2, d2) {
         if (arguments.length >= 4) {
-          return body(a, b, c, d);
+          return body(a2, b2, c2, d2);
         }
-        return function (self) {
-          return body(self, a, b, c);
+        return function(self) {
+          return body(self, a2, b2, c2);
         };
       };
     case 5:
-      return function (a, b, c, d, e) {
+      return function(a2, b2, c2, d2, e2) {
         if (arguments.length >= 5) {
-          return body(a, b, c, d, e);
+          return body(a2, b2, c2, d2, e2);
         }
-        return function (self) {
-          return body(self, a, b, c, d);
+        return function(self) {
+          return body(self, a2, b2, c2, d2);
         };
       };
     default:
-      return function () {
+      return function() {
         if (arguments.length >= arity) {
-          // @ts-expect-error
           return body.apply(this, arguments);
         }
         const args = arguments;
-        return function (self) {
+        return function(self) {
           return body(self, ...args);
         };
       };
   }
 };
-/**
- * Creates a constant value that never changes.
- *
- * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
- * and want that inner function to always use the same value, no matter how many times it is called.
- *
- * @param value - The constant value to be returned.
- *
- * @example
- * import { constant } from "effect/Function"
- *
- * const constNull = constant(null)
- *
- * assert.deepStrictEqual(constNull(), null)
- * assert.deepStrictEqual(constNull(), null)
- *
- * @since 2.0.0
- */
-const constant = value => () => value;
-/**
- * A thunk that returns always `true`.
- *
- * @example
- * import { constTrue } from "effect/Function"
- *
- * assert.deepStrictEqual(constTrue(), true)
- *
- * @since 2.0.0
- */
-const constTrue = /*#__PURE__*/constant(true);
-/**
- * A thunk that returns always `false`.
- *
- * @example
- * import { constFalse } from "effect/Function"
- *
- * assert.deepStrictEqual(constFalse(), false)
- *
- * @since 2.0.0
- */
-const constFalse = /*#__PURE__*/constant(false);
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+var apply = (a2) => (self) => self(a2);
+var identity = (a2) => a2;
+var unsafeCoerce = identity;
+var constant = (value) => () => value;
+var constTrue = /* @__PURE__ */ constant(true);
+var constFalse = /* @__PURE__ */ constant(false);
+var constNull = /* @__PURE__ */ constant(null);
+var constUndefined = /* @__PURE__ */ constant(void 0);
+var constVoid = constUndefined;
+var flip = (f2) => (...b2) => (...a2) => f2(...a2)(...b2);
+var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a2) => bc(ab(a2)));
+var absurd = (_2) => {
+  throw new Error("Called `absurd` function which should be uncallable");
+};
+var tupled = (f2) => (a2) => f2(...a2);
+var untupled = (f2) => (...a2) => f2(a2);
+function pipe(a2, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
-      return a;
+      return a2;
     case 2:
-      return ab(a);
+      return ab(a2);
     case 3:
-      return bc(ab(a));
+      return bc(ab(a2));
     case 4:
-      return cd(bc(ab(a)));
+      return cd(bc(ab(a2)));
     case 5:
-      return de(cd(bc(ab(a))));
+      return de(cd(bc(ab(a2))));
     case 6:
-      return ef(de(cd(bc(ab(a)))));
+      return ef(de(cd(bc(ab(a2)))));
     case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
+      return fg(ef(de(cd(bc(ab(a2))))));
     case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
+      return gh(fg(ef(de(cd(bc(ab(a2)))))));
     case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default:
-      {
-        let ret = arguments[0];
-        for (let i = 1; i < arguments.length; i++) {
-          ret = arguments[i](ret);
-        }
-        return ret;
+      return hi(gh(fg(ef(de(cd(bc(ab(a2))))))));
+    default: {
+      let ret = arguments[0];
+      for (let i2 = 1; i2 < arguments.length; i2++) {
+        ret = arguments[i2](ret);
       }
+      return ret;
+    }
+  }
+}
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+  switch (arguments.length) {
+    case 1:
+      return ab;
+    case 2:
+      return function() {
+        return bc(ab.apply(this, arguments));
+      };
+    case 3:
+      return function() {
+        return cd(bc(ab.apply(this, arguments)));
+      };
+    case 4:
+      return function() {
+        return de(cd(bc(ab.apply(this, arguments))));
+      };
+    case 5:
+      return function() {
+        return ef(de(cd(bc(ab.apply(this, arguments)))));
+      };
+    case 6:
+      return function() {
+        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+      };
+    case 7:
+      return function() {
+        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+      };
+    case 8:
+      return function() {
+        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+      };
+    case 9:
+      return function() {
+        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+      };
   }
+  return;
 }
+var hole = /* @__PURE__ */ unsafeCoerce(absurd);
+var SK = (_2, b2) => b2;
-const moduleVersion = "2.3.1";
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "2.3.3";
-/**
- * @since 2.0.0
- */
-const globalStoreId = /*#__PURE__*/Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`);
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`);
 if (!(globalStoreId in globalThis)) {
-  globalThis[globalStoreId] = /*#__PURE__*/new Map();
+  globalThis[globalStoreId] = /* @__PURE__ */ new Map();
 }
-const globalStore = globalThis[globalStoreId];
-/**
- * @since 2.0.0
- */
-const globalValue = (id, compute) => {
+var globalStore = globalThis[globalStoreId];
+var globalValue = (id, compute) => {
   if (!globalStore.has(id)) {
     globalStore.set(id, compute());
   }
   return globalStore.get(id);
 };
-/**
- * @since 2.0.0
- */
-/**
- * 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";
-/**
- * Tests if a value is a `function`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isFunction } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isFunction(isFunction), true)
- *
- * assert.deepStrictEqual(isFunction("function"), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isFunction = isFunction$1;
-const isRecordOrArray = input => typeof input === "object" && input !== null;
-/**
- * Tests if a value is an `object`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isObject } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isObject({}), true)
- * assert.deepStrictEqual(isObject([]), true)
- *
- * assert.deepStrictEqual(isObject(null), false)
- * assert.deepStrictEqual(isObject(undefined), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isObject = input => isRecordOrArray(input) || isFunction(input);
-/**
- * Checks whether a value is an `object` containing a specified property key.
- *
- * @param property - The field to check within the object.
- * @param self - The value to examine.
- *
- * @category guards
- * @since 2.0.0
- */
-const hasProperty = /*#__PURE__*/dual(2, (self, property) => isObject(self) && property in self);
-/**
- * A guard that succeeds when the input is `null` or `undefined`.
- *
- * @param input - The value to test.
- *
- * @example
- * import { isNullable } from "effect/Predicate"
- *
- * assert.deepStrictEqual(isNullable(null), true)
- * assert.deepStrictEqual(isNullable(undefined), true)
- *
- * assert.deepStrictEqual(isNullable({}), false)
- * assert.deepStrictEqual(isNullable([]), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isNullable = input => input === null || input === undefined;
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Predicate.js
+var Predicate_exports = {};
+__export(Predicate_exports, {
+  all: () => all,
+  and: () => and,
+  compose: () => compose2,
+  eqv: () => eqv,
+  every: () => every,
+  hasProperty: () => hasProperty,
+  implies: () => implies,
+  isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isError: () => isError,
+  isFunction: () => isFunction2,
+  isIterable: () => isIterable,
+  isNever: () => isNever,
+  isNotNull: () => isNotNull,
+  isNotNullable: () => isNotNullable,
+  isNotUndefined: () => isNotUndefined,
+  isNull: () => isNull,
+  isNullable: () => isNullable,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPromise: () => isPromise,
+  isReadonlyRecord: () => isReadonlyRecord,
+  isRecord: () => isRecord,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isTagged: () => isTagged,
+  isUint8Array: () => isUint8Array,
+  isUndefined: () => isUndefined,
+  isUnknown: () => isUnknown,
+  mapInput: () => mapInput,
+  nand: () => nand,
+  nor: () => nor,
+  not: () => not,
+  or: () => or,
+  product: () => product,
+  productMany: () => productMany,
+  some: () => some,
+  struct: () => struct,
+  tuple: () => tuple,
+  xor: () => xor
+});
+var mapInput = /* @__PURE__ */ dual(2, (self, f2) => (b2) => self(f2(b2)));
+var isString = (input) => typeof input === "string";
+var isNumber = (input) => typeof input === "number";
+var isBoolean = (input) => typeof input === "boolean";
+var isBigInt = (input) => typeof input === "bigint";
+var isSymbol = (input) => typeof input === "symbol";
+var isFunction2 = isFunction;
+var isUndefined = (input) => input === void 0;
+var isNotUndefined = (input) => input !== void 0;
+var isNull = (input) => input === null;
+var isNotNull = (input) => input !== null;
+var isNever = (_2) => false;
+var isUnknown = (_2) => true;
+var isRecordOrArray = (input) => typeof input === "object" && input !== null;
+var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
+var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
+var isNullable = (input) => input === null || input === void 0;
+var isNotNullable = (input) => input !== null && input !== void 0;
+var isError = (input) => input instanceof Error;
+var isUint8Array = (input) => input instanceof Uint8Array;
+var isDate = (input) => input instanceof Date;
+var isIterable = (input) => hasProperty(input, Symbol.iterator);
+var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
+var isReadonlyRecord = isRecord;
+var isPromise = (input) => hasProperty(input, "then") && "catch" in input && isFunction2(input.then) && isFunction2(input.catch);
+var compose2 = /* @__PURE__ */ dual(2, (ab, bc) => (a2) => ab(a2) && bc(a2));
+var product = (self, that) => ([a2, b2]) => self(a2) && that(b2);
+var all = (collection) => {
+  return (as2) => {
+    let collectionIndex = 0;
+    for (const p2 of collection) {
+      if (collectionIndex >= as2.length) {
+        break;
+      }
+      if (p2(as2[collectionIndex]) === false) {
+        return false;
+      }
+      collectionIndex++;
+    }
+    return true;
+  };
+};
+var productMany = (self, collection) => {
+  const rest = all(collection);
+  return ([head, ...tail]) => self(head) === false ? false : rest(tail);
+};
+var tuple = (...elements) => all(elements);
+var struct = (fields) => {
+  const keys = Object.keys(fields);
+  return (a2) => {
+    for (const key of keys) {
+      if (!fields[key](a2[key])) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+var not = (self) => (a2) => !self(a2);
+var or = /* @__PURE__ */ dual(2, (self, that) => (a2) => self(a2) || that(a2));
+var and = /* @__PURE__ */ dual(2, (self, that) => (a2) => self(a2) && that(a2));
+var xor = /* @__PURE__ */ dual(2, (self, that) => (a2) => self(a2) !== that(a2));
+var eqv = /* @__PURE__ */ dual(2, (self, that) => (a2) => self(a2) === that(a2));
+var implies = /* @__PURE__ */ dual(2, (self, that) => (a2) => self(a2) ? that(a2) : true);
+var nor = /* @__PURE__ */ dual(2, (self, that) => (a2) => !(self(a2) || that(a2)));
+var nand = /* @__PURE__ */ dual(2, (self, that) => (a2) => !(self(a2) && that(a2)));
+var every = (collection) => (a2) => {
+  for (const p2 of collection) {
+    if (!p2(a2)) {
+      return false;
+    }
+  }
+  return true;
+};
+var some = (collection) => (a2) => {
+  for (const p2 of collection) {
+    if (p2(a2)) {
+      return true;
+    }
+  }
+  return false;
+};
-/**
- * @since 2.0.0
- */
-const defaultIncHi = 0x14057b7e;
-const defaultIncLo = 0xf767814f;
-const MUL_HI = 0x5851f42d >>> 0;
-const MUL_LO = 0x4c957f2d >>> 0;
-const BIT_53 = 9007199254740992.0;
-const BIT_27 = 134217728.0;
-/**
- * PCG is a family of simple fast space-efficient statistically good algorithms
- * for random number generation. Unlike many general-purpose RNGs, they are also
- * hard to predict.
- *
- * @category model
- * @since 2.0.0
- */
-class PCGRandom {
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Utils.js
+var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
+var GenKindImpl = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _F() {
+    return identity;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _R() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _O() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _E() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [GenKindTypeId] = GenKindTypeId;
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+};
+var SingleShotGen = class _SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  /**
+   * @since 2.0.0
+   */
+  next(a2) {
+    return this.called ? {
+      value: a2,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  /**
+   * @since 2.0.0
+   */
+  return(a2) {
+    return {
+      value: a2,
+      done: true
+    };
+  }
+  /**
+   * @since 2.0.0
+   */
+  throw(e2) {
+    throw e2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+var adapter = () => (
+  // @ts-expect-error
+  function() {
+    let x2 = arguments[0];
+    for (let i2 = 1; i2 < arguments.length; i2++) {
+      x2 = arguments[i2](x2);
+    }
+    return new GenKindImpl(x2);
+  }
+);
+var defaultIncHi = 335903614;
+var defaultIncLo = 4150755663;
+var MUL_HI = 1481765933 >>> 0;
+var MUL_LO = 1284865837 >>> 0;
+var BIT_53 = 9007199254740992;
+var BIT_27 = 134217728;
+var PCGRandom = class {
   _state;
   constructor(seedHi, seedLo, incHi, incLo) {
     if (isNullable(seedLo) && isNullable(seedHi)) {
-      seedLo = Math.random() * 0xffffffff >>> 0;
+      seedLo = Math.random() * 4294967295 >>> 0;
       seedHi = 0;
     } else if (isNullable(seedLo)) {
       seedLo = seedHi;
@@ -371,13 +483,11 @@ class PCGRandom {
     }
     max = max >>> 0;
     if ((max & max - 1) === 0) {
-      return this._next() & max - 1; // fast path for power of 2
+      return this._next() & max - 1;
     }
     let num = 0;
     const skew = (-max >>> 0) % max >>> 0;
     for (num = this._next(); num < skew; num = this._next()) {
-      // this loop will rarely execute more than twice,
-      // and is intentionally empty
     }
     return num % max;
   }
@@ -389,35 +499,30 @@ class PCGRandom {
    * @since 2.0.0
    */
   number() {
-    const hi = (this._next() & 0x03ffffff) * 1.0;
-    const lo = (this._next() & 0x07ffffff) * 1.0;
+    const hi = (this._next() & 67108863) * 1;
+    const lo = (this._next() & 134217727) * 1;
     return (hi * BIT_27 + lo) / BIT_53;
   }
   /** @internal */
   _next() {
-    // save current state (what we'll use for this number)
     const oldHi = this._state[0] >>> 0;
     const oldLo = this._state[1] >>> 0;
-    // churn LCG.
     mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
     add64(this._state, this._state[0], this._state[1], this._state[2], this._state[3]);
-    // get least sig. 32 bits of ((oldstate >> 18) ^ oldstate) >> 27
     let xsHi = oldHi >>> 18;
     let xsLo = (oldLo >>> 18 | oldHi << 14) >>> 0;
     xsHi = (xsHi ^ oldHi) >>> 0;
     xsLo = (xsLo ^ oldLo) >>> 0;
     const xorshifted = (xsLo >>> 27 | xsHi << 5) >>> 0;
-    // rotate xorshifted right a random amount, based on the most sig. 5 bits
-    // bits of the old state.
     const rot = oldHi >>> 27;
     const rot2 = (-rot >>> 0 & 31) >>> 0;
     return (xorshifted >>> rot | xorshifted << rot2) >>> 0;
   }
-}
+};
 function mul64(out, aHi, aLo, bHi, bLo) {
-  let c1 = (aLo >>> 16) * (bLo & 0xffff) >>> 0;
-  let c0 = (aLo & 0xffff) * (bLo >>> 16) >>> 0;
-  let lo = (aLo & 0xffff) * (bLo & 0xffff) >>> 0;
+  let c1 = (aLo >>> 16) * (bLo & 65535) >>> 0;
+  let c0 = (aLo & 65535) * (bLo >>> 16) >>> 0;
+  let lo = (aLo & 65535) * (bLo & 65535) >>> 0;
   let hi = (aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;
   c0 = c0 << 16 >>> 0;
   lo = lo + c0 >>> 0;
@@ -434,7 +539,6 @@ function mul64(out, aHi, aLo, bHi, bLo) {
   out[0] = hi;
   out[1] = lo;
 }
-// add two 64 bit numbers (given in parts), and store the result in `out`.
 function add64(out, aHi, aLo, bHi, bLo) {
   let hi = aHi + bHi >>> 0;
   const lo = aLo + bLo >>> 0;
@@ -445,23 +549,11 @@ function add64(out, aHi, aLo, bHi, bLo) {
   out[1] = lo;
 }
-/**
- * @since 2.0.0
- */
-/** @internal */
-const randomHashCache = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Hash/randomHashCache"), () => new WeakMap());
-/** @internal */
-const pcgr = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Hash/pcgr"), () => new PCGRandom());
-/**
- * @since 2.0.0
- * @category symbols
- */
-const symbol$1 = /*#__PURE__*/Symbol.for("effect/Hash");
-/**
- * @since 2.0.0
- * @category hashing
- */
-const hash = self => {
+// ../../../node_modules/.pnpm/effect@2.3.3/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");
+var hash = (self) => {
   switch (typeof self) {
     case "number":
       return number(self);
@@ -476,84 +568,55 @@ const hash = self => {
     case "undefined":
       return string("undefined");
     case "function":
-    case "object":
-      {
-        if (self === null) {
-          return string("null");
-        }
-        if (isHash(self)) {
-          return self[symbol$1]();
-        } else {
-          return random(self);
-        }
+    case "object": {
+      if (self === null) {
+        return string("null");
+      }
+      if (isHash(self)) {
+        return self[symbol]();
+      } else {
+        return random(self);
       }
+    }
     default:
       throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
   }
 };
-/**
- * @since 2.0.0
- * @category hashing
- */
-const random = self => {
+var random = (self) => {
   if (!randomHashCache.has(self)) {
     randomHashCache.set(self, number(pcgr.integer(Number.MAX_SAFE_INTEGER)));
   }
   return randomHashCache.get(self);
 };
-/**
- * @since 2.0.0
- * @category hashing
- */
-const combine = b => self => self * 53 ^ b;
-/**
- * @since 2.0.0
- * @category hashing
- */
-const optimize = n => n & 0xbfffffff | n >>> 1 & 0x40000000;
-/**
- * @since 2.0.0
- * @category guards
- */
-const isHash = u => hasProperty(u, symbol$1);
-/**
- * @since 2.0.0
- * @category hashing
- */
-const number = n => {
-  if (n !== n || n === Infinity) {
+var combine = (b2) => (self) => self * 53 ^ b2;
+var optimize = (n2) => n2 & 3221225471 | n2 >>> 1 & 1073741824;
+var isHash = (u2) => hasProperty(u2, symbol);
+var number = (n2) => {
+  if (n2 !== n2 || n2 === Infinity) {
     return 0;
   }
-  let h = n | 0;
-  if (h !== n) {
-    h ^= n * 0xffffffff;
+  let h2 = n2 | 0;
+  if (h2 !== n2) {
+    h2 ^= n2 * 4294967295;
   }
-  while (n > 0xffffffff) {
-    h ^= n /= 0xffffffff;
+  while (n2 > 4294967295) {
+    h2 ^= n2 /= 4294967295;
   }
-  return optimize(n);
+  return optimize(n2);
 };
-/**
- * @since 2.0.0
- * @category hashing
- */
-const string = str => {
-  let h = 5381,
-    i = str.length;
-  while (i) {
-    h = h * 33 ^ str.charCodeAt(--i);
-  }
-  return optimize(h);
+var string = (str) => {
+  let h2 = 5381, i2 = str.length;
+  while (i2) {
+    h2 = h2 * 33 ^ str.charCodeAt(--i2);
+  }
+  return optimize(h2);
 };
-/**
- * @since 2.0.0
- * @category symbols
- */
-const symbol = /*#__PURE__*/Symbol.for("effect/Equal");
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Equal.js
+var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
-    return self => compareBoth(self, arguments[0]);
+    return (self) => compareBoth(self, arguments[0]);
   }
   return compareBoth(arguments[0], arguments[1]);
 }
@@ -567,48 +630,93 @@ function compareBoth(self, that) {
   }
   if ((selfType === "object" || selfType === "function") && self !== null && that !== null) {
     if (isEqual(self) && isEqual(that)) {
-      return hash(self) === hash(that) && self[symbol](that);
+      return hash(self) === hash(that) && self[symbol2](that);
     }
   }
   return false;
 }
-/**
- * @since 2.0.0
- * @category guards
- */
-const isEqual = u => hasProperty(u, symbol);
+var isEqual = (u2) => hasProperty(u2, symbol2);
+var equivalence = () => (self, that) => equals(self, that);
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const NodeInspectSymbol = /*#__PURE__*/Symbol.for("nodejs.util.inspect.custom");
-/**
- * @since 2.0.0
- */
-const toJSON = x => {
-  if (hasProperty(x, "toJSON") && isFunction(x["toJSON"]) && x["toJSON"].length === 0) {
-    return x.toJSON();
-  } else if (Array.isArray(x)) {
-    return x.map(toJSON);
-  }
-  return x;
+// ../../../node_modules/.pnpm/effect@2.3.3/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) {
+    return x2.toJSON();
+  } else if (Array.isArray(x2)) {
+    return x2.map(toJSON);
+  }
+  return x2;
 };
-/**
- * @since 2.0.0
- */
-const format = x => JSON.stringify(x, null, 2);
+var format = (x2) => JSON.stringify(x2, null, 2);
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- */
-const pipeArguments = (self, args) => {
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Option.js
+var Option_exports = {};
+__export(Option_exports, {
+  Do: () => Do,
+  TypeId: () => TypeId3,
+  all: () => all2,
+  andThen: () => andThen,
+  ap: () => ap,
+  as: () => as,
+  asUnit: () => asUnit,
+  bind: () => bind,
+  bindTo: () => bindTo,
+  composeK: () => composeK,
+  contains: () => contains,
+  containsWith: () => containsWith,
+  exists: () => exists,
+  filter: () => filter,
+  filterMap: () => filterMap,
+  firstSomeOf: () => firstSomeOf,
+  flatMap: () => flatMap,
+  flatMapNullable: () => flatMapNullable,
+  flatten: () => flatten,
+  fromIterable: () => fromIterable,
+  fromNullable: () => fromNullable,
+  gen: () => gen,
+  getEquivalence: () => getEquivalence,
+  getLeft: () => getLeft2,
+  getOrElse: () => getOrElse,
+  getOrNull: () => getOrNull,
+  getOrThrow: () => getOrThrow,
+  getOrThrowWith: () => getOrThrowWith,
+  getOrUndefined: () => getOrUndefined,
+  getOrder: () => getOrder,
+  getRight: () => getRight2,
+  isNone: () => isNone2,
+  isOption: () => isOption2,
+  isSome: () => isSome2,
+  let: () => let_,
+  lift2: () => lift2,
+  liftNullable: () => liftNullable,
+  liftPredicate: () => liftPredicate,
+  liftThrowable: () => liftThrowable,
+  map: () => map,
+  match: () => match,
+  none: () => none2,
+  orElse: () => orElse,
+  orElseEither: () => orElseEither,
+  orElseSome: () => orElseSome,
+  partitionMap: () => partitionMap,
+  product: () => product2,
+  productMany: () => productMany2,
+  reduceCompact: () => reduceCompact,
+  some: () => some3,
+  tap: () => tap,
+  toArray: () => toArray,
+  toRefinement: () => toRefinement,
+  unit: () => unit,
+  zipLeft: () => zipLeft,
+  zipRight: () => zipRight,
+  zipWith: () => zipWith
+});
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Pipeable.js
+var pipeArguments = (self, args) => {
   switch (args.length) {
     case 1:
       return args[0](self);
@@ -628,73 +736,67 @@ const pipeArguments = (self, args) => {
       return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
     case 9:
       return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
-    default:
-      {
-        let ret = self;
-        for (let i = 0, len = args.length; i < len; i++) {
-          ret = args[i](ret);
-        }
-        return ret;
+    default: {
+      let ret = self;
+      for (let i2 = 0, len = args.length; i2 < len; i2++) {
+        ret = args[i2](ret);
       }
+      return ret;
+    }
   }
 };
-/** @internal */
-const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
-/** @internal */
-const StreamTypeId = /*#__PURE__*/Symbol.for("effect/Stream");
-/** @internal */
-const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
-/** @internal */
-const ChannelTypeId = /*#__PURE__*/Symbol.for("effect/Channel");
-/** @internal */
-const effectVariance = {
+// ../../../node_modules/.pnpm/effect@2.3.3/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");
+var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
+var effectVariance = {
   /* c8 ignore next */
-  _R: _ => _,
+  _R: (_2) => _2,
   /* c8 ignore next */
-  _E: _ => _,
+  _E: (_2) => _2,
   /* c8 ignore next */
-  _A: _ => _,
+  _A: (_2) => _2,
   _V: moduleVersion
 };
-const sinkVariance = {
+var sinkVariance = {
   /* c8 ignore next */
-  _A: _ => _,
+  _A: (_2) => _2,
   /* c8 ignore next */
-  _In: _ => _,
+  _In: (_2) => _2,
   /* c8 ignore next */
-  _L: _ => _,
+  _L: (_2) => _2,
   /* c8 ignore next */
-  _E: _ => _,
+  _E: (_2) => _2,
   /* c8 ignore next */
-  _R: _ => _
+  _R: (_2) => _2
 };
-const channelVariance = {
+var channelVariance = {
   /* c8 ignore next */
-  _Env: _ => _,
+  _Env: (_2) => _2,
   /* c8 ignore next */
-  _InErr: _ => _,
+  _InErr: (_2) => _2,
   /* c8 ignore next */
-  _InElem: _ => _,
+  _InElem: (_2) => _2,
   /* c8 ignore next */
-  _InDone: _ => _,
+  _InDone: (_2) => _2,
   /* c8 ignore next */
-  _OutErr: _ => _,
+  _OutErr: (_2) => _2,
   /* c8 ignore next */
-  _OutElem: _ => _,
+  _OutElem: (_2) => _2,
   /* c8 ignore next */
-  _OutDone: _ => _
+  _OutDone: (_2) => _2
 };
-/** @internal */
-const EffectPrototype = {
+var EffectPrototype = {
   [EffectTypeId]: effectVariance,
   [StreamTypeId]: effectVariance,
   [SinkTypeId]: sinkVariance,
   [ChannelTypeId]: channelVariance,
-  [symbol](that) {
+  [symbol2](that) {
     return this === that;
   },
-  [symbol$1]() {
+  [symbol]() {
     return random(this);
   },
   pipe() {
@@ -702,14 +804,12 @@ const EffectPrototype = {
   }
 };
-/**
- * @since 2.0.0
- */
-const TypeId = /*#__PURE__*/Symbol.for("effect/Option");
-const CommonProto = {
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/internal/option.js
+var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
+var CommonProto = {
   ...EffectPrototype,
   [TypeId]: {
-    _A: _ => _
+    _A: (_2) => _2
   },
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -718,13 +818,13 @@ const CommonProto = {
     return format(this.toJSON());
   }
 };
-const SomeProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
   _tag: "Some",
   _op: "Some",
-  [symbol](that) {
-    return isOption(that) && isSome$1(that) && equals(that.value, this.value);
+  [symbol2](that) {
+    return isOption(that) && isSome(that) && equals(that.value, this.value);
   },
-  [symbol$1]() {
+  [symbol]() {
     return combine(hash(this._tag))(hash(this.value));
   },
   toJSON() {
@@ -735,13 +835,13 @@ const SomeProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonP
     };
   }
 });
-const NoneProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
   _tag: "None",
   _op: "None",
-  [symbol](that) {
-    return isOption(that) && isNone$1(that);
+  [symbol2](that) {
+    return isOption(that) && isNone(that);
   },
-  [symbol$1]() {
+  [symbol]() {
     return combine(hash(this._tag));
   },
   toJSON() {
@@ -751,865 +851,902 @@ const NoneProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonP
     };
   }
 });
-/** @internal */
-const isOption = input => hasProperty(input, TypeId);
-/** @internal */
-const isNone$1 = fa => fa._tag === "None";
-/** @internal */
-const isSome$1 = fa => fa._tag === "Some";
-/** @internal */
-const none$1 = /*#__PURE__*/Object.create(NoneProto);
-/** @internal */
-const some$1 = value => {
-  const a = Object.create(SomeProto);
-  a.value = value;
-  return a;
+var isOption = (input) => hasProperty(input, TypeId);
+var isNone = (fa) => fa._tag === "None";
+var isSome = (fa) => fa._tag === "Some";
+var none = /* @__PURE__ */ Object.create(NoneProto);
+var some2 = (value) => {
+  const a2 = Object.create(SomeProto);
+  a2.value = value;
+  return a2;
 };
-/**
- * Creates a new `Option` that represents the absence of a value.
- *
- * @category constructors
- * @since 2.0.0
- */
-const none = () => none$1;
-/**
- * Creates a new `Option` that wraps the given value.
- *
- * @param value - The value to wrap.
- *
- * @category constructors
- * @since 2.0.0
- */
-const some = some$1;
-/**
- * Determine if a `Option` is a `None`.
- *
- * @param self - The `Option` to check.
- *
- * @example
- * import { some, none, isNone } from 'effect/Option'
- *
- * assert.deepStrictEqual(isNone(some(1)), false)
- * assert.deepStrictEqual(isNone(none()), true)
- *
- * @category guards
- * @since 2.0.0
- */
-const isNone = isNone$1;
-/**
- * Determine if a `Option` is a `Some`.
- *
- * @param self - The `Option` to check.
- *
- * @example
- * import { some, none, isSome } from 'effect/Option'
- *
- * assert.deepStrictEqual(isSome(some(1)), true)
- * assert.deepStrictEqual(isSome(none()), false)
- *
- * @category guards
- * @since 2.0.0
- */
-const isSome = isSome$1;
-/**
- * Returns the value of the `Option` if it is `Some`, otherwise returns `onNone`
- *
- * @param self - The `Option` to get the value of.
- * @param onNone - Function that returns the default value to return if the `Option` is `None`.
- *
- * @example
- * import { some, none, getOrElse } from 'effect/Option'
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(pipe(some(1), getOrElse(() => 0)), 1)
- * assert.deepStrictEqual(pipe(none(), getOrElse(() => 0)), 0)
- *
- * @category getters
- * @since 2.0.0
- */
-const getOrElse = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);
-/**
- * Returns the provided `Option` `that` if `self` is `None`, otherwise returns `self`.
- *
- * @param self - The first `Option` to be checked.
- * @param that - The `Option` to return if `self` is `None`.
- *
- * @example
- * import * as O from "effect/Option"
- * import { pipe } from "effect/Function"
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     O.none(),
- *     O.orElse(() => O.none())
- *   ),
- *   O.none()
- * )
- * assert.deepStrictEqual(
- *   pipe(
- *     O.some('a'),
- *     O.orElse(() => O.none())
- *   ),
- *   O.some('a')
- * )
- * assert.deepStrictEqual(
- *   pipe(
- *     O.none(),
- *     O.orElse(() => O.some('b'))
- *   ),
- *   O.some('b')
- * )
- * assert.deepStrictEqual(
- *   pipe(
- *     O.some('a'),
- *     O.orElse(() => O.some('b'))
- *   ),
- *   O.some('a')
- * )
- *
- * @category error handling
- * @since 2.0.0
- */
-const orElse = /*#__PURE__*/dual(2, (self, that) => isNone(self) ? that() : self);
-/**
- * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise
- * returns the value wrapped in a `Some`.
- *
- * @param nullableValue - The nullable value to be converted to an `Option`.
- *
- * @example
- * import * as O from "effect/Option"
- *
- * assert.deepStrictEqual(O.fromNullable(undefined), O.none())
- * assert.deepStrictEqual(O.fromNullable(null), O.none())
- * assert.deepStrictEqual(O.fromNullable(1), O.some(1))
- *
- * @category conversions
- * @since 2.0.0
- */
-const fromNullable = nullableValue => nullableValue == null ? none() : some(nullableValue);
-/**
- * Maps the `Some` side of an `Option` value to a new `Option` value.
- *
- * @param self - An `Option` to map
- * @param f - The function to map over the value of the `Option`
- *
- * @category mapping
- * @since 2.0.0
- */
-const map = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : some(f(self.value)));
-/**
- * Applies a function to the value of an `Option` and flattens the result, if the input is `Some`.
- *
- * @category sequencing
- * @since 2.0.0
- */
-const flatMap = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : f(self.value));
-/**
- * This is `flatMap` + `fromNullable`, useful when working with optional values.
- *
- * @example
- * import { some, none, flatMapNullable } from 'effect/Option'
- * import { pipe } from "effect/Function"
- *
- * interface Employee {
- *   company?: {
- *     address?: {
- *       street?: {
- *         name?: string
- *       }
- *     }
- *   }
- * }
- *
- * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     some(employee1),
- *     flatMapNullable(employee => employee.company?.address?.street?.name),
- *   ),
- *   some('high street')
- * )
- *
- * const employee2: Employee = { company: { address: { street: {} } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     some(employee2),
- *     flatMapNullable(employee => employee.company?.address?.street?.name),
- *   ),
- *   none()
- * )
- *
- * @category sequencing
- * @since 2.0.0
- */
-const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : fromNullable(f(self.value)));
-/**
- * @category combining
- * @since 2.0.0
- */
-const product = (self, that) => isSome(self) && isSome(that) ? some([self.value, that.value]) : none();
-/**
- * Zips two `Option` values together using a provided function, returning a new `Option` of the result.
- *
- * @param self - The left-hand side of the zip operation
- * @param that - The right-hand side of the zip operation
- * @param f - The function used to combine the values of the two `Option`s
- *
- * @example
- * import * as O from "effect/Option"
- *
- * type Complex = [real: number, imaginary: number]
- *
- * const complex = (real: number, imaginary: number): Complex => [real, imaginary]
- *
- * assert.deepStrictEqual(O.zipWith(O.none(), O.none(), complex), O.none())
- * assert.deepStrictEqual(O.zipWith(O.some(1), O.none(), complex), O.none())
- * assert.deepStrictEqual(O.zipWith(O.none(), O.some(1), complex), O.none())
- * assert.deepStrictEqual(O.zipWith(O.some(1), O.some(2), complex), O.some([1, 2]))
- *
- * assert.deepStrictEqual(O.zipWith(O.some(1), complex)(O.some(2)), O.some([2, 1]))
- *
- * @category zipping
- * @since 2.0.0
- */
-const zipWith = /*#__PURE__*/dual(3, (self, that, f) => map(product(self, that), ([a, b]) => f(a, b)));
-/**
- * Maps over the value of an `Option` and filters out `None`s.
- *
- * Useful when in addition to filtering you also want to change the type of the `Option`.
- *
- * @param self - The `Option` to map over.
- * @param f - A function to apply to the value of the `Option`.
- *
- * @example
- * import * as O from "effect/Option"
- *
- * const evenNumber = (n: number) => n % 2 === 0 ? O.some(n) : O.none()
- *
- * assert.deepStrictEqual(O.filterMap(O.none(), evenNumber), O.none())
- * assert.deepStrictEqual(O.filterMap(O.some(3), evenNumber), O.none())
- * assert.deepStrictEqual(O.filterMap(O.some(2), evenNumber), O.some(2))
- *
- * @category filtering
- * @since 2.0.0
- */
-const filterMap = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : f(self.value));
-/**
- * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`.
- *
- * If you need to change the type of the `Option` in addition to filtering, see `filterMap`.
- *
- * @param predicate - A predicate function to apply to the `Option` value.
- * @param fb - The `Option` to filter.
- *
- * @example
- * import * as O from "effect/Option"
- *
- * // predicate
- * const isEven = (n: number) => n % 2 === 0
- *
- * assert.deepStrictEqual(O.filter(O.none(), isEven), O.none())
- * assert.deepStrictEqual(O.filter(O.some(3), isEven), O.none())
- * assert.deepStrictEqual(O.filter(O.some(2), isEven), O.some(2))
- *
- * // refinement
- * const isNumber = (v: unknown): v is number => typeof v === "number"
- *
- * assert.deepStrictEqual(O.filter(O.none(), isNumber), O.none())
- * assert.deepStrictEqual(O.filter(O.some('hello'), isNumber), O.none())
- * assert.deepStrictEqual(O.filter(O.some(2), isNumber), O.some(2))
- *
- * @category filtering
- * @since 2.0.0
- */
-const filter = /*#__PURE__*/dual(2, (self, predicate) => filterMap(self, b => predicate(b) ? some$1(b) : none$1));
-/**
- * Transforms a `Predicate` function into a `Some` of the input value if the predicate returns `true` or `None`
- * if the predicate returns `false`.
- *
- * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
- *
- * @example
- * import * as O from "effect/Option"
- *
- * const getOption = O.liftPredicate((n: number) => n >= 0)
- *
- * assert.deepStrictEqual(getOption(-1), O.none())
- * assert.deepStrictEqual(getOption(1), O.some(1))
- *
- * @category lifting
- * @since 2.0.0
- */
-const liftPredicate = predicate => b => predicate(b) ? some(b) : none();
-/**
- * Check if a value in an `Option` type meets a certain predicate.
- *
- * @param self - The `Option` to check.
- * @param predicate - The condition to check.
- *
- * @example
- * import { some, none, exists } from 'effect/Option'
- * import { pipe } from "effect/Function"
- *
- * const isEven = (n: number) => n % 2 === 0
- *
- * assert.deepStrictEqual(pipe(some(2), exists(isEven)), true)
- * assert.deepStrictEqual(pipe(some(1), exists(isEven)), false)
- * assert.deepStrictEqual(pipe(none(), exists(isEven)), false)
- *
- * @since 2.0.0
- */
-const exists = /*#__PURE__*/dual(2, (self, refinement) => isNone(self) ? false : refinement(self.value));
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/internal/either.js
+var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
+var CommonProto2 = {
+  ...EffectPrototype,
+  [TypeId2]: {
+    _A: (_2) => _2
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Right",
+  _op: "Right",
+  [symbol2](that) {
+    return isEither(that) && isRight(that) && equals(that.right, this.right);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.right));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    };
+  }
+});
+var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Left",
+  _op: "Left",
+  [symbol2](that) {
+    return isEither(that) && isLeft(that) && equals(that.left, this.left);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.left));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    };
+  }
+});
+var isEither = (input) => hasProperty(input, TypeId2);
+var isLeft = (ma) => ma._tag === "Left";
+var isRight = (ma) => ma._tag === "Right";
+var left = (left2) => {
+  const a2 = Object.create(LeftProto);
+  a2.left = left2;
+  return a2;
+};
+var right = (right2) => {
+  const a2 = Object.create(RightProto);
+  a2.right = right2;
+  return a2;
+};
+var getLeft = (self) => isRight(self) ? none : some2(self.left);
+var getRight = (self) => isLeft(self) ? none : some2(self.right);
-/**
- * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
- *
- * @see https://github.com/oven-sh/bun/issues/3333
- */
-/** @internal */
-typeof process === "undefined" ? false : !!process?.isBun;
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Order.js
+var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
-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;
+// ../../../node_modules/.pnpm/effect@2.3.3/node_modules/effect/dist/esm/Option.js
+var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Option");
+var none2 = () => none;
+var some3 = some2;
+var isOption2 = isOption;
+var isNone2 = isNone;
+var isSome2 = isSome;
+var match = /* @__PURE__ */ dual(2, (self, {
+  onNone,
+  onSome
+}) => isNone2(self) ? onNone() : onSome(self.value));
+var toRefinement = (f2) => (a2) => isSome2(f2(a2));
+var fromIterable = (collection) => {
+  for (const a2 of collection) {
+    return some3(a2);
+  }
+  return none2();
+};
+var getRight2 = getRight;
+var getLeft2 = getLeft;
+var getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
+var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
+var orElseSome = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? some3(onNone()) : self);
+var orElseEither = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? map(that(), right) : map(self, left));
+var firstSomeOf = (collection) => {
+  let out = none2();
+  for (out of collection) {
+    if (isSome2(out)) {
+      return out;
+    }
+  }
+  return out;
+};
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some3(nullableValue);
+var liftNullable = (f2) => (...a2) => fromNullable(f2(...a2));
+var getOrNull = /* @__PURE__ */ getOrElse(constNull);
+var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
+var liftThrowable = (f2) => (...a2) => {
+  try {
+    return some3(f2(...a2));
+  } catch (e2) {
+    return none2();
+  }
+};
+var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onNone) => {
+  if (isSome2(self)) {
+    return self.value;
+  }
+  throw onNone();
+});
+var getOrThrow = /* @__PURE__ */ getOrThrowWith(() => new Error("getOrThrow called on a None"));
+var map = /* @__PURE__ */ dual(2, (self, f2) => isNone2(self) ? none2() : some3(f2(self.value)));
+var as = /* @__PURE__ */ dual(2, (self, b2) => map(self, () => b2));
+var asUnit = /* @__PURE__ */ as(void 0);
+var unit = /* @__PURE__ */ some3(void 0);
+var flatMap = /* @__PURE__ */ dual(2, (self, f2) => isNone2(self) ? none2() : f2(self.value));
+var andThen = /* @__PURE__ */ dual(2, (self, f2) => flatMap(self, (a2) => {
+  const b2 = isFunction(f2) ? f2(a2) : f2;
+  return isOption2(b2) ? b2 : some3(b2);
+}));
+var flatMapNullable = /* @__PURE__ */ dual(2, (self, f2) => isNone2(self) ? none2() : fromNullable(f2(self.value)));
+var flatten = /* @__PURE__ */ flatMap(identity);
+var zipRight = /* @__PURE__ */ dual(2, (self, that) => flatMap(self, () => that));
+var composeK = /* @__PURE__ */ dual(2, (afb, bfc) => (a2) => flatMap(afb(a2), bfc));
+var zipLeft = /* @__PURE__ */ dual(2, (self, that) => tap(self, () => that));
+var tap = /* @__PURE__ */ dual(2, (self, f2) => flatMap(self, (a2) => map(f2(a2), () => a2)));
+var product2 = (self, that) => isSome2(self) && isSome2(that) ? some3([self.value, that.value]) : none2();
+var productMany2 = (self, collection) => {
+  if (isNone2(self)) {
+    return none2();
+  }
+  const out = [self.value];
+  for (const o2 of collection) {
+    if (isNone2(o2)) {
+      return none2();
+    }
+    out.push(o2.value);
+  }
+  return some3(out);
+};
+var all2 = (input) => {
+  if (Symbol.iterator in input) {
+    const out2 = [];
+    for (const o2 of input) {
+      if (isNone2(o2)) {
+        return none2();
+      }
+      out2.push(o2.value);
+    }
+    return some3(out2);
+  }
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const o2 = input[key];
+    if (isNone2(o2)) {
+      return none2();
+    }
+    out[key] = o2.value;
+  }
+  return some3(out);
+};
+var zipWith = /* @__PURE__ */ dual(3, (self, that, f2) => map(product2(self, that), ([a2, b2]) => f2(a2, b2)));
+var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f2, a2) => f2(a2)));
+var reduceCompact = /* @__PURE__ */ dual(3, (self, b2, f2) => {
+  let out = b2;
+  for (const oa of self) {
+    if (isSome2(oa)) {
+      out = f2(out, oa.value);
+    }
+  }
+  return out;
+});
+var toArray = (self) => isNone2(self) ? [] : [self.value];
+var partitionMap = /* @__PURE__ */ dual(2, (self, f2) => {
+  if (isNone2(self)) {
+    return [none2(), none2()];
+  }
+  const e2 = f2(self.value);
+  return isLeft(e2) ? [some3(e2.left), none2()] : [none2(), some3(e2.right)];
+});
+var filterMap = /* @__PURE__ */ dual(2, (self, f2) => isNone2(self) ? none2() : f2(self.value));
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => filterMap(self, (b2) => predicate(b2) ? some2(b2) : none));
+var getEquivalence = (isEquivalent) => make((x2, y2) => x2 === y2 || (isNone2(x2) ? isNone2(y2) : isNone2(y2) ? false : isEquivalent(x2.value, y2.value)));
+var getOrder = (O2) => make2((self, that) => isSome2(self) ? isSome2(that) ? O2(self.value, that.value) : 1 : -1);
+var lift2 = (f2) => dual(2, (self, that) => zipWith(self, that, f2));
+var liftPredicate = (predicate) => (b2) => predicate(b2) ? some3(b2) : none2();
+var containsWith = (isEquivalent) => dual(2, (self, a2) => isNone2(self) ? false : isEquivalent(self.value, a2));
+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 Do = /* @__PURE__ */ some3({});
+var adapter2 = /* @__PURE__ */ adapter();
+var gen = (f2) => {
+  const iterator = f2(adapter2);
+  let state = iterator.next();
+  if (state.done) {
+    return some3(state.value);
+  } else {
+    let current = state.value.value;
+    if (isNone2(current)) {
+      return current;
+    }
+    while (!state.done) {
+      state = iterator.next(current.value);
+      if (!state.done) {
+        current = state.value.value;
+        if (isNone2(current)) {
+          return current;
+        }
+      }
+    }
+    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 (isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment)) return fragment;
-    return "Fragment";
+  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";
 }
-const getPragmaFromContext = memo((context)=>{
+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 pipe(orElse(fromNullable(pragma), ()=>pipe(fromNullable(pragmaNode), map(({ value })=>RE_JSX_ANNOTATION_REGEX.exec(value)), flatMapNullable((matches)=>matches?.[1]?.split(".")[0]))), flatMap(liftPredicate((x)=>RE_JS_IDENTIFIER_REGEX.test(x))), getOrElse(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]?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(){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}`)}run(){return this.exhaustive()}returnType(){return this}}
+    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"))
+    );
+  }
+);
-function isInitializedFromPragma(variableName, context, initialScope, pragma = getPragmaFromContext(context)) {
-    const maybeVariable = findVariable(variableName, initialScope);
-    const maybeLatestDef = flatMapNullable(maybeVariable, (variable)=>variable.defs.at(-1));
-    if (isNone(maybeLatestDef)) return false;
-    const latestDef = maybeLatestDef.value;
-    const { node, parent } = latestDef;
-    if (node.type === NodeType.VariableDeclarator && node.init) {
-        const { init } = node;
-        // check for: `variable = pragma.variable`
-        if (a({
-            type: "MemberExpression",
-            object: {
-                type: "Identifier",
-                name: pragma
-            }
-        }, init)) return true;
-        // check for: `{ variable } = pragma`
-        if (a({
-            type: "Identifier",
-            name: pragma
-        }, init)) return true;
-        // check if from a require call: `require("react")`
-        const maybeRequireExpression = N(init).with({
-            type: NodeType.CallExpression,
-            callee: {
-                type: NodeType.Identifier,
-                name: "require"
-            }
-        }, (exp)=>some(exp)).with({
-            type: NodeType.MemberExpression,
-            object: {
-                type: NodeType.CallExpression,
-                callee: {
-                    type: NodeType.Identifier,
-                    name: "require"
-                }
-            }
-        }, ({ object })=>some(object)).otherwise(none);
-        if (isNone(maybeRequireExpression)) return false;
-        const requireExpression = maybeRequireExpression.value;
-        const [firstArg] = requireExpression.arguments;
-        if (firstArg?.type !== NodeType.Literal) return false;
-        return firstArg.value === pragma.toLowerCase();
+// ../../../node_modules/.pnpm/ts-pattern@5.0.6/node_modules/ts-pattern/dist/index.js
+var t = Symbol.for("@ts-pattern/matcher");
+var e = Symbol.for("@ts-pattern/isVariadic");
+var n = "@ts-pattern/anonymous-select-key";
+var r = (t2) => Boolean(t2 && "object" == typeof t2);
+var i = (e2) => e2 && !!e2[t];
+var s = (n2, o2, c2) => {
+  if (i(n2)) {
+    const e2 = n2[t](), { matched: r2, selections: i2 } = e2.match(o2);
+    return r2 && i2 && Object.keys(i2).forEach((t2) => c2(t2, i2[t2])), r2;
+  }
+  if (r(n2)) {
+    if (!r(o2))
+      return false;
+    if (Array.isArray(n2)) {
+      if (!Array.isArray(o2))
+        return false;
+      let t2 = [], r2 = [], a2 = [];
+      for (const s2 of n2.keys()) {
+        const o3 = n2[s2];
+        i(o3) && o3[e] ? a2.push(o3) : a2.length ? r2.push(o3) : t2.push(o3);
+      }
+      if (a2.length) {
+        if (a2.length > 1)
+          throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+        if (o2.length < t2.length + r2.length)
+          return false;
+        const e2 = o2.slice(0, t2.length), n3 = 0 === r2.length ? [] : o2.slice(-r2.length), i2 = o2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
+        return t2.every((t3, n4) => s(t3, e2[n4], c2)) && r2.every((t3, e3) => s(t3, n3[e3], c2)) && (0 === a2.length || s(a2[0], i2, c2));
+      }
+      return n2.length === o2.length && n2.every((t3, e2) => s(t3, o2[e2], c2));
     }
-    // latest definition is an import declaration: import { variable } from 'react'
-    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 Object.keys(n2).every((e2) => {
+      const r2 = n2[e2];
+      return (e2 in o2 || i(a2 = r2) && "optional" === a2[t]().matcherType) && s(r2, o2[e2], c2);
+      var a2;
+    });
+  }
+  return Object.is(o2, n2);
+};
+var o = (e2) => {
+  var n2, s2, a2;
+  return r(e2) ? i(e2) ? null != (n2 = null == (s2 = (a2 = e2[t]()).getSelectionKeys) ? void 0 : s2.call(a2)) ? n2 : [] : Array.isArray(e2) ? c(e2, o) : c(Object.values(e2), o) : [];
+};
+var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
+function a(...t2) {
+  if (1 === t2.length) {
+    const [e2] = t2;
+    return (t3) => s(e2, t3, () => {
+    });
+  }
+  if (2 === t2.length) {
+    const [e2, n2] = t2;
+    return s(e2, n2, () => {
     });
-    return isMatch;
+  }
+  throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t2.length}.`);
 }
-/**
- * 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
- */ function isFromPragma(name) {
-    return (node, context)=>{
-        const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
-        if (node.type === NodeType.MemberExpression) return isPropertyOfPragma(name, context)(node);
-        if (node.name === name) return isInitializedFromPragma(name, context, initialScope);
-        return false;
+function u(t2) {
+  return Object.assign(t2, { optional: () => l(t2), and: (e2) => m(t2, e2), or: (e2) => y(t2, e2), select: (e2) => void 0 === e2 ? p(t2) : p(e2, t2) });
+}
+function h(t2) {
+  return Object.assign(((t3) => Object.assign(t3, { *[Symbol.iterator]() {
+    yield Object.assign(t3, { [e]: true });
+  } }))(t2), { optional: () => h(l(t2)), select: (e2) => h(void 0 === e2 ? p(t2) : p(e2, t2)) });
+}
+function l(e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
     };
+    return void 0 === t2 ? (o(e2).forEach((t3) => r2(t3, void 0)), { matched: true, selections: n2 }) : { matched: s(e2, t2, r2), selections: n2 };
+  }, getSelectionKeys: () => o(e2), matcherType: "optional" }) });
 }
-/**
- * @internal
- * @param pragmaMemberName
- * @param name
- * @returns A function that checks if a given node is a member expression of a Pragma member.
- */ function isFromPragmaMember(pragmaMemberName, name) {
-    return (node, context, pragma = getPragmaFromContext(context))=>{
-        const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
-        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;
+var f = (t2, e2) => {
+  for (const n2 of t2)
+    if (!e2(n2))
+      return false;
+  return true;
+};
+var g = (t2, e2) => {
+  for (const [n2, r2] of t2.entries())
+    if (!e2(r2, n2))
+      return false;
+  return true;
+};
+function m(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
     };
+    return { matched: e2.every((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "and" }) });
 }
-function isCallFromPragma(name) {
-    return (node, context)=>{
-        if (!isOneOf([
-            NodeType.Identifier,
-            NodeType.MemberExpression
-        ])(node.callee)) return false;
-        return isFromPragma(name)(node.callee, context);
+function y(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    let n2 = {};
+    const r2 = (t3, e3) => {
+      n2[t3] = e3;
     };
+    return c(e2, o).forEach((t3) => r2(t3, void 0)), { matched: e2.some((e3) => s(e3, t2, r2)), selections: n2 };
+  }, getSelectionKeys: () => c(e2, o), matcherType: "or" }) });
 }
-function isCallFromPragmaMember(pragmaMemberName, name) {
-    return (node, context)=>{
-        if (!is(NodeType.MemberExpression)(node.callee)) return false;
-        return isFromPragmaMember(pragmaMemberName, name)(node.callee, context);
+function d(e2) {
+  return { [t]: () => ({ match: (t2) => ({ matched: Boolean(e2(t2)) }) }) };
+}
+function p(...e2) {
+  const r2 = "string" == typeof e2[0] ? e2[0] : void 0, i2 = 2 === e2.length ? e2[1] : "string" == typeof e2[0] ? void 0 : e2[0];
+  return u({ [t]: () => ({ match: (t2) => {
+    let e3 = { [null != r2 ? r2 : n]: t2 };
+    return { matched: void 0 === i2 || s(i2, t2, (t3, n2) => {
+      e3[t3] = n2;
+    }), selections: e3 };
+  }, getSelectionKeys: () => [null != r2 ? r2 : n].concat(void 0 === i2 ? [] : o(i2)) }) });
+}
+function v(t2) {
+  return "number" == typeof t2;
+}
+function b(t2) {
+  return "string" == typeof t2;
+}
+function w(t2) {
+  return "bigint" == typeof t2;
+}
+var S = u(d(function(t2) {
+  return true;
+}));
+var O = S;
+var j = (t2) => Object.assign(u(t2), { startsWith: (e2) => {
+  return j(m(t2, (n2 = e2, d((t3) => b(t3) && t3.startsWith(n2)))));
+  var n2;
+}, endsWith: (e2) => {
+  return j(m(t2, (n2 = e2, d((t3) => b(t3) && t3.endsWith(n2)))));
+  var n2;
+}, minLength: (e2) => j(m(t2, ((t3) => d((e3) => b(e3) && e3.length >= t3))(e2))), maxLength: (e2) => j(m(t2, ((t3) => d((e3) => b(e3) && e3.length <= t3))(e2))), includes: (e2) => {
+  return j(m(t2, (n2 = e2, d((t3) => b(t3) && t3.includes(n2)))));
+  var n2;
+}, regex: (e2) => {
+  return j(m(t2, (n2 = e2, d((t3) => b(t3) && Boolean(t3.match(n2))))));
+  var n2;
+} });
+var E = j(d(b));
+var K = (t2) => Object.assign(u(t2), { between: (e2, n2) => K(m(t2, ((t3, e3) => d((n3) => v(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => K(m(t2, ((t3) => d((e3) => v(e3) && e3 < t3))(e2))), gt: (e2) => K(m(t2, ((t3) => d((e3) => v(e3) && e3 > t3))(e2))), lte: (e2) => K(m(t2, ((t3) => d((e3) => v(e3) && e3 <= t3))(e2))), gte: (e2) => K(m(t2, ((t3) => d((e3) => v(e3) && e3 >= t3))(e2))), int: () => K(m(t2, d((t3) => v(t3) && Number.isInteger(t3)))), finite: () => K(m(t2, d((t3) => v(t3) && Number.isFinite(t3)))), positive: () => K(m(t2, d((t3) => v(t3) && t3 > 0))), negative: () => K(m(t2, d((t3) => v(t3) && t3 < 0))) });
+var A = K(d(v));
+var x = (t2) => Object.assign(u(t2), { between: (e2, n2) => x(m(t2, ((t3, e3) => d((n3) => w(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => x(m(t2, ((t3) => d((e3) => w(e3) && e3 < t3))(e2))), gt: (e2) => x(m(t2, ((t3) => d((e3) => w(e3) && e3 > t3))(e2))), lte: (e2) => x(m(t2, ((t3) => d((e3) => w(e3) && e3 <= t3))(e2))), gte: (e2) => x(m(t2, ((t3) => d((e3) => w(e3) && e3 >= t3))(e2))), positive: () => x(m(t2, d((t3) => w(t3) && t3 > 0))), negative: () => x(m(t2, d((t3) => w(t3) && t3 < 0))) });
+var P = x(d(w));
+var T = u(d(function(t2) {
+  return "boolean" == typeof t2;
+}));
+var k = u(d(function(t2) {
+  return "symbol" == typeof t2;
+}));
+var B = u(d(function(t2) {
+  return null == t2;
+}));
+var _ = { __proto__: null, matcher: t, optional: l, array: function(...e2) {
+  return h({ [t]: () => ({ match: (t2) => {
+    if (!Array.isArray(t2))
+      return { matched: false };
+    if (0 === e2.length)
+      return { matched: true };
+    const n2 = e2[0];
+    let r2 = {};
+    if (0 === t2.length)
+      return o(n2).forEach((t3) => {
+        r2[t3] = [];
+      }), { matched: true, selections: r2 };
+    const i2 = (t3, e3) => {
+      r2[t3] = (r2[t3] || []).concat([e3]);
+    };
+    return { matched: t2.every((t3) => s(n2, t3, i2)), selections: r2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : o(e2[0]) }) });
+}, set: function(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    if (!(t2 instanceof Set))
+      return { matched: false };
+    let n2 = {};
+    if (0 === t2.size)
+      return { matched: true, selections: n2 };
+    if (0 === e2.length)
+      return { matched: true };
+    const r2 = (t3, e3) => {
+      n2[t3] = (n2[t3] || []).concat([e3]);
+    }, i2 = e2[0];
+    return { matched: f(t2, (t3) => s(i2, t3, r2)), selections: n2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : o(e2[0]) }) });
+}, map: function(...e2) {
+  return u({ [t]: () => ({ match: (t2) => {
+    if (!(t2 instanceof Map))
+      return { matched: false };
+    let n2 = {};
+    if (0 === t2.size)
+      return { matched: true, selections: n2 };
+    const r2 = (t3, e3) => {
+      n2[t3] = (n2[t3] || []).concat([e3]);
     };
+    if (0 === e2.length)
+      return { matched: true };
+    var i2;
+    if (1 === e2.length)
+      throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i2 = e2[0]) ? void 0 : i2.toString()}`);
+    const [o2, c2] = e2;
+    return { matched: g(t2, (t3, e3) => {
+      const n3 = s(o2, e3, r2), i3 = s(c2, t3, r2);
+      return n3 && i3;
+    }), selections: n2 };
+  }, getSelectionKeys: () => 0 === e2.length ? [] : [...o(e2[0]), ...o(e2[1])] }) });
+}, intersection: m, union: y, not: function(e2) {
+  return u({ [t]: () => ({ match: (t2) => ({ matched: !s(e2, t2, () => {
+  }) }), getSelectionKeys: () => [], matcherType: "not" }) });
+}, when: d, select: p, any: S, _: O, string: E, number: A, bigint: P, boolean: T, symbol: k, nullish: B, instanceOf: function(t2) {
+  return u(d(/* @__PURE__ */ function(t3) {
+    return (e2) => e2 instanceof t3;
+  }(t2)));
+}, shape: function(t2) {
+  return u(d(a(t2)));
+} };
+var W = { matched: false, value: void 0 };
+function N(t2) {
+  return new $(t2, W);
 }
-const isCreateElement = isFromPragma("createElement");
-const isCreateElementCall = (node, context)=>{
-    if (!isOneOf([
-        NodeType.Identifier,
-        NodeType.MemberExpression
-    ])(node.callee)) return false;
-    return isCreateElement(node.callee, context);
-};
-const isCloneElement = isFromPragma("cloneElement");
-const isCloneElementCall = (node, context)=>{
-    if (!isOneOf([
-        NodeType.Identifier,
-        NodeType.MemberExpression
-    ])(node.callee)) return false;
-    return isCloneElement(node.callee, context);
+var $ = class _$ {
+  constructor(t2, e2) {
+    this.input = void 0, this.state = void 0, this.input = t2, this.state = e2;
+  }
+  with(...t2) {
+    if (this.state.matched)
+      return this;
+    const e2 = t2[t2.length - 1], r2 = [t2[0]];
+    let i2;
+    3 === t2.length && "function" == typeof t2[1] ? i2 = t2[1] : t2.length > 2 && r2.push(...t2.slice(1, t2.length - 1));
+    let o2 = false, c2 = {};
+    const a2 = (t3, e3) => {
+      o2 = true, c2[t3] = e3;
+    }, u2 = !r2.some((t3) => s(t3, this.input, a2)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(o2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
+    return new _$(this.input, u2);
+  }
+  when(t2, e2) {
+    if (this.state.matched)
+      return this;
+    const n2 = Boolean(t2(this.input));
+    return new _$(this.input, n2 ? { matched: true, value: e2(this.input, this.input) } : W);
+  }
+  otherwise(t2) {
+    return this.state.matched ? this.state.value : t2(this.input);
+  }
+  exhaustive() {
+    if (this.state.matched)
+      return this.state.value;
+    let t2;
+    try {
+      t2 = JSON.stringify(this.input);
+    } catch (e2) {
+      t2 = this.input;
+    }
+    throw new Error(`Pattern matching error: no pattern matches value ${t2}`);
+  }
+  run() {
+    return this.exhaustive();
+  }
+  returnType() {
+    return this;
+  }
 };
-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}`;
+// 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 = N(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);
 }
-/**
- * Returns the tag name associated with a JSXOpeningElement.
- * @param node The visited JSXOpeningElement node object.
- * @returns The element's tag name.
- */ function elementType(node) {
-    if (node.type === AST_NODE_TYPES.JSXOpeningFragment) {
-        return "<>";
+function isPropertyOfPragma(name, context, pragma = getPragmaFromContext(context)) {
+  const isMatch = a({
+    type: NodeType.MemberExpression,
+    object: {
+      type: NodeType.Identifier,
+      name: pragma
+    },
+    property: {
+      name
     }
-    const { name } = node;
-    if (name.type === AST_NODE_TYPES.JSXMemberExpression) {
-        const { object, property } = name;
-        return resolveMemberExpressions(object, property);
+  });
+  return isMatch;
+}
+function isFromPragma(name) {
+  return (node, context) => {
+    const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
+    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) ?? context.getScope();
+    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 (name.type === AST_NODE_TYPES.JSXNamespacedName) {
-        return `${name.namespace.name}:${name.name.name}`;
+    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 name.name;
+    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);
+  };
 }
-/**
- * Determines whether inside createElement's props.
- * @param node The AST node to check
- * @param context The rule context
- * @returns `true` if the node is inside createElement's props
- */ function isInsideCreateElementProps(node, context) {
-    return pipe(traverseUp(node, (n)=>is(NodeType.CallExpression)(n) && isCreateElementCall(n, context)), filter(is(NodeType.CallExpression)), flatMapNullable((c)=>c.arguments.at(1)), filter(is(NodeType.ObjectExpression)), zipWith(traverseUp(node, is(NodeType.ObjectExpression)), (a, b)=>a === b), getOrElse(constFalse));
+// 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 pipe(fromNullable(node.parent), filter(is(NodeType.CallExpression)), filter((n)=>isCreateElementCall(n, context)), exists((n)=>n.arguments.slice(2).some((arg)=>arg === node)));
+  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)
+    )
+  );
 }
-/**
- * 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 (isFunction(predicate)) return node.children.some(predicate);
-    return node.children.length > 0;
+function hasChildren(node, predicate) {
+  if (Predicate_exports.isFunction(predicate))
+    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);
+function isChildOfJSXElement(node) {
+  return node.parent?.type === NodeType.JSXElement && node.parent.children.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.openingElement.name.type === NodeType.JSXIdentifier && /^[A-Z]/u.test(node.openingElement.name.name);
+function isJSXElementOfUserDefinedComponent(node) {
+  return 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.openingElement.name.type === NodeType.JSXIdentifier && node.openingElement.name.name.toLowerCase() === node.openingElement.name.name && /^[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);
 }
-const isFragment = (node, pragma, fragment)=>{
-    if (!isOneOf([
-        NodeType.JSXElement,
-        NodeType.JSXFragment
-    ])(node)) return false;
-    return isFragmentSyntax(node) || isFragmentElement(node, pragma, fragment);
+var 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;
+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;
 }
-// type ReactNode =
-//   | ReactElement
-//   | string
-//   | number
-//   | Iterable<ReactNode>
-//   | ReactPortal
-//   | boolean
-//   | null
-//   | undefined
-//   | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES[
-//     keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES
-//   ];
-/* eslint-disable perfectionist/sort-objects */ const JSXValueHint = {
-    None: 0n,
-    SkipNullLiteral: 1n << 0n,
-    SkipUndefinedLiteral: 1n << 1n,
-    SkipBooleanLiteral: 1n << 2n,
-    SkipStringLiteral: 1n << 3n,
-    SkipNumberLiteral: 1n << 4n,
-    SkipCreateElement: 1n << 5n,
-    StrictArray: 1n << 6n,
-    StrictLogical: 1n << 7n,
-    StrictConditional: 1n << 8n
+var JSXValueHint = {
+  None: 0n,
+  SkipNullLiteral: 1n << 0n,
+  SkipUndefinedLiteral: 1n << 1n,
+  SkipBooleanLiteral: 1n << 2n,
+  SkipStringLiteral: 1n << 3n,
+  SkipNumberLiteral: 1n << 4n,
+  SkipCreateElement: 1n << 5n,
+  StrictArray: 1n << 6n,
+  StrictLogical: 1n << 7n,
+  StrictConditional: 1n << 8n
 };
-/* eslint-enable perfectionist/sort-objects */ const DEFAULT_JSX_VALUE_HINT = JSXValueHint.SkipUndefinedLiteral | JSXValueHint.SkipBooleanLiteral;
-/**
- * Check if a node is a JSX value
- * @param node The AST node to check
- * @param context The rule context
- * @param hint The `JSXValueHint` to use
- * @returns boolean
- */ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
-    if (!node) return false;
-    return N(node).with({
-        type: NodeType.JSXElement
-    }, constTrue).with({
-        type: NodeType.JSXFragment
-    }, constTrue).with({
-        type: NodeType.JSXMemberExpression
-    }, constTrue).with({
-        type: NodeType.JSXNamespacedName
-    }, constTrue).with({
-        type: NodeType.Literal
-    }, (node)=>{
-        return N(node.value).with(null, ()=>!(hint & JSXValueHint.SkipNullLiteral)).with(_.boolean, ()=>!(hint & JSXValueHint.SkipBooleanLiteral)).with(_.string, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with(_.number, ()=>!(hint & JSXValueHint.SkipNumberLiteral)).otherwise(constFalse);
-    }).with({
-        type: NodeType.TemplateLiteral
-    }, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with({
-        type: NodeType.ArrayExpression
-    }, (node)=>{
-        if (hint & JSXValueHint.StrictArray) return node.elements.every((n)=>isJSXValue(n, context, hint));
-        return node.elements.some((n)=>isJSXValue(n, context, hint));
-    }).with({
-        type: NodeType.ConditionalExpression
-    }, (node)=>{
-        function leftHasJSX(node) {
-            if (Array.isArray(node.consequent)) {
-                if (hint & JSXValueHint.StrictArray) {
-                    return node.consequent.every((n)=>isJSXValue(n, context, hint));
-                }
-                return node.consequent.some((n)=>isJSXValue(n, context, hint));
-            }
-            return isJSXValue(node.consequent, context, hint);
-        }
-        function rightHasJSX(node) {
-            return isJSXValue(node.alternate, context, hint);
-        }
-        if (hint & JSXValueHint.StrictConditional) {
-            return leftHasJSX(node) && rightHasJSX(node);
+var DEFAULT_JSX_VALUE_HINT = JSXValueHint.SkipUndefinedLiteral | JSXValueHint.SkipBooleanLiteral;
+function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
+  if (!node)
+    return false;
+  return N(node).with({ type: NodeType.JSXElement }, Function_exports.constTrue).with({ type: NodeType.JSXFragment }, Function_exports.constTrue).with({ type: NodeType.JSXMemberExpression }, Function_exports.constTrue).with({ type: NodeType.JSXNamespacedName }, Function_exports.constTrue).with({ type: NodeType.Literal }, (node2) => {
+    return N(node2.value).with(null, () => !(hint & JSXValueHint.SkipNullLiteral)).with(_.boolean, () => !(hint & JSXValueHint.SkipBooleanLiteral)).with(_.string, () => !(hint & JSXValueHint.SkipStringLiteral)).with(_.number, () => !(hint & JSXValueHint.SkipNumberLiteral)).otherwise(Function_exports.constFalse);
+  }).with({ type: NodeType.TemplateLiteral }, () => !(hint & JSXValueHint.SkipStringLiteral)).with({ type: NodeType.ArrayExpression }, (node2) => {
+    if (hint & JSXValueHint.StrictArray)
+      return node2.elements.every((n2) => isJSXValue(n2, context, hint));
+    return node2.elements.some((n2) => isJSXValue(n2, context, hint));
+  }).with({ type: NodeType.ConditionalExpression }, (node2) => {
+    function leftHasJSX(node3) {
+      if (Array.isArray(node3.consequent)) {
+        if (hint & JSXValueHint.StrictArray) {
+          return node3.consequent.every((n2) => isJSXValue(n2, context, hint));
         }
-        return leftHasJSX(node) || rightHasJSX(node);
-    }).with({
-        type: NodeType.LogicalExpression
-    }, (node)=>{
-        return isJSXValue(node.left, context, hint) || isJSXValue(node.right, context, hint);
-    }).with({
-        type: NodeType.SequenceExpression
-    }, (node)=>{
-        const exp = node.expressions.at(-1);
-        return isJSXValue(exp, context, hint);
-    }).with({
-        type: NodeType.CallExpression
-    }, (node)=>{
-        if (hint & JSXValueHint.SkipCreateElement) return false;
-        return isCreateElementCall(node, context);
-    }).with({
-        type: NodeType.Identifier
-    }, (node)=>{
-        const { name } = node;
-        if (name === "undefined") return !(hint & JSXValueHint.SkipUndefinedLiteral);
-        if (isJSXTagNameExpression(node)) return true;
-        const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
-        const maybeVariable = findVariable(name, initialScope);
-        return pipe(maybeVariable, flatMap(getVariableInit(0)), exists((n)=>isJSXValue(n, context, hint)));
-    }).otherwise(constFalse);
-}
-/**
- * Check if function is returning JSX
- * @param node The return statement node to check
- * @param context The rule context
- * @param hint The `JSXValueHint` to use
- * @returns boolean
- */ function isFunctionReturningJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
-    if (node.body.type !== NodeType.BlockStatement) {
-        return isJSXValue(node.body, context, hint);
+        return node3.consequent.some((n2) => isJSXValue(n2, context, hint));
+      }
+      return isJSXValue(node3.consequent, context, hint);
+    }
+    function rightHasJSX(node3) {
+      return isJSXValue(node3.alternate, context, hint);
     }
-    const statements = getNestedReturnStatements(node.body);
-    return statements.some((statement)=>isJSXValue(statement.argument, context, hint));
+    if (hint & JSXValueHint.StrictConditional) {
+      return leftHasJSX(node2) && rightHasJSX(node2);
+    }
+    return leftHasJSX(node2) || rightHasJSX(node2);
+  }).with({ type: NodeType.LogicalExpression }, (node2) => {
+    return isJSXValue(node2.left, context, hint) || isJSXValue(node2.right, context, hint);
+  }).with({ type: NodeType.SequenceExpression }, (node2) => {
+    const exp = node2.expressions.at(-1);
+    return isJSXValue(exp, context, hint);
+  }).with({ type: NodeType.CallExpression }, (node2) => {
+    if (hint & JSXValueHint.SkipCreateElement)
+      return false;
+    return isCreateElementCall(node2, context);
+  }).with({ type: NodeType.Identifier }, (node2) => {
+    const { name } = node2;
+    if (name === "undefined")
+      return !(hint & JSXValueHint.SkipUndefinedLiteral);
+    if (isJSXTagNameExpression(node2))
+      return true;
+    const initialScope = context.sourceCode.getScope?.(node2) ?? context.getScope();
+    const maybeVariable = findVariable(name, initialScope);
+    return Function_exports.pipe(
+      maybeVariable,
+      Option_exports.flatMap(getVariableInit(0)),
+      Option_exports.exists((n2) => isJSXValue(n2, context, hint))
+    );
+  }).otherwise(Function_exports.constFalse);
 }
-const { getStaticValue } = ESLintCommunityESLintUtils;
-/**
- * Get the name of a JSX attribute with namespace
- * @param node The JSX attribute node
- * @returns string
- */ function getPropName(node) {
-    return N(node.name).when(is(NodeType.JSXIdentifier), (n)=>n.name).when(is(NodeType.JSXNamespacedName), (n)=>`${n.namespace.name}:${n.name.name}`).exhaustive();
+// src/misc.ts
+function isFunctionReturningJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
+  if (node.body.type !== NodeType.BlockStatement) {
+    return isJSXValue(node.body, context, hint);
+  }
+  const statements = getNestedReturnStatements(node.body);
+  return statements.some((statement) => isJSXValue(statement.argument, context, hint));
+}
+var { getStaticValue } = ESLintCommunityESLintUtils;
+function getPropName(node) {
+  return N(node.name).when(is(NodeType.JSXIdentifier), (n2) => n2.name).when(is(NodeType.JSXNamespacedName), (n2) => `${n2.namespace.name}:${n2.name.name}`).exhaustive();
 }
 function getProp(props, propName, context, initialScope) {
-    return findPropInAttributes(props, context, initialScope)(propName);
+  return findPropInAttributes(props, context, initialScope)(propName);
 }
-/**
- * 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 initialScope = context.sourceCode.getScope?.(attribute) ?? context.getScope();
-    if (attribute.type === NodeType.JSXAttribute && "value" in attribute) {
-        const { value } = attribute;
-        if (value === null) return none();
-        if (value.type === NodeType.Literal) return some(getStaticValue(value, initialScope));
-        if (value.type === NodeType.JSXExpressionContainer) return some(getStaticValue(value.expression, initialScope));
-        return none();
-    }
-    const { argument } = attribute;
-    return some(getStaticValue(argument, initialScope));
+function getPropValue(attribute, context) {
+  const initialScope = context.sourceCode.getScope?.(attribute) ?? context.getScope();
+  if (attribute.type === NodeType.JSXAttribute && "value" in attribute) {
+    const { value } = attribute;
+    if (value === null)
+      return Option_exports.none();
+    if (value.type === NodeType.Literal)
+      return Option_exports.some(getStaticValue(value, initialScope));
+    if (value.type === NodeType.JSXExpressionContainer)
+      return Option_exports.some(getStaticValue(value.expression, initialScope));
+    return Option_exports.none();
+  }
+  const { argument } = attribute;
+  return Option_exports.some(getStaticValue(argument, initialScope));
 }
-/**
- * @param properties The properties to search in
- * @param context The rule context
- * @param initialScope
- * @param seenProps The properties that have already been seen
- * @returns A function that searches for a property in the given properties
- */ function findPropInProperties(properties, context, initialScope, seenProps = []) {
-    /**
-   * Search for a property in the given properties
-   * @param propName The name of the property to search for
-   * @returns The property if found
-   */ return (propName)=>{
-        return fromNullable(properties.find((prop)=>{
-            return N(prop).when(is(NodeType.Property), (prop)=>{
-                return "name" in prop.key && prop.key.name === propName;
-            }).when(is(NodeType.SpreadElement), (prop)=>{
-                return N(prop.argument).when(is(NodeType.Identifier), (argument)=>{
-                    const { name } = argument;
-                    const maybeInit = flatMap(findVariable(name, initialScope), getVariableInit(0));
-                    if (isNone(maybeInit)) return false;
-                    const init = maybeInit.value;
-                    if (init.type !== NodeType.ObjectExpression) return false;
-                    if (seenProps.includes(name)) return false;
-                    return isSome(findPropInProperties(init.properties, context, initialScope, [
-                        ...seenProps,
-                        name
-                    ])(propName));
-                }).when(is(NodeType.ObjectExpression), (argument)=>{
-                    return isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
-                }).when(is(NodeType.MemberExpression), ()=>{
-                // Not implemented
-                }).when(is(NodeType.CallExpression), ()=>{
-                // Not implemented
-                }).otherwise(constFalse);
-            }).when(is(NodeType.RestElement), ()=>{
-                // Not implemented
-                return false;
-            }).otherwise(constFalse);
-        }));
-    };
+function findPropInProperties(properties, context, initialScope, seenProps = []) {
+  return (propName) => {
+    return Option_exports.fromNullable(
+      properties.find((prop) => {
+        return N(prop).when(is(NodeType.Property), (prop2) => {
+          return "name" in prop2.key && prop2.key.name === propName;
+        }).when(is(NodeType.SpreadElement), (prop2) => {
+          return N(prop2.argument).when(is(NodeType.Identifier), (argument) => {
+            const { name } = argument;
+            const maybeInit = Option_exports.flatMap(
+              findVariable(name, initialScope),
+              getVariableInit(0)
+            );
+            if (Option_exports.isNone(maybeInit))
+              return false;
+            const init = maybeInit.value;
+            if (init.type !== NodeType.ObjectExpression)
+              return false;
+            if (seenProps.includes(name))
+              return false;
+            return Option_exports.isSome(
+              findPropInProperties(init.properties, context, initialScope, [...seenProps, name])(propName)
+            );
+          }).when(is(NodeType.ObjectExpression), (argument) => {
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
+          }).when(is(NodeType.MemberExpression), () => {
+          }).when(is(NodeType.CallExpression), () => {
+          }).otherwise(Function_exports.constFalse);
+        }).when(is(NodeType.RestElement), () => {
+          return false;
+        }).otherwise(Function_exports.constFalse);
+      })
+    );
+  };
 }
-/**
- * @param attributes The attributes to search in
- * @param context The rule context
- * @param initialScope
- * @returns A function that searches for a property in the given attributes
- */ function findPropInAttributes(attributes, context, initialScope) {
-    /**
-   * Search for a property in the given attributes
-   * @param propName The name of the property to search for
-   * @returns The property if found
-   */ return (propName)=>{
-        return fromNullable(attributes.find((attr)=>{
-            return N(attr).when(is(NodeType.JSXAttribute), (attr)=>getPropName(attr) === propName).when(is(NodeType.JSXSpreadAttribute), (attr)=>{
-                return N(attr.argument).with({
-                    type: NodeType.Identifier
-                }, (argument)=>{
-                    const { name } = argument;
-                    const maybeInit = flatMap(findVariable(name, initialScope), getVariableInit(0));
-                    if (isNone(maybeInit)) return false;
-                    const init = maybeInit.value;
-                    if (!("properties" in init)) return false;
-                    return isSome(findPropInProperties(init.properties, context, initialScope)(propName));
-                }).when(is(NodeType.ObjectExpression), (argument)=>{
-                    return isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
-                }).when(is(NodeType.MemberExpression), ()=>{
-                    // Not implemented
-                    return false;
-                }).when(is(NodeType.CallExpression), ()=>{
-                    // Not implemented
-                    return false;
-                }).otherwise(constFalse);
-            }).otherwise(constFalse);
-        }));
-    };
+function findPropInAttributes(attributes, context, initialScope) {
+  return (propName) => {
+    return Option_exports.fromNullable(
+      attributes.find((attr) => {
+        return N(attr).when(is(NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(is(NodeType.JSXSpreadAttribute), (attr2) => {
+          return N(attr2.argument).with({ type: NodeType.Identifier }, (argument) => {
+            const { name } = argument;
+            const maybeInit = Option_exports.flatMap(
+              findVariable(name, initialScope),
+              getVariableInit(0)
+            );
+            if (Option_exports.isNone(maybeInit))
+              return false;
+            const init = maybeInit.value;
+            if (!("properties" in init))
+              return false;
+            return Option_exports.isSome(findPropInProperties(init.properties, context, initialScope)(propName));
+          }).when(is(NodeType.ObjectExpression), (argument) => {
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
+          }).when(is(NodeType.MemberExpression), () => {
+            return false;
+          }).when(is(NodeType.CallExpression), () => {
+            return false;
+          }).otherwise(Function_exports.constFalse);
+        }).otherwise(Function_exports.constFalse);
+      })
+    );
+  };
 }
-/**
- * Check if the given prop name is present in the given attributes
- * @param attributes The attributes to search in
- * @param propName The prop name to search for
- * @param context The rule context
- * @param initialScope
- * @returns `true` if the given prop name is present in the given properties
- */ function hasProp(attributes, propName, context, initialScope) {
-    return isSome(findPropInAttributes(attributes, context, initialScope)(propName));
+// src/prop/has-prop.ts
+function hasProp(attributes, propName, context, initialScope) {
+  return Option_exports.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
 }
-/**
- * Check if any of the given prop names are present in the given attributes
- * @param attributes The attributes to search in
- * @param propNames The prop names to search for
- * @param context The rule context
- * @param initialScope
- * @returns `true` if any of the given prop names are present in the given attributes
- */ function hasAnyProp(attributes, propNames, context, initialScope) {
-    return propNames.some((propName)=>hasProp(attributes, propName, context, initialScope));
+function hasAnyProp(attributes, propNames, context, initialScope) {
+  return propNames.some((propName) => hasProp(attributes, propName, context, initialScope));
 }
-/**
- * Check if all of the given prop names are present in the given attributes
- * @param attributes The attributes to search in
- * @param propNames The prop names to search for
- * @param context The rule context
- * @param initialScope
- * @returns `true` if all of the given prop names are present in the given attributes
- */ function hasEveryProp(attributes, propNames, context, initialScope) {
-    return propNames.every((propName)=>hasProp(attributes, propName, context, initialScope));
+function hasEveryProp(attributes, propNames, context, initialScope) {
+  return propNames.every((propName) => hasProp(attributes, propName, context, initialScope));
 }
-/**
- * Traverses up prop node
- * @param node The AST node to start traversing from
- * @param predicate The predicate to check each node
- * @returns prop node if found
- */ function traverseUpProp(node, predicate = constTrue) {
-    const guard = (node)=>{
-        return node.type === NodeType.JSXAttribute && predicate(node);
-    };
-    return traverseUpGuard(node, guard);
+function traverseUpProp(node, predicate = Function_exports.constTrue) {
+  const guard = (node2) => {
+    return node2.type === NodeType.JSXAttribute && predicate(node2);
+  };
+  return traverseUpGuard(node, guard);
 }
-/**
- * Checks if the node is inside a prop's value
- * @param node The AST node to check
- * @returns `true` if the node is inside a prop's value
- */ function isInsidePropValue(node) {
-    if (isStringLiteral(node)) return node.parent.type === NodeType.JSXAttribute;
-    return isSome(traverseUpProp(node, (n)=>n.value?.type === NodeType.JSXExpressionContainer));
+// src/prop/misc.ts
+function isInsidePropValue(node) {
+  if (isStringLiteral(node))
+    return node.parent.type === NodeType.JSXAttribute;
+  return Option_exports.isSome(traverseUpProp(node, (n2) => n2.value?.type === NodeType.JSXExpressionContainer));
 }
-/**
- * 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() === "";
+var isLiteral = isOneOf([NodeType.Literal, NodeType.JSXText]);
+function isWhiteSpace(node) {
+  return Predicate_exports.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);
+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");
+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 };