@nunofyobiz/effect-extras 0.0.1

package/dist/index.js

@@ -0,0 +1,1006 @@
+import { pipe, Record, Option, Array, Data, Duration, DateTime, Match, Effect, Function, Schema, Predicate, Number as Number$1, SchemaGetter, Struct, Result, BigInt as BigInt$1, Cause, String as String$1 } from 'effect';
+import { dual, identity, pipe as pipe$1, constUndefined } from 'effect/Function';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ArrayX/ArrayX.ts
+var ArrayX_exports = {};
+__export(ArrayX_exports, {
+  categorize: () => categorize,
+  chunkBy: () => chunkBy,
+  compactNullable: () => compactNullable,
+  filterHead: () => filterHead,
+  filterMapNullable: () => filterMapNullable,
+  filterTail: () => filterTail,
+  findFirstWithIndex2d: () => findFirstWithIndex2d,
+  insertUniq: () => insertUniq,
+  mapRightAccum: () => mapRightAccum,
+  maxOption: () => maxOption,
+  slice: () => slice,
+  takeFirstWhere: () => takeFirstWhere2,
+  takeLastWhere: () => takeLastWhere2,
+  zipWithThese: () => zipWithThese
+});
+
+// src/RecordX/RecordX.ts
+var RecordX_exports = {};
+__export(RecordX_exports, {
+  collectBy: () => collectBy,
+  getOrThrow: () => getOrThrow,
+  getOrThrowWith: () => getOrThrowWith,
+  isNonEmptyRecord: () => isNonEmptyRecord,
+  keysAs: () => keysAs,
+  modifyIfExists: () => modifyIfExists,
+  takeFirstWhere: () => takeFirstWhere,
+  takeLast: () => takeLast,
+  takeLastWhere: () => takeLastWhere,
+  upsert: () => upsert
+});
+var isNonEmptyRecord = (record) => pipe(record, Predicate.not(Record.isEmptyRecord));
+var modifyIfExists = dual(
+  3,
+  (self, key, f) => pipe(
+    Record.modify(self, key, f),
+    Option.getOrElse(() => self)
+  )
+);
+var takeFirstWhere = dual(
+  3,
+  (record, predicate, order) => ArrayX_exports.takeFirstWhere(Record.values(record), predicate, order)
+);
+var takeLastWhere = dual(
+  3,
+  (record, predicate, order) => ArrayX_exports.takeLastWhere(Record.values(record), predicate, order)
+);
+var takeLast = dual(
+  2,
+  (record, order) => pipe(Record.values(record), Array.sort(order), Array.last)
+);
+var keysAs = () => (record) => record;
+var getOrThrow = dual(
+  2,
+  (record, key) => getOrThrowWith(
+    record,
+    key,
+    (key2) => new Error(
+      `Key ${String(key2)} not found in record
+Existing keys=${String(Record.keys(record))}`
+    )
+  )
+);
+var getOrThrowWith = dual(
+  3,
+  (record, key, onNone) => Record.get(record, key).pipe(Option.getOrThrowWith(() => onNone(key)))
+);
+var upsert = dual(
+  3,
+  (record, key, upsert2) => {
+    const existingValue = Record.get(record, key);
+    const updatedValue = upsert2(existingValue);
+    return Record.set(record, key, updatedValue);
+  }
+);
+var collectBy = dual(
+  2,
+  (values, identify) => Array.reduce(
+    values,
+    {},
+    (accumulator, value) => Record.set(accumulator, identify(value), value)
+  )
+);
+
+// src/These/These.ts
+var These_exports = {};
+__export(These_exports, {
+  LeftAndRight: () => LeftAndRight,
+  LeftOnly: () => LeftOnly,
+  RightOnly: () => RightOnly,
+  WithLeft: () => WithLeft,
+  WithRight: () => WithRight,
+  flatMapLeft: () => flatMapLeft,
+  flatMapLeftEffect: () => flatMapLeftEffect,
+  flatMapRight: () => flatMapRight,
+  flatMapRightEffect: () => flatMapRightEffect,
+  fromNullables: () => fromNullables,
+  is: () => is,
+  leftOption: () => leftOption,
+  leftOrElse: () => leftOrElse,
+  leftOrUndefined: () => leftOrUndefined,
+  mapBoth: () => mapBoth,
+  mapBothEffect: () => mapBothEffect,
+  mapLeft: () => mapLeft,
+  mapLeftEffect: () => mapLeftEffect,
+  mapRight: () => mapRight,
+  mapRightEffect: () => mapRightEffect,
+  match: () => match,
+  matchLeft: () => matchLeft,
+  matchRight: () => matchRight,
+  optionFromNullables: () => optionFromNullables,
+  orElse: () => orElse,
+  orUndefined: () => orUndefined,
+  rightOption: () => rightOption,
+  rightOrElse: () => rightOrElse,
+  rightOrUndefined: () => rightOrUndefined
+});
+var taggedEnum = Data.taggedEnum();
+var LeftOnly = taggedEnum.LeftOnly;
+var RightOnly = taggedEnum.RightOnly;
+var LeftAndRight = taggedEnum.LeftAndRight;
+var is = taggedEnum.$is;
+var match = taggedEnum.$match;
+var WithLeft = ({
+  left,
+  right
+}) => Predicate.isNotNullish(right) ? LeftAndRight({ left, right }) : LeftOnly({ left });
+var WithRight = ({
+  left,
+  right
+}) => Predicate.isNotNullish(left) ? LeftAndRight({ left, right }) : RightOnly({ right });
+var optionFromNullables = ({
+  left,
+  right
+}) => {
+  if (Predicate.isNotNullish(left) && Predicate.isNotNullish(right)) {
+    return Option.some(LeftAndRight({ left, right }));
+  }
+  if (Predicate.isNotNullish(left)) {
+    return Option.some(LeftOnly({ left }));
+  }
+  if (Predicate.isNotNullish(right)) {
+    return Option.some(RightOnly({ right }));
+  }
+  return Option.none();
+};
+var fromNullables = ({
+  left,
+  right,
+  orElse: orElse2 = () => {
+    throw new Error("Both left and right are nullable");
+  }
+}) => pipe(optionFromNullables({ left, right }), Option.getOrElse(orElse2));
+var matchLeft = ({
+  Left,
+  RightOnly: RightOnly2
+}) => (these) => pipe(
+  these,
+  match({
+    LeftOnly: ({ left }) => Left(left),
+    RightOnly: ({ right }) => RightOnly2(right),
+    LeftAndRight: ({ left }) => Left(left)
+  }),
+  // Make Typescript happy
+  (a) => a
+);
+var matchRight = ({
+  LeftOnly: LeftOnly2,
+  Right
+}) => (these) => pipe(
+  these,
+  match({
+    LeftOnly: ({ left }) => LeftOnly2(left),
+    RightOnly: ({ right }) => Right(right),
+    LeftAndRight: ({ right }) => Right(right)
+  }),
+  // Make Typescript happy
+  (a) => a
+);
+var orElse = ({
+  orElseLeft,
+  orElseRight
+}) => match({
+  LeftOnly: ({ left }) => LeftAndRight({ left, right: orElseRight() }),
+  RightOnly: ({ right }) => LeftAndRight({ left: orElseLeft(), right }),
+  LeftAndRight: ({ left, right }) => LeftAndRight({ left, right })
+});
+var orUndefined = orElse({
+  orElseLeft: () => void 0,
+  orElseRight: () => void 0
+});
+var leftOrElse = (orElseReturn) => (these) => pipe(
+  these,
+  orElse({
+    orElseLeft: orElseReturn,
+    orElseRight: constUndefined
+  }),
+  Struct.get("left")
+);
+var leftOrUndefined = leftOrElse(() => void 0);
+var rightOrElse = (orElseReturn) => (these) => pipe(
+  these,
+  orElse({
+    orElseLeft: constUndefined,
+    orElseRight: orElseReturn
+  }),
+  Struct.get("right")
+);
+var rightOrUndefined = rightOrElse(() => void 0);
+var rightOption = (these) => pipe(
+  these,
+  matchRight({
+    LeftOnly: () => Option.none(),
+    Right: Option.some
+  })
+);
+var leftOption = (these) => pipe(
+  these,
+  matchLeft({
+    Left: Option.some,
+    RightOnly: () => Option.none()
+  })
+);
+var mapBoth = ({
+  mapLeft: mapLeft2,
+  mapRight: mapRight2
+}) => match({
+  LeftOnly: ({ left }) => LeftOnly({ left: mapLeft2(left) }),
+  RightOnly: ({ right }) => RightOnly({ right: mapRight2(right) }),
+  LeftAndRight: ({ left, right }) => LeftAndRight({ left: mapLeft2(left), right: mapRight2(right) })
+});
+var mapBothEffect = ({
+  mapLeft: mapLeft2,
+  mapRight: mapRight2
+}) => match({
+  LeftOnly: ({ left }) => pipe(
+    mapLeft2(left),
+    Effect.map((left2) => LeftOnly({ left: left2 }))
+  ),
+  RightOnly: ({ right }) => pipe(
+    mapRight2(right),
+    Effect.map((right2) => RightOnly({ right: right2 }))
+  ),
+  LeftAndRight: ({ left, right }) => pipe(
+    Effect.all({ left: mapLeft2(left), right: mapRight2(right) }),
+    Effect.map(
+      ({ left: left2, right: right2 }) => LeftAndRight({ left: left2, right: right2 })
+    )
+  )
+});
+var mapLeft = (mapLeft2) => mapBoth({ mapLeft: mapLeft2, mapRight: identity });
+var flatMapLeft = (mapLeft2) => match({
+  LeftOnly: ({ left }) => mapLeft2(left),
+  RightOnly: ({ right }) => RightOnly({ right }),
+  LeftAndRight: ({ left }) => mapLeft2(left)
+});
+var mapLeftEffect = (mapLeft2) => mapBothEffect({ mapLeft: mapLeft2, mapRight: Effect.succeed });
+var flatMapLeftEffect = (mapLeft2) => match({
+  LeftOnly: ({ left }) => mapLeft2(left),
+  RightOnly: ({ right }) => Effect.succeed(RightOnly({ right })),
+  LeftAndRight: ({ left }) => mapLeft2(left)
+});
+var mapRight = (mapRight2) => mapBoth({ mapLeft: identity, mapRight: mapRight2 });
+var flatMapRight = (mapRight2) => match({
+  LeftOnly: ({ left }) => LeftOnly({ left }),
+  RightOnly: ({ right }) => mapRight2(right),
+  LeftAndRight: ({ right }) => mapRight2(right)
+});
+var mapRightEffect = (mapRight2) => mapBothEffect({ mapLeft: Effect.succeed, mapRight: mapRight2 });
+var flatMapRightEffect = (mapRight2) => match({
+  LeftOnly: ({ left }) => Effect.succeed(LeftOnly({ left })),
+  RightOnly: ({ right }) => mapRight2(right),
+  LeftAndRight: ({ right }) => mapRight2(right)
+});
+
+// src/ResultX/ResultX.ts
+var ResultX_exports = {};
+__export(ResultX_exports, {
+  fromOption: () => fromOption
+});
+var fromOption = (option) => Option.isSome(option) ? Result.succeed(option.value) : Result.failVoid;
+
+// src/ArrayX/ArrayX.ts
+var slice = dual(
+  3,
+  (array, start, end) => array.slice(start, end)
+);
+var zipWithThese = dual(
+  3,
+  (array1, array2, f) => {
+    const newLength = Math.max(array1.length, array2.length);
+    if (newLength === 0) {
+      return [];
+    }
+    return Array.makeBy(newLength, (index) => {
+      if (index < array1.length && index < array2.length) {
+        return f(
+          These_exports.LeftAndRight({
+            left: array1[index],
+            right: array2[index]
+          })
+        );
+      }
+      if (index < array1.length) {
+        return f(
+          These_exports.LeftOnly({
+            left: array1[index]
+          })
+        );
+      }
+      if (index < array2.length) {
+        return f(
+          These_exports.RightOnly({
+            right: array2[index]
+          })
+        );
+      }
+      throw new Error(`Index ${index} is out of bounds for array1 and array2`);
+    });
+  }
+);
+var moveUniqWith = dual(
+  2,
+  (inputArray, {
+    identify,
+    sourceId,
+    moveToBeLeftOfId
+  }) => {
+    const array = [...inputArray];
+    const sourceIndex = array.findIndex((item) => identify(item) === sourceId);
+    if (sourceIndex < 0) {
+      return array;
+    }
+    const sourceItem = array[sourceIndex];
+    const arrayWithoutSource = array.filter(
+      (item) => identify(item) !== sourceId
+    );
+    if (moveToBeLeftOfId === null) {
+      return [...arrayWithoutSource, sourceItem];
+    }
+    const destinationIndex = arrayWithoutSource.findIndex(
+      (item) => identify(item) === moveToBeLeftOfId
+    );
+    if (destinationIndex < 0) {
+      return array;
+    }
+    return [
+      ...slice(arrayWithoutSource, 0, destinationIndex),
+      sourceItem,
+      ...slice(arrayWithoutSource, destinationIndex, arrayWithoutSource.length)
+    ];
+  }
+);
+var insertUniq = dual(
+  2,
+  (array, { item, insertToBeLeftOf }) => {
+    const arrayWithNewItem = pipe(
+      array,
+      Array.filter((existingItem) => existingItem !== item),
+      Array.append(item)
+    );
+    return moveUniqWith(arrayWithNewItem, {
+      identify: identity,
+      sourceId: item,
+      moveToBeLeftOfId: insertToBeLeftOf
+    });
+  }
+);
+var mapRightAccum = dual(
+  3,
+  (array, initialAccumulator, f) => {
+    const [accumulator, result] = pipe(
+      array,
+      Array.reverse,
+      Array.mapAccum(initialAccumulator, f)
+    );
+    return [accumulator, Array.reverse(result)];
+  }
+);
+var maxOption = dual(
+  2,
+  (array, order) => pipe(
+    // If the array is empty, there is no max
+    array,
+    Option.liftPredicate(Array.isArrayNonEmpty),
+    // If it is non-empty, get the max
+    Option.map(Array.max(order))
+  )
+);
+var takeFirstOrLastWhere = dual(
+  3,
+  (array, predicate, takeOne) => pipe(
+    // Keep only the items that match
+    array,
+    Array.filter(predicate),
+    // If there is anything left, take one
+    Option.liftPredicate(Array.isArrayNonEmpty),
+    Option.map(takeOne)
+  )
+);
+var takeFirstWhere2 = dual(
+  3,
+  (array, predicate, order) => takeFirstOrLastWhere(array, predicate, Array.min(order))
+);
+var takeLastWhere2 = dual(
+  3,
+  (array, predicate, order) => takeFirstOrLastWhere(array, predicate, Array.max(order))
+);
+var categorize = (items, categorize2) => Array.reduce(
+  items,
+  // Start with an empty record of categorized items. `Record.empty()`
+  // returns a `NonLiteralKey<C>`-keyed record, which is structurally
+  // equivalent to `Partial<Record<C, A[]>>`; the cast tells TypeScript
+  // we'll be writing typed keys back via the reducer below.
+  Record.empty(),
+  // For each item, add it to the appropriate category
+  (categorizedItems, item) => RecordX_exports.upsert(
+    categorizedItems,
+    categorize2(item),
+    // This is the next item's category
+    Option.match({
+      // This is the first item in this category, so create a new array
+      onNone: () => Array.of(item),
+      // Append the item to the existing array
+      onSome: Array.append(item)
+    })
+  )
+);
+var compactNullable = (array) => Array.filter(array, Predicate.isNotNullish);
+var filterHead = dual(2, (array, predicate) => {
+  const firstMatchingIndex = Array.findFirstIndex(array, predicate);
+  return Option.match(firstMatchingIndex, {
+    onSome: (index) => slice(array, index, array.length),
+    onNone: () => []
+  });
+});
+var filterTail = dual(2, (array, predicate) => {
+  const lastMatchingIndex = Array.findLastIndex(array, predicate);
+  return Option.match(lastMatchingIndex, {
+    onSome: (index) => slice(array, 0, index + 1),
+    onNone: () => []
+  });
+});
+var filterMapNullable = dual(
+  2,
+  (array, f) => pipe(
+    array,
+    Array.filterMap(
+      (value) => pipe(f(value), Option.fromNullishOr, ResultX_exports.fromOption)
+    )
+  )
+);
+var findFirstWithIndex2d = dual(
+  2,
+  (array, predicate) => Array.findFirstWithIndex(
+    array,
+    (row) => Array.findFirstWithIndex(row, predicate)
+  ).pipe(
+    Option.map(([[value, secondIndex], firstIndex]) => [
+      value,
+      firstIndex,
+      secondIndex
+    ])
+  )
+);
+var chunkBy = dual(
+  3,
+  (array, chunk, chunkEquals) => {
+    if (array.length === 0) {
+      return [];
+    }
+    const result = [];
+    for (const item of array) {
+      const groupValue = chunk(item);
+      if (result.length > 0) {
+        const lastGroup = result.at(-1);
+        if (lastGroup && chunkEquals(lastGroup.group, groupValue)) {
+          lastGroup.values.push(item);
+          continue;
+        }
+      }
+      result.push({ group: groupValue, values: Array.of(item) });
+    }
+    return result;
+  }
+);
+
+// src/BigIntX/BigIntX.ts
+var BigIntX_exports = {};
+__export(BigIntX_exports, {
+  toNumberOrThrow: () => toNumberOrThrow
+});
+var toNumberOrThrow = (value) => BigInt$1.toNumber(value).pipe(
+  Option.getOrThrowWith(
+    () => new Error(`Value ${value} is outside safe integer range`)
+  )
+);
+
+// src/BooleanX/BooleanX.ts
+var BooleanX_exports = {};
+__export(BooleanX_exports, {
+  toBinary: () => toBinary
+});
+var toBinary = (value) => value ? 1 : 0;
+
+// src/DurationX/DurationX.ts
+var DurationX_exports = {};
+__export(DurationX_exports, {
+  diff: () => diff,
+  mapAsUnit: () => mapAsUnit
+});
+var MICROS_PER_MILLI = 1e3;
+var diff = dual(
+  2,
+  (self, that) => Duration.millis(
+    // Clamp at 0 — "diff" represents elapsed time since `that`; if `that`
+    // is in the future relative to `self`, the elapsed time is zero
+    // (not negative).
+    Math.max(0, DateTime.toEpochMillis(self) - DateTime.toEpochMillis(that))
+  )
+);
+var toUnit = dual(
+  2,
+  (duration, unit) => Match.value(unit).pipe(
+    Match.whenOr("week", "weeks", () => Duration.toWeeks(duration)),
+    Match.whenOr("day", "days", () => Duration.toDays(duration)),
+    Match.whenOr("hour", "hours", () => Duration.toHours(duration)),
+    Match.whenOr("minute", "minutes", () => Duration.toMinutes(duration)),
+    Match.whenOr("second", "seconds", () => Duration.toSeconds(duration)),
+    Match.whenOr("milli", "millis", () => Duration.toMillis(duration)),
+    Match.whenOr(
+      "micro",
+      "micros",
+      () => Duration.toMillis(duration) * MICROS_PER_MILLI
+    ),
+    Match.whenOr(
+      "nano",
+      "nanos",
+      () => pipe$1(
+        Duration.toNanos(duration),
+        Option.getOrThrowWith(
+          () => new Error("Duration.toNanos returned None")
+        ),
+        BigIntX_exports.toNumberOrThrow
+      )
+    ),
+    Match.exhaustive
+  )
+);
+var fromUnit = dual(
+  2,
+  (value, unit) => Match.value(unit).pipe(
+    Match.whenOr("week", "weeks", () => Duration.weeks(value)),
+    Match.whenOr("day", "days", () => Duration.days(value)),
+    Match.whenOr("hour", "hours", () => Duration.hours(value)),
+    Match.whenOr("minute", "minutes", () => Duration.minutes(value)),
+    Match.whenOr("second", "seconds", () => Duration.seconds(value)),
+    Match.whenOr("milli", "millis", () => Duration.millis(value)),
+    Match.whenOr("micro", "micros", () => Duration.micros(BigInt(value))),
+    Match.whenOr("nano", "nanos", () => Duration.nanos(BigInt(value))),
+    Match.exhaustive
+  )
+);
+var mapAsUnit = dual(
+  3,
+  (duration, unit, map2) => pipe$1(
+    duration,
+    // Convert to that unit
+    toUnit(unit),
+    // Truncate to the requested number of digits
+    map2,
+    // Convert back to a duration
+    fromUnit(unit)
+  )
+);
+
+// src/EffectX/EffectX.ts
+var EffectX_exports = {};
+__export(EffectX_exports, {
+  flattenOption: () => flattenOption,
+  fromOptionOrElse: () => fromOptionOrElse,
+  tryUntil: () => tryUntil
+});
+var USER_INSTANT_DURATION = Duration.millis(200);
+var flattenOption = dual(
+  2,
+  (effect, onNone) => Effect.flatMap(
+    effect,
+    (option) => pipe(Effect.fromOption(option), Effect.mapError(onNone))
+  )
+);
+var fromOptionOrElse = dual(
+  2,
+  (option, onNone) => pipe(Effect.fromOption(option), Effect.mapError(onNone))
+);
+var tryUntil = ({
+  try: doTry,
+  until: isDone,
+  sleepDuration = USER_INSTANT_DURATION,
+  maxDuration
+}) => {
+  const immediateValue = doTry();
+  if (isDone(immediateValue)) {
+    return Effect.succeed(immediateValue);
+  }
+  return Effect.sync(doTry).pipe(
+    // Sleep in between each attempt
+    Effect.delay(sleepDuration),
+    // Keep doing this until the predicate passes
+    Effect.repeat({ until: isDone }),
+    // Until a timeout occurs. In v4, `Effect.timeout` raises `TimeoutError`
+    // on its own — no separate `timeoutFail` overload is needed.
+    Effect.timeout(maxDuration),
+    Effect.catchTag(
+      "TimeoutError",
+      () => Effect.fail(
+        new Cause.TimeoutError(
+          `Timed out after ${Duration.format(maxDuration)} waiting for value to pass predicate`
+        )
+      )
+    )
+  );
+};
+
+// src/FormDataX/FormDataX.ts
+var FormDataX_exports = {};
+__export(FormDataX_exports, {
+  decodeSync: () => decodeSync
+});
+var decodeSync = Function.dual(
+  2,
+  (formData, schema) => Schema.decodeUnknownSync(Schema.fromFormData(schema))(formData)
+);
+
+// src/MapX/MapX.ts
+var MapX_exports = {};
+__export(MapX_exports, {
+  getOrElseSetGet: () => getOrElseSetGet
+});
+var getOrElseSetGet = dual(3, (map2, key, fallbackIfNotFound) => {
+  if (!map2.has(key)) {
+    map2.set(key, fallbackIfNotFound());
+    return fallbackIfNotFound();
+  }
+  const existingValue = map2.get(key);
+  if (Predicate.isNullish(existingValue)) {
+    throw new Error(`Value is nullable: ${String(key)}`);
+  }
+  return existingValue;
+});
+
+// src/NonNullableX/NonNullableX.ts
+var NonNullableX_exports = {};
+__export(NonNullableX_exports, {
+  fromNullableOrThrow: () => fromNullableOrThrow,
+  lift: () => lift,
+  map: () => map,
+  match: () => match2,
+  nullableOrder: () => nullableOrder
+});
+var fromNullableOrThrow = (value, variableName) => {
+  if (Predicate.isNotNullish(value)) {
+    return value;
+  }
+  throw new Error(
+    `Value is nullable: ${String(value)}${Predicate.isNotNullish(variableName) ? ` (variable name: ${variableName})` : ""}`
+  );
+};
+var match2 = dual(
+  2,
+  (value, {
+    whenNullable,
+    whenNotNullable
+  }) => Predicate.isNotNullish(value) ? whenNotNullable(value) : whenNullable()
+);
+var map = dual(
+  2,
+  (a, map2) => {
+    if (Predicate.isNotNullish(a)) {
+      return map2(a);
+    }
+    if (Predicate.isNullish(a)) {
+      return a;
+    }
+    throw new Error(`Value is neither nullable nor non-nullable: ${String(a)}`);
+  }
+);
+var lift = (map2) => (a) => {
+  if (Predicate.isNullish(a)) {
+    return a;
+  }
+  return map2(a);
+};
+var nullableOrder = dual(
+  2,
+  (order, behavior) => {
+    const { nullableSortCategory, valueSortCategory } = Match.value(
+      behavior
+    ).pipe(
+      Match.when("value-null", () => ({
+        nullableSortCategory: 1,
+        valueSortCategory: 0
+      })),
+      Match.when("null-value", () => ({
+        nullableSortCategory: 0,
+        valueSortCategory: 1
+      })),
+      Match.exhaustive
+    );
+    return (a, b) => {
+      if (Predicate.isNotNullish(a) && Predicate.isNotNullish(b)) {
+        return order(a, b);
+      }
+      const aCategory = Predicate.isNotNullish(a) ? valueSortCategory : nullableSortCategory;
+      const bCategory = Predicate.isNotNullish(b) ? valueSortCategory : nullableSortCategory;
+      return Number$1.sign(aCategory - bCategory);
+    };
+  }
+);
+
+// src/NumberX/NumberX.ts
+var NumberX_exports = {};
+__export(NumberX_exports, {
+  indexToExcel: () => indexToExcel,
+  indexToRank: () => indexToRank,
+  padLeftZeroes: () => padLeftZeroes,
+  roundToDigits: () => roundToDigits,
+  toFixed: () => toFixed,
+  unsafeLogBase: () => unsafeLogBase,
+  unsafeToPercentOf: () => unsafeToPercentOf
+});
+var logBase = dual(2, (number, base) => {
+  if (number <= 0) {
+    return Option.none();
+  }
+  if (base <= 0 || base === 1) {
+    return Option.none();
+  }
+  if (base < 1 && number >= 1) {
+    return Option.none();
+  }
+  if (base >= 1 && number < 1) {
+    return Option.none();
+  }
+  return Option.some(Math.log(number) / Math.log(base));
+});
+var unsafeLogBase = dual(
+  2,
+  (number, base) => Option.getOrThrowWith(
+    logBase(number, base),
+    () => new Error(`Error calculating log base ${base} of ${number}`)
+  )
+);
+var toPercentOf = dual(
+  2,
+  (numerator, total) => pipe(
+    Number$1.divide(numerator, total),
+    Option.map((ratio) => ratio * 100)
+  )
+);
+var unsafeToPercentOf = dual(
+  2,
+  (numerator, total) => Option.getOrThrowWith(
+    toPercentOf(numerator, total),
+    () => new Error(`Division by zero when dividing ${numerator} by ${total}`)
+  )
+);
+var toFixed = dual(
+  2,
+  (number, numberDigits) => number.toFixed(numberDigits)
+);
+var roundToDigits = dual(
+  2,
+  (number, numberDigits) => Number(number.toFixed(numberDigits))
+);
+var padLeftZeroes = dual(
+  2,
+  (number, numberDigits) => number.toString().padStart(numberDigits, "0")
+);
+var indexToRank = (index) => index + 1;
+var EXCEL_COLUMNS_BASE_CHARS = [..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"];
+var indexToExcel = (index) => {
+  if (index < 0) {
+    return Option.none();
+  }
+  const baseChars = EXCEL_COLUMNS_BASE_CHARS;
+  let excel = "";
+  const base = baseChars.length;
+  do {
+    excel = baseChars[index % base] + excel;
+    index = Math.floor(index / base) - 1;
+  } while (index >= 0);
+  return Option.some(excel);
+};
+
+// src/OptionX/OptionX.ts
+var OptionX_exports = {};
+__export(OptionX_exports, {
+  fromNullableOption: () => fromNullableOption,
+  ifSome: () => ifSome,
+  inspectSome: () => inspectSome,
+  mapSomeOrNull: () => mapSomeOrNull,
+  mapSomeOrUndefined: () => mapSomeOrUndefined,
+  tupleOf: () => tupleOf
+});
+var tupleOf = dual(
+  2,
+  (a, b) => Option.flatMap(a, (a2) => Option.map(b, (b2) => [a2, b2]))
+);
+var ifSome = dual(2, (self, ifSome2) => {
+  Option.match(self, {
+    onSome: (value) => {
+      ifSome2(value);
+    },
+    onNone: () => {
+    }
+  });
+});
+var inspectSome = dual(
+  2,
+  (self, function_) => {
+    ifSome(self, function_);
+    return self;
+  }
+);
+var fromNullableOption = (nullableOption) => Predicate.isNotNullish(nullableOption) ? nullableOption : Option.none();
+var mapSomeOrNull = dual(
+  2,
+  (self, map2) => pipe(self, Option.map(map2), Option.getOrNull)
+);
+var mapSomeOrUndefined = dual(
+  2,
+  (self, map2) => pipe(self, Option.map(map2), Option.getOrUndefined)
+);
+
+// src/OrderX/OrderX.ts
+var OrderX_exports = {};
+__export(OrderX_exports, {
+  rankedEnum: () => rankedEnum
+});
+var rankedEnum = (ranks) => (self, that) => Number$1.sign(ranks[self] - ranks[that]);
+
+// src/PredicateX/PredicateX.ts
+var PredicateX_exports = {};
+__export(PredicateX_exports, {
+  isNonEmptyString: () => isNonEmptyString,
+  matchRefine: () => matchRefine
+});
+var matchRefine = dual(
+  3,
+  (value, predicate, handlers) => predicate(value) ? handlers.whenTrue(value) : handlers.whenFalse()
+);
+function isNonEmptyString(value) {
+  return Predicate.isNotNullish(value) && Predicate.isString(value) && String$1.isNonEmpty(value);
+}
+
+// src/PromiseX/PromiseX.ts
+var PromiseX_exports = {};
+__export(PromiseX_exports, {
+  asVoid: () => asVoid
+});
+var asVoid = (promise) => promise.then(() => void 0);
+
+// src/SchemaX/SchemaX.ts
+var SchemaX_exports = {};
+__export(SchemaX_exports, {
+  TrimmedNonEmptyString: () => TrimmedNonEmptyString,
+  URLSafeFilePath: () => URLSafeFilePath,
+  nonNegativeBigInt: () => nonNegativeBigInt,
+  omit: () => omit,
+  partial: () => partial,
+  pick: () => pick,
+  pickPartial: () => pickPartial
+});
+var TrimmedNonEmptyString = Schema.NonEmptyString.pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((s) => s.trim()),
+    encode: SchemaGetter.transform((s) => s.trim())
+  })
+);
+var URLSafeFilePath = TrimmedNonEmptyString.pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((path) => decodeURIComponent(path)),
+    encode: SchemaGetter.transform((path) => encodeURIComponent(path))
+  })
+);
+var clampMinBigInt = (min) => (schema) => schema.pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((value) => BigInt$1.max(value, min)),
+    encode: SchemaGetter.transform((value) => BigInt$1.max(value, min))
+  })
+);
+var nonNegativeBigInt = clampMinBigInt(0n);
+var pick = (schema, ...keys) => schema.mapFields(
+  (fields) => Struct.pick(fields, keys)
+);
+var omit = (schema, ...keys) => schema.mapFields(
+  (fields) => Struct.omit(fields, keys)
+);
+var partial = (schema) => schema.mapFields((fields) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = Schema.optional(fields[key]);
+  }
+  return result;
+});
+var pickPartial = (schema, ...keys) => partial(pick(schema, ...keys));
+
+// src/SetX/SetX.ts
+var SetX_exports = {};
+__export(SetX_exports, {
+  add: () => add,
+  remove: () => remove,
+  safelyMutate: () => safelyMutate,
+  toggle: () => toggle
+});
+var safelyMutate = dual(2, (set, mutate) => {
+  const copy = new Set(set);
+  return mutate(copy);
+});
+var add = dual(
+  2,
+  (set, value) => set.has(value) ? set : new Set(set).add(value)
+);
+var remove = dual(2, (set, value) => {
+  if (set.has(value)) {
+    const newSet = new Set(set);
+    newSet.delete(value);
+    return newSet;
+  }
+  return set;
+});
+var toggle = dual(
+  2,
+  (set, value) => set.has(value) ? remove(set, value) : add(set, value)
+);
+
+// src/StringX/StringX.ts
+var StringX_exports = {};
+__export(StringX_exports, {
+  ensurePrepend: () => ensurePrepend,
+  prepend: () => prepend,
+  surround: () => surround
+});
+var prepend = dual(2, (string_, start) => `${start}${string_}`);
+var surround = dual(
+  3,
+  (string_, start, end) => `${start}${string_}${end}`
+);
+var ensurePrepend = dual(2, (string_, start) => {
+  if (string_.startsWith(start)) {
+    return string_;
+  }
+  return `${start}${string_}`;
+});
+
+// src/StructX/StructX.ts
+var StructX_exports = {};
+__export(StructX_exports, {
+  defined: () => defined,
+  filterDefined: () => filterDefined,
+  hasNotNullableProperty: () => hasNotNullableProperty,
+  pickSome: () => pickSome,
+  some: () => some,
+  truthy: () => truthy
+});
+var defined = (name, value) => Predicate.isUndefined(value) ? {} : Record.singleton(name, value);
+var filterDefined = (record) => Object.entries(record).reduce(
+  (accumulator, [key, value]) => ({ ...accumulator, ...defined(key, value) }),
+  {}
+);
+var some = (name, value) => Option.match(value, {
+  onSome: (someValue) => Record.singleton(name, someValue),
+  onNone: () => ({})
+});
+var someSingleton = dual(
+  2,
+  (value, name) => some(name, value)
+);
+function pickSome(record, key, renameKeyTo) {
+  return pipe(
+    Record.get(record, key),
+    Option.flatten,
+    someSingleton(renameKeyTo ?? key)
+  );
+}
+var truthy = (name, value) => Predicate.isTruthy(value) ? Record.singleton(name, value) : {};
+var hasNotNullableProperty = dual(
+  2,
+  (object, key) => Predicate.hasProperty(object, key) && Predicate.isNotNullish(object[key])
+);
+
+export { ArrayX_exports as ArrayX, BigIntX_exports as BigIntX, BooleanX_exports as BooleanX, DurationX_exports as DurationX, EffectX_exports as EffectX, FormDataX_exports as FormDataX, MapX_exports as MapX, NonNullableX_exports as NonNullableX, NumberX_exports as NumberX, OptionX_exports as OptionX, OrderX_exports as OrderX, PredicateX_exports as PredicateX, PromiseX_exports as PromiseX, RecordX_exports as RecordX, ResultX_exports as ResultX, SchemaX_exports as SchemaX, SetX_exports as SetX, StringX_exports as StringX, StructX_exports as StructX, These_exports as These, fromNullableOrThrow as nn };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map