@eslint-react/jsx 1.5.0 → 1.5.1-beta.0

package/dist/index.cjs

@@ -2,18 +2,1086 @@
 
 var ast = require('@eslint-react/ast');
 var shared = require('@eslint-react/shared');
-var tools = require('@eslint-react/tools');
 var memo = require('micro-memoize');
 var _var = require('@eslint-react/var');
 var types = require('@typescript-eslint/types');
 
+/**
+ * Tests if a value is a `function`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isFunction } from 'effect/Predicate'
+ *
+ * assert.deepStrictEqual(isFunction(isFunction), true)
+ * assert.deepStrictEqual(isFunction("function"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isFunction$1 = input => typeof input === "function";
+/**
+ * Creates a function that can be used in a data-last (aka `pipe`able) or
+ * data-first style.
+ *
+ * The first parameter to `dual` is either the arity of the uncurried function
+ * or a predicate that determines if the function is being used in a data-first
+ * or data-last style.
+ *
+ * Using the arity is the most common use case, but there are some cases where
+ * you may want to use a predicate. For example, if you have a function that
+ * takes an optional argument, you can use a predicate to determine if the
+ * function is being used in a data-first or data-last style.
+ *
+ * @param arity - Either the arity of the uncurried function or a predicate
+ *                which determines if the function is being used in a data-first
+ *                or data-last style.
+ * @param body - The definition of the uncurried function.
+ *
+ * @example
+ * import { dual, pipe } from "effect/Function"
+ *
+ * // Exampe using arity to determine data-first or data-last style
+ * const sum: {
+ *   (that: number): (self: number) => number
+ *   (self: number, that: number): number
+ * } = dual(2, (self: number, that: number): number => self + that)
+ *
+ * assert.deepStrictEqual(sum(2, 3), 5)
+ * assert.deepStrictEqual(pipe(2, sum(3)), 5)
+ *
+ * // Example using a predicate to determine data-first or data-last style
+ * const sum2: {
+ *   (that: number): (self: number) => number
+ *   (self: number, that: number): number
+ * } = dual((args) => args.length === 1, (self: number, that: number): number => self + that)
+ *
+ * assert.deepStrictEqual(sum(2, 3), 5)
+ * assert.deepStrictEqual(pipe(2, sum(3)), 5)
+ *
+ * @since 2.0.0
+ */
+const dual = function (arity, body) {
+  if (typeof arity === "function") {
+    return function () {
+      if (arity(arguments)) {
+        // @ts-expect-error
+        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 (a, b) {
+        if (arguments.length >= 2) {
+          return body(a, b);
+        }
+        return function (self) {
+          return body(self, a);
+        };
+      };
+    case 3:
+      return function (a, b, c) {
+        if (arguments.length >= 3) {
+          return body(a, b, c);
+        }
+        return function (self) {
+          return body(self, a, b);
+        };
+      };
+    case 4:
+      return function (a, b, c, d) {
+        if (arguments.length >= 4) {
+          return body(a, b, c, d);
+        }
+        return function (self) {
+          return body(self, a, b, c);
+        };
+      };
+    case 5:
+      return function (a, b, c, d, e) {
+        if (arguments.length >= 5) {
+          return body(a, b, c, d, e);
+        }
+        return function (self) {
+          return body(self, a, b, c, d);
+        };
+      };
+    default:
+      return function () {
+        if (arguments.length >= arity) {
+          // @ts-expect-error
+          return body.apply(this, arguments);
+        }
+        const args = arguments;
+        return function (self) {
+          return body(self, ...args);
+        };
+      };
+  }
+};
+/**
+ * Creates a constant value that never changes.
+ *
+ * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
+ * and want that inner function to always use the same value, no matter how many times it is called.
+ *
+ * @param value - The constant value to be returned.
+ *
+ * @example
+ * import { constant } from "effect/Function"
+ *
+ * const constNull = constant(null)
+ *
+ * assert.deepStrictEqual(constNull(), null)
+ * assert.deepStrictEqual(constNull(), null)
+ *
+ * @since 2.0.0
+ */
+const constant = value => () => value;
+/**
+ * A thunk that returns always `true`.
+ *
+ * @example
+ * import { constTrue } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constTrue(), true)
+ *
+ * @since 2.0.0
+ */
+const constTrue = /*#__PURE__*/constant(true);
+/**
+ * A thunk that returns always `false`.
+ *
+ * @example
+ * import { constFalse } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constFalse(), false)
+ *
+ * @since 2.0.0
+ */
+const constFalse = /*#__PURE__*/constant(false);
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default:
+      {
+        let ret = arguments[0];
+        for (let i = 1; i < arguments.length; i++) {
+          ret = arguments[i](ret);
+        }
+        return ret;
+      }
+  }
+}
+
+const moduleVersion = "2.2.2";
+
+/**
+ * @since 2.0.0
+ */
+const globalStoreId = /*#__PURE__*/Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`);
+if (!(globalStoreId in globalThis)) {
+  globalThis[globalStoreId] = /*#__PURE__*/new Map();
+}
+const globalStore = globalThis[globalStoreId];
+/**
+ * @since 2.0.0
+ */
+const globalValue = (id, compute) => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id);
+};
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * Tests if a value is a `string`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isString } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isString("a"), true)
+ *
+ * assert.deepStrictEqual(isString(1), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isString = input => typeof input === "string";
+/**
+ * Tests if a value is a `function`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isFunction } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isFunction(isFunction), true)
+ *
+ * assert.deepStrictEqual(isFunction("function"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isFunction = isFunction$1;
+const isRecordOrArray = input => typeof input === "object" && input !== null;
+/**
+ * Tests if a value is an `object`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isObject } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isObject({}), true)
+ * assert.deepStrictEqual(isObject([]), true)
+ *
+ * assert.deepStrictEqual(isObject(null), false)
+ * assert.deepStrictEqual(isObject(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isObject = input => isRecordOrArray(input) || isFunction(input);
+/**
+ * Checks whether a value is an `object` containing a specified property key.
+ *
+ * @param property - The field to check within the object.
+ * @param self - The value to examine.
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const hasProperty = /*#__PURE__*/dual(2, (self, property) => isObject(self) && property in self);
+/**
+ * A guard that succeeds when the input is `null` or `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNullable } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNullable(null), true)
+ * assert.deepStrictEqual(isNullable(undefined), true)
+ *
+ * assert.deepStrictEqual(isNullable({}), false)
+ * assert.deepStrictEqual(isNullable([]), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNullable = input => input === null || input === undefined;
+
+/**
+ * @since 2.0.0
+ */
+const defaultIncHi = 0x14057b7e;
+const defaultIncLo = 0xf767814f;
+const MUL_HI = 0x5851f42d >>> 0;
+const MUL_LO = 0x4c957f2d >>> 0;
+const BIT_53 = 9007199254740992.0;
+const BIT_27 = 134217728.0;
+/**
+ * PCG is a family of simple fast space-efficient statistically good algorithms
+ * for random number generation. Unlike many general-purpose RNGs, they are also
+ * hard to predict.
+ *
+ * @category model
+ * @since 2.0.0
+ */
+class PCGRandom {
+  _state;
+  constructor(seedHi, seedLo, incHi, incLo) {
+    if (isNullable(seedLo) && isNullable(seedHi)) {
+      seedLo = Math.random() * 0xffffffff >>> 0;
+      seedHi = 0;
+    } else if (isNullable(seedLo)) {
+      seedLo = seedHi;
+      seedHi = 0;
+    }
+    if (isNullable(incLo) && isNullable(incHi)) {
+      incLo = this._state ? this._state[3] : defaultIncLo;
+      incHi = this._state ? this._state[2] : defaultIncHi;
+    } else if (isNullable(incLo)) {
+      incLo = incHi;
+      incHi = 0;
+    }
+    this._state = new Int32Array([0, 0, incHi >>> 0, ((incLo || 0) | 1) >>> 0]);
+    this._next();
+    add64(this._state, this._state[0], this._state[1], seedHi >>> 0, seedLo >>> 0);
+    this._next();
+    return this;
+  }
+  /**
+   * Returns a copy of the internal state of this random number generator as a
+   * JavaScript Array.
+   *
+   * @category getters
+   * @since 2.0.0
+   */
+  getState() {
+    return [this._state[0], this._state[1], this._state[2], this._state[3]];
+  }
+  /**
+   * Restore state previously retrieved using `getState()`.
+   *
+   * @since 2.0.0
+   */
+  setState(state) {
+    this._state[0] = state[0];
+    this._state[1] = state[1];
+    this._state[2] = state[2];
+    this._state[3] = state[3] | 1;
+  }
+  /**
+   * Get a uniformly distributed 32 bit integer between [0, max).
+   *
+   * @category getter
+   * @since 2.0.0
+   */
+  integer(max) {
+    if (!max) {
+      return this._next();
+    }
+    max = max >>> 0;
+    if ((max & max - 1) === 0) {
+      return this._next() & max - 1; // fast path for power of 2
+    }
+    let num = 0;
+    const skew = (-max >>> 0) % max >>> 0;
+    for (num = this._next(); num < skew; num = this._next()) {
+      // this loop will rarely execute more than twice,
+      // and is intentionally empty
+    }
+    return num % max;
+  }
+  /**
+   * Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
+   * 53 bits of precision (every bit of the mantissa is randomized).
+   *
+   * @category getters
+   * @since 2.0.0
+   */
+  number() {
+    const hi = (this._next() & 0x03ffffff) * 1.0;
+    const lo = (this._next() & 0x07ffffff) * 1.0;
+    return (hi * BIT_27 + lo) / BIT_53;
+  }
+  /** @internal */
+  _next() {
+    // save current state (what we'll use for this number)
+    const oldHi = this._state[0] >>> 0;
+    const oldLo = this._state[1] >>> 0;
+    // churn LCG.
+    mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
+    add64(this._state, this._state[0], this._state[1], this._state[2], this._state[3]);
+    // get least sig. 32 bits of ((oldstate >> 18) ^ oldstate) >> 27
+    let xsHi = oldHi >>> 18;
+    let xsLo = (oldLo >>> 18 | oldHi << 14) >>> 0;
+    xsHi = (xsHi ^ oldHi) >>> 0;
+    xsLo = (xsLo ^ oldLo) >>> 0;
+    const xorshifted = (xsLo >>> 27 | xsHi << 5) >>> 0;
+    // rotate xorshifted right a random amount, based on the most sig. 5 bits
+    // bits of the old state.
+    const rot = oldHi >>> 27;
+    const rot2 = (-rot >>> 0 & 31) >>> 0;
+    return (xorshifted >>> rot | xorshifted << rot2) >>> 0;
+  }
+}
+function mul64(out, aHi, aLo, bHi, bLo) {
+  let c1 = (aLo >>> 16) * (bLo & 0xffff) >>> 0;
+  let c0 = (aLo & 0xffff) * (bLo >>> 16) >>> 0;
+  let lo = (aLo & 0xffff) * (bLo & 0xffff) >>> 0;
+  let hi = (aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;
+  c0 = c0 << 16 >>> 0;
+  lo = lo + c0 >>> 0;
+  if (lo >>> 0 < c0 >>> 0) {
+    hi = hi + 1 >>> 0;
+  }
+  c1 = c1 << 16 >>> 0;
+  lo = lo + c1 >>> 0;
+  if (lo >>> 0 < c1 >>> 0) {
+    hi = hi + 1 >>> 0;
+  }
+  hi = hi + Math.imul(aLo, bHi) >>> 0;
+  hi = hi + Math.imul(aHi, bLo) >>> 0;
+  out[0] = hi;
+  out[1] = lo;
+}
+// add two 64 bit numbers (given in parts), and store the result in `out`.
+function add64(out, aHi, aLo, bHi, bLo) {
+  let hi = aHi + bHi >>> 0;
+  const lo = aLo + bLo >>> 0;
+  if (lo >>> 0 < aLo >>> 0) {
+    hi = hi + 1 | 0;
+  }
+  out[0] = hi;
+  out[1] = lo;
+}
+
+/**
+ * @since 2.0.0
+ */
+/** @internal */
+const randomHashCache = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Hash/randomHashCache"), () => new WeakMap());
+/** @internal */
+const pcgr = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Hash/pcgr"), () => new PCGRandom());
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const symbol$1 = /*#__PURE__*/Symbol.for("effect/Hash");
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const hash = self => {
+  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");
+        }
+        if (isHash(self)) {
+          return self[symbol$1]();
+        } else {
+          return random(self);
+        }
+      }
+    default:
+      throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
+  }
+};
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const random = self => {
+  if (!randomHashCache.has(self)) {
+    randomHashCache.set(self, number(pcgr.integer(Number.MAX_SAFE_INTEGER)));
+  }
+  return randomHashCache.get(self);
+};
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const combine = b => self => self * 53 ^ b;
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const optimize = n => n & 0xbfffffff | n >>> 1 & 0x40000000;
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+const isHash = u => hasProperty(u, symbol$1);
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const number = n => {
+  if (n !== n || n === Infinity) {
+    return 0;
+  }
+  let h = n | 0;
+  if (h !== n) {
+    h ^= n * 0xffffffff;
+  }
+  while (n > 0xffffffff) {
+    h ^= n /= 0xffffffff;
+  }
+  return optimize(n);
+};
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+const string = str => {
+  let h = 5381,
+    i = str.length;
+  while (i) {
+    h = h * 33 ^ str.charCodeAt(--i);
+  }
+  return optimize(h);
+};
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const symbol = /*#__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") && self !== null && that !== null) {
+    if (isEqual(self) && isEqual(that)) {
+      return hash(self) === hash(that) && self[symbol](that);
+    }
+  }
+  return false;
+}
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+const isEqual = u => hasProperty(u, symbol);
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const NodeInspectSymbol = /*#__PURE__*/Symbol.for("nodejs.util.inspect.custom");
+/**
+ * @since 2.0.0
+ */
+const toJSON = x => {
+  if (hasProperty(x, "toJSON") && isFunction(x["toJSON"]) && x["toJSON"].length === 0) {
+    return x.toJSON();
+  } else if (Array.isArray(x)) {
+    return x.map(toJSON);
+  }
+  return x;
+};
+/**
+ * @since 2.0.0
+ */
+const format = x => JSON.stringify(x, null, 2);
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ */
+const 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 i = 0, len = args.length; i < len; i++) {
+          ret = args[i](ret);
+        }
+        return ret;
+      }
+  }
+};
+
+/** @internal */
+const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
+/** @internal */
+const StreamTypeId = /*#__PURE__*/Symbol.for("effect/Stream");
+/** @internal */
+const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
+/** @internal */
+const ChannelTypeId = /*#__PURE__*/Symbol.for("effect/Channel");
+/** @internal */
+const effectVariance = {
+  /* c8 ignore next */
+  _R: _ => _,
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _A: _ => _,
+  _V: moduleVersion
+};
+const sinkVariance = {
+  /* c8 ignore next */
+  _R: _ => _,
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _In: _ => _,
+  /* c8 ignore next */
+  _L: _ => _,
+  /* c8 ignore next */
+  _Z: _ => _
+};
+const channelVariance = {
+  /* c8 ignore next */
+  _Env: _ => _,
+  /* c8 ignore next */
+  _InErr: _ => _,
+  /* c8 ignore next */
+  _InElem: _ => _,
+  /* c8 ignore next */
+  _InDone: _ => _,
+  /* c8 ignore next */
+  _OutErr: _ => _,
+  /* c8 ignore next */
+  _OutElem: _ => _,
+  /* c8 ignore next */
+  _OutDone: _ => _
+};
+/** @internal */
+const EffectPrototype = {
+  [EffectTypeId]: effectVariance,
+  [StreamTypeId]: effectVariance,
+  [SinkTypeId]: sinkVariance,
+  [ChannelTypeId]: channelVariance,
+  [symbol](that) {
+    return this === that;
+  },
+  [symbol$1]() {
+    return random(this);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/**
+ * @since 2.0.0
+ */
+const TypeId = /*#__PURE__*/Symbol.for("effect/Option");
+const CommonProto = {
+  ...EffectPrototype,
+  [TypeId]: {
+    _A: _ => _
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+const SomeProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+  _tag: "Some",
+  _op: "Some",
+  [symbol](that) {
+    return isOption(that) && isSome$1(that) && equals(that.value, this.value);
+  },
+  [symbol$1]() {
+    return combine(hash(this._tag))(hash(this.value));
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag,
+      value: toJSON(this.value)
+    };
+  }
+});
+const NoneProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+  _tag: "None",
+  _op: "None",
+  [symbol](that) {
+    return isOption(that) && isNone$1(that);
+  },
+  [symbol$1]() {
+    return combine(hash(this._tag));
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag
+    };
+  }
+});
+/** @internal */
+const isOption = input => hasProperty(input, TypeId);
+/** @internal */
+const isNone$1 = fa => fa._tag === "None";
+/** @internal */
+const isSome$1 = fa => fa._tag === "Some";
+/** @internal */
+const none$1 = /*#__PURE__*/Object.create(NoneProto);
+/** @internal */
+const some$1 = value => {
+  const a = Object.create(SomeProto);
+  a.value = value;
+  return a;
+};
+
+/**
+ * Creates a new `Option` that represents the absence of a value.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const none = () => none$1;
+/**
+ * Creates a new `Option` that wraps the given value.
+ *
+ * @param value - The value to wrap.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const some = some$1;
+/**
+ * Determine if a `Option` is a `None`.
+ *
+ * @param self - The `Option` to check.
+ *
+ * @example
+ * import { some, none, isNone } from 'effect/Option'
+ *
+ * assert.deepStrictEqual(isNone(some(1)), false)
+ * assert.deepStrictEqual(isNone(none()), true)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNone = isNone$1;
+/**
+ * Determine if a `Option` is a `Some`.
+ *
+ * @param self - The `Option` to check.
+ *
+ * @example
+ * import { some, none, isSome } from 'effect/Option'
+ *
+ * assert.deepStrictEqual(isSome(some(1)), true)
+ * assert.deepStrictEqual(isSome(none()), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isSome = isSome$1;
+/**
+ * Returns the value of the `Option` if it is `Some`, otherwise returns `onNone`
+ *
+ * @param self - The `Option` to get the value of.
+ * @param onNone - Function that returns the default value to return if the `Option` is `None`.
+ *
+ * @example
+ * import { some, none, getOrElse } from 'effect/Option'
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(pipe(some(1), getOrElse(() => 0)), 1)
+ * assert.deepStrictEqual(pipe(none(), getOrElse(() => 0)), 0)
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrElse = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);
+/**
+ * Returns the provided `Option` `that` if `self` is `None`, otherwise returns `self`.
+ *
+ * @param self - The first `Option` to be checked.
+ * @param that - The `Option` to return if `self` is `None`.
+ *
+ * @example
+ * import * as O from "effect/Option"
+ * import { pipe } from "effect/Function"
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     O.none(),
+ *     O.orElse(() => O.none())
+ *   ),
+ *   O.none()
+ * )
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     O.some('a'),
+ *     O.orElse(() => O.none())
+ *   ),
+ *   O.some('a')
+ * )
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     O.none(),
+ *     O.orElse(() => O.some('b'))
+ *   ),
+ *   O.some('b')
+ * )
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     O.some('a'),
+ *     O.orElse(() => O.some('b'))
+ *   ),
+ *   O.some('a')
+ * )
+ *
+ * @category error handling
+ * @since 2.0.0
+ */
+const orElse = /*#__PURE__*/dual(2, (self, that) => isNone(self) ? that() : self);
+/**
+ * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise
+ * returns the value wrapped in a `Some`.
+ *
+ * @param nullableValue - The nullable value to be converted to an `Option`.
+ *
+ * @example
+ * import * as O from "effect/Option"
+ *
+ * assert.deepStrictEqual(O.fromNullable(undefined), O.none())
+ * assert.deepStrictEqual(O.fromNullable(null), O.none())
+ * assert.deepStrictEqual(O.fromNullable(1), O.some(1))
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const fromNullable = nullableValue => nullableValue == null ? none() : some(nullableValue);
+/**
+ * Maps the `Some` side of an `Option` value to a new `Option` value.
+ *
+ * @param self - An `Option` to map
+ * @param f - The function to map over the value of the `Option`
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+const map = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : some(f(self.value)));
+/**
+ * Applies a function to the value of an `Option` and flattens the result, if the input is `Some`.
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : f(self.value));
+/**
+ * This is `flatMap` + `fromNullable`, useful when working with optional values.
+ *
+ * @example
+ * import { some, none, flatMapNullable } from 'effect/Option'
+ * import { pipe } from "effect/Function"
+ *
+ * interface Employee {
+ *   company?: {
+ *     address?: {
+ *       street?: {
+ *         name?: string
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     some(employee1),
+ *     flatMapNullable(employee => employee.company?.address?.street?.name),
+ *   ),
+ *   some('high street')
+ * )
+ *
+ * const employee2: Employee = { company: { address: { street: {} } } }
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     some(employee2),
+ *     flatMapNullable(employee => employee.company?.address?.street?.name),
+ *   ),
+ *   none()
+ * )
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : fromNullable(f(self.value)));
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const product = (self, that) => isSome(self) && isSome(that) ? some([self.value, that.value]) : none();
+/**
+ * Zips two `Option` values together using a provided function, returning a new `Option` of the result.
+ *
+ * @param self - The left-hand side of the zip operation
+ * @param that - The right-hand side of the zip operation
+ * @param f - The function used to combine the values of the two `Option`s
+ *
+ * @example
+ * import * as O from "effect/Option"
+ *
+ * type Complex = [real: number, imaginary: number]
+ *
+ * const complex = (real: number, imaginary: number): Complex => [real, imaginary]
+ *
+ * assert.deepStrictEqual(O.zipWith(O.none(), O.none(), complex), O.none())
+ * assert.deepStrictEqual(O.zipWith(O.some(1), O.none(), complex), O.none())
+ * assert.deepStrictEqual(O.zipWith(O.none(), O.some(1), complex), O.none())
+ * assert.deepStrictEqual(O.zipWith(O.some(1), O.some(2), complex), O.some([1, 2]))
+ *
+ * assert.deepStrictEqual(O.zipWith(O.some(1), complex)(O.some(2)), O.some([2, 1]))
+ *
+ * @category zipping
+ * @since 2.0.0
+ */
+const zipWith = /*#__PURE__*/dual(3, (self, that, f) => map(product(self, that), ([a, b]) => f(a, b)));
+/**
+ * Maps over the value of an `Option` and filters out `None`s.
+ *
+ * Useful when in addition to filtering you also want to change the type of the `Option`.
+ *
+ * @param self - The `Option` to map over.
+ * @param f - A function to apply to the value of the `Option`.
+ *
+ * @example
+ * import * as O from "effect/Option"
+ *
+ * const evenNumber = (n: number) => n % 2 === 0 ? O.some(n) : O.none()
+ *
+ * assert.deepStrictEqual(O.filterMap(O.none(), evenNumber), O.none())
+ * assert.deepStrictEqual(O.filterMap(O.some(3), evenNumber), O.none())
+ * assert.deepStrictEqual(O.filterMap(O.some(2), evenNumber), O.some(2))
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const filterMap = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : f(self.value));
+/**
+ * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`.
+ *
+ * If you need to change the type of the `Option` in addition to filtering, see `filterMap`.
+ *
+ * @param predicate - A predicate function to apply to the `Option` value.
+ * @param fb - The `Option` to filter.
+ *
+ * @example
+ * import * as O from "effect/Option"
+ *
+ * // predicate
+ * const isEven = (n: number) => n % 2 === 0
+ *
+ * assert.deepStrictEqual(O.filter(O.none(), isEven), O.none())
+ * assert.deepStrictEqual(O.filter(O.some(3), isEven), O.none())
+ * assert.deepStrictEqual(O.filter(O.some(2), isEven), O.some(2))
+ *
+ * // refinement
+ * const isNumber = (v: unknown): v is number => typeof v === "number"
+ *
+ * assert.deepStrictEqual(O.filter(O.none(), isNumber), O.none())
+ * assert.deepStrictEqual(O.filter(O.some('hello'), isNumber), O.none())
+ * assert.deepStrictEqual(O.filter(O.some(2), isNumber), O.some(2))
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const filter = /*#__PURE__*/dual(2, (self, predicate) => filterMap(self, b => predicate(b) ? some$1(b) : none$1));
+/**
+ * Transforms a `Predicate` function into a `Some` of the input value if the predicate returns `true` or `None`
+ * if the predicate returns `false`.
+ *
+ * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
+ *
+ * @example
+ * import * as O from "effect/Option"
+ *
+ * const getOption = O.liftPredicate((n: number) => n >= 0)
+ *
+ * assert.deepStrictEqual(getOption(-1), O.none())
+ * assert.deepStrictEqual(getOption(1), O.some(1))
+ *
+ * @category lifting
+ * @since 2.0.0
+ */
+const liftPredicate = predicate => b => predicate(b) ? some(b) : none();
+/**
+ * Check if a value in an `Option` type meets a certain predicate.
+ *
+ * @param self - The `Option` to check.
+ * @param predicate - The condition to check.
+ *
+ * @example
+ * import { some, none, exists } from 'effect/Option'
+ * import { pipe } from "effect/Function"
+ *
+ * const isEven = (n: number) => n % 2 === 0
+ *
+ * assert.deepStrictEqual(pipe(some(2), exists(isEven)), true)
+ * assert.deepStrictEqual(pipe(some(1), exists(isEven)), false)
+ * assert.deepStrictEqual(pipe(none(), exists(isEven)), false)
+ *
+ * @since 2.0.0
+ */
+const exists = /*#__PURE__*/dual(2, (self, refinement) => isNone(self) ? false : refinement(self.value));
+
+/**
+ * Bun currently has a bug where `setTimeout` doesn't behave correctly with a 0ms delay.
+ *
+ * @see https://github.com/oven-sh/bun/issues/3333
+ */
+/** @internal */
+typeof process === "undefined" ? false : !!process?.isBun;
+
 const RE_JSX_ANNOTATION_REGEX = /@jsx\s+(\S+)/u;
 // Does not check for reserved keywords or unicode characters
 const RE_JS_IDENTIFIER_REGEX = /^[$A-Z_a-z][\w$]*$/u;
 function getFragmentFromContext(context) {
     const settings = shared.parseSchema(shared.ESLintSettingsSchema, context.settings);
     const fragment = settings.reactOptions?.jsxPragmaFrag;
-    if (tools.Prd.isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment)) return fragment;
+    if (isString(fragment) && RE_JS_IDENTIFIER_REGEX.test(fragment)) return fragment;
     return "Fragment";
 }
 const getPragmaFromContext = memo((context)=>{
@@ -21,15 +1089,15 @@ const getPragmaFromContext = memo((context)=>{
     const pragma = settings.reactOptions?.jsxPragma;
     const { sourceCode } = context;
     const pragmaNode = sourceCode.getAllComments().find((node)=>RE_JSX_ANNOTATION_REGEX.test(node.value));
-    return tools.F.pipe(tools.O.orElse(tools.O.fromNullable(pragma), ()=>tools.F.pipe(tools.O.fromNullable(pragmaNode), tools.O.map(({ value })=>RE_JSX_ANNOTATION_REGEX.exec(value)), tools.O.flatMapNullable((matches)=>matches?.[1]?.split(".")[0]))), tools.O.flatMap(tools.O.liftPredicate((x)=>RE_JS_IDENTIFIER_REGEX.test(x))), tools.O.getOrElse(tools.F.constant("React")));
+    return pipe(orElse(fromNullable(pragma), ()=>pipe(fromNullable(pragmaNode), map(({ value })=>RE_JSX_ANNOTATION_REGEX.exec(value)), flatMapNullable((matches)=>matches?.[1]?.split(".")[0]))), flatMap(liftPredicate((x)=>RE_JS_IDENTIFIER_REGEX.test(x))), getOrElse(constant("React")));
 });
 
 const t=Symbol.for("@ts-pattern/matcher"),e=Symbol.for("@ts-pattern/isVariadic"),n="@ts-pattern/anonymous-select-key",r=t=>Boolean(t&&"object"==typeof t),i=e=>e&&!!e[t],s=(n,o,c)=>{if(i(n)){const e=n[t](),{matched:r,selections:i}=e.match(o);return r&&i&&Object.keys(i).forEach(t=>c(t,i[t])),r}if(r(n)){if(!r(o))return !1;if(Array.isArray(n)){if(!Array.isArray(o))return !1;let t=[],r=[],a=[];for(const s of n.keys()){const o=n[s];i(o)&&o[e]?a.push(o):a.length?r.push(o):t.push(o);}if(a.length){if(a.length>1)throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");if(o.length<t.length+r.length)return !1;const e=o.slice(0,t.length),n=0===r.length?[]:o.slice(-r.length),i=o.slice(t.length,0===r.length?Infinity:-r.length);return t.every((t,n)=>s(t,e[n],c))&&r.every((t,e)=>s(t,n[e],c))&&(0===a.length||s(a[0],i,c))}return n.length===o.length&&n.every((t,e)=>s(t,o[e],c))}return Object.keys(n).every(e=>{const r=n[e];return (e in o||i(a=r)&&"optional"===a[t]().matcherType)&&s(r,o[e],c);var a;})}return Object.is(o,n)},o=e=>{var n,s,a;return r(e)?i(e)?null!=(n=null==(s=(a=e[t]()).getSelectionKeys)?void 0:s.call(a))?n:[]:Array.isArray(e)?c(e,o):c(Object.values(e),o):[]},c=(t,e)=>t.reduce((t,n)=>t.concat(e(n)),[]);function a(...t){if(1===t.length){const[e]=t;return t=>s(e,t,()=>{})}if(2===t.length){const[e,n]=t;return s(e,n,()=>{})}throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`)}function u(t){return Object.assign(t,{optional:()=>l(t),and:e=>m(t,e),or:e=>y(t,e),select:e=>void 0===e?p(t):p(e,t)})}function h(t){return Object.assign((t=>Object.assign(t,{*[Symbol.iterator](){yield Object.assign(t,{[e]:!0});}}))(t),{optional:()=>h(l(t)),select:e=>h(void 0===e?p(t):p(e,t))})}function l(e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return void 0===t?(o(e).forEach(t=>r(t,void 0)),{matched:!0,selections:n}):{matched:s(e,t,r),selections:n}},getSelectionKeys:()=>o(e),matcherType:"optional"})})}const f=(t,e)=>{for(const n of t)if(!e(n))return !1;return !0},g=(t,e)=>{for(const[n,r]of t.entries())if(!e(r,n))return !1;return !0};function m(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return {matched:e.every(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"and"})})}function y(...e){return u({[t]:()=>({match:t=>{let n={};const r=(t,e)=>{n[t]=e;};return c(e,o).forEach(t=>r(t,void 0)),{matched:e.some(e=>s(e,t,r)),selections:n}},getSelectionKeys:()=>c(e,o),matcherType:"or"})})}function d(e){return {[t]:()=>({match:t=>({matched:Boolean(e(t))})})}}function p(...e){const r="string"==typeof e[0]?e[0]:void 0,i=2===e.length?e[1]:"string"==typeof e[0]?void 0:e[0];return u({[t]:()=>({match:t=>{let e={[null!=r?r:n]:t};return {matched:void 0===i||s(i,t,(t,n)=>{e[t]=n;}),selections:e}},getSelectionKeys:()=>[null!=r?r:n].concat(void 0===i?[]:o(i))})})}function v(t){return "number"==typeof t}function b(t){return "string"==typeof t}function w(t){return "bigint"==typeof t}const S=u(d(function(t){return !0})),O=S,j=t=>Object.assign(u(t),{startsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.startsWith(n)))));var n;},endsWith:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.endsWith(n)))));var n;},minLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length>=t))(e))),maxLength:e=>j(m(t,(t=>d(e=>b(e)&&e.length<=t))(e))),includes:e=>{return j(m(t,(n=e,d(t=>b(t)&&t.includes(n)))));var n;},regex:e=>{return j(m(t,(n=e,d(t=>b(t)&&Boolean(t.match(n))))));var n;}}),E=j(d(b)),K=t=>Object.assign(u(t),{between:(e,n)=>K(m(t,((t,e)=>d(n=>v(n)&&t<=n&&e>=n))(e,n))),lt:e=>K(m(t,(t=>d(e=>v(e)&&e<t))(e))),gt:e=>K(m(t,(t=>d(e=>v(e)&&e>t))(e))),lte:e=>K(m(t,(t=>d(e=>v(e)&&e<=t))(e))),gte:e=>K(m(t,(t=>d(e=>v(e)&&e>=t))(e))),int:()=>K(m(t,d(t=>v(t)&&Number.isInteger(t)))),finite:()=>K(m(t,d(t=>v(t)&&Number.isFinite(t)))),positive:()=>K(m(t,d(t=>v(t)&&t>0))),negative:()=>K(m(t,d(t=>v(t)&&t<0)))}),A=K(d(v)),x=t=>Object.assign(u(t),{between:(e,n)=>x(m(t,((t,e)=>d(n=>w(n)&&t<=n&&e>=n))(e,n))),lt:e=>x(m(t,(t=>d(e=>w(e)&&e<t))(e))),gt:e=>x(m(t,(t=>d(e=>w(e)&&e>t))(e))),lte:e=>x(m(t,(t=>d(e=>w(e)&&e<=t))(e))),gte:e=>x(m(t,(t=>d(e=>w(e)&&e>=t))(e))),positive:()=>x(m(t,d(t=>w(t)&&t>0))),negative:()=>x(m(t,d(t=>w(t)&&t<0)))}),P=x(d(w)),T=u(d(function(t){return "boolean"==typeof t})),k=u(d(function(t){return "symbol"==typeof t})),B=u(d(function(t){return null==t}));var _={__proto__:null,matcher:t,optional:l,array:function(...e){return h({[t]:()=>({match:t=>{if(!Array.isArray(t))return {matched:!1};if(0===e.length)return {matched:!0};const n=e[0];let r={};if(0===t.length)return o(n).forEach(t=>{r[t]=[];}),{matched:!0,selections:r};const i=(t,e)=>{r[t]=(r[t]||[]).concat([e]);};return {matched:t.every(t=>s(n,t,i)),selections:r}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},set:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Set))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};if(0===e.length)return {matched:!0};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);},i=e[0];return {matched:f(t,t=>s(i,t,r)),selections:n}},getSelectionKeys:()=>0===e.length?[]:o(e[0])})})},map:function(...e){return u({[t]:()=>({match:t=>{if(!(t instanceof Map))return {matched:!1};let n={};if(0===t.size)return {matched:!0,selections:n};const r=(t,e)=>{n[t]=(n[t]||[]).concat([e]);};if(0===e.length)return {matched:!0};var i;if(1===e.length)throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null==(i=e[0])?void 0:i.toString()}`);const[o,c]=e;return {matched:g(t,(t,e)=>{const n=s(o,e,r),i=s(c,t,r);return n&&i}),selections:n}},getSelectionKeys:()=>0===e.length?[]:[...o(e[0]),...o(e[1])]})})},intersection:m,union:y,not:function(e){return u({[t]:()=>({match:t=>({matched:!s(e,t,()=>{})}),getSelectionKeys:()=>[],matcherType:"not"})})},when:d,select:p,any:S,_:O,string:E,number:A,bigint:P,boolean:T,symbol:k,nullish:B,instanceOf:function(t){return u(d(function(t){return e=>e instanceof t}(t)))},shape:function(t){return u(d(a(t)))}};const W={matched:!1,value:void 0};function N(t){return new $(t,W)}class ${constructor(t,e){this.input=void 0,this.state=void 0,this.input=t,this.state=e;}with(...t){if(this.state.matched)return this;const e=t[t.length-1],r=[t[0]];let i;3===t.length&&"function"==typeof t[1]?i=t[1]:t.length>2&&r.push(...t.slice(1,t.length-1));let o=!1,c={};const a=(t,e)=>{o=!0,c[t]=e;},u=!r.some(t=>s(t,this.input,a))||i&&!Boolean(i(this.input))?W:{matched:!0,value:e(o?n in c?c[n]:c:this.input,this.input)};return new $(this.input,u)}when(t,e){if(this.state.matched)return this;const n=Boolean(t(this.input));return new $(this.input,n?{matched:!0,value:e(this.input,this.input)}:W)}otherwise(t){return this.state.matched?this.state.value:t(this.input)}exhaustive(){if(this.state.matched)return this.state.value;let t;try{t=JSON.stringify(this.input);}catch(e){t=this.input;}throw new Error(`Pattern matching error: no pattern matches value ${t}`)}run(){return this.exhaustive()}returnType(){return this}}
 
 function isInitializedFromPragma(variableName, context, initialScope, pragma = getPragmaFromContext(context)) {
     const maybeVariable = _var.findVariable(variableName, initialScope);
-    const maybeLatestDef = tools.O.flatMapNullable(maybeVariable, (variable)=>variable.defs.at(-1));
-    if (tools.O.isNone(maybeLatestDef)) return false;
+    const maybeLatestDef = flatMapNullable(maybeVariable, (variable)=>variable.defs.at(-1));
+    if (isNone(maybeLatestDef)) return false;
     const latestDef = maybeLatestDef.value;
     const { node, parent } = latestDef;
     if (node.type === ast.NodeType.VariableDeclarator && node.init) {
@@ -54,7 +1122,7 @@ function isInitializedFromPragma(variableName, context, initialScope, pragma = g
                 type: ast.NodeType.Identifier,
                 name: "require"
             }
-        }, (exp)=>tools.O.some(exp)).with({
+        }, (exp)=>some(exp)).with({
             type: ast.NodeType.MemberExpression,
             object: {
                 type: ast.NodeType.CallExpression,
@@ -63,8 +1131,8 @@ function isInitializedFromPragma(variableName, context, initialScope, pragma = g
                     name: "require"
                 }
             }
-        }, ({ object })=>tools.O.some(object)).otherwise(tools.O.none);
-        if (tools.O.isNone(maybeRequireExpression)) return false;
+        }, ({ object })=>some(object)).otherwise(none);
+        if (isNone(maybeRequireExpression)) return false;
         const requireExpression = maybeRequireExpression.value;
         const [firstArg] = requireExpression.arguments;
         if (firstArg?.type !== ast.NodeType.Literal) return false;
@@ -188,10 +1256,10 @@ function resolveMemberExpressions(object, property) {
  * @param context The rule context
  * @returns `true` if the node is inside createElement's props
  */ function isInsideCreateElementProps(node, context) {
-    return tools.F.pipe(ast.traverseUp(node, (n)=>ast.is(ast.NodeType.CallExpression)(n) && isCreateElementCall(n, context)), tools.O.filter(ast.is(ast.NodeType.CallExpression)), tools.O.flatMapNullable((c)=>c.arguments.at(1)), tools.O.filter(ast.is(ast.NodeType.ObjectExpression)), tools.O.zipWith(ast.traverseUp(node, ast.is(ast.NodeType.ObjectExpression)), (a, b)=>a === b), tools.O.getOrElse(tools.F.constFalse));
+    return pipe(ast.traverseUp(node, (n)=>ast.is(ast.NodeType.CallExpression)(n) && isCreateElementCall(n, context)), filter(ast.is(ast.NodeType.CallExpression)), flatMapNullable((c)=>c.arguments.at(1)), filter(ast.is(ast.NodeType.ObjectExpression)), zipWith(ast.traverseUp(node, ast.is(ast.NodeType.ObjectExpression)), (a, b)=>a === b), getOrElse(constFalse));
 }
 function isChildrenOfCreateElement(node, context) {
-    return tools.F.pipe(tools.O.fromNullable(node.parent), tools.O.filter(ast.is(ast.NodeType.CallExpression)), tools.O.filter((n)=>isCreateElementCall(n, context)), tools.O.exists((n)=>n.arguments.slice(2).some((arg)=>arg === node)));
+    return pipe(fromNullable(node.parent), filter(ast.is(ast.NodeType.CallExpression)), filter((n)=>isCreateElementCall(n, context)), exists((n)=>n.arguments.slice(2).some((arg)=>arg === node)));
 }
 /**
  * Check if a `JSXElement` or `JSXFragment` has children
@@ -199,7 +1267,7 @@ function isChildrenOfCreateElement(node, context) {
  * @param predicate A predicate to filter the children
  * @returns `true` if the node has children
  */ function hasChildren(node, predicate) {
-    if (tools.Prd.isFunction(predicate)) return node.children.some(predicate);
+    if (isFunction(predicate)) return node.children.some(predicate);
     return node.children.length > 0;
 }
 /**
@@ -283,16 +1351,16 @@ const isFragment = (node, pragma, fragment)=>{
     if (!node) return false;
     return N(node).with({
         type: ast.NodeType.JSXElement
-    }, tools.F.constTrue).with({
+    }, constTrue).with({
         type: ast.NodeType.JSXFragment
-    }, tools.F.constTrue).with({
+    }, constTrue).with({
         type: ast.NodeType.JSXMemberExpression
-    }, tools.F.constTrue).with({
+    }, constTrue).with({
         type: ast.NodeType.JSXNamespacedName
-    }, tools.F.constTrue).with({
+    }, constTrue).with({
         type: ast.NodeType.Literal
     }, (node)=>{
-        return N(node.value).with(null, ()=>!(hint & JSXValueHint.SkipNullLiteral)).with(_.boolean, ()=>!(hint & JSXValueHint.SkipBooleanLiteral)).with(_.string, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with(_.number, ()=>!(hint & JSXValueHint.SkipNumberLiteral)).otherwise(tools.F.constFalse);
+        return N(node.value).with(null, ()=>!(hint & JSXValueHint.SkipNullLiteral)).with(_.boolean, ()=>!(hint & JSXValueHint.SkipBooleanLiteral)).with(_.string, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with(_.number, ()=>!(hint & JSXValueHint.SkipNumberLiteral)).otherwise(constFalse);
     }).with({
         type: ast.NodeType.TemplateLiteral
     }, ()=>!(hint & JSXValueHint.SkipStringLiteral)).with({
@@ -341,8 +1409,8 @@ const isFragment = (node, pragma, fragment)=>{
         if (ast.isJSXTagNameExpression(node)) return true;
         const initialScope = context.sourceCode.getScope?.(node) ?? context.getScope();
         const maybeVariable = _var.findVariable(name, initialScope);
-        return tools.F.pipe(maybeVariable, tools.O.flatMap(_var.getVariableInit(0)), tools.O.exists((n)=>isJSXValue(n, context, hint)));
-    }).otherwise(tools.F.constFalse);
+        return pipe(maybeVariable, flatMap(_var.getVariableInit(0)), exists((n)=>isJSXValue(n, context, hint)));
+    }).otherwise(constFalse);
 }
 
 /**
@@ -379,13 +1447,13 @@ function getProp(props, propName, context, initialScope) {
     const initialScope = context.sourceCode.getScope?.(attribute) ?? context.getScope();
     if (attribute.type === ast.NodeType.JSXAttribute && "value" in attribute) {
         const { value } = attribute;
-        if (value === null) return tools.O.none();
-        if (value.type === ast.NodeType.Literal) return tools.O.some(getStaticValue(value, initialScope));
-        if (value.type === ast.NodeType.JSXExpressionContainer) return tools.O.some(getStaticValue(value.expression, initialScope));
-        return tools.O.none();
+        if (value === null) return none();
+        if (value.type === ast.NodeType.Literal) return some(getStaticValue(value, initialScope));
+        if (value.type === ast.NodeType.JSXExpressionContainer) return some(getStaticValue(value.expression, initialScope));
+        return none();
     }
     const { argument } = attribute;
-    return tools.O.some(getStaticValue(argument, initialScope));
+    return some(getStaticValue(argument, initialScope));
 }
 /**
  * @param properties The properties to search in
@@ -399,32 +1467,32 @@ function getProp(props, propName, context, initialScope) {
    * @param propName The name of the property to search for
    * @returns The property if found
    */ return (propName)=>{
-        return tools.O.fromNullable(properties.find((prop)=>{
+        return fromNullable(properties.find((prop)=>{
             return N(prop).when(ast.is(ast.NodeType.Property), (prop)=>{
                 return "name" in prop.key && prop.key.name === propName;
             }).when(ast.is(ast.NodeType.SpreadElement), (prop)=>{
                 return N(prop.argument).when(ast.is(ast.NodeType.Identifier), (argument)=>{
                     const { name } = argument;
-                    const maybeInit = tools.O.flatMap(_var.findVariable(name, initialScope), _var.getVariableInit(0));
-                    if (tools.O.isNone(maybeInit)) return false;
+                    const maybeInit = flatMap(_var.findVariable(name, initialScope), _var.getVariableInit(0));
+                    if (isNone(maybeInit)) return false;
                     const init = maybeInit.value;
                     if (init.type !== ast.NodeType.ObjectExpression) return false;
                     if (seenProps.includes(name)) return false;
-                    return tools.O.isSome(findPropInProperties(init.properties, context, initialScope, [
+                    return isSome(findPropInProperties(init.properties, context, initialScope, [
                         ...seenProps,
                         name
                     ])(propName));
                 }).when(ast.is(ast.NodeType.ObjectExpression), (argument)=>{
-                    return tools.O.isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
+                    return isSome(findPropInProperties(argument.properties, context, initialScope, seenProps)(propName));
                 }).when(ast.is(ast.NodeType.MemberExpression), ()=>{
                 // Not implemented
                 }).when(ast.is(ast.NodeType.CallExpression), ()=>{
                 // Not implemented
-                }).otherwise(tools.F.constFalse);
+                }).otherwise(constFalse);
             }).when(ast.is(ast.NodeType.RestElement), ()=>{
                 // Not implemented
                 return false;
-            }).otherwise(tools.F.constFalse);
+            }).otherwise(constFalse);
         }));
     };
 }
@@ -439,27 +1507,27 @@ function getProp(props, propName, context, initialScope) {
    * @param propName The name of the property to search for
    * @returns The property if found
    */ return (propName)=>{
-        return tools.O.fromNullable(attributes.find((attr)=>{
+        return fromNullable(attributes.find((attr)=>{
             return N(attr).when(ast.is(ast.NodeType.JSXAttribute), (attr)=>getPropName(attr) === propName).when(ast.is(ast.NodeType.JSXSpreadAttribute), (attr)=>{
                 return N(attr.argument).with({
                     type: ast.NodeType.Identifier
                 }, (argument)=>{
                     const { name } = argument;
-                    const maybeInit = tools.O.flatMap(_var.findVariable(name, initialScope), _var.getVariableInit(0));
-                    if (tools.O.isNone(maybeInit)) return false;
+                    const maybeInit = flatMap(_var.findVariable(name, initialScope), _var.getVariableInit(0));
+                    if (isNone(maybeInit)) return false;
                     const init = maybeInit.value;
                     if (!("properties" in init)) return false;
-                    return tools.O.isSome(findPropInProperties(init.properties, context, initialScope)(propName));
+                    return isSome(findPropInProperties(init.properties, context, initialScope)(propName));
                 }).when(ast.is(ast.NodeType.ObjectExpression), (argument)=>{
-                    return tools.O.isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
+                    return isSome(findPropInProperties(argument.properties, context, initialScope)(propName));
                 }).when(ast.is(ast.NodeType.MemberExpression), ()=>{
                     // Not implemented
                     return false;
                 }).when(ast.is(ast.NodeType.CallExpression), ()=>{
                     // Not implemented
                     return false;
-                }).otherwise(tools.F.constFalse);
-            }).otherwise(tools.F.constFalse);
+                }).otherwise(constFalse);
+            }).otherwise(constFalse);
         }));
     };
 }
@@ -472,7 +1540,7 @@ function getProp(props, propName, context, initialScope) {
  * @param initialScope
  * @returns `true` if the given prop name is present in the given properties
  */ function hasProp(attributes, propName, context, initialScope) {
-    return tools.O.isSome(findPropInAttributes(attributes, context, initialScope)(propName));
+    return isSome(findPropInAttributes(attributes, context, initialScope)(propName));
 }
 /**
  * Check if any of the given prop names are present in the given attributes
@@ -500,7 +1568,7 @@ function getProp(props, propName, context, initialScope) {
  * @param node The AST node to start traversing from
  * @param predicate The predicate to check each node
  * @returns prop node if found
- */ function traverseUpProp(node, predicate = tools.F.constTrue) {
+ */ function traverseUpProp(node, predicate = constTrue) {
     const guard = (node)=>{
         return node.type === ast.NodeType.JSXAttribute && predicate(node);
     };
@@ -513,7 +1581,7 @@ function getProp(props, propName, context, initialScope) {
  * @returns `true` if the node is inside a prop's value
  */ function isInsidePropValue(node) {
     if (ast.isStringLiteral(node)) return node.parent.type === ast.NodeType.JSXAttribute;
-    return tools.O.isSome(traverseUpProp(node, (n)=>n.value?.type === ast.NodeType.JSXExpressionContainer));
+    return isSome(traverseUpProp(node, (n)=>n.value?.type === ast.NodeType.JSXExpressionContainer));
 }
 
 /**
@@ -529,7 +1597,7 @@ function getProp(props, propName, context, initialScope) {
  * @param node The AST node to check
  * @returns boolean `true` if the node is whitespace
  */ function isWhiteSpace(node) {
-    return tools.Prd.isString(node.value) && node.value.trim() === "";
+    return isString(node.value) && node.value.trim() === "";
 }
 /**
  * Check if a Literal or JSXText node is a line break