@eslint-react/jsx 1.5.25-next.6 → 1.5.25-next.8

package/dist/index.mjs

@@ -1,12 +1,9 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import { F, O, Pred } from '@eslint-react/tools';
 import { isOneOf, NodeType, is, isJSXTagNameExpression, isMultiLine, traverseUpGuard, ESLintCommunityESLintUtils } from '@eslint-react/ast';
 import { findVariable, getVariableInit } from '@eslint-react/var';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all3) => {
-  for (var name in all3)
-    __defProp(target, name, { get: all3[name], enumerable: true });
-};
+// src/element-type.ts
 function resolveMemberExpressions(object, property) {
   if (object.type === AST_NODE_TYPES.JSXMemberExpression) {
     return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
@@ -30,1856 +27,15 @@ function elementType(node) {
   }
   return name.name;
 }
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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,
-  satisfies: () => satisfies,
-  tupled: () => tupled,
-  unsafeCoerce: () => unsafeCoerce,
-  untupled: () => untupled
-});
-var isFunction = (input) => typeof input === "function";
-var dual = function(arity, body) {
-  if (typeof arity === "function") {
-    return function() {
-      if (arity(arguments)) {
-        return body.apply(this, arguments);
-      }
-      return (self) => body(self, ...arguments);
-    };
-  }
-  switch (arity) {
-    case 0:
-    case 1:
-      throw new RangeError(`Invalid arity ${arity}`);
-    case 2:
-      return function(a2, b2) {
-        if (arguments.length >= 2) {
-          return body(a2, b2);
-        }
-        return function(self) {
-          return body(self, a2);
-        };
-      };
-    case 3:
-      return function(a2, b2, c2) {
-        if (arguments.length >= 3) {
-          return body(a2, b2, c2);
-        }
-        return function(self) {
-          return body(self, a2, b2);
-        };
-      };
-    case 4:
-      return function(a2, b2, c2, d2) {
-        if (arguments.length >= 4) {
-          return body(a2, b2, c2, d2);
-        }
-        return function(self) {
-          return body(self, a2, b2, c2);
-        };
-      };
-    case 5:
-      return function(a2, b2, c2, d2, e2) {
-        if (arguments.length >= 5) {
-          return body(a2, b2, c2, d2, e2);
-        }
-        return function(self) {
-          return body(self, a2, b2, c2, d2);
-        };
-      };
-    default:
-      return function() {
-        if (arguments.length >= arity) {
-          return body.apply(this, arguments);
-        }
-        const args = arguments;
-        return function(self) {
-          return body(self, ...args);
-        };
-      };
-  }
-};
-var apply = (a2) => (self) => self(a2);
-var identity = (a2) => a2;
-var satisfies = () => (b2) => b2;
-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 a2;
-    case 2:
-      return ab(a2);
-    case 3:
-      return bc(ab(a2));
-    case 4:
-      return cd(bc(ab(a2)));
-    case 5:
-      return de(cd(bc(ab(a2))));
-    case 6:
-      return ef(de(cd(bc(ab(a2)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a2))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a2)))))));
-    case 9:
-      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;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Array.js
-var Array_exports = {};
-__export(Array_exports, {
-  Do: () => Do2,
-  allocate: () => allocate,
-  append: () => append,
-  appendAll: () => appendAll,
-  bind: () => bind3,
-  bindTo: () => bindTo3,
-  cartesian: () => cartesian,
-  cartesianWith: () => cartesianWith,
-  chop: () => chop,
-  chunksOf: () => chunksOf,
-  contains: () => contains2,
-  containsWith: () => containsWith2,
-  copy: () => copy,
-  dedupe: () => dedupe,
-  dedupeAdjacent: () => dedupeAdjacent,
-  dedupeAdjacentWith: () => dedupeAdjacentWith,
-  dedupeWith: () => dedupeWith,
-  difference: () => difference,
-  differenceWith: () => differenceWith,
-  drop: () => drop,
-  dropRight: () => dropRight,
-  dropWhile: () => dropWhile,
-  empty: () => empty2,
-  ensure: () => ensure,
-  every: () => every2,
-  extend: () => extend,
-  filter: () => filter2,
-  filterMap: () => filterMap2,
-  filterMapWhile: () => filterMapWhile,
-  findFirst: () => findFirst2,
-  findFirstIndex: () => findFirstIndex,
-  findLast: () => findLast,
-  findLastIndex: () => findLastIndex,
-  flatMap: () => flatMap2,
-  flatMapNullable: () => flatMapNullable2,
-  flatten: () => flatten2,
-  forEach: () => forEach,
-  fromIterable: () => fromIterable2,
-  fromNullable: () => fromNullable2,
-  fromOption: () => fromOption2,
-  fromRecord: () => fromRecord,
-  get: () => get,
-  getEquivalence: () => getEquivalence2,
-  getLefts: () => getLefts,
-  getOrder: () => getOrder2,
-  getRights: () => getRights,
-  getSomes: () => getSomes,
-  group: () => group,
-  groupBy: () => groupBy,
-  groupWith: () => groupWith,
-  head: () => head,
-  headNonEmpty: () => headNonEmpty,
-  init: () => init,
-  initNonEmpty: () => initNonEmpty,
-  insertAt: () => insertAt,
-  intersection: () => intersection,
-  intersectionWith: () => intersectionWith,
-  intersperse: () => intersperse,
-  isArray: () => isArray,
-  isEmptyArray: () => isEmptyArray,
-  isEmptyReadonlyArray: () => isEmptyReadonlyArray,
-  isNonEmptyArray: () => isNonEmptyArray2,
-  isNonEmptyReadonlyArray: () => isNonEmptyReadonlyArray,
-  join: () => join,
-  last: () => last,
-  lastNonEmpty: () => lastNonEmpty,
-  length: () => length,
-  let: () => let_3,
-  liftEither: () => liftEither,
-  liftNullable: () => liftNullable2,
-  liftOption: () => liftOption,
-  liftPredicate: () => liftPredicate2,
-  make: () => make4,
-  makeBy: () => makeBy,
-  map: () => map2,
-  mapAccum: () => mapAccum,
-  match: () => match2,
-  matchLeft: () => matchLeft,
-  matchRight: () => matchRight,
-  max: () => max2,
-  min: () => min2,
-  modify: () => modify,
-  modifyNonEmptyHead: () => modifyNonEmptyHead,
-  modifyNonEmptyLast: () => modifyNonEmptyLast,
-  modifyOption: () => modifyOption,
-  of: () => of,
-  partition: () => partition,
-  partitionMap: () => partitionMap2,
-  prepend: () => prepend,
-  prependAll: () => prependAll,
-  range: () => range,
-  reduce: () => reduce,
-  reduceRight: () => reduceRight,
-  remove: () => remove,
-  replace: () => replace,
-  replaceOption: () => replaceOption,
-  replicate: () => replicate,
-  reverse: () => reverse,
-  rotate: () => rotate,
-  scan: () => scan,
-  scanRight: () => scanRight,
-  separate: () => separate,
-  setNonEmptyHead: () => setNonEmptyHead,
-  setNonEmptyLast: () => setNonEmptyLast,
-  some: () => some4,
-  sort: () => sort,
-  sortBy: () => sortBy,
-  sortWith: () => sortWith,
-  span: () => span,
-  split: () => split,
-  splitAt: () => splitAt,
-  splitNonEmptyAt: () => splitNonEmptyAt,
-  splitWhere: () => splitWhere,
-  tail: () => tail,
-  tailNonEmpty: () => tailNonEmpty,
-  take: () => take,
-  takeRight: () => takeRight,
-  takeWhile: () => takeWhile,
-  unappend: () => unappend,
-  unfold: () => unfold,
-  union: () => union,
-  unionWith: () => unionWith,
-  unprepend: () => unprepend,
-  unsafeGet: () => unsafeGet,
-  unzip: () => unzip,
-  zip: () => zip,
-  zipWith: () => zipWith2
-});
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Equivalence.js
-var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
-var array = (item) => make((self, that) => {
-  if (self.length !== that.length) {
-    return false;
-  }
-  for (let i2 = 0; i2 < self.length; i2++) {
-    const isEq = item(self[i2], that[i2]);
-    if (!isEq) {
-      return false;
-    }
-  }
-  return true;
-});
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/doNotation.js
-var let_ = (map3) => dual(3, (self, name, f2) => map3(self, (a2) => Object.assign({}, a2, {
-  [name]: f2(a2)
-})));
-var bindTo = (map3) => dual(2, (self, name) => map3(self, (a2) => ({
-  [name]: a2
-})));
-var bind = (map3, flatMap3) => dual(3, (self, name, f2) => flatMap3(self, (a2) => map3(f2(a2), (b2) => Object.assign({}, a2, {
-  [name]: b2
-}))));
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.5.1";
-var getCurrentVersion = () => moduleVersion;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/GlobalValue.js
-var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`);
-if (!(globalStoreId in globalThis)) {
-  globalThis[globalStoreId] = /* @__PURE__ */ new Map();
-}
-var globalStore = globalThis[globalStoreId];
-var globalValue = (id, compute) => {
-  if (!globalStore.has(id)) {
-    globalStore.set(id, compute());
-  }
-  return globalStore.get(id);
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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,
-  isMap: () => isMap,
-  isNever: () => isNever,
-  isNotNull: () => isNotNull,
-  isNotNullable: () => isNotNullable,
-  isNotUndefined: () => isNotUndefined,
-  isNull: () => isNull,
-  isNullable: () => isNullable,
-  isNumber: () => isNumber,
-  isObject: () => isObject,
-  isPromise: () => isPromise,
-  isPromiseLike: () => isPromiseLike,
-  isReadonlyRecord: () => isReadonlyRecord,
-  isRecord: () => isRecord,
-  isSet: () => isSet,
-  isString: () => isString,
-  isSymbol: () => isSymbol,
-  isTagged: () => isTagged,
-  isTruthy: () => isTruthy,
-  isTupleOf: () => isTupleOf,
-  isTupleOfAtLeast: () => isTupleOfAtLeast,
-  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 isTupleOf = /* @__PURE__ */ dual(2, (self, n2) => self.length === n2);
-var isTupleOfAtLeast = /* @__PURE__ */ dual(2, (self, n2) => self.length >= n2);
-var isTruthy = (input) => !!input;
-var isSet = (input) => input instanceof Set;
-var isMap = (input) => input instanceof Map;
-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 isPromiseLike = (input) => hasProperty(input, "then") && isFunction2(input.then);
-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 ([head2, ...tail2]) => self(head2) === false ? false : rest(tail2);
-};
-var tuple = (...elements) => all(elements);
-var struct = (fields) => {
-  const keys2 = Object.keys(fields);
-  return (a2) => {
-    for (const key of keys2) {
-      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, (antecedent, consequent) => (a2) => antecedent(a2) ? consequent(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;
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/errors.js
-var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Utils.js
-var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
-var isGenKind = (u2) => isObject(u2) && GenKindTypeId in u2;
-var GenKindImpl = class {
-  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 = () => function() {
-  let x2 = arguments[0];
-  for (let i2 = 1; i2 < arguments.length; i2++) {
-    x2 = arguments[i2](x2);
-  }
-  return new GenKindImpl(x2);
-};
-var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
-var YieldWrap = class {
-  /**
-   * @since 3.0.6
-   */
-  #value;
-  constructor(value) {
-    this.#value = value;
-  }
-  /**
-   * @since 3.0.6
-   */
-  [YieldWrapTypeId]() {
-    return this.#value;
-  }
-};
-function yieldWrapGet(self) {
-  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
-    return self[YieldWrapTypeId]();
-  }
-  throw new Error(getBugErrorMessage("yieldWrapGet"));
-}
-var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
-  enabled: false,
-  tester: void 0
-}));
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Hash.js
-var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
-var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
-var hash = (self) => {
-  if (structuralRegionState.enabled === true) {
-    return 0;
-  }
-  switch (typeof self) {
-    case "number":
-      return number(self);
-    case "bigint":
-      return string(self.toString(10));
-    case "boolean":
-      return string(String(self));
-    case "symbol":
-      return string(String(self));
-    case "string":
-      return string(self);
-    case "undefined":
-      return string("undefined");
-    case "function":
-    case "object": {
-      if (self === null) {
-        return string("null");
-      } else if (self instanceof Date) {
-        return hash(self.toISOString());
-      } else 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`);
-  }
-};
-var random = (self) => {
-  if (!randomHashCache.has(self)) {
-    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
-  }
-  return randomHashCache.get(self);
-};
-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 h2 = n2 | 0;
-  if (h2 !== n2) {
-    h2 ^= n2 * 4294967295;
-  }
-  while (n2 > 4294967295) {
-    h2 ^= n2 /= 4294967295;
-  }
-  return optimize(n2);
-};
-var string = (str) => {
-  let h2 = 5381, i2 = str.length;
-  while (i2) {
-    h2 = h2 * 33 ^ str.charCodeAt(--i2);
-  }
-  return optimize(h2);
-};
-var cached = function() {
-  if (arguments.length === 1) {
-    const self2 = arguments[0];
-    return function(hash3) {
-      Object.defineProperty(self2, symbol, {
-        value() {
-          return hash3;
-        },
-        enumerable: false
-      });
-      return hash3;
-    };
-  }
-  const self = arguments[0];
-  const hash2 = arguments[1];
-  Object.defineProperty(self, symbol, {
-    value() {
-      return hash2;
-    },
-    enumerable: false
-  });
-  return hash2;
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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 compareBoth(arguments[0], arguments[1]);
-}
-function compareBoth(self, that) {
-  if (self === that) {
-    return true;
-  }
-  const selfType = typeof self;
-  if (selfType !== typeof that) {
-    return false;
-  }
-  if (selfType === "object" || selfType === "function") {
-    if (self !== null && that !== null) {
-      if (isEqual(self) && isEqual(that)) {
-        if (hash(self) === hash(that) && self[symbol2](that)) {
-          return true;
-        } else {
-          return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-        }
-      } else if (self instanceof Date && that instanceof Date) {
-        return self.toISOString() === that.toISOString();
-      }
-    }
-    if (structuralRegionState.enabled) {
-      if (Array.isArray(self) && Array.isArray(that)) {
-        return self.length === that.length && self.every((v2, i2) => compareBoth(v2, that[i2]));
-      }
-      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
-        const keysSelf = Object.keys(self);
-        const keysThat = Object.keys(that);
-        if (keysSelf.length === keysThat.length) {
-          for (const key of keysSelf) {
-            if (!(key in that && compareBoth(self[key], that[key]))) {
-              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-            }
-          }
-          return true;
-        }
-      }
-      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-    }
-  }
-  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-}
-var isEqual = (u2) => hasProperty(u2, symbol2);
-var equivalence = () => equals;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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;
-};
-var format = (x2) => JSON.stringify(x2, null, 2);
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Pipeable.js
-var pipeArguments = (self, args) => {
-  switch (args.length) {
-    case 1:
-      return args[0](self);
-    case 2:
-      return args[1](args[0](self));
-    case 3:
-      return args[2](args[1](args[0](self)));
-    case 4:
-      return args[3](args[2](args[1](args[0](self))));
-    case 5:
-      return args[4](args[3](args[2](args[1](args[0](self)))));
-    case 6:
-      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
-    case 7:
-      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
-    case 8:
-      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 i2 = 0, len = args.length; i2 < len; i2++) {
-        ret = args[i2](ret);
-      }
-      return ret;
-    }
-  }
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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: (_2) => _2,
-  /* c8 ignore next */
-  _E: (_2) => _2,
-  /* c8 ignore next */
-  _A: (_2) => _2,
-  _V: /* @__PURE__ */ getCurrentVersion()
-};
-var sinkVariance = {
-  /* c8 ignore next */
-  _A: (_2) => _2,
-  /* c8 ignore next */
-  _In: (_2) => _2,
-  /* c8 ignore next */
-  _L: (_2) => _2,
-  /* c8 ignore next */
-  _E: (_2) => _2,
-  /* c8 ignore next */
-  _R: (_2) => _2
-};
-var channelVariance = {
-  /* c8 ignore next */
-  _Env: (_2) => _2,
-  /* c8 ignore next */
-  _InErr: (_2) => _2,
-  /* c8 ignore next */
-  _InElem: (_2) => _2,
-  /* c8 ignore next */
-  _InDone: (_2) => _2,
-  /* c8 ignore next */
-  _OutErr: (_2) => _2,
-  /* c8 ignore next */
-  _OutElem: (_2) => _2,
-  /* c8 ignore next */
-  _OutDone: (_2) => _2
-};
-var EffectPrototype = {
-  [EffectTypeId]: effectVariance,
-  [StreamTypeId]: effectVariance,
-  [SinkTypeId]: sinkVariance,
-  [ChannelTypeId]: channelVariance,
-  [symbol2](that) {
-    return this === that;
-  },
-  [symbol]() {
-    return cached(this, random(this));
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/option.js
-var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
-var CommonProto = {
-  ...EffectPrototype,
-  [TypeId]: {
-    _A: (_2) => _2
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  toString() {
-    return format(this.toJSON());
-  }
-};
-var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
-  _tag: "Some",
-  _op: "Some",
-  [symbol2](that) {
-    return isOption(that) && isSome(that) && equals(this.value, that.value);
-  },
-  [symbol]() {
-    return cached(this, combine(hash(this._tag))(hash(this.value)));
-  },
-  toJSON() {
-    return {
-      _id: "Option",
-      _tag: this._tag,
-      value: toJSON(this.value)
-    };
-  }
-});
-var NoneHash = /* @__PURE__ */ hash("None");
-var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
-  _tag: "None",
-  _op: "None",
-  [symbol2](that) {
-    return isOption(that) && isNone(that);
-  },
-  [symbol]() {
-    return NoneHash;
-  },
-  toJSON() {
-    return {
-      _id: "Option",
-      _tag: this._tag
-    };
-  }
-});
-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;
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/either.js
-var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
-var CommonProto2 = {
-  ...EffectPrototype,
-  [TypeId2]: {
-    _R: (_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(this.right, that.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(this.left, that.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);
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Either.js
-var isLeft2 = isLeft;
-var isRight2 = isRight;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/internal/array.js
-var isNonEmptyArray = (self) => self.length > 0;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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,
-  asVoid: () => asVoid,
-  bind: () => bind2,
-  bindTo: () => bindTo2,
-  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_2,
-  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,
-  void: () => void_,
-  zipLeft: () => zipLeft,
-  zipRight: () => zipRight,
-  zipWith: () => zipWith
-});
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Order.js
-var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
-var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
-var combineMany = /* @__PURE__ */ dual(2, (self, collection) => make2((a1, a2) => {
-  let out = self(a1, a2);
-  if (out !== 0) {
-    return out;
-  }
-  for (const O2 of collection) {
-    out = O2(a1, a2);
-    if (out !== 0) {
-      return out;
-    }
-  }
-  return out;
-}));
-var empty = () => make2(() => 0);
-var combineAll = (collection) => combineMany(empty(), collection);
-var mapInput2 = /* @__PURE__ */ dual(2, (self, f2) => make2((b1, b2) => self(f2(b1), f2(b2))));
-var array2 = (O2) => make2((self, that) => {
-  const aLen = self.length;
-  const bLen = that.length;
-  const len = Math.min(aLen, bLen);
-  for (let i2 = 0; i2 < len; i2++) {
-    const o2 = O2(self[i2], that[i2]);
-    if (o2 !== 0) {
-      return o2;
-    }
-  }
-  return number2(aLen, bLen);
-});
-var min = (O2) => dual(2, (self, that) => self === that || O2(self, that) < 1 ? self : that);
-var max = (O2) => dual(2, (self, that) => self === that || O2(self, that) > -1 ? self : that);
-
-// ../../../node_modules/.pnpm/effect@3.5.1/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 asVoid = /* @__PURE__ */ as(void 0);
-var void_ = /* @__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) => 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 = /* @__PURE__ */ dual(2, (b2, predicate) => 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 bindTo2 = /* @__PURE__ */ bindTo(map);
-var let_2 = /* @__PURE__ */ let_(map);
-var bind2 = /* @__PURE__ */ bind(map, flatMap);
-var Do = /* @__PURE__ */ some3({});
-var adapter2 = /* @__PURE__ */ adapter();
-var gen = (...args) => {
-  let f2;
-  if (args.length === 1) {
-    f2 = args[0];
-  } else {
-    f2 = args[1].bind(args[0]);
-  }
-  const iterator = f2(adapter2);
-  let state = iterator.next();
-  if (state.done) {
-    return some3(state.value);
-  } else {
-    let current = state.value;
-    if (isGenKind(current)) {
-      current = current.value;
-    } else {
-      current = yieldWrapGet(current);
-    }
-    if (isNone2(current)) {
-      return current;
-    }
-    while (!state.done) {
-      state = iterator.next(current.value);
-      if (!state.done) {
-        current = state.value;
-        if (isGenKind(current)) {
-          current = current.value;
-        } else {
-          current = yieldWrapGet(current);
-        }
-        if (isNone2(current)) {
-          return current;
-        }
-      }
-    }
-    return some3(state.value);
-  }
-};
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Tuple.js
-var make3 = (...elements) => elements;
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Iterable.js
-var findFirst = /* @__PURE__ */ dual(2, (self, f2) => {
-  let i2 = 0;
-  for (const a2 of self) {
-    const o2 = f2(a2, i2);
-    if (isBoolean(o2)) {
-      if (o2) {
-        return some3(a2);
-      }
-    } else {
-      if (isSome2(o2)) {
-        return o2;
-      }
-    }
-    i2++;
-  }
-  return none2();
-});
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Record.js
-var collect = /* @__PURE__ */ dual(2, (self, f2) => {
-  const out = [];
-  for (const key of keys(self)) {
-    out.push(f2(key, self[key]));
-  }
-  return out;
-});
-var toEntries = /* @__PURE__ */ collect((key, value) => [key, value]);
-var keys = (self) => Object.keys(self);
-
-// ../../../node_modules/.pnpm/effect@3.5.1/node_modules/effect/dist/esm/Array.js
-var make4 = (...elements) => elements;
-var allocate = (n2) => new Array(n2);
-var makeBy = (n2, f2) => {
-  const max3 = Math.max(1, Math.floor(n2));
-  const out = new Array(max3);
-  for (let i2 = 0; i2 < max3; i2++) {
-    out[i2] = f2(i2);
-  }
-  return out;
-};
-var range = (start, end) => start <= end ? makeBy(end - start + 1, (i2) => start + i2) : [start];
-var replicate = /* @__PURE__ */ dual(2, (a2, n2) => makeBy(n2, () => a2));
-var fromIterable2 = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
-var ensure = (self) => Array.isArray(self) ? self : [self];
-var fromRecord = toEntries;
-var fromOption2 = toArray;
-var match2 = /* @__PURE__ */ dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(self) : onEmpty());
-var matchLeft = /* @__PURE__ */ dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());
-var matchRight = /* @__PURE__ */ dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());
-var prepend = /* @__PURE__ */ dual(2, (self, head2) => [head2, ...self]);
-var prependAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable2(that).concat(fromIterable2(self)));
-var append = /* @__PURE__ */ dual(2, (self, last2) => [...self, last2]);
-var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable2(self).concat(fromIterable2(that)));
-var scan = /* @__PURE__ */ dual(3, (self, b2, f2) => {
-  const out = [b2];
-  let i2 = 0;
-  for (const a2 of self) {
-    out[i2 + 1] = f2(out[i2], a2);
-    i2++;
-  }
-  return out;
-});
-var scanRight = /* @__PURE__ */ dual(3, (self, b2, f2) => {
-  const input = fromIterable2(self);
-  const out = new Array(input.length + 1);
-  out[input.length] = b2;
-  for (let i2 = input.length - 1; i2 >= 0; i2--) {
-    out[i2] = f2(out[i2 + 1], input[i2]);
-  }
-  return out;
-});
-var isArray = Array.isArray;
-var isEmptyArray = (self) => self.length === 0;
-var isEmptyReadonlyArray = isEmptyArray;
-var isNonEmptyArray2 = isNonEmptyArray;
-var isNonEmptyReadonlyArray = isNonEmptyArray;
-var length = (self) => self.length;
-var isOutOfBound = (i2, as2) => i2 < 0 || i2 >= as2.length;
-var clamp = (i2, as2) => Math.floor(Math.min(Math.max(0, i2), as2.length));
-var get = /* @__PURE__ */ dual(2, (self, index) => {
-  const i2 = Math.floor(index);
-  return isOutOfBound(i2, self) ? none2() : some3(self[i2]);
-});
-var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
-  const i2 = Math.floor(index);
-  if (isOutOfBound(i2, self)) {
-    throw new Error(`Index ${i2} out of bounds`);
-  }
-  return self[i2];
-});
-var unprepend = (self) => [headNonEmpty(self), tailNonEmpty(self)];
-var unappend = (self) => [initNonEmpty(self), lastNonEmpty(self)];
-var head = /* @__PURE__ */ get(0);
-var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
-var last = (self) => isNonEmptyReadonlyArray(self) ? some3(lastNonEmpty(self)) : none2();
-var lastNonEmpty = (self) => self[self.length - 1];
-var tail = (self) => {
-  const input = fromIterable2(self);
-  return isNonEmptyReadonlyArray(input) ? some3(tailNonEmpty(input)) : none2();
-};
-var tailNonEmpty = (self) => self.slice(1);
-var init = (self) => {
-  const input = fromIterable2(self);
-  return isNonEmptyReadonlyArray(input) ? some3(initNonEmpty(input)) : none2();
-};
-var initNonEmpty = (self) => self.slice(0, -1);
-var take = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  return input.slice(0, clamp(n2, input));
-});
-var takeRight = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  const i2 = clamp(n2, input);
-  return i2 === 0 ? [] : input.slice(-i2);
-});
-var takeWhile = /* @__PURE__ */ dual(2, (self, predicate) => {
-  let i2 = 0;
-  const out = [];
-  for (const a2 of self) {
-    if (!predicate(a2, i2)) {
-      break;
-    }
-    out.push(a2);
-    i2++;
-  }
-  return out;
-});
-var spanIndex = (self, predicate) => {
-  let i2 = 0;
-  for (const a2 of self) {
-    if (!predicate(a2, i2)) {
-      break;
-    }
-    i2++;
-  }
-  return i2;
-};
-var span = /* @__PURE__ */ dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
-var drop = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  return input.slice(clamp(n2, input), input.length);
-});
-var dropRight = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  return input.slice(0, input.length - clamp(n2, input));
-});
-var dropWhile = /* @__PURE__ */ dual(2, (self, predicate) => fromIterable2(self).slice(spanIndex(self, predicate)));
-var findFirstIndex = /* @__PURE__ */ dual(2, (self, predicate) => {
-  let i2 = 0;
-  for (const a2 of self) {
-    if (predicate(a2, i2)) {
-      return some3(i2);
-    }
-    i2++;
-  }
-  return none2();
-});
-var findLastIndex = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const input = fromIterable2(self);
-  for (let i2 = input.length - 1; i2 >= 0; i2--) {
-    if (predicate(input[i2], i2)) {
-      return some3(i2);
-    }
-  }
-  return none2();
-});
-var findFirst2 = findFirst;
-var findLast = /* @__PURE__ */ dual(2, (self, f2) => {
-  const input = fromIterable2(self);
-  for (let i2 = input.length - 1; i2 >= 0; i2--) {
-    const a2 = input[i2];
-    const o2 = f2(a2, i2);
-    if (isBoolean(o2)) {
-      if (o2) {
-        return some3(a2);
-      }
-    } else {
-      if (isSome2(o2)) {
-        return o2;
-      }
-    }
-  }
-  return none2();
-});
-var insertAt = /* @__PURE__ */ dual(3, (self, i2, b2) => {
-  const out = Array.from(self);
-  if (i2 < 0 || i2 > out.length) {
-    return none2();
-  }
-  out.splice(i2, 0, b2);
-  return some3(out);
-});
-var replace = /* @__PURE__ */ dual(3, (self, i2, b2) => modify(self, i2, () => b2));
-var replaceOption = /* @__PURE__ */ dual(3, (self, i2, b2) => modifyOption(self, i2, () => b2));
-var modify = /* @__PURE__ */ dual(3, (self, i2, f2) => getOrElse(modifyOption(self, i2, f2), () => Array.from(self)));
-var modifyOption = /* @__PURE__ */ dual(3, (self, i2, f2) => {
-  const out = Array.from(self);
-  if (isOutOfBound(i2, out)) {
-    return none2();
-  }
-  const next = f2(out[i2]);
-  out[i2] = next;
-  return some3(out);
-});
-var remove = /* @__PURE__ */ dual(2, (self, i2) => {
-  const out = Array.from(self);
-  if (isOutOfBound(i2, out)) {
-    return out;
-  }
-  out.splice(i2, 1);
-  return out;
-});
-var reverse = (self) => Array.from(self).reverse();
-var sort = /* @__PURE__ */ dual(2, (self, O2) => {
-  const out = Array.from(self);
-  out.sort(O2);
-  return out;
-});
-var sortWith = /* @__PURE__ */ dual(3, (self, f2, order) => sort(self, mapInput2(order, f2)));
-var sortBy = (...orders) => {
-  const sortByAll = sort(combineAll(orders));
-  return (self) => {
-    const input = fromIterable2(self);
-    if (isNonEmptyReadonlyArray(input)) {
-      return sortByAll(input);
-    }
-    return [];
-  };
-};
-var zip = /* @__PURE__ */ dual(2, (self, that) => zipWith2(self, that, make3));
-var zipWith2 = /* @__PURE__ */ dual(3, (self, that, f2) => {
-  const as2 = fromIterable2(self);
-  const bs = fromIterable2(that);
-  if (isNonEmptyReadonlyArray(as2) && isNonEmptyReadonlyArray(bs)) {
-    const out = [f2(headNonEmpty(as2), headNonEmpty(bs))];
-    const len = Math.min(as2.length, bs.length);
-    for (let i2 = 1; i2 < len; i2++) {
-      out[i2] = f2(as2[i2], bs[i2]);
-    }
-    return out;
-  }
-  return [];
-});
-var unzip = (self) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const fa = [input[0][0]];
-    const fb = [input[0][1]];
-    for (let i2 = 1; i2 < input.length; i2++) {
-      fa[i2] = input[i2][0];
-      fb[i2] = input[i2][1];
-    }
-    return [fa, fb];
-  }
-  return [[], []];
-};
-var intersperse = /* @__PURE__ */ dual(2, (self, middle) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const out = [headNonEmpty(input)];
-    const tail2 = tailNonEmpty(input);
-    for (let i2 = 0; i2 < tail2.length; i2++) {
-      if (i2 < tail2.length) {
-        out.push(middle);
-      }
-      out.push(tail2[i2]);
-    }
-    return out;
-  }
-  return [];
-});
-var modifyNonEmptyHead = /* @__PURE__ */ dual(2, (self, f2) => [f2(headNonEmpty(self)), ...tailNonEmpty(self)]);
-var setNonEmptyHead = /* @__PURE__ */ dual(2, (self, b2) => modifyNonEmptyHead(self, () => b2));
-var modifyNonEmptyLast = /* @__PURE__ */ dual(2, (self, f2) => append(initNonEmpty(self), f2(lastNonEmpty(self))));
-var setNonEmptyLast = /* @__PURE__ */ dual(2, (self, b2) => modifyNonEmptyLast(self, () => b2));
-var rotate = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const len = input.length;
-    const m2 = Math.round(n2) % len;
-    if (isOutOfBound(Math.abs(m2), input) || m2 === 0) {
-      return copy(input);
-    }
-    if (m2 < 0) {
-      const [f2, s2] = splitNonEmptyAt(input, -m2);
-      return appendAll(s2, f2);
-    } else {
-      return rotate(self, m2 - len);
-    }
-  }
-  return [];
-});
-var containsWith2 = (isEquivalent) => dual(2, (self, a2) => {
-  for (const i2 of self) {
-    if (isEquivalent(a2, i2)) {
-      return true;
-    }
-  }
-  return false;
-});
-var _equivalence2 = /* @__PURE__ */ equivalence();
-var contains2 = /* @__PURE__ */ containsWith2(_equivalence2);
-var chop = /* @__PURE__ */ dual(2, (self, f2) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const [b2, rest] = f2(input);
-    const out = [b2];
-    let next = rest;
-    while (isNonEmptyArray(next)) {
-      const [b3, rest2] = f2(next);
-      out.push(b3);
-      next = rest2;
-    }
-    return out;
-  }
-  return [];
-});
-var splitAt = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = Array.from(self);
-  const _n = Math.floor(n2);
-  if (isNonEmptyReadonlyArray(input)) {
-    if (_n >= 1) {
-      return splitNonEmptyAt(input, _n);
-    }
-    return [[], input];
-  }
-  return [input, []];
-});
-var splitNonEmptyAt = /* @__PURE__ */ dual(2, (self, n2) => {
-  const _n = Math.max(1, Math.floor(n2));
-  return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];
-});
-var split = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  return chunksOf(input, Math.ceil(input.length / Math.floor(n2)));
-});
-var splitWhere = /* @__PURE__ */ dual(2, (self, predicate) => span(self, (a2, i2) => !predicate(a2, i2)));
-var copy = (self) => self.slice();
-var chunksOf = /* @__PURE__ */ dual(2, (self, n2) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    return chop(input, splitNonEmptyAt(n2));
-  }
-  return [];
-});
-var groupWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => chop(self, (as2) => {
-  const h2 = headNonEmpty(as2);
-  const out = [h2];
-  let i2 = 1;
-  for (; i2 < as2.length; i2++) {
-    const a2 = as2[i2];
-    if (isEquivalent(a2, h2)) {
-      out.push(a2);
-    } else {
-      break;
-    }
-  }
-  return [out, as2.slice(i2)];
-}));
-var group = /* @__PURE__ */ groupWith(/* @__PURE__ */ equivalence());
-var groupBy = /* @__PURE__ */ dual(2, (self, f2) => {
-  const out = {};
-  for (const a2 of self) {
-    const k2 = f2(a2);
-    if (Object.prototype.hasOwnProperty.call(out, k2)) {
-      out[k2].push(a2);
-    } else {
-      out[k2] = [a2];
-    }
-  }
-  return out;
-});
-var unionWith = /* @__PURE__ */ dual(3, (self, that, isEquivalent) => {
-  const a2 = fromIterable2(self);
-  const b2 = fromIterable2(that);
-  if (isNonEmptyReadonlyArray(a2)) {
-    if (isNonEmptyReadonlyArray(b2)) {
-      const dedupe2 = dedupeWith(isEquivalent);
-      return dedupe2(appendAll(a2, b2));
-    }
-    return a2;
-  }
-  return b2;
-});
-var union = /* @__PURE__ */ dual(2, (self, that) => unionWith(self, that, _equivalence2));
-var intersectionWith = (isEquivalent) => {
-  const has = containsWith2(isEquivalent);
-  return dual(2, (self, that) => fromIterable2(self).filter((a2) => has(that, a2)));
-};
-var intersection = /* @__PURE__ */ intersectionWith(_equivalence2);
-var differenceWith = (isEquivalent) => {
-  const has = containsWith2(isEquivalent);
-  return dual(2, (self, that) => fromIterable2(self).filter((a2) => !has(that, a2)));
-};
-var difference = /* @__PURE__ */ differenceWith(_equivalence2);
-var empty2 = () => [];
-var of = (a2) => [a2];
-var map2 = /* @__PURE__ */ dual(2, (self, f2) => self.map(f2));
-var flatMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
-  if (isEmptyReadonlyArray(self)) {
-    return [];
-  }
-  const out = [];
-  for (let i2 = 0; i2 < self.length; i2++) {
-    const inner = f2(self[i2], i2);
-    for (let j2 = 0; j2 < inner.length; j2++) {
-      out.push(inner[j2]);
-    }
-  }
-  return out;
-});
-var flatten2 = /* @__PURE__ */ flatMap2(identity);
-var filterMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
-  const as2 = fromIterable2(self);
-  const out = [];
-  for (let i2 = 0; i2 < as2.length; i2++) {
-    const o2 = f2(as2[i2], i2);
-    if (isSome2(o2)) {
-      out.push(o2.value);
-    }
-  }
-  return out;
-});
-var filterMapWhile = /* @__PURE__ */ dual(2, (self, f2) => {
-  let i2 = 0;
-  const out = [];
-  for (const a2 of self) {
-    const b2 = f2(a2, i2);
-    if (isSome2(b2)) {
-      out.push(b2.value);
-    } else {
-      break;
-    }
-    i2++;
-  }
-  return out;
-});
-var partitionMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
-  const left2 = [];
-  const right2 = [];
-  const as2 = fromIterable2(self);
-  for (let i2 = 0; i2 < as2.length; i2++) {
-    const e2 = f2(as2[i2], i2);
-    if (isLeft2(e2)) {
-      left2.push(e2.left);
-    } else {
-      right2.push(e2.right);
-    }
-  }
-  return [left2, right2];
-});
-var getSomes = /* @__PURE__ */ filterMap2(identity);
-var getLefts = (self) => {
-  const out = [];
-  for (const a2 of self) {
-    if (isLeft2(a2)) {
-      out.push(a2.left);
-    }
-  }
-  return out;
-};
-var getRights = (self) => {
-  const out = [];
-  for (const a2 of self) {
-    if (isRight2(a2)) {
-      out.push(a2.right);
-    }
-  }
-  return out;
-};
-var filter2 = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const as2 = fromIterable2(self);
-  const out = [];
-  for (let i2 = 0; i2 < as2.length; i2++) {
-    if (predicate(as2[i2], i2)) {
-      out.push(as2[i2]);
-    }
-  }
-  return out;
-});
-var partition = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const left2 = [];
-  const right2 = [];
-  const as2 = fromIterable2(self);
-  for (let i2 = 0; i2 < as2.length; i2++) {
-    if (predicate(as2[i2], i2)) {
-      right2.push(as2[i2]);
-    } else {
-      left2.push(as2[i2]);
-    }
-  }
-  return [left2, right2];
-});
-var separate = /* @__PURE__ */ partitionMap2(identity);
-var reduce = /* @__PURE__ */ dual(3, (self, b2, f2) => fromIterable2(self).reduce((b3, a2, i2) => f2(b3, a2, i2), b2));
-var reduceRight = /* @__PURE__ */ dual(3, (self, b2, f2) => fromIterable2(self).reduceRight((b3, a2, i2) => f2(b3, a2, i2), b2));
-var liftPredicate2 = (predicate) => (b2) => predicate(b2) ? [b2] : [];
-var liftOption = (f2) => (...a2) => fromOption2(f2(...a2));
-var fromNullable2 = (a2) => a2 == null ? empty2() : [a2];
-var liftNullable2 = (f2) => (...a2) => fromNullable2(f2(...a2));
-var flatMapNullable2 = /* @__PURE__ */ dual(2, (self, f2) => flatMap2(self, (a2) => fromNullable2(f2(a2))));
-var liftEither = (f2) => (...a2) => {
-  const e2 = f2(...a2);
-  return isLeft2(e2) ? [] : [e2.right];
-};
-var every2 = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
-var some4 = /* @__PURE__ */ dual(2, (self, predicate) => self.some(predicate));
-var extend = /* @__PURE__ */ dual(2, (self, f2) => self.map((_2, i2, as2) => f2(as2.slice(i2))));
-var min2 = /* @__PURE__ */ dual(2, (self, O2) => self.reduce(min(O2)));
-var max2 = /* @__PURE__ */ dual(2, (self, O2) => self.reduce(max(O2)));
-var unfold = (b2, f2) => {
-  const out = [];
-  let next = b2;
-  let o2;
-  while (isSome2(o2 = f2(next))) {
-    const [a2, b3] = o2.value;
-    out.push(a2);
-    next = b3;
-  }
-  return out;
-};
-var getOrder2 = array2;
-var getEquivalence2 = array;
-var forEach = /* @__PURE__ */ dual(2, (self, f2) => fromIterable2(self).forEach((a2, i2) => f2(a2, i2)));
-var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
-  const input = fromIterable2(self);
-  if (isNonEmptyReadonlyArray(input)) {
-    const out = [headNonEmpty(input)];
-    const rest = tailNonEmpty(input);
-    for (const r2 of rest) {
-      if (out.every((a2) => !isEquivalent(r2, a2))) {
-        out.push(r2);
-      }
-    }
-    return out;
-  }
-  return [];
-});
-var dedupe = (self) => dedupeWith(self, equivalence());
-var dedupeAdjacentWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
-  const out = [];
-  let lastA = none2();
-  for (const a2 of self) {
-    if (isNone2(lastA) || !isEquivalent(a2, lastA.value)) {
-      out.push(a2);
-      lastA = some3(a2);
-    }
-  }
-  return out;
-});
-var dedupeAdjacent = /* @__PURE__ */ dedupeAdjacentWith(/* @__PURE__ */ equivalence());
-var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable2(self).join(sep));
-var mapAccum = /* @__PURE__ */ dual(3, (self, s2, f2) => {
-  let i2 = 0;
-  let s1 = s2;
-  const out = [];
-  for (const a2 of self) {
-    const r2 = f2(s1, a2, i2);
-    s1 = r2[0];
-    out.push(r2[1]);
-    i2++;
-  }
-  return [s1, out];
-});
-var cartesianWith = /* @__PURE__ */ dual(3, (self, that, f2) => flatMap2(self, (a2) => map2(that, (b2) => f2(a2, b2))));
-var cartesian = /* @__PURE__ */ dual(2, (self, that) => cartesianWith(self, that, (a2, b2) => [a2, b2]));
-var Do2 = /* @__PURE__ */ of({});
-var bind3 = /* @__PURE__ */ bind(map2, flatMap2);
-var bindTo3 = /* @__PURE__ */ bindTo(map2);
-var let_3 = /* @__PURE__ */ let_(map2);
-
-// src/get-jsx-pragma.ts
 var RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
 var RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
 function getJSXPragma(context) {
   const { sourceCode } = context;
-  return Function_exports.pipe(
-    Array_exports.findFirst(sourceCode.getAllComments(), (node) => RE_JSX_ANNOTATION_REGEX.test(node.value)),
-    Option_exports.map(({ value }) => RE_JSX_ANNOTATION_REGEX.exec(value)),
-    Option_exports.flatMapNullable((matches) => matches?.[1]),
-    Option_exports.filter((pragma) => RE_JS_IDENTIFIER_REGEX.test(pragma))
+  return F.pipe(
+    O.fromNullable(sourceCode.getAllComments().find((node) => RE_JSX_ANNOTATION_REGEX.test(node.value))),
+    O.map(({ value }) => RE_JSX_ANNOTATION_REGEX.exec(value)),
+    O.flatMapNullable((matches) => matches?.[1]),
+    O.filter((pragma) => RE_JS_IDENTIFIER_REGEX.test(pragma))
   );
 }
 
@@ -2009,7 +165,7 @@ function w(t2) {
 var S = u(y(function(t2) {
   return true;
 }));
-var O = S;
+var O2 = S;
 var j = (t2) => Object.assign(u(t2), { startsWith: (e2) => {
   return j(m(t2, (n2 = e2, y((t3) => b(t3) && t3.startsWith(n2)))));
   var n2;
@@ -2085,7 +241,7 @@ var N = { __proto__: null, matcher: t, optional: l, array: function(...e2) {
 }, intersection: m, union: d, not: function(e2) {
   return u({ [t]: () => ({ match: (t2) => ({ matched: !o(e2, t2, () => {
   }) }), getSelectionKeys: () => [], matcherType: "not" }) });
-}, when: y, select: p, any: S, _: O, string: E, number: x, bigint: P, boolean: T, symbol: k, nullish: B, nonNullable: _, instanceOf: function(t2) {
+}, when: y, select: p, any: S, _: O2, string: E, number: x, bigint: P, boolean: T, symbol: k, nullish: B, nonNullable: _, instanceOf: function(t2) {
   return u(y(/* @__PURE__ */ function(t3) {
     return (e2) => e2 instanceof t3;
   }(t2)));
@@ -2149,77 +305,75 @@ function getPropValue(attribute, context) {
   const initialScope = context.sourceCode.getScope(attribute);
   if (attribute.type === NodeType.JSXAttribute && "value" in attribute) {
     const { value } = attribute;
-    if (value === null) return Option_exports.none();
-    if (value.type === NodeType.Literal) return Option_exports.some(getStaticValue(value, initialScope));
-    if (value.type === NodeType.JSXExpressionContainer) return Option_exports.some(getStaticValue(value.expression, initialScope));
-    return Option_exports.none();
+    if (value === null) return O.none();
+    if (value.type === NodeType.Literal) return O.some(getStaticValue(value, initialScope));
+    if (value.type === NodeType.JSXExpressionContainer) return O.some(getStaticValue(value.expression, initialScope));
+    return O.none();
   }
   const { argument } = attribute;
-  return Option_exports.some(getStaticValue(argument, initialScope));
+  return O.some(getStaticValue(argument, initialScope));
 }
 function findPropInProperties(properties, context, initialScope, seenProps = []) {
   return (propName) => {
-    return Option_exports.fromNullable(
+    return O.fromNullable(
       properties.find((prop) => {
         return $(prop).when(is(NodeType.Property), (prop2) => {
           return "name" in prop2.key && prop2.key.name === propName;
         }).when(is(NodeType.SpreadElement), (prop2) => {
           return $(prop2.argument).when(is(NodeType.Identifier), (argument) => {
             const { name } = argument;
-            const maybeInit = Option_exports.flatMap(
+            const maybeInit = O.flatMap(
               findVariable(name, initialScope),
               getVariableInit(0)
             );
-            if (Option_exports.isNone(maybeInit)) return false;
-            const init2 = maybeInit.value;
-            if (init2.type !== NodeType.ObjectExpression) return false;
+            if (O.isNone(maybeInit)) return false;
+            const init = maybeInit.value;
+            if (init.type !== NodeType.ObjectExpression) return false;
             if (seenProps.includes(name)) return false;
-            return Option_exports.isSome(
-              findPropInProperties(init2.properties, context, initialScope, [...seenProps, name])(propName)
+            return O.isSome(
+              findPropInProperties(init.properties, context, initialScope, [...seenProps, name])(propName)
             );
           }).when(is(NodeType.ObjectExpression), (argument) => {
-            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
+            return O.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
           }).when(is(NodeType.MemberExpression), () => {
           }).when(is(NodeType.CallExpression), () => {
-          }).otherwise(Function_exports.constFalse);
+          }).otherwise(F.constFalse);
         }).when(is(NodeType.RestElement), () => {
           return false;
-        }).otherwise(Function_exports.constFalse);
+        }).otherwise(F.constFalse);
       })
     );
   };
 }
 function findPropInAttributes(attributes, context, initialScope) {
   return (propName) => {
-    return Option_exports.fromNullable(
+    return O.fromNullable(
       attributes.find((attr) => {
         return $(attr).when(is(NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(is(NodeType.JSXSpreadAttribute), (attr2) => {
           return $(attr2.argument).with({ type: NodeType.Identifier }, (argument) => {
             const { name } = argument;
-            const maybeInit = Option_exports.flatMap(
+            const maybeInit = O.flatMap(
               findVariable(name, initialScope),
               getVariableInit(0)
             );
-            if (Option_exports.isNone(maybeInit)) return false;
-            const init2 = maybeInit.value;
-            if (!("properties" in init2)) return false;
-            return Option_exports.isSome(findPropInProperties(init2.properties, context, initialScope)(propName));
+            if (O.isNone(maybeInit)) return false;
+            const init = maybeInit.value;
+            if (!("properties" in init)) return false;
+            return O.isSome(findPropInProperties(init.properties, context, initialScope)(propName));
           }).when(is(NodeType.ObjectExpression), (argument) => {
-            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
+            return O.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
           }).when(is(NodeType.MemberExpression), () => {
             return false;
           }).when(is(NodeType.CallExpression), () => {
             return false;
-          }).otherwise(Function_exports.constFalse);
-        }).otherwise(Function_exports.constFalse);
+          }).otherwise(F.constFalse);
+        }).otherwise(F.constFalse);
       })
     );
   };
 }
-
-// src/has-prop.ts
 function hasProp(attributes, propName, context, initialScope) {
-  return Option_exports.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
+  return O.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
 }
 function hasAnyProp(attributes, propNames, context, initialScope) {
   return propNames.some((propName) => hasProp(attributes, propName, context, initialScope));
@@ -2255,8 +409,8 @@ var JSXValueHint = {
 var DEFAULT_JSX_VALUE_HINT = 0n | JSXValueHint.SkipUndefinedLiteral | JSXValueHint.SkipBooleanLiteral;
 function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
   if (!node) return false;
-  return $(node).with({ type: NodeType.JSXElement }, Function_exports.constTrue).with({ type: NodeType.JSXFragment }, Function_exports.constTrue).with({ type: NodeType.JSXMemberExpression }, Function_exports.constTrue).with({ type: NodeType.JSXNamespacedName }, Function_exports.constTrue).with({ type: NodeType.Literal }, (node2) => {
-    return $(node2.value).with(null, () => !(hint & JSXValueHint.SkipNullLiteral)).with(N.boolean, () => !(hint & JSXValueHint.SkipBooleanLiteral)).with(N.string, () => !(hint & JSXValueHint.SkipStringLiteral)).with(N.number, () => !(hint & JSXValueHint.SkipNumberLiteral)).otherwise(Function_exports.constFalse);
+  return $(node).with({ type: NodeType.JSXElement }, F.constTrue).with({ type: NodeType.JSXFragment }, F.constTrue).with({ type: NodeType.JSXMemberExpression }, F.constTrue).with({ type: NodeType.JSXNamespacedName }, F.constTrue).with({ type: NodeType.Literal }, (node2) => {
+    return $(node2.value).with(null, () => !(hint & JSXValueHint.SkipNullLiteral)).with(N.boolean, () => !(hint & JSXValueHint.SkipBooleanLiteral)).with(N.string, () => !(hint & JSXValueHint.SkipStringLiteral)).with(N.number, () => !(hint & JSXValueHint.SkipNumberLiteral)).otherwise(F.constFalse);
   }).with({ type: NodeType.TemplateLiteral }, () => !(hint & JSXValueHint.SkipStringLiteral)).with({ type: NodeType.ArrayExpression }, (node2) => {
     if (hint & JSXValueHint.StrictArray) return node2.elements.every((n2) => isJSXValue(n2, context, hint));
     return node2.elements.some((n2) => isJSXValue(n2, context, hint));
@@ -2288,23 +442,23 @@ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
     return isJSXValue(exp, context, hint);
   }).with({ type: NodeType.CallExpression }, (node2) => {
     if (hint & JSXValueHint.SkipCreateElement) return false;
-    return $(node2.callee).with({ type: NodeType.Identifier, name: "createElement" }, Function_exports.constTrue).with({ type: NodeType.MemberExpression, property: { name: "createElement" } }, Function_exports.constTrue).otherwise(Function_exports.constFalse);
+    return $(node2.callee).with({ type: NodeType.Identifier, name: "createElement" }, F.constTrue).with({ type: NodeType.MemberExpression, property: { name: "createElement" } }, F.constTrue).otherwise(F.constFalse);
   }).with({ type: NodeType.Identifier }, (node2) => {
     const { name } = node2;
     if (name === "undefined") return !(hint & JSXValueHint.SkipUndefinedLiteral);
     if (isJSXTagNameExpression(node2)) return true;
     const initialScope = context.sourceCode.getScope(node2);
     const maybeVariable = findVariable(name, initialScope);
-    return Function_exports.pipe(
+    return F.pipe(
       maybeVariable,
-      Option_exports.flatMap(getVariableInit(0)),
-      Option_exports.exists((n2) => isJSXValue(n2, context, hint))
+      O.flatMap(getVariableInit(0)),
+      O.exists((n2) => isJSXValue(n2, context, hint))
     );
-  }).otherwise(Function_exports.constFalse);
+  }).otherwise(F.constFalse);
 }
 var isLiteral = isOneOf([NodeType.Literal, NodeType.JSXText]);
 function isWhiteSpace(node) {
-  return Predicate_exports.isString(node.value) && node.value.trim() === "";
+  return Pred.isString(node.value) && node.value.trim() === "";
 }
 function isLineBreak(node) {
   return isLiteral(node) && isWhiteSpace(node) && isMultiLine(node);
@@ -2312,7 +466,7 @@ function isLineBreak(node) {
 function isPaddingSpaces(node) {
   return isLiteral(node) && isWhiteSpace(node) && node.raw.includes("\n");
 }
-function traverseUpProp(node, predicate = Function_exports.constTrue) {
+function traverseUpProp(node, predicate = F.constTrue) {
   const guard = (node2) => {
     return node2.type === NodeType.JSXAttribute && predicate(node2);
   };