@eslint-react/jsx 1.5.13-next.3 → 1.5.13-next.5

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { isOneOf, NodeType, is, traverseUpGuard, isStringLiteral, isMultiLine, isJSXTagNameExpression, ESLintCommunityESLintUtils } from '@eslint-react/ast';
 import { findVariable, getVariableInit } from '@eslint-react/var';
-import '@typescript-eslint/utils';
+import { match as match$1, P } from 'ts-pattern';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all3) => {
@@ -78,39 +78,39 @@ var dual = function(arity, body) {
     case 1:
       throw new RangeError(`Invalid arity ${arity}`);
     case 2:
-      return function(a2, b2) {
+      return function(a, b) {
         if (arguments.length >= 2) {
-          return body(a2, b2);
+          return body(a, b);
         }
         return function(self) {
-          return body(self, a2);
+          return body(self, a);
         };
       };
     case 3:
-      return function(a2, b2, c2) {
+      return function(a, b, c) {
         if (arguments.length >= 3) {
-          return body(a2, b2, c2);
+          return body(a, b, c);
         }
         return function(self) {
-          return body(self, a2, b2);
+          return body(self, a, b);
         };
       };
     case 4:
-      return function(a2, b2, c2, d2) {
+      return function(a, b, c, d) {
         if (arguments.length >= 4) {
-          return body(a2, b2, c2, d2);
+          return body(a, b, c, d);
         }
         return function(self) {
-          return body(self, a2, b2, c2);
+          return body(self, a, b, c);
         };
       };
     case 5:
-      return function(a2, b2, c2, d2, e2) {
+      return function(a, b, c, d, e) {
         if (arguments.length >= 5) {
-          return body(a2, b2, c2, d2, e2);
+          return body(a, b, c, d, e);
         }
         return function(self) {
-          return body(self, a2, b2, c2, d2);
+          return body(self, a, b, c, d);
         };
       };
     default:
@@ -125,9 +125,9 @@ var dual = function(arity, body) {
       };
   }
 };
-var apply = (a2) => (self) => self(a2);
-var identity = (a2) => a2;
-var satisfies = () => (b2) => b2;
+var apply = (a) => (self) => self(a);
+var identity = (a) => a;
+var satisfies = () => (b) => b;
 var unsafeCoerce = identity;
 var constant = (value) => () => value;
 var constTrue = /* @__PURE__ */ constant(true);
@@ -135,37 +135,37 @@ 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) => {
+var flip = (f) => (...b) => (...a) => f(...a)(...b);
+var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => bc(ab(a)));
+var absurd = (_) => {
   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) {
+var tupled = (f) => (a) => f(...a);
+var untupled = (f) => (...a) => f(a);
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
-      return a2;
+      return a;
     case 2:
-      return ab(a2);
+      return ab(a);
     case 3:
-      return bc(ab(a2));
+      return bc(ab(a));
     case 4:
-      return cd(bc(ab(a2)));
+      return cd(bc(ab(a)));
     case 5:
-      return de(cd(bc(ab(a2))));
+      return de(cd(bc(ab(a))));
     case 6:
-      return ef(de(cd(bc(ab(a2)))));
+      return ef(de(cd(bc(ab(a)))));
     case 7:
-      return fg(ef(de(cd(bc(ab(a2))))));
+      return fg(ef(de(cd(bc(ab(a))))));
     case 8:
-      return gh(fg(ef(de(cd(bc(ab(a2)))))));
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
     case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a2))))))));
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
     default: {
       let ret = arguments[0];
-      for (let i2 = 1; i2 < arguments.length; i2++) {
-        ret = arguments[i2](ret);
+      for (let i = 1; i < arguments.length; i++) {
+        ret = arguments[i](ret);
       }
       return ret;
     }
@@ -211,7 +211,7 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
   return;
 }
 var hole = /* @__PURE__ */ unsafeCoerce(absurd);
-var SK = (_2, b2) => b2;
+var SK = (_, b) => b;
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/Array.js
 var Array_exports = {};
@@ -350,8 +350,8 @@ 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]);
+  for (let i = 0; i < self.length; i++) {
+    const isEq = item(self[i], that[i]);
     if (!isEq) {
       return false;
     }
@@ -360,14 +360,14 @@ var array = (item) => make((self, that) => {
 });
 
 // ../../../node_modules/.pnpm/effect@3.2.5/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 let_ = (map3) => dual(3, (self, name, f) => map3(self, (a) => Object.assign({}, a, {
+  [name]: f(a)
 })));
-var bindTo = (map3) => dual(2, (self, name) => map3(self, (a2) => ({
-  [name]: a2
+var bindTo = (map3) => dual(2, (self, name) => map3(self, (a) => ({
+  [name]: a
 })));
-var bind = (map3, flatMap3) => dual(3, (self, name, f2) => flatMap3(self, (a2) => map3(f2(a2), (b2) => Object.assign({}, a2, {
-  [name]: b2
+var bind = (map3, flatMap3) => dual(3, (self, name, f) => flatMap3(self, (a) => map3(f(a), (b) => Object.assign({}, a, {
+  [name]: b
 }))));
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/internal/version.js
@@ -436,7 +436,7 @@ __export(Predicate_exports, {
   tuple: () => tuple,
   xor: () => xor
 });
-var mapInput = /* @__PURE__ */ dual(2, (self, f2) => (b2) => self(f2(b2)));
+var mapInput = /* @__PURE__ */ dual(2, (self, f) => (b) => self(f(b)));
 var isTruthy = (input) => !!input;
 var isSet = (input) => input instanceof Set;
 var isMap = (input) => input instanceof Map;
@@ -450,8 +450,8 @@ 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 isNever = (_) => false;
+var isUnknown = (_) => 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);
@@ -466,16 +466,16 @@ 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 compose2 = /* @__PURE__ */ dual(2, (ab, bc) => (a) => ab(a) && bc(a));
+var product = (self, that) => ([a, b]) => self(a) && that(b);
 var all = (collection) => {
   return (as2) => {
     let collectionIndex = 0;
-    for (const p2 of collection) {
+    for (const p of collection) {
       if (collectionIndex >= as2.length) {
         break;
       }
-      if (p2(as2[collectionIndex]) === false) {
+      if (p(as2[collectionIndex]) === false) {
         return false;
       }
       collectionIndex++;
@@ -490,34 +490,34 @@ var productMany = (self, collection) => {
 var tuple = (...elements) => all(elements);
 var struct = (fields) => {
   const keys2 = Object.keys(fields);
-  return (a2) => {
+  return (a) => {
     for (const key of keys2) {
-      if (!fields[key](a2[key])) {
+      if (!fields[key](a[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)) {
+var not = (self) => (a) => !self(a);
+var or = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) || that(a));
+var and = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) && that(a));
+var xor = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) !== that(a));
+var eqv = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) === that(a));
+var implies = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) ? that(a) : true);
+var nor = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) || that(a)));
+var nand = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) && that(a)));
+var every = (collection) => (a) => {
+  for (const p of collection) {
+    if (!p(a)) {
       return false;
     }
   }
   return true;
 };
-var some = (collection) => (a2) => {
-  for (const p2 of collection) {
-    if (p2(a2)) {
+var some = (collection) => (a) => {
+  for (const p of collection) {
+    if (p(a)) {
       return true;
     }
   }
@@ -529,7 +529,7 @@ var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
-var isGenKind = (u2) => isObject(u2) && GenKindTypeId in u2;
+var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
 var GenKindImpl = class {
   value;
   constructor(value) {
@@ -545,19 +545,19 @@ var GenKindImpl = class {
    * @since 2.0.0
    */
   get _R() {
-    return (_2) => _2;
+    return (_) => _;
   }
   /**
    * @since 2.0.0
    */
   get _O() {
-    return (_2) => _2;
+    return (_) => _;
   }
   /**
    * @since 2.0.0
    */
   get _E() {
-    return (_2) => _2;
+    return (_) => _;
   }
   /**
    * @since 2.0.0
@@ -579,9 +579,9 @@ var SingleShotGen = class _SingleShotGen {
   /**
    * @since 2.0.0
    */
-  next(a2) {
+  next(a) {
     return this.called ? {
-      value: a2,
+      value: a,
       done: true
     } : (this.called = true, {
       value: this.self,
@@ -591,17 +591,17 @@ var SingleShotGen = class _SingleShotGen {
   /**
    * @since 2.0.0
    */
-  return(a2) {
+  return(a) {
     return {
-      value: a2,
+      value: a,
       done: true
     };
   }
   /**
    * @since 2.0.0
    */
-  throw(e2) {
-    throw e2;
+  throw(e) {
+    throw e;
   }
   /**
    * @since 2.0.0
@@ -611,11 +611,11 @@ var SingleShotGen = class _SingleShotGen {
   }
 };
 var adapter = () => function() {
-  let x2 = arguments[0];
-  for (let i2 = 1; i2 < arguments.length; i2++) {
-    x2 = arguments[i2](x2);
+  let x = arguments[0];
+  for (let i = 1; i < arguments.length; i++) {
+    x = arguments[i](x);
   }
-  return new GenKindImpl(x2);
+  return new GenKindImpl(x);
 };
 var defaultIncHi = 335903614;
 var defaultIncLo = 4150755663;
@@ -813,28 +813,28 @@ var random = (self) => {
   }
   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) {
+var combine = (b) => (self) => self * 53 ^ b;
+var optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
+var isHash = (u) => hasProperty(u, symbol);
+var number = (n) => {
+  if (n !== n || n === Infinity) {
     return 0;
   }
-  let h2 = n2 | 0;
-  if (h2 !== n2) {
-    h2 ^= n2 * 4294967295;
+  let h = n | 0;
+  if (h !== n) {
+    h ^= n * 4294967295;
   }
-  while (n2 > 4294967295) {
-    h2 ^= n2 /= 4294967295;
+  while (n > 4294967295) {
+    h ^= n /= 4294967295;
   }
-  return optimize(n2);
+  return optimize(n);
 };
 var string = (str) => {
-  let h2 = 5381, i2 = str.length;
-  while (i2) {
-    h2 = h2 * 33 ^ str.charCodeAt(--i2);
+  let h = 5381, i = str.length;
+  while (i) {
+    h = h * 33 ^ str.charCodeAt(--i);
   }
-  return optimize(h2);
+  return optimize(h);
 };
 var cached = function() {
   if (arguments.length === 1) {
@@ -888,7 +888,7 @@ function compareBoth(self, that) {
     }
     if (structuralRegionState.enabled) {
       if (Array.isArray(self) && Array.isArray(that)) {
-        return self.length === that.length && self.every((v2, i2) => compareBoth(v2, that[i2]));
+        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
       }
       if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
         const keysSelf = Object.keys(self);
@@ -907,20 +907,20 @@ function compareBoth(self, that) {
   }
   return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
 }
-var isEqual = (u2) => hasProperty(u2, symbol2);
+var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
 // ../../../node_modules/.pnpm/effect@3.2.5/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);
+var toJSON = (x) => {
+  if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
+    return x.toJSON();
+  } else if (Array.isArray(x)) {
+    return x.map(toJSON);
   }
-  return x2;
+  return x;
 };
-var format = (x2) => JSON.stringify(x2, null, 2);
+var format = (x) => JSON.stringify(x, null, 2);
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
@@ -945,8 +945,8 @@ var pipeArguments = (self, args) => {
       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);
+      for (let i = 0, len = args.length; i < len; i++) {
+        ret = args[i](ret);
       }
       return ret;
     }
@@ -960,40 +960,40 @@ var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
 var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
 var effectVariance = {
   /* c8 ignore next */
-  _R: (_2) => _2,
+  _R: (_) => _,
   /* c8 ignore next */
-  _E: (_2) => _2,
+  _E: (_) => _,
   /* c8 ignore next */
-  _A: (_2) => _2,
+  _A: (_) => _,
   _V: /* @__PURE__ */ getCurrentVersion()
 };
 var sinkVariance = {
   /* c8 ignore next */
-  _A: (_2) => _2,
+  _A: (_) => _,
   /* c8 ignore next */
-  _In: (_2) => _2,
+  _In: (_) => _,
   /* c8 ignore next */
-  _L: (_2) => _2,
+  _L: (_) => _,
   /* c8 ignore next */
-  _E: (_2) => _2,
+  _E: (_) => _,
   /* c8 ignore next */
-  _R: (_2) => _2
+  _R: (_) => _
 };
 var channelVariance = {
   /* c8 ignore next */
-  _Env: (_2) => _2,
+  _Env: (_) => _,
   /* c8 ignore next */
-  _InErr: (_2) => _2,
+  _InErr: (_) => _,
   /* c8 ignore next */
-  _InElem: (_2) => _2,
+  _InElem: (_) => _,
   /* c8 ignore next */
-  _InDone: (_2) => _2,
+  _InDone: (_) => _,
   /* c8 ignore next */
-  _OutErr: (_2) => _2,
+  _OutErr: (_) => _,
   /* c8 ignore next */
-  _OutElem: (_2) => _2,
+  _OutElem: (_) => _,
   /* c8 ignore next */
-  _OutDone: (_2) => _2
+  _OutDone: (_) => _
 };
 var EffectPrototype = {
   [EffectTypeId]: effectVariance,
@@ -1019,7 +1019,7 @@ var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
   [TypeId]: {
-    _A: (_2) => _2
+    _A: (_) => _
   },
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -1067,9 +1067,9 @@ 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;
+  const a = Object.create(SomeProto);
+  a.value = value;
+  return a;
 };
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/internal/either.js
@@ -1077,7 +1077,7 @@ var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
   [TypeId2]: {
-    _R: (_2) => _2
+    _R: (_) => _
   },
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -1124,14 +1124,14 @@ 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;
+  const a = Object.create(LeftProto);
+  a.left = left2;
+  return a;
 };
 var right = (right2) => {
-  const a2 = Object.create(RightProto);
-  a2.right = right2;
-  return a2;
+  const a = Object.create(RightProto);
+  a.right = right2;
+  return a;
 };
 var getLeft = (self) => isRight(self) ? none : some2(self.left);
 var getRight = (self) => isLeft(self) ? none : some2(self.right);
@@ -1213,8 +1213,8 @@ var combineMany = /* @__PURE__ */ dual(2, (self, collection) => make2((a1, a2) =
   if (out !== 0) {
     return out;
   }
-  for (const O2 of collection) {
-    out = O2(a1, a2);
+  for (const O of collection) {
+    out = O(a1, a2);
     if (out !== 0) {
       return out;
     }
@@ -1223,21 +1223,21 @@ var combineMany = /* @__PURE__ */ dual(2, (self, collection) => make2((a1, a2) =
 }));
 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) => {
+var mapInput2 = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
+var array2 = (O) => 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;
+  for (let i = 0; i < len; i++) {
+    const o = O(self[i], that[i]);
+    if (o !== 0) {
+      return o;
     }
   }
   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);
+var min = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
+var max = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/Option.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Option");
@@ -1250,10 +1250,10 @@ var match = /* @__PURE__ */ dual(2, (self, {
   onNone,
   onSome
 }) => isNone2(self) ? onNone() : onSome(self.value));
-var toRefinement = (f2) => (a2) => isSome2(f2(a2));
+var toRefinement = (f) => (a) => isSome2(f(a));
 var fromIterable = (collection) => {
-  for (const a2 of collection) {
-    return some3(a2);
+  for (const a of collection) {
+    return some3(a);
   }
   return none2();
 };
@@ -1273,13 +1273,13 @@ var firstSomeOf = (collection) => {
   return out;
 };
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some3(nullableValue);
-var liftNullable = (f2) => (...a2) => fromNullable(f2(...a2));
+var liftNullable = (f) => (...a) => fromNullable(f(...a));
 var getOrNull = /* @__PURE__ */ getOrElse(constNull);
 var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
-var liftThrowable = (f2) => (...a2) => {
+var liftThrowable = (f) => (...a) => {
   try {
-    return some3(f2(...a2));
-  } catch (e2) {
+    return some3(f(...a));
+  } catch (e) {
     return none2();
   }
 };
@@ -1290,82 +1290,82 @@ var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onNone) => {
   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 map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some3(f(self.value)));
+var as = /* @__PURE__ */ dual(2, (self, b) => map(self, () => b));
 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 flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var andThen = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => {
+  const b = isFunction(f) ? f(a) : f;
+  return isOption2(b) ? b : some3(b);
 }));
-var flatMapNullable = /* @__PURE__ */ dual(2, (self, f2) => isNone2(self) ? none2() : fromNullable(f2(self.value)));
+var flatMapNullable = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : fromNullable(f(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 composeK = /* @__PURE__ */ dual(2, (afb, bfc) => (a) => flatMap(afb(a), 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 tap = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => map(f(a), () => a)));
 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)) {
+  for (const o of collection) {
+    if (isNone2(o)) {
       return none2();
     }
-    out.push(o2.value);
+    out.push(o.value);
   }
   return some3(out);
 };
 var all2 = (input) => {
   if (Symbol.iterator in input) {
     const out2 = [];
-    for (const o2 of input) {
-      if (isNone2(o2)) {
+    for (const o of input) {
+      if (isNone2(o)) {
         return none2();
       }
-      out2.push(o2.value);
+      out2.push(o.value);
     }
     return some3(out2);
   }
   const out = {};
   for (const key of Object.keys(input)) {
-    const o2 = input[key];
-    if (isNone2(o2)) {
+    const o = input[key];
+    if (isNone2(o)) {
       return none2();
     }
-    out[key] = o2.value;
+    out[key] = o.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;
+var zipWith = /* @__PURE__ */ dual(3, (self, that, f) => map(product2(self, that), ([a, b]) => f(a, b)));
+var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
+var reduceCompact = /* @__PURE__ */ dual(3, (self, b, f) => {
+  let out = b;
   for (const oa of self) {
     if (isSome2(oa)) {
-      out = f2(out, oa.value);
+      out = f(out, oa.value);
     }
   }
   return out;
 });
 var toArray = (self) => isNone2(self) ? [] : [self.value];
-var partitionMap = /* @__PURE__ */ dual(2, (self, f2) => {
+var partitionMap = /* @__PURE__ */ dual(2, (self, f) => {
   if (isNone2(self)) {
     return [none2(), none2()];
   }
-  const e2 = f2(self.value);
-  return isLeft(e2) ? [some3(e2.left), none2()] : [none2(), some3(e2.right)];
+  const e = f(self.value);
+  return isLeft(e) ? [some3(e.left), none2()] : [none2(), some3(e.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 filterMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => filterMap(self, (b) => predicate(b) ? some2(b) : none));
+var getEquivalence = (isEquivalent) => make((x, y) => x === y || (isNone2(x) ? isNone2(y) : isNone2(y) ? false : isEquivalent(x.value, y.value)));
+var getOrder = (O) => make2((self, that) => isSome2(self) ? isSome2(that) ? O(self.value, that.value) : 1 : -1);
+var lift2 = (f) => dual(2, (self, that) => zipWith(self, that, f));
+var liftPredicate = (predicate) => (b) => predicate(b) ? some3(b) : none2();
+var containsWith = (isEquivalent) => dual(2, (self, a) => isNone2(self) ? false : isEquivalent(self.value, a));
 var _equivalence = /* @__PURE__ */ equivalence();
 var contains = /* @__PURE__ */ containsWith(_equivalence);
 var exists = /* @__PURE__ */ dual(2, (self, refinement) => isNone2(self) ? false : refinement(self.value));
@@ -1374,8 +1374,8 @@ var let_2 = /* @__PURE__ */ let_(map);
 var bind2 = /* @__PURE__ */ bind(map, flatMap);
 var Do = /* @__PURE__ */ some3({});
 var adapter2 = /* @__PURE__ */ adapter();
-var gen = (f2) => {
-  const iterator = f2(adapter2);
+var gen = (f) => {
+  const iterator = f(adapter2);
   let state = iterator.next();
   if (state.done) {
     return some3(state.value);
@@ -1411,29 +1411,29 @@ var gen = (f2) => {
 var make3 = (...elements) => elements;
 
 // ../../../node_modules/.pnpm/effect@3.2.5/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);
+var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
+  let i = 0;
+  for (const a of self) {
+    const o = f(a, i);
+    if (isBoolean(o)) {
+      if (o) {
+        return some3(a);
       }
     } else {
-      if (isSome2(o2)) {
-        return o2;
+      if (isSome2(o)) {
+        return o;
       }
     }
-    i2++;
+    i++;
   }
   return none2();
 });
 
 // ../../../node_modules/.pnpm/effect@3.2.5/node_modules/effect/dist/esm/Record.js
-var collect = /* @__PURE__ */ dual(2, (self, f2) => {
+var collect = /* @__PURE__ */ dual(2, (self, f) => {
   const out = [];
   for (const key of keys(self)) {
-    out.push(f2(key, self[key]));
+    out.push(f(key, self[key]));
   }
   return out;
 });
@@ -1442,17 +1442,17 @@ var keys = (self) => Object.keys(self);
 
 // ../../../node_modules/.pnpm/effect@3.2.5/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));
+var allocate = (n) => new Array(n);
+var makeBy = (n, f) => {
+  const max3 = Math.max(1, Math.floor(n));
   const out = new Array(max3);
-  for (let i2 = 0; i2 < max3; i2++) {
-    out[i2] = f2(i2);
+  for (let i = 0; i < max3; i++) {
+    out[i] = f(i);
   }
   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 range = (start, end) => start <= end ? makeBy(end - start + 1, (i) => start + i) : [start];
+var replicate = /* @__PURE__ */ dual(2, (a, n) => makeBy(n, () => a));
 var fromIterable2 = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var fromRecord = toEntries;
 var fromOption2 = toArray;
@@ -1472,21 +1472,21 @@ 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++;
+var scan = /* @__PURE__ */ dual(3, (self, b, f) => {
+  const out = [b];
+  let i = 0;
+  for (const a of self) {
+    out[i + 1] = f(out[i], a);
+    i++;
   }
   return out;
 });
-var scanRight = /* @__PURE__ */ dual(3, (self, b2, f2) => {
+var scanRight = /* @__PURE__ */ dual(3, (self, b, f) => {
   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]);
+  out[input.length] = b;
+  for (let i = input.length - 1; i >= 0; i--) {
+    out[i] = f(out[i + 1], input[i]);
   }
   return out;
 });
@@ -1496,18 +1496,18 @@ 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 isOutOfBound = (i, as2) => i < 0 || i >= as2.length;
+var clamp = (i, as2) => Math.floor(Math.min(Math.max(0, i), as2.length));
 var get = /* @__PURE__ */ dual(2, (self, index) => {
-  const i2 = Math.floor(index);
-  return isOutOfBound(i2, self) ? none2() : some3(self[i2]);
+  const i = Math.floor(index);
+  return isOutOfBound(i, self) ? none2() : some3(self[i]);
 });
 var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
-  const i2 = Math.floor(index);
-  if (isOutOfBound(i2, self)) {
-    throw new Error(`Index ${i2} out of bounds`);
+  const i = Math.floor(index);
+  if (isOutOfBound(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
   }
-  return self[i2];
+  return self[i];
 });
 var unprepend = (self) => [headNonEmpty(self), tailNonEmpty(self)];
 var unappend = (self) => [initNonEmpty(self), lastNonEmpty(self)];
@@ -1525,119 +1525,119 @@ var init = (self) => {
   return isNonEmptyReadonlyArray(input) ? some3(initNonEmpty(input)) : none2();
 };
 var initNonEmpty = (self) => self.slice(0, -1);
-var take = /* @__PURE__ */ dual(2, (self, n2) => {
+var take = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
-  return input.slice(0, clamp(n2, input));
+  return input.slice(0, clamp(n, input));
 });
-var takeRight = /* @__PURE__ */ dual(2, (self, n2) => {
+var takeRight = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
-  const i2 = clamp(n2, input);
-  return i2 === 0 ? [] : input.slice(-i2);
+  const i = clamp(n, input);
+  return i === 0 ? [] : input.slice(-i);
 });
 var takeWhile = /* @__PURE__ */ dual(2, (self, predicate) => {
-  let i2 = 0;
+  let i = 0;
   const out = [];
-  for (const a2 of self) {
-    if (!predicate(a2, i2)) {
+  for (const a of self) {
+    if (!predicate(a, i)) {
       break;
     }
-    out.push(a2);
-    i2++;
+    out.push(a);
+    i++;
   }
   return out;
 });
 var spanIndex = (self, predicate) => {
-  let i2 = 0;
-  for (const a2 of self) {
-    if (!predicate(a2, i2)) {
+  let i = 0;
+  for (const a of self) {
+    if (!predicate(a, i)) {
       break;
     }
-    i2++;
+    i++;
   }
-  return i2;
+  return i;
 };
 var span = /* @__PURE__ */ dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
-var drop = /* @__PURE__ */ dual(2, (self, n2) => {
+var drop = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
-  return input.slice(clamp(n2, input), input.length);
+  return input.slice(clamp(n, input), input.length);
 });
-var dropRight = /* @__PURE__ */ dual(2, (self, n2) => {
+var dropRight = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
-  return input.slice(0, input.length - clamp(n2, input));
+  return input.slice(0, input.length - clamp(n, 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);
+  let i = 0;
+  for (const a of self) {
+    if (predicate(a, i)) {
+      return some3(i);
     }
-    i2++;
+    i++;
   }
   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);
+  for (let i = input.length - 1; i >= 0; i--) {
+    if (predicate(input[i], i)) {
+      return some3(i);
     }
   }
   return none2();
 });
 var findFirst2 = findFirst;
-var findLast = /* @__PURE__ */ dual(2, (self, f2) => {
+var findLast = /* @__PURE__ */ dual(2, (self, f) => {
   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);
+  for (let i = input.length - 1; i >= 0; i--) {
+    const a = input[i];
+    const o = f(a, i);
+    if (isBoolean(o)) {
+      if (o) {
+        return some3(a);
       }
     } else {
-      if (isSome2(o2)) {
-        return o2;
+      if (isSome2(o)) {
+        return o;
       }
     }
   }
   return none2();
 });
-var insertAt = /* @__PURE__ */ dual(3, (self, i2, b2) => {
+var insertAt = /* @__PURE__ */ dual(3, (self, i, b) => {
   const out = Array.from(self);
-  if (i2 < 0 || i2 > out.length) {
+  if (i < 0 || i > out.length) {
     return none2();
   }
-  out.splice(i2, 0, b2);
+  out.splice(i, 0, b);
   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) => {
+var replace = /* @__PURE__ */ dual(3, (self, i, b) => modify(self, i, () => b));
+var replaceOption = /* @__PURE__ */ dual(3, (self, i, b) => modifyOption(self, i, () => b));
+var modify = /* @__PURE__ */ dual(3, (self, i, f) => getOrElse(modifyOption(self, i, f), () => Array.from(self)));
+var modifyOption = /* @__PURE__ */ dual(3, (self, i, f) => {
   const out = Array.from(self);
-  if (isOutOfBound(i2, out)) {
+  if (isOutOfBound(i, out)) {
     return none2();
   }
-  const next = f2(out[i2]);
-  out[i2] = next;
+  const next = f(out[i]);
+  out[i] = next;
   return some3(out);
 });
-var remove = /* @__PURE__ */ dual(2, (self, i2) => {
+var remove = /* @__PURE__ */ dual(2, (self, i) => {
   const out = Array.from(self);
-  if (isOutOfBound(i2, out)) {
+  if (isOutOfBound(i, out)) {
     return out;
   }
-  out.splice(i2, 1);
+  out.splice(i, 1);
   return out;
 });
 var reverse = (self) => Array.from(self).reverse();
-var sort = /* @__PURE__ */ dual(2, (self, O2) => {
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
-  out.sort(O2);
+  out.sort(O);
   return out;
 });
-var sortWith = /* @__PURE__ */ dual(3, (self, f2, order) => sort(self, mapInput2(order, f2)));
+var sortWith = /* @__PURE__ */ dual(3, (self, f, order) => sort(self, mapInput2(order, f)));
 var sortBy = (...orders) => {
   const sortByAll = sort(combineAll(orders));
   return (self) => {
@@ -1649,14 +1649,14 @@ var sortBy = (...orders) => {
   };
 };
 var zip = /* @__PURE__ */ dual(2, (self, that) => zipWith2(self, that, make3));
-var zipWith2 = /* @__PURE__ */ dual(3, (self, that, f2) => {
+var zipWith2 = /* @__PURE__ */ dual(3, (self, that, f) => {
   const as2 = fromIterable2(self);
   const bs = fromIterable2(that);
   if (isNonEmptyReadonlyArray(as2) && isNonEmptyReadonlyArray(bs)) {
-    const out = [f2(headNonEmpty(as2), headNonEmpty(bs))];
+    const out = [f(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]);
+    for (let i = 1; i < len; i++) {
+      out[i] = f(as2[i], bs[i]);
     }
     return out;
   }
@@ -1667,9 +1667,9 @@ var unzip = (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];
+    for (let i = 1; i < input.length; i++) {
+      fa[i] = input[i][0];
+      fb[i] = input[i][1];
     }
     return [fa, fb];
   }
@@ -1680,40 +1680,40 @@ var intersperse = /* @__PURE__ */ dual(2, (self, middle) => {
   if (isNonEmptyReadonlyArray(input)) {
     const out = [headNonEmpty(input)];
     const tail2 = tailNonEmpty(input);
-    for (let i2 = 0; i2 < tail2.length; i2++) {
-      if (i2 < tail2.length) {
+    for (let i = 0; i < tail2.length; i++) {
+      if (i < tail2.length) {
         out.push(middle);
       }
-      out.push(tail2[i2]);
+      out.push(tail2[i]);
     }
     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) => {
+var modifyNonEmptyHead = /* @__PURE__ */ dual(2, (self, f) => [f(headNonEmpty(self)), ...tailNonEmpty(self)]);
+var setNonEmptyHead = /* @__PURE__ */ dual(2, (self, b) => modifyNonEmptyHead(self, () => b));
+var modifyNonEmptyLast = /* @__PURE__ */ dual(2, (self, f) => append(initNonEmpty(self), f(lastNonEmpty(self))));
+var setNonEmptyLast = /* @__PURE__ */ dual(2, (self, b) => modifyNonEmptyLast(self, () => b));
+var rotate = /* @__PURE__ */ dual(2, (self, n) => {
   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) {
+    const m = Math.round(n) % len;
+    if (isOutOfBound(Math.abs(m), input) || m === 0) {
       return copy(input);
     }
-    if (m2 < 0) {
-      const [f2, s2] = splitNonEmptyAt(input, -m2);
-      return appendAll(s2, f2);
+    if (m < 0) {
+      const [f, s] = splitNonEmptyAt(input, -m);
+      return appendAll(s, f);
     } else {
-      return rotate(self, m2 - len);
+      return rotate(self, m - len);
     }
   }
   return [];
 });
-var containsWith2 = (isEquivalent) => dual(2, (self, a2) => {
-  for (const i2 of self) {
-    if (isEquivalent(a2, i2)) {
+var containsWith2 = (isEquivalent) => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
       return true;
     }
   }
@@ -1721,24 +1721,24 @@ var containsWith2 = (isEquivalent) => dual(2, (self, a2) => {
 });
 var _equivalence2 = /* @__PURE__ */ equivalence();
 var contains2 = /* @__PURE__ */ containsWith2(_equivalence2);
-var chop = /* @__PURE__ */ dual(2, (self, f2) => {
+var chop = /* @__PURE__ */ dual(2, (self, f) => {
   const input = fromIterable2(self);
   if (isNonEmptyReadonlyArray(input)) {
-    const [b2, rest] = f2(input);
-    const out = [b2];
+    const [b, rest] = f(input);
+    const out = [b];
     let next = rest;
     while (isNonEmptyArray(next)) {
-      const [b3, rest2] = f2(next);
-      out.push(b3);
+      const [b2, rest2] = f(next);
+      out.push(b2);
       next = rest2;
     }
     return out;
   }
   return [];
 });
-var splitAt = /* @__PURE__ */ dual(2, (self, n2) => {
+var splitAt = /* @__PURE__ */ dual(2, (self, n) => {
   const input = Array.from(self);
-  const _n = Math.floor(n2);
+  const _n = Math.floor(n);
   if (isNonEmptyReadonlyArray(input)) {
     if (_n >= 1) {
       return splitNonEmptyAt(input, _n);
@@ -1747,125 +1747,125 @@ var splitAt = /* @__PURE__ */ dual(2, (self, n2) => {
   }
   return [input, []];
 });
-var splitNonEmptyAt = /* @__PURE__ */ dual(2, (self, n2) => {
-  const _n = Math.max(1, Math.floor(n2));
+var splitNonEmptyAt = /* @__PURE__ */ dual(2, (self, n) => {
+  const _n = Math.max(1, Math.floor(n));
   return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];
 });
-var split = /* @__PURE__ */ dual(2, (self, n2) => {
+var split = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
-  return chunksOf(input, Math.ceil(input.length / Math.floor(n2)));
+  return chunksOf(input, Math.ceil(input.length / Math.floor(n)));
 });
-var splitWhere = /* @__PURE__ */ dual(2, (self, predicate) => span(self, (a2, i2) => !predicate(a2, i2)));
+var splitWhere = /* @__PURE__ */ dual(2, (self, predicate) => span(self, (a, i) => !predicate(a, i)));
 var copy = (self) => self.slice();
-var chunksOf = /* @__PURE__ */ dual(2, (self, n2) => {
+var chunksOf = /* @__PURE__ */ dual(2, (self, n) => {
   const input = fromIterable2(self);
   if (isNonEmptyReadonlyArray(input)) {
-    return chop(input, splitNonEmptyAt(n2));
+    return chop(input, splitNonEmptyAt(n));
   }
   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);
+  const h = headNonEmpty(as2);
+  const out = [h];
+  let i = 1;
+  for (; i < as2.length; i++) {
+    const a = as2[i];
+    if (isEquivalent(a, h)) {
+      out.push(a);
     } else {
       break;
     }
   }
-  return [out, as2.slice(i2)];
+  return [out, as2.slice(i)];
 }));
 var group = /* @__PURE__ */ groupWith(/* @__PURE__ */ equivalence());
-var groupBy = /* @__PURE__ */ dual(2, (self, f2) => {
+var groupBy = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {};
-  for (const a2 of self) {
-    const k2 = f2(a2);
-    if (Object.prototype.hasOwnProperty.call(out, k2)) {
-      out[k2].push(a2);
+  for (const a of self) {
+    const k = f(a);
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      out[k].push(a);
     } else {
-      out[k2] = [a2];
+      out[k] = [a];
     }
   }
   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 a = fromIterable2(self);
+  const b = fromIterable2(that);
+  if (isNonEmptyReadonlyArray(a)) {
+    if (isNonEmptyReadonlyArray(b)) {
       const dedupe2 = dedupeWith(isEquivalent);
-      return dedupe2(appendAll(a2, b2));
+      return dedupe2(appendAll(a, b));
     }
-    return a2;
+    return a;
   }
-  return b2;
+  return b;
 });
 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)));
+  return dual(2, (self, that) => fromIterable2(self).filter((a) => has(that, a)));
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence2);
 var differenceWith = (isEquivalent) => {
   const has = containsWith2(isEquivalent);
-  return dual(2, (self, that) => fromIterable2(self).filter((a2) => !has(that, a2)));
+  return dual(2, (self, that) => fromIterable2(self).filter((a) => !has(that, a)));
 };
 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) => {
+var of = (a) => [a];
+var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   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]);
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
     }
   }
   return out;
 });
 var flatten2 = /* @__PURE__ */ flatMap2(identity);
-var filterMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
+var filterMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   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);
+  for (let i = 0; i < as2.length; i++) {
+    const o = f(as2[i], i);
+    if (isSome2(o)) {
+      out.push(o.value);
     }
   }
   return out;
 });
-var filterMapWhile = /* @__PURE__ */ dual(2, (self, f2) => {
-  let i2 = 0;
+var filterMapWhile = /* @__PURE__ */ dual(2, (self, f) => {
+  let i = 0;
   const out = [];
-  for (const a2 of self) {
-    const b2 = f2(a2, i2);
-    if (isSome2(b2)) {
-      out.push(b2.value);
+  for (const a of self) {
+    const b = f(a, i);
+    if (isSome2(b)) {
+      out.push(b.value);
     } else {
       break;
     }
-    i2++;
+    i++;
   }
   return out;
 });
-var partitionMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
+var partitionMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   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);
+  for (let i = 0; i < as2.length; i++) {
+    const e = f(as2[i], i);
+    if (isLeft2(e)) {
+      left2.push(e.left);
     } else {
-      right2.push(e2.right);
+      right2.push(e.right);
     }
   }
   return [left2, right2];
@@ -1873,18 +1873,18 @@ var partitionMap2 = /* @__PURE__ */ dual(2, (self, f2) => {
 var getSomes = /* @__PURE__ */ filterMap2(identity);
 var getLefts = (self) => {
   const out = [];
-  for (const a2 of self) {
-    if (isLeft2(a2)) {
-      out.push(a2.left);
+  for (const a of self) {
+    if (isLeft2(a)) {
+      out.push(a.left);
     }
   }
   return out;
 };
 var getRights = (self) => {
   const out = [];
-  for (const a2 of self) {
-    if (isRight2(a2)) {
-      out.push(a2.right);
+  for (const a of self) {
+    if (isRight2(a)) {
+      out.push(a.right);
     }
   }
   return out;
@@ -1892,9 +1892,9 @@ var getRights = (self) => {
 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]);
+  for (let i = 0; i < as2.length; i++) {
+    if (predicate(as2[i], i)) {
+      out.push(as2[i]);
     }
   }
   return out;
@@ -1903,54 +1903,54 @@ 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]);
+  for (let i = 0; i < as2.length; i++) {
+    if (predicate(as2[i], i)) {
+      right2.push(as2[i]);
     } else {
-      left2.push(as2[i2]);
+      left2.push(as2[i]);
     }
   }
   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 reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable2(self).reduce((b2, a, i) => f(b2, a, i), b));
+var reduceRight = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable2(self).reduceRight((b2, a, i) => f(b2, a, i), b));
+var liftPredicate2 = (predicate) => (b) => predicate(b) ? [b] : [];
+var liftOption = (f) => (...a) => fromOption2(f(...a));
+var fromNullable2 = (a) => a == null ? empty2() : [a];
+var liftNullable2 = (f) => (...a) => fromNullable2(f(...a));
+var flatMapNullable2 = /* @__PURE__ */ dual(2, (self, f) => flatMap2(self, (a) => fromNullable2(f(a))));
+var liftEither = (f) => (...a) => {
+  const e = f(...a);
+  return isLeft2(e) ? [] : [e.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) => {
+var extend = /* @__PURE__ */ dual(2, (self, f) => self.map((_, i, as2) => f(as2.slice(i))));
+var min2 = /* @__PURE__ */ dual(2, (self, O) => self.reduce(min(O)));
+var max2 = /* @__PURE__ */ dual(2, (self, O) => self.reduce(max(O)));
+var unfold = (b, f) => {
   const out = [];
-  let next = b2;
-  let o2;
-  while (isSome2(o2 = f2(next))) {
-    const [a2, b3] = o2.value;
-    out.push(a2);
-    next = b3;
+  let next = b;
+  let o;
+  while (isSome2(o = f(next))) {
+    const [a, b2] = o.value;
+    out.push(a);
+    next = b2;
   }
   return out;
 };
 var getOrder2 = array2;
 var getEquivalence2 = array;
-var forEach = /* @__PURE__ */ dual(2, (self, f2) => fromIterable2(self).forEach((a2, i2) => f2(a2, i2)));
+var forEach = /* @__PURE__ */ dual(2, (self, f) => fromIterable2(self).forEach((a, i) => f(a, i)));
 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);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
       }
     }
     return out;
@@ -1961,30 +1961,30 @@ 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);
+  for (const a of self) {
+    if (isNone2(lastA) || !isEquivalent(a, lastA.value)) {
+      out.push(a);
+      lastA = some3(a);
     }
   }
   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;
+var mapAccum = /* @__PURE__ */ dual(3, (self, s, f) => {
+  let i = 0;
+  let s1 = s;
   const out = [];
-  for (const a2 of self) {
-    const r2 = f2(s1, a2, i2);
-    s1 = r2[0];
-    out.push(r2[1]);
-    i2++;
+  for (const a of self) {
+    const r = f(s1, a, i);
+    s1 = r[0];
+    out.push(r[1]);
+    i++;
   }
   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 cartesianWith = /* @__PURE__ */ dual(3, (self, that, f) => flatMap2(self, (a) => map2(that, (b) => f(a, b))));
+var cartesian = /* @__PURE__ */ dual(2, (self, that) => cartesianWith(self, that, (a, b) => [a, b]));
 var Do2 = /* @__PURE__ */ of({});
 var bind3 = /* @__PURE__ */ bind(map2, flatMap2);
 var bindTo3 = /* @__PURE__ */ bindTo(map2);
@@ -2002,286 +2002,9 @@ function getJSXPragmaFromContext(context) {
     Option_exports.filter((pragma) => RE_JS_IDENTIFIER_REGEX.test(pragma))
   );
 }
-
-// ../../../node_modules/.pnpm/ts-pattern@5.1.2/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 o = (n2, s2, c2) => {
-  if (i(n2)) {
-    const e2 = n2[t](), { matched: r2, selections: i2 } = e2.match(s2);
-    return r2 && i2 && Object.keys(i2).forEach((t2) => c2(t2, i2[t2])), r2;
-  }
-  if (r(n2)) {
-    if (!r(s2))
-      return false;
-    if (Array.isArray(n2)) {
-      if (!Array.isArray(s2))
-        return false;
-      let t2 = [], r2 = [], a2 = [];
-      for (const o2 of n2.keys()) {
-        const s3 = n2[o2];
-        i(s3) && s3[e] ? a2.push(s3) : a2.length ? r2.push(s3) : t2.push(s3);
-      }
-      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 (s2.length < t2.length + r2.length)
-          return false;
-        const e2 = s2.slice(0, t2.length), n3 = 0 === r2.length ? [] : s2.slice(-r2.length), i2 = s2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
-        return t2.every((t3, n4) => o(t3, e2[n4], c2)) && r2.every((t3, e3) => o(t3, n3[e3], c2)) && (0 === a2.length || o(a2[0], i2, c2));
-      }
-      return n2.length === s2.length && n2.every((t3, e2) => o(t3, s2[e2], c2));
-    }
-    return Object.keys(n2).every((e2) => {
-      const r2 = n2[e2];
-      return (e2 in s2 || i(a2 = r2) && "optional" === a2[t]().matcherType) && o(r2, s2[e2], c2);
-      var a2;
-    });
-  }
-  return Object.is(s2, n2);
-};
-var s = (e2) => {
-  var n2, o2, a2;
-  return r(e2) ? i(e2) ? null != (n2 = null == (o2 = (a2 = e2[t]()).getSelectionKeys) ? void 0 : o2.call(a2)) ? n2 : [] : Array.isArray(e2) ? c(e2, s) : c(Object.values(e2), s) : [];
-};
-var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
-function a(...t2) {
-  if (1 === t2.length) {
-    const [e2] = t2;
-    return (t3) => o(e2, t3, () => {
-    });
-  }
-  if (2 === t2.length) {
-    const [e2, n2] = t2;
-    return o(e2, n2, () => {
-    });
-  }
-  throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t2.length}.`);
-}
-function u(t2) {
-  return Object.assign(t2, { optional: () => l(t2), and: (e2) => m(t2, e2), or: (e2) => d(t2, e2), select: (e2) => void 0 === e2 ? p(t2) : p(e2, t2) });
-}
-function h(t2) {
-  return Object.assign(((t3) => Object.assign(t3, { [Symbol.iterator]() {
-    let n2 = 0;
-    const r2 = [{ value: Object.assign(t3, { [e]: true }), done: false }, { done: true, value: void 0 }];
-    return { next: () => {
-      var t4;
-      return null != (t4 = r2[n2++]) ? t4 : r2.at(-1);
-    } };
-  } }))(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 ? (s(e2).forEach((t3) => r2(t3, void 0)), { matched: true, selections: n2 }) : { matched: o(e2, t2, r2), selections: n2 };
-  }, getSelectionKeys: () => s(e2), matcherType: "optional" }) });
-}
-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) => o(e3, t2, r2)), selections: n2 };
-  }, getSelectionKeys: () => c(e2, s), matcherType: "and" }) });
-}
-function d(...e2) {
-  return u({ [t]: () => ({ match: (t2) => {
-    let n2 = {};
-    const r2 = (t3, e3) => {
-      n2[t3] = e3;
-    };
-    return c(e2, s).forEach((t3) => r2(t3, void 0)), { matched: e2.some((e3) => o(e3, t2, r2)), selections: n2 };
-  }, getSelectionKeys: () => c(e2, s), matcherType: "or" }) });
-}
-function y(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 || o(i2, t2, (t3, n2) => {
-      e3[t3] = n2;
-    }), selections: e3 };
-  }, getSelectionKeys: () => [null != r2 ? r2 : n].concat(void 0 === i2 ? [] : s(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(y(function(t2) {
-  return true;
-}));
-var O = 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;
-}, endsWith: (e2) => {
-  return j(m(t2, (n2 = e2, y((t3) => b(t3) && t3.endsWith(n2)))));
-  var n2;
-}, minLength: (e2) => j(m(t2, ((t3) => y((e3) => b(e3) && e3.length >= t3))(e2))), maxLength: (e2) => j(m(t2, ((t3) => y((e3) => b(e3) && e3.length <= t3))(e2))), includes: (e2) => {
-  return j(m(t2, (n2 = e2, y((t3) => b(t3) && t3.includes(n2)))));
-  var n2;
-}, regex: (e2) => {
-  return j(m(t2, (n2 = e2, y((t3) => b(t3) && Boolean(t3.match(n2))))));
-  var n2;
-} });
-var E = j(y(b));
-var K = (t2) => Object.assign(u(t2), { between: (e2, n2) => K(m(t2, ((t3, e3) => y((n3) => v(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => K(m(t2, ((t3) => y((e3) => v(e3) && e3 < t3))(e2))), gt: (e2) => K(m(t2, ((t3) => y((e3) => v(e3) && e3 > t3))(e2))), lte: (e2) => K(m(t2, ((t3) => y((e3) => v(e3) && e3 <= t3))(e2))), gte: (e2) => K(m(t2, ((t3) => y((e3) => v(e3) && e3 >= t3))(e2))), int: () => K(m(t2, y((t3) => v(t3) && Number.isInteger(t3)))), finite: () => K(m(t2, y((t3) => v(t3) && Number.isFinite(t3)))), positive: () => K(m(t2, y((t3) => v(t3) && t3 > 0))), negative: () => K(m(t2, y((t3) => v(t3) && t3 < 0))) });
-var x = K(y(v));
-var A = (t2) => Object.assign(u(t2), { between: (e2, n2) => A(m(t2, ((t3, e3) => y((n3) => w(n3) && t3 <= n3 && e3 >= n3))(e2, n2))), lt: (e2) => A(m(t2, ((t3) => y((e3) => w(e3) && e3 < t3))(e2))), gt: (e2) => A(m(t2, ((t3) => y((e3) => w(e3) && e3 > t3))(e2))), lte: (e2) => A(m(t2, ((t3) => y((e3) => w(e3) && e3 <= t3))(e2))), gte: (e2) => A(m(t2, ((t3) => y((e3) => w(e3) && e3 >= t3))(e2))), positive: () => A(m(t2, y((t3) => w(t3) && t3 > 0))), negative: () => A(m(t2, y((t3) => w(t3) && t3 < 0))) });
-var P = A(y(w));
-var T = u(y(function(t2) {
-  return "boolean" == typeof t2;
-}));
-var k = u(y(function(t2) {
-  return "symbol" == typeof t2;
-}));
-var B = u(y(function(t2) {
-  return null == t2;
-}));
-var _ = u(y(function(t2) {
-  return null != t2;
-}));
-var N = { __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 s(n2).forEach((t3) => {
-        r2[t3] = [];
-      }), { matched: true, selections: r2 };
-    const i2 = (t3, e3) => {
-      r2[t3] = (r2[t3] || []).concat([e3]);
-    };
-    return { matched: t2.every((t3) => o(n2, t3, i2)), selections: r2 };
-  }, getSelectionKeys: () => 0 === e2.length ? [] : s(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) => o(i2, t3, r2)), selections: n2 };
-  }, getSelectionKeys: () => 0 === e2.length ? [] : s(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 [s2, c2] = e2;
-    return { matched: g(t2, (t3, e3) => {
-      const n3 = o(s2, e3, r2), i3 = o(c2, t3, r2);
-      return n3 && i3;
-    }), selections: n2 };
-  }, getSelectionKeys: () => 0 === e2.length ? [] : [...s(e2[0]), ...s(e2[1])] }) });
-}, 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) {
-  return u(y(/* @__PURE__ */ function(t3) {
-    return (e2) => e2 instanceof t3;
-  }(t2)));
-}, shape: function(t2) {
-  return u(y(a(t2)));
-} };
-var W = { matched: false, value: void 0 };
-function $(t2) {
-  return new z(t2, W);
-}
-var z = class _z {
-  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 s2 = false, c2 = {};
-    const a2 = (t3, e3) => {
-      s2 = true, c2[t3] = e3;
-    }, u2 = !r2.some((t3) => o(t3, this.input, a2)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(s2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
-    return new _z(this.input, u2);
-  }
-  when(t2, e2) {
-    if (this.state.matched)
-      return this;
-    const n2 = Boolean(t2(this.input));
-    return new _z(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;
-  }
-};
-
-// src/prop/get-prop.ts
 var { getStaticValue } = ESLintCommunityESLintUtils;
 function getPropName(node) {
-  return $(node.name).when(is(NodeType.JSXIdentifier), (n2) => n2.name).when(is(NodeType.JSXNamespacedName), (n2) => `${n2.namespace.name}:${n2.name.name}`).exhaustive();
+  return match$1(node.name).when(is(NodeType.JSXIdentifier), (n) => n.name).when(is(NodeType.JSXNamespacedName), (n) => `${n.namespace.name}:${n.name.name}`).exhaustive();
 }
 function getProp(props, propName, context, initialScope) {
   return findPropInAttributes(props, context, initialScope)(propName);
@@ -2305,10 +2028,10 @@ function findPropInProperties(properties, context, initialScope, seenProps = [])
   return (propName) => {
     return Option_exports.fromNullable(
       properties.find((prop) => {
-        return $(prop).when(is(NodeType.Property), (prop2) => {
+        return match$1(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) => {
+          return match$1(prop2.argument).when(is(NodeType.Identifier), (argument) => {
             const { name } = argument;
             const maybeInit = Option_exports.flatMap(
               findVariable(name, initialScope),
@@ -2340,8 +2063,8 @@ function findPropInAttributes(attributes, context, initialScope) {
   return (propName) => {
     return Option_exports.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) => {
+        return match$1(attr).when(is(NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(is(NodeType.JSXSpreadAttribute), (attr2) => {
+          return match$1(attr2.argument).with({ type: NodeType.Identifier }, (argument) => {
             const { name } = argument;
             const maybeInit = Option_exports.flatMap(
               findVariable(name, initialScope),
@@ -2387,7 +2110,7 @@ function traverseUpProp(node, predicate = Function_exports.constTrue) {
 function isInsidePropValue(node) {
   if (isStringLiteral(node))
     return node.parent.type === NodeType.JSXAttribute;
-  return Option_exports.isSome(traverseUpProp(node, (n2) => n2.value?.type === NodeType.JSXExpressionContainer));
+  return Option_exports.isSome(traverseUpProp(node, (n) => n.value?.type === NodeType.JSXExpressionContainer));
 }
 var isLiteral = isOneOf([NodeType.Literal, NodeType.JSXText]);
 function isWhiteSpace(node) {
@@ -2415,19 +2138,19 @@ var DEFAULT_JSX_VALUE_HINT = JSXValueHint.SkipUndefinedLiteral | JSXValueHint.Sk
 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 match$1(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 match$1(node2.value).with(null, () => !(hint & JSXValueHint.SkipNullLiteral)).with(P.boolean, () => !(hint & JSXValueHint.SkipBooleanLiteral)).with(P.string, () => !(hint & JSXValueHint.SkipStringLiteral)).with(P.number, () => !(hint & JSXValueHint.SkipNumberLiteral)).otherwise(Function_exports.constFalse);
   }).with({ type: NodeType.TemplateLiteral }, () => !(hint & JSXValueHint.SkipStringLiteral)).with({ type: NodeType.ArrayExpression }, (node2) => {
     if (hint & JSXValueHint.StrictArray)
-      return node2.elements.every((n2) => isJSXValue(n2, context, hint));
-    return node2.elements.some((n2) => isJSXValue(n2, context, hint));
+      return node2.elements.every((n) => isJSXValue(n, context, hint));
+    return node2.elements.some((n) => isJSXValue(n, context, hint));
   }).with({ type: NodeType.ConditionalExpression }, (node2) => {
     function leftHasJSX(node3) {
       if (Array.isArray(node3.consequent)) {
         if (hint & JSXValueHint.StrictArray) {
-          return node3.consequent.every((n2) => isJSXValue(n2, context, hint));
+          return node3.consequent.every((n) => isJSXValue(n, context, hint));
         }
-        return node3.consequent.some((n2) => isJSXValue(n2, context, hint));
+        return node3.consequent.some((n) => isJSXValue(n, context, hint));
       }
       return isJSXValue(node3.consequent, context, hint);
     }
@@ -2446,7 +2169,7 @@ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_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 match$1(node2.callee).with({ type: NodeType.Identifier, name: "createElement" }, Function_exports.constTrue).with({ type: NodeType.MemberExpression, property: { name: "createElement" } }, Function_exports.constTrue).otherwise(Function_exports.constFalse);
   }).with({ type: NodeType.Identifier }, (node2) => {
     const { name } = node2;
     if (name === "undefined")
@@ -2458,7 +2181,7 @@ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
     return Function_exports.pipe(
       maybeVariable,
       Option_exports.flatMap(getVariableInit(0)),
-      Option_exports.exists((n2) => isJSXValue(n2, context, hint))
+      Option_exports.exists((n) => isJSXValue(n, context, hint))
     );
   }).otherwise(Function_exports.constFalse);
 }