@eslint-react/jsx 1.5.21-next.0 → 1.5.21-next.2

package/dist/index.js

@@ -3,10 +3,12 @@
 var types = require('@typescript-eslint/types');
 var ast = require('@eslint-react/ast');
 var _var = require('@eslint-react/var');
-var effect = require('effect');
-var tsPattern = require('ts-pattern');
 
-// src/element/element-type.ts
+var __defProp = Object.defineProperty;
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
+};
 function resolveMemberExpressions(object, property) {
   if (object.type === types.AST_NODE_TYPES.JSXMemberExpression) {
     return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
@@ -30,9 +32,2104 @@ function elementType(node) {
   }
   return name.name;
 }
+
+// ../../../node_modules/.pnpm/effect@3.4.6/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.4.6/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.4.6/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.4.6/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.4.6/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.4.6";
+var getCurrentVersion = () => moduleVersion;
+
+// ../../../node_modules/.pnpm/effect@3.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/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.4.6/node_modules/effect/dist/esm/Either.js
+var isLeft2 = isLeft;
+var isRight2 = isRight;
+
+// ../../../node_modules/.pnpm/effect@3.4.6/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
+// ../../../node_modules/.pnpm/effect@3.4.6/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.4.6/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.4.6/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.4.6/node_modules/effect/dist/esm/Tuple.js
+var make3 = (...elements) => elements;
+
+// ../../../node_modules/.pnpm/effect@3.4.6/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.4.6/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.4.6/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);
+
+// ../../../node_modules/.pnpm/ts-pattern@5.2.0/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))), length: (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 } = ast.ESLintCommunityESLintUtils;
 function getPropName(node) {
-  return tsPattern.match(node.name).when(ast.is(ast.NodeType.JSXIdentifier), (n) => n.name).when(ast.is(ast.NodeType.JSXNamespacedName), (n) => `${n.namespace.name}:${n.name.name}`).exhaustive();
+  return $(node.name).when(ast.is(ast.NodeType.JSXIdentifier), (n2) => n2.name).when(ast.is(ast.NodeType.JSXNamespacedName), (n2) => `${n2.namespace.name}:${n2.name.name}`).exhaustive();
 }
 function getProp(props, propName, context, initialScope) {
   return findPropInAttributes(props, context, initialScope)(propName);
@@ -41,75 +2138,77 @@ function getPropValue(attribute, context) {
   const initialScope = context.sourceCode.getScope(attribute);
   if (attribute.type === ast.NodeType.JSXAttribute && "value" in attribute) {
     const { value } = attribute;
-    if (value === null) return effect.Option.none();
-    if (value.type === ast.NodeType.Literal) return effect.Option.some(getStaticValue(value, initialScope));
-    if (value.type === ast.NodeType.JSXExpressionContainer) return effect.Option.some(getStaticValue(value.expression, initialScope));
-    return effect.Option.none();
+    if (value === null) return Option_exports.none();
+    if (value.type === ast.NodeType.Literal) return Option_exports.some(getStaticValue(value, initialScope));
+    if (value.type === ast.NodeType.JSXExpressionContainer) return Option_exports.some(getStaticValue(value.expression, initialScope));
+    return Option_exports.none();
   }
   const { argument } = attribute;
-  return effect.Option.some(getStaticValue(argument, initialScope));
+  return Option_exports.some(getStaticValue(argument, initialScope));
 }
 function findPropInProperties(properties, context, initialScope, seenProps = []) {
   return (propName) => {
-    return effect.Option.fromNullable(
+    return Option_exports.fromNullable(
       properties.find((prop) => {
-        return tsPattern.match(prop).when(ast.is(ast.NodeType.Property), (prop2) => {
+        return $(prop).when(ast.is(ast.NodeType.Property), (prop2) => {
           return "name" in prop2.key && prop2.key.name === propName;
         }).when(ast.is(ast.NodeType.SpreadElement), (prop2) => {
-          return tsPattern.match(prop2.argument).when(ast.is(ast.NodeType.Identifier), (argument) => {
+          return $(prop2.argument).when(ast.is(ast.NodeType.Identifier), (argument) => {
             const { name } = argument;
-            const maybeInit = effect.Option.flatMap(
+            const maybeInit = Option_exports.flatMap(
               _var.findVariable(name, initialScope),
               _var.getVariableInit(0)
             );
-            if (effect.Option.isNone(maybeInit)) return false;
-            const init = maybeInit.value;
-            if (init.type !== ast.NodeType.ObjectExpression) return false;
+            if (Option_exports.isNone(maybeInit)) return false;
+            const init2 = maybeInit.value;
+            if (init2.type !== ast.NodeType.ObjectExpression) return false;
             if (seenProps.includes(name)) return false;
-            return effect.Option.isSome(
-              findPropInProperties(init.properties, context, initialScope, [...seenProps, name])(propName)
+            return Option_exports.isSome(
+              findPropInProperties(init2.properties, context, initialScope, [...seenProps, name])(propName)
             );
           }).when(ast.is(ast.NodeType.ObjectExpression), (argument) => {
-            return effect.Option.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
           }).when(ast.is(ast.NodeType.MemberExpression), () => {
           }).when(ast.is(ast.NodeType.CallExpression), () => {
-          }).otherwise(effect.Function.constFalse);
+          }).otherwise(Function_exports.constFalse);
         }).when(ast.is(ast.NodeType.RestElement), () => {
           return false;
-        }).otherwise(effect.Function.constFalse);
+        }).otherwise(Function_exports.constFalse);
       })
     );
   };
 }
 function findPropInAttributes(attributes, context, initialScope) {
   return (propName) => {
-    return effect.Option.fromNullable(
+    return Option_exports.fromNullable(
       attributes.find((attr) => {
-        return tsPattern.match(attr).when(ast.is(ast.NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr2) => {
-          return tsPattern.match(attr2.argument).with({ type: ast.NodeType.Identifier }, (argument) => {
+        return $(attr).when(ast.is(ast.NodeType.JSXAttribute), (attr2) => getPropName(attr2) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr2) => {
+          return $(attr2.argument).with({ type: ast.NodeType.Identifier }, (argument) => {
             const { name } = argument;
-            const maybeInit = effect.Option.flatMap(
+            const maybeInit = Option_exports.flatMap(
               _var.findVariable(name, initialScope),
               _var.getVariableInit(0)
             );
-            if (effect.Option.isNone(maybeInit)) return false;
-            const init = maybeInit.value;
-            if (!("properties" in init)) return false;
-            return effect.Option.isSome(findPropInProperties(init.properties, context, initialScope)(propName));
+            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));
           }).when(ast.is(ast.NodeType.ObjectExpression), (argument) => {
-            return effect.Option.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
+            return Option_exports.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
           }).when(ast.is(ast.NodeType.MemberExpression), () => {
             return false;
           }).when(ast.is(ast.NodeType.CallExpression), () => {
             return false;
-          }).otherwise(effect.Function.constFalse);
-        }).otherwise(effect.Function.constFalse);
+          }).otherwise(Function_exports.constFalse);
+        }).otherwise(Function_exports.constFalse);
       })
     );
   };
 }
+
+// src/prop/has-prop.ts
 function hasProp(attributes, propName, context, initialScope) {
-  return effect.Option.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
+  return Option_exports.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
 }
 function hasAnyProp(attributes, propNames, context, initialScope) {
   return propNames.some((propName) => hasProp(attributes, propName, context, initialScope));
@@ -117,7 +2216,7 @@ function hasAnyProp(attributes, propNames, context, initialScope) {
 function hasEveryProp(attributes, propNames, context, initialScope) {
   return propNames.every((propName) => hasProp(attributes, propName, context, initialScope));
 }
-function traverseUpProp(node, predicate = effect.Function.constTrue) {
+function traverseUpProp(node, predicate = Function_exports.constTrue) {
   const guard = (node2) => {
     return node2.type === ast.NodeType.JSXAttribute && predicate(node2);
   };
@@ -127,7 +2226,7 @@ function traverseUpProp(node, predicate = effect.Function.constTrue) {
 // src/prop/misc.ts
 function isInsidePropValue(node) {
   if (ast.isStringLiteral(node)) return node.parent.type === ast.NodeType.JSXAttribute;
-  return effect.Option.isSome(traverseUpProp(node, (n) => n.value?.type === ast.NodeType.JSXExpressionContainer));
+  return Option_exports.isSome(traverseUpProp(node, (n2) => n2.value?.type === ast.NodeType.JSXExpressionContainer));
 }
 
 // src/element/is.ts
@@ -143,20 +2242,22 @@ function isBuiltInElement(node) {
   if (node.type !== ast.NodeType.JSXElement) return false;
   return node.openingElement.name.type === ast.NodeType.JSXIdentifier && node.openingElement.name.name.toLowerCase() === node.openingElement.name.name && /^[a-z]/u.test(node.openingElement.name.name);
 }
+
+// src/pragma.ts
 var RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
 var RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
 function getJSXPragmaFromContext(context) {
   const { sourceCode } = context;
-  return effect.Function.pipe(
-    effect.Array.findFirst(sourceCode.getAllComments(), (node) => RE_JSX_ANNOTATION_REGEX.test(node.value)),
-    effect.Option.map(({ value }) => RE_JSX_ANNOTATION_REGEX.exec(value)),
-    effect.Option.flatMapNullable((matches) => matches?.[1]),
-    effect.Option.filter((pragma) => RE_JS_IDENTIFIER_REGEX.test(pragma))
+  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))
   );
 }
 var isLiteral = ast.isOneOf([ast.NodeType.Literal, ast.NodeType.JSXText]);
 function isWhiteSpace(node) {
-  return effect.Predicate.isString(node.value) && node.value.trim() === "";
+  return Predicate_exports.isString(node.value) && node.value.trim() === "";
 }
 function isLineBreak(node) {
   return isLiteral(node) && isWhiteSpace(node) && ast.isMultiLine(node);
@@ -180,19 +2281,19 @@ var JSXValueHint = {
 var DEFAULT_JSX_VALUE_HINT = JSXValueHint.SkipUndefinedLiteral | JSXValueHint.SkipBooleanLiteral;
 function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
   if (!node) return false;
-  return tsPattern.match(node).with({ type: ast.NodeType.JSXElement }, effect.Function.constTrue).with({ type: ast.NodeType.JSXFragment }, effect.Function.constTrue).with({ type: ast.NodeType.JSXMemberExpression }, effect.Function.constTrue).with({ type: ast.NodeType.JSXNamespacedName }, effect.Function.constTrue).with({ type: ast.NodeType.Literal }, (node2) => {
-    return tsPattern.match(node2.value).with(null, () => !(hint & JSXValueHint.SkipNullLiteral)).with(tsPattern.P.boolean, () => !(hint & JSXValueHint.SkipBooleanLiteral)).with(tsPattern.P.string, () => !(hint & JSXValueHint.SkipStringLiteral)).with(tsPattern.P.number, () => !(hint & JSXValueHint.SkipNumberLiteral)).otherwise(effect.Function.constFalse);
+  return $(node).with({ type: ast.NodeType.JSXElement }, Function_exports.constTrue).with({ type: ast.NodeType.JSXFragment }, Function_exports.constTrue).with({ type: ast.NodeType.JSXMemberExpression }, Function_exports.constTrue).with({ type: ast.NodeType.JSXNamespacedName }, Function_exports.constTrue).with({ type: ast.NodeType.Literal }, (node2) => {
+    return $(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);
   }).with({ type: ast.NodeType.TemplateLiteral }, () => !(hint & JSXValueHint.SkipStringLiteral)).with({ type: ast.NodeType.ArrayExpression }, (node2) => {
-    if (hint & JSXValueHint.StrictArray) return node2.elements.every((n) => isJSXValue(n, context, hint));
-    return node2.elements.some((n) => isJSXValue(n, context, hint));
+    if (hint & JSXValueHint.StrictArray) return node2.elements.every((n2) => isJSXValue(n2, context, hint));
+    return node2.elements.some((n2) => isJSXValue(n2, context, hint));
   }).with({ type: ast.NodeType.ConditionalExpression }, (node2) => {
     function leftHasJSX(node3) {
       if (Array.isArray(node3.consequent)) {
         if (node3.consequent.length === 0) return !(hint & JSXValueHint.SkipEmptyArray);
         if (hint & JSXValueHint.StrictArray) {
-          return node3.consequent.every((n) => isJSXValue(n, context, hint));
+          return node3.consequent.every((n2) => isJSXValue(n2, context, hint));
         }
-        return node3.consequent.some((n) => isJSXValue(n, context, hint));
+        return node3.consequent.some((n2) => isJSXValue(n2, context, hint));
       }
       return isJSXValue(node3.consequent, context, hint);
     }
@@ -213,19 +2314,19 @@ function isJSXValue(node, context, hint = DEFAULT_JSX_VALUE_HINT) {
     return isJSXValue(exp, context, hint);
   }).with({ type: ast.NodeType.CallExpression }, (node2) => {
     if (hint & JSXValueHint.SkipCreateElement) return false;
-    return tsPattern.match(node2.callee).with({ type: ast.NodeType.Identifier, name: "createElement" }, effect.Function.constTrue).with({ type: ast.NodeType.MemberExpression, property: { name: "createElement" } }, effect.Function.constTrue).otherwise(effect.Function.constFalse);
+    return $(node2.callee).with({ type: ast.NodeType.Identifier, name: "createElement" }, Function_exports.constTrue).with({ type: ast.NodeType.MemberExpression, property: { name: "createElement" } }, Function_exports.constTrue).otherwise(Function_exports.constFalse);
   }).with({ type: ast.NodeType.Identifier }, (node2) => {
     const { name } = node2;
     if (name === "undefined") return !(hint & JSXValueHint.SkipUndefinedLiteral);
     if (ast.isJSXTagNameExpression(node2)) return true;
     const initialScope = context.sourceCode.getScope(node2);
     const maybeVariable = _var.findVariable(name, initialScope);
-    return effect.Function.pipe(
+    return Function_exports.pipe(
       maybeVariable,
-      effect.Option.flatMap(_var.getVariableInit(0)),
-      effect.Option.exists((n) => isJSXValue(n, context, hint))
+      Option_exports.flatMap(_var.getVariableInit(0)),
+      Option_exports.exists((n2) => isJSXValue(n2, context, hint))
     );
-  }).otherwise(effect.Function.constFalse);
+  }).otherwise(Function_exports.constFalse);
 }
 
 exports.DEFAULT_JSX_VALUE_HINT = DEFAULT_JSX_VALUE_HINT;