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

package/dist/index.js

@@ -5,71 +5,50 @@ var shared = require('@eslint-react/shared');
 var memo = require('micro-memoize');
 var _var = require('@eslint-react/var');
 var types = require('@typescript-eslint/types');
+require('@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) {
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var memo__default = /*#__PURE__*/_interopDefault(memo);
+
+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) {
@@ -77,251 +56,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;
@@ -373,13 +489,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;
   }
@@ -391,35 +505,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;
@@ -436,7 +545,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;
@@ -447,23 +555,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);
@@ -478,84 +574,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]);
 }
@@ -569,48 +636,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);
 
-/**
- * @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/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+
+// ../../../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);
@@ -630,73 +742,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() {
@@ -704,14 +810,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();
@@ -720,13 +824,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() {
@@ -737,13 +841,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() {
@@ -753,865 +857,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 = shared.parseSchema(shared.ESLintSettingsSchema, context.settings);
-    const fragment = settings.reactOptions?.jsxPragmaFrag;
-    if (isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment)) return fragment;
-    return "Fragment";
+  const settings = shared.parseSchema(shared.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__default.default(
+  (context) => {
     const settings = shared.parseSchema(shared.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 = _var.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 === ast.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: ast.NodeType.CallExpression,
-            callee: {
-                type: ast.NodeType.Identifier,
-                name: "require"
-            }
-        }, (exp)=>some(exp)).with({
-            type: ast.NodeType.MemberExpression,
-            object: {
-                type: ast.NodeType.CallExpression,
-                callee: {
-                    type: ast.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 !== ast.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: ast.NodeType.MemberExpression,
-        object: {
-            type: ast.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, () => {
     });
-    return isMatch;
+  }
+  if (2 === t2.length) {
+    const [e2, n2] = t2;
+    return s(e2, n2, () => {
+    });
+  }
+  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 === ast.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 !== ast.NodeType.Identifier || node.property.name !== name) return false;
-        if (node.object.type === ast.NodeType.Identifier && node.object.name === pragmaMemberName) {
-            return isInitializedFromPragma(node.object.name, context, initialScope, pragma);
-        }
-        if (node.object.type === ast.NodeType.MemberExpression && node.object.object.type === ast.NodeType.Identifier && node.object.object.name === pragma && node.object.property.type === ast.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 (!ast.isOneOf([
-            ast.NodeType.Identifier,
-            ast.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 (!ast.is(ast.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 (!ast.isOneOf([
-        ast.NodeType.Identifier,
-        ast.NodeType.MemberExpression
-    ])(node.callee)) return false;
-    return isCreateElement(node.callee, context);
-};
-const isCloneElement = isFromPragma("cloneElement");
-const isCloneElementCall = (node, context)=>{
-    if (!ast.isOneOf([
-        ast.NodeType.Identifier,
-        ast.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 === types.AST_NODE_TYPES.JSXMemberExpression) {
-        return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
-    }
-    if (object.type === types.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 = _var.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 === ast.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: ast.NodeType.CallExpression,
+      callee: { type: ast.NodeType.Identifier, name: "require" }
+    }, (exp) => Option_exports.some(exp)).with(
+      {
+        type: ast.NodeType.MemberExpression,
+        object: {
+          type: ast.NodeType.CallExpression,
+          callee: { type: ast.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 !== ast.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 === types.AST_NODE_TYPES.JSXOpeningFragment) {
-        return "<>";
+function isPropertyOfPragma(name, context, pragma = getPragmaFromContext(context)) {
+  const isMatch = a({
+    type: ast.NodeType.MemberExpression,
+    object: {
+      type: ast.NodeType.Identifier,
+      name: pragma
+    },
+    property: {
+      name
     }
-    const { name } = node;
-    if (name.type === types.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 === ast.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 !== ast.NodeType.Identifier || node.property.name !== name)
+      return false;
+    if (node.object.type === ast.NodeType.Identifier && node.object.name === pragmaMemberName) {
+      return isInitializedFromPragma(node.object.name, context, initialScope, pragma);
     }
-    if (name.type === types.AST_NODE_TYPES.JSXNamespacedName) {
-        return `${name.namespace.name}:${name.name.name}`;
+    if (node.object.type === ast.NodeType.MemberExpression && node.object.object.type === ast.NodeType.Identifier && node.object.object.name === pragma && node.object.property.type === ast.NodeType.Identifier) {
+      return node.object.property.name === pragmaMemberName;
     }
-    return name.name;
+    return false;
+  };
+}
+function isCallFromPragma(name) {
+  return (node, context) => {
+    if (!ast.isOneOf([ast.NodeType.Identifier, ast.NodeType.MemberExpression])(node.callee))
+      return false;
+    return isFromPragma(name)(node.callee, context);
+  };
+}
+function isCallFromPragmaMember(pragmaMemberName, name) {
+  return (node, context) => {
+    if (!ast.is(ast.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(ast.traverseUp(node, (n)=>ast.is(ast.NodeType.CallExpression)(n) && isCreateElementCall(n, context)), filter(ast.is(ast.NodeType.CallExpression)), flatMapNullable((c)=>c.arguments.at(1)), filter(ast.is(ast.NodeType.ObjectExpression)), zipWith(ast.traverseUp(node, ast.is(ast.NodeType.ObjectExpression)), (a, b)=>a === b), getOrElse(constFalse));
+// src/element/api.ts
+var isCreateElement = isFromPragma("createElement");
+var isCreateElementCall = (node, context) => {
+  if (!ast.isOneOf([ast.NodeType.Identifier, ast.NodeType.MemberExpression])(node.callee))
+    return false;
+  return isCreateElement(node.callee, context);
+};
+var isCloneElement = isFromPragma("cloneElement");
+var isCloneElementCall = (node, context) => {
+  if (!ast.isOneOf([ast.NodeType.Identifier, ast.NodeType.MemberExpression])(node.callee))
+    return false;
+  return isCloneElement(node.callee, context);
+};
+function resolveMemberExpressions(object, property) {
+  if (object.type === types.AST_NODE_TYPES.JSXMemberExpression) {
+    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
+  }
+  if (object.type === types.AST_NODE_TYPES.JSXNamespacedName) {
+    return `${object.namespace.name}:${object.name.name}.${property.name}`;
+  }
+  return `${object.name}.${property.name}`;
+}
+function elementType(node) {
+  if (node.type === types.AST_NODE_TYPES.JSXOpeningFragment) {
+    return "<>";
+  }
+  const { name } = node;
+  if (name.type === types.AST_NODE_TYPES.JSXMemberExpression) {
+    const { object, property } = name;
+    return resolveMemberExpressions(object, property);
+  }
+  if (name.type === types.AST_NODE_TYPES.JSXNamespacedName) {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return name.name;
+}
+function isInsideCreateElementProps(node, context) {
+  return Function_exports.pipe(
+    ast.traverseUp(node, (n2) => ast.is(ast.NodeType.CallExpression)(n2) && isCreateElementCall(n2, context)),
+    Option_exports.filter(ast.is(ast.NodeType.CallExpression)),
+    Option_exports.flatMapNullable((c2) => c2.arguments.at(1)),
+    Option_exports.filter(ast.is(ast.NodeType.ObjectExpression)),
+    Option_exports.zipWith(ast.traverseUp(node, ast.is(ast.NodeType.ObjectExpression)), (a2, b2) => a2 === b2),
+    Option_exports.getOrElse(Function_exports.constFalse)
+  );
 }
 function isChildrenOfCreateElement(node, context) {
-    return pipe(fromNullable(node.parent), filter(ast.is(ast.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(ast.is(ast.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 === ast.NodeType.JSXElement && node.parent.children.some((child)=>child === node);
+function isChildOfJSXElement(node) {
+  return node.parent?.type === ast.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 === ast.NodeType.JSXIdentifier && /^[A-Z]/u.test(node.openingElement.name.name);
+function isJSXElementOfUserDefinedComponent(node) {
+  return node.openingElement.name.type === ast.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 === ast.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 === ast.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 (!ast.isOneOf([
-        ast.NodeType.JSXElement,
-        ast.NodeType.JSXFragment
-    ])(node)) return false;
-    return isFragmentSyntax(node) || isFragmentElement(node, pragma, fragment);
+var isFragment = (node, pragma, fragment) => {
+  if (!ast.isOneOf([ast.NodeType.JSXElement, ast.NodeType.JSXFragment])(node))
+    return false;
+  return isFragmentSyntax(node) || isFragmentElement(node, pragma, fragment);
 };
-/**
- * Check if a node is `<></>`
- */ const isFragmentSyntax = ast.is(ast.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 === ast.NodeType.JSXIdentifier && name.name === fragment) return true;
-    // <Pragma.Fragment>
-    return name.type === ast.NodeType.JSXMemberExpression && name.object.type === ast.NodeType.JSXIdentifier && name.object.name === pragma && name.property.name === fragment;
+var isFragmentSyntax = ast.is(ast.NodeType.JSXFragment);
+function isFragmentElement(node, pragma, fragment) {
+  const { name } = node.openingElement;
+  if (name.type === ast.NodeType.JSXIdentifier && name.name === fragment)
+    return true;
+  return name.type === ast.NodeType.JSXMemberExpression && name.object.type === ast.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: ast.NodeType.JSXElement
-    }, constTrue).with({
-        type: ast.NodeType.JSXFragment
-    }, constTrue).with({
-        type: ast.NodeType.JSXMemberExpression
-    }, constTrue).with({
-        type: ast.NodeType.JSXNamespacedName
-    }, constTrue).with({
-        type: ast.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: ast.NodeType.TemplateLiteral
-    }, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with({
-        type: ast.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: ast.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: ast.NodeType.JSXElement }, Function_exports.constTrue).with({ type: ast.NodeType.JSXFragment }, Function_exports.constTrue).with({ type: ast.NodeType.JSXMemberExpression }, Function_exports.constTrue).with({ type: ast.NodeType.JSXNamespacedName }, Function_exports.constTrue).with({ type: ast.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: ast.NodeType.TemplateLiteral }, () => !(hint & JSXValueHint.SkipStringLiteral)).with({ type: ast.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: ast.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: ast.NodeType.LogicalExpression
-    }, (node)=>{
-        return isJSXValue(node.left, context, hint) || isJSXValue(node.right, context, hint);
-    }).with({
-        type: ast.NodeType.SequenceExpression
-    }, (node)=>{
-        const exp = node.expressions.at(-1);
-        return isJSXValue(exp, context, hint);
-    }).with({
-        type: ast.NodeType.CallExpression
-    }, (node)=>{
-        if (hint & JSXValueHint.SkipCreateElement) return false;
-        return isCreateElementCall(node, context);
-    }).with({
-        type: ast.NodeType.Identifier
-    }, (node)=>{
-        const { name } = node;
-        if (name === "undefined") return !(hint & JSXValueHint.SkipUndefinedLiteral);
-        if (ast.isJSXTagNameExpression(node)) return true;
-        const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
-        const maybeVariable = _var.findVariable(name, initialScope);
-        return pipe(maybeVariable, flatMap(_var.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 !== ast.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 = ast.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: ast.NodeType.LogicalExpression }, (node2) => {
+    return isJSXValue(node2.left, context, hint) || isJSXValue(node2.right, context, hint);
+  }).with({ type: ast.NodeType.SequenceExpression }, (node2) => {
+    const exp = node2.expressions.at(-1);
+    return isJSXValue(exp, context, hint);
+  }).with({ type: ast.NodeType.CallExpression }, (node2) => {
+    if (hint & JSXValueHint.SkipCreateElement)
+      return false;
+    return isCreateElementCall(node2, context);
+  }).with({ type: ast.NodeType.Identifier }, (node2) => {
+    const { name } = node2;
+    if (name === "undefined")
+      return !(hint & JSXValueHint.SkipUndefinedLiteral);
+    if (ast.isJSXTagNameExpression(node2))
+      return true;
+    const initialScope = context.sourceCode.getScope?.(node2) ?? context.getScope();
+    const maybeVariable = _var.findVariable(name, initialScope);
+    return Function_exports.pipe(
+      maybeVariable,
+      Option_exports.flatMap(_var.getVariableInit(0)),
+      Option_exports.exists((n2) => isJSXValue(n2, context, hint))
+    );
+  }).otherwise(Function_exports.constFalse);
 }
 
-const { getStaticValue } = ast.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(ast.is(ast.NodeType.JSXIdentifier), (n)=>n.name).when(ast.is(ast.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 !== ast.NodeType.BlockStatement) {
+    return isJSXValue(node.body, context, hint);
+  }
+  const statements = ast.getNestedReturnStatements(node.body);
+  return statements.some((statement) => isJSXValue(statement.argument, context, hint));
+}
+var { getStaticValue } = ast.ESLintCommunityESLintUtils;
+function getPropName(node) {
+  return N(node.name).when(ast.is(ast.NodeType.JSXIdentifier), (n2) => n2.name).when(ast.is(ast.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 === ast.NodeType.JSXAttribute && "value" in attribute) {
-        const { value } = attribute;
-        if (value === null) return none();
-        if (value.type === ast.NodeType.Literal) return some(getStaticValue(value, initialScope));
-        if (value.type === ast.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 === ast.NodeType.JSXAttribute && "value" in attribute) {
+    const { value } = attribute;
+    if (value === null)
+      return Option_exports.none();
+    if (value.type === ast.NodeType.Literal)
+      return Option_exports.some(getStaticValue(value, initialScope));
+    if (value.type === ast.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(ast.is(ast.NodeType.Property), (prop)=>{
-                return "name" in prop.key && prop.key.name === propName;
-            }).when(ast.is(ast.NodeType.SpreadElement), (prop)=>{
-                return N(prop.argument).when(ast.is(ast.NodeType.Identifier), (argument)=>{
-                    const { name } = argument;
-                    const maybeInit = flatMap(_var.findVariable(name, initialScope), _var.getVariableInit(0));
-                    if (isNone(maybeInit)) return false;
-                    const init = maybeInit.value;
-                    if (init.type !== ast.NodeType.ObjectExpression) return false;
-                    if (seenProps.includes(name)) return false;
-                    return isSome(findPropInProperties(init.properties, context, initialScope, [
-                        ...seenProps,
-                        name
-                    ])(propName));
-                }).when(ast.is(ast.NodeType.ObjectExpression), (argument)=>{
-                    return isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
-                }).when(ast.is(ast.NodeType.MemberExpression), ()=>{
-                // Not implemented
-                }).when(ast.is(ast.NodeType.CallExpression), ()=>{
-                // Not implemented
-                }).otherwise(constFalse);
-            }).when(ast.is(ast.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(ast.is(ast.NodeType.Property), (prop2) => {
+          return "name" in prop2.key && prop2.key.name === propName;
+        }).when(ast.is(ast.NodeType.SpreadElement), (prop2) => {
+          return N(prop2.argument).when(ast.is(ast.NodeType.Identifier), (argument) => {
+            const { name } = argument;
+            const maybeInit = Option_exports.flatMap(
+              _var.findVariable(name, initialScope),
+              _var.getVariableInit(0)
+            );
+            if (Option_exports.isNone(maybeInit))
+              return false;
+            const init = maybeInit.value;
+            if (init.type !== ast.NodeType.ObjectExpression)
+              return false;
+            if (seenProps.includes(name))
+              return false;
+            return Option_exports.isSome(
+              findPropInProperties(init.properties, context, initialScope, [...seenProps, name])(propName)
+            );
+          }).when(ast.is(ast.NodeType.ObjectExpression), (argument) => {
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
+          }).when(ast.is(ast.NodeType.MemberExpression), () => {
+          }).when(ast.is(ast.NodeType.CallExpression), () => {
+          }).otherwise(Function_exports.constFalse);
+        }).when(ast.is(ast.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(ast.is(ast.NodeType.JSXAttribute), (attr)=>getPropName(attr) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr)=>{
-                return N(attr.argument).with({
-                    type: ast.NodeType.Identifier
-                }, (argument)=>{
-                    const { name } = argument;
-                    const maybeInit = flatMap(_var.findVariable(name, initialScope), _var.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(ast.is(ast.NodeType.ObjectExpression), (argument)=>{
-                    return isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
-                }).when(ast.is(ast.NodeType.MemberExpression), ()=>{
-                    // Not implemented
-                    return false;
-                }).when(ast.is(ast.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(ast.is(ast.NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr2) => {
+          return N(attr2.argument).with({ type: ast.NodeType.Identifier }, (argument) => {
+            const { name } = argument;
+            const maybeInit = Option_exports.flatMap(
+              _var.findVariable(name, initialScope),
+              _var.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(ast.is(ast.NodeType.ObjectExpression), (argument) => {
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
+          }).when(ast.is(ast.NodeType.MemberExpression), () => {
+            return false;
+          }).when(ast.is(ast.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 === ast.NodeType.JSXAttribute && predicate(node);
-    };
-    return ast.traverseUpGuard(node, guard);
+function traverseUpProp(node, predicate = Function_exports.constTrue) {
+  const guard = (node2) => {
+    return node2.type === ast.NodeType.JSXAttribute && predicate(node2);
+  };
+  return ast.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 (ast.isStringLiteral(node)) return node.parent.type === ast.NodeType.JSXAttribute;
-    return isSome(traverseUpProp(node, (n)=>n.value?.type === ast.NodeType.JSXExpressionContainer));
+// src/prop/misc.ts
+function isInsidePropValue(node) {
+  if (ast.isStringLiteral(node))
+    return node.parent.type === ast.NodeType.JSXAttribute;
+  return Option_exports.isSome(traverseUpProp(node, (n2) => n2.value?.type === ast.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 = ast.isOneOf([
-    ast.NodeType.Literal,
-    ast.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 = ast.isOneOf([ast.NodeType.Literal, ast.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) && ast.isMultiLine(node);
+function isLineBreak(node) {
+  return isLiteral(node) && isWhiteSpace(node) && ast.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");
 }
 
 exports.DEFAULT_JSX_VALUE_HINT = DEFAULT_JSX_VALUE_HINT;