@nunofyobiz/effect-extras 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,1012 +1,23 @@
-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,
-  zipWithWarnings: () => zipWithWarnings
-});
-
-// 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/WarnResult/WarnResult.ts
-var WarnResult_exports = {};
-__export(WarnResult_exports, {
-  SuccessOnly: () => SuccessOnly,
-  SuccessWithWarnings: () => SuccessWithWarnings,
-  WarningsOnly: () => WarningsOnly,
-  WithSuccess: () => WithSuccess,
-  WithWarnings: () => WithWarnings,
-  flatMapSuccess: () => flatMapSuccess,
-  flatMapSuccessEffect: () => flatMapSuccessEffect,
-  flatMapWarnings: () => flatMapWarnings,
-  flatMapWarningsEffect: () => flatMapWarningsEffect,
-  fromNullables: () => fromNullables,
-  is: () => is,
-  mapBoth: () => mapBoth,
-  mapBothEffect: () => mapBothEffect,
-  mapSuccess: () => mapSuccess,
-  mapSuccessEffect: () => mapSuccessEffect,
-  mapWarnings: () => mapWarnings,
-  mapWarningsEffect: () => mapWarningsEffect,
-  match: () => match,
-  matchSuccess: () => matchSuccess,
-  matchWarnings: () => matchWarnings,
-  optionFromNullables: () => optionFromNullables,
-  orElse: () => orElse,
-  orUndefined: () => orUndefined,
-  successOption: () => successOption,
-  successOrElse: () => successOrElse,
-  successOrUndefined: () => successOrUndefined,
-  warningsOption: () => warningsOption,
-  warningsOrElse: () => warningsOrElse,
-  warningsOrUndefined: () => warningsOrUndefined
-});
-var taggedEnum = Data.taggedEnum();
-var WarningsOnly = taggedEnum.WarningsOnly;
-var SuccessOnly = taggedEnum.SuccessOnly;
-var SuccessWithWarnings = taggedEnum.SuccessWithWarnings;
-var is = taggedEnum.$is;
-var match = taggedEnum.$match;
-var WithWarnings = ({
-  warnings,
-  success
-}) => Predicate.isNotNullish(success) ? SuccessWithWarnings({ warnings, success }) : WarningsOnly({ warnings });
-var WithSuccess = ({
-  warnings,
-  success
-}) => Predicate.isNotNullish(warnings) ? SuccessWithWarnings({ warnings, success }) : SuccessOnly({ success });
-var optionFromNullables = ({
-  warnings,
-  success
-}) => {
-  if (Predicate.isNotNullish(warnings) && Predicate.isNotNullish(success)) {
-    return Option.some(SuccessWithWarnings({ warnings, success }));
-  }
-  if (Predicate.isNotNullish(warnings)) {
-    return Option.some(WarningsOnly({ warnings }));
-  }
-  if (Predicate.isNotNullish(success)) {
-    return Option.some(SuccessOnly({ success }));
-  }
-  return Option.none();
-};
-var fromNullables = ({
-  warnings,
-  success,
-  orElse: orElse2 = () => {
-    throw new Error("Both warnings and success are nullish");
-  }
-}) => pipe(optionFromNullables({ warnings, success }), Option.getOrElse(orElse2));
-var matchWarnings = ({
-  Warnings,
-  SuccessOnly: SuccessOnly2
-}) => (warnResult) => pipe(
-  warnResult,
-  match({
-    WarningsOnly: ({ warnings }) => Warnings(warnings),
-    SuccessOnly: ({ success }) => SuccessOnly2(success),
-    SuccessWithWarnings: ({ warnings }) => Warnings(warnings)
-  }),
-  // Make Typescript happy
-  (a) => a
-);
-var matchSuccess = ({
-  WarningsOnly: WarningsOnly2,
-  Success
-}) => (warnResult) => pipe(
-  warnResult,
-  match({
-    WarningsOnly: ({ warnings }) => WarningsOnly2(warnings),
-    SuccessOnly: ({ success }) => Success(success),
-    SuccessWithWarnings: ({ success }) => Success(success)
-  }),
-  // Make Typescript happy
-  (a) => a
-);
-var orElse = ({
-  orElseWarnings,
-  orElseSuccess
-}) => match({
-  WarningsOnly: ({ warnings }) => SuccessWithWarnings({ warnings, success: orElseSuccess() }),
-  SuccessOnly: ({ success }) => SuccessWithWarnings({ warnings: orElseWarnings(), success }),
-  SuccessWithWarnings: ({ warnings, success }) => SuccessWithWarnings({ warnings, success })
-});
-var orUndefined = orElse({
-  orElseWarnings: () => void 0,
-  orElseSuccess: () => void 0
-});
-var warningsOrElse = (orElseReturn) => (warnResult) => pipe(
-  warnResult,
-  orElse({
-    orElseWarnings: orElseReturn,
-    orElseSuccess: constUndefined
-  }),
-  Struct.get("warnings")
-);
-var warningsOrUndefined = warningsOrElse(() => void 0);
-var successOrElse = (orElseReturn) => (warnResult) => pipe(
-  warnResult,
-  orElse({
-    orElseWarnings: constUndefined,
-    orElseSuccess: orElseReturn
-  }),
-  Struct.get("success")
-);
-var successOrUndefined = successOrElse(() => void 0);
-var successOption = (warnResult) => pipe(
-  warnResult,
-  matchSuccess({
-    WarningsOnly: () => Option.none(),
-    Success: Option.some
-  })
-);
-var warningsOption = (warnResult) => pipe(
-  warnResult,
-  matchWarnings({
-    Warnings: Option.some,
-    SuccessOnly: () => Option.none()
-  })
-);
-var mapBoth = ({
-  mapWarnings: mapWarnings2,
-  mapSuccess: mapSuccess2
-}) => match({
-  WarningsOnly: ({ warnings }) => WarningsOnly({ warnings: mapWarnings2(warnings) }),
-  SuccessOnly: ({ success }) => SuccessOnly({ success: mapSuccess2(success) }),
-  SuccessWithWarnings: ({ warnings, success }) => SuccessWithWarnings({
-    warnings: mapWarnings2(warnings),
-    success: mapSuccess2(success)
-  })
-});
-var mapBothEffect = ({
-  mapWarnings: mapWarnings2,
-  mapSuccess: mapSuccess2
-}) => match({
-  WarningsOnly: ({ warnings }) => pipe(
-    mapWarnings2(warnings),
-    Effect.map((warnings2) => WarningsOnly({ warnings: warnings2 }))
-  ),
-  SuccessOnly: ({ success }) => pipe(
-    mapSuccess2(success),
-    Effect.map((success2) => SuccessOnly({ success: success2 }))
-  ),
-  SuccessWithWarnings: ({ warnings, success }) => pipe(
-    Effect.all({
-      warnings: mapWarnings2(warnings),
-      success: mapSuccess2(success)
-    }),
-    Effect.map(
-      ({ warnings: warnings2, success: success2 }) => SuccessWithWarnings({ warnings: warnings2, success: success2 })
-    )
-  )
-});
-var mapWarnings = (mapWarnings2) => mapBoth({ mapWarnings: mapWarnings2, mapSuccess: identity });
-var flatMapWarnings = (mapWarnings2) => match({
-  WarningsOnly: ({ warnings }) => mapWarnings2(warnings),
-  SuccessOnly: ({ success }) => SuccessOnly({ success }),
-  SuccessWithWarnings: ({ warnings }) => mapWarnings2(warnings)
-});
-var mapWarningsEffect = (mapWarnings2) => mapBothEffect({ mapWarnings: mapWarnings2, mapSuccess: Effect.succeed });
-var flatMapWarningsEffect = (mapWarnings2) => match({
-  WarningsOnly: ({ warnings }) => mapWarnings2(warnings),
-  SuccessOnly: ({ success }) => Effect.succeed(SuccessOnly({ success })),
-  SuccessWithWarnings: ({ warnings }) => mapWarnings2(warnings)
-});
-var mapSuccess = (mapSuccess2) => mapBoth({ mapWarnings: identity, mapSuccess: mapSuccess2 });
-var flatMapSuccess = (mapSuccess2) => match({
-  WarningsOnly: ({ warnings }) => WarningsOnly({ warnings }),
-  SuccessOnly: ({ success }) => mapSuccess2(success),
-  SuccessWithWarnings: ({ success }) => mapSuccess2(success)
-});
-var mapSuccessEffect = (mapSuccess2) => mapBothEffect({ mapWarnings: Effect.succeed, mapSuccess: mapSuccess2 });
-var flatMapSuccessEffect = (mapSuccess2) => match({
-  WarningsOnly: ({ warnings }) => Effect.succeed(WarningsOnly({ warnings })),
-  SuccessOnly: ({ success }) => mapSuccess2(success),
-  SuccessWithWarnings: ({ success }) => mapSuccess2(success)
-});
-
-// 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 zipWithWarnings = 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(
-          WarnResult_exports.SuccessWithWarnings({
-            warnings: array1[index],
-            success: array2[index]
-          })
-        );
-      }
-      if (index < array1.length) {
-        return f(
-          WarnResult_exports.WarningsOnly({
-            warnings: array1[index]
-          })
-        );
-      }
-      if (index < array2.length) {
-        return f(
-          WarnResult_exports.SuccessOnly({
-            success: 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, WarnResult_exports as WarnResult, fromNullableOrThrow as nn };
-//# sourceMappingURL=index.js.map
+export * as ArrayX from "./ArrayX.js";
+export * as BigIntX from "./BigIntX.js";
+export * as BooleanX from "./BooleanX.js";
+export * as DurationX from "./DurationX.js";
+export * as EffectX from "./EffectX.js";
+export * as FormDataX from "./FormDataX.js";
+export * as InclusiveOr from "./InclusiveOr.js";
+export * as MapX from "./MapX.js";
+export * as NonNullableX from "./NonNullableX.js";
+export { fromNullableOrThrow as nn } from "./NonNullableX.js";
+export * as NumberX from "./NumberX.js";
+export * as OptionX from "./OptionX.js";
+export * as OrderX from "./OrderX.js";
+export * as PredicateX from "./PredicateX.js";
+export * as PromiseX from "./PromiseX.js";
+export * as RecordX from "./RecordX.js";
+export * as ResultX from "./ResultX.js";
+export * as SchemaX from "./SchemaX.js";
+export * as SetX from "./SetX.js";
+export * as StringX from "./StringX.js";
+export * as StructX from "./StructX.js";
+export * as WarnResult from "./WarnResult.js";
 //# sourceMappingURL=index.js.map