@nlozgachev/pipelined 0.44.0 → 0.46.0

package/dist/utils.js

@@ -32,57 +32,75 @@ module.exports = __toCommonJS(Data_exports);
 // src/Core/Deferred.ts
 var Deferred;
 ((Deferred2) => {
-  Deferred2.fromPromise = (p) => (
-    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
-    { then: ((f) => p.then(f)) }
-  );
-  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+  let from;
+  ((from2) => {
+    from2.Promise = (p) => (
+      // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+      { then: ((f) => p.then(f)) }
+    );
+  })(from = Deferred2.from || (Deferred2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Promise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
+  })(to = Deferred2.to || (Deferred2.to = {}));
 })(Deferred || (Deferred = {}));
 
 // src/Core/Maybe.ts
 var _none = { kind: "None" };
 var Maybe;
-((Maybe2) => {
-  Maybe2.some = (value) => ({ kind: "Some", value });
-  Maybe2.isSome = (data) => data.kind === "Some";
-  Maybe2.none = () => _none;
-  Maybe2.isNone = (data) => data.kind === "None";
-  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
-  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
-  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
-  Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
-  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
-  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
-  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
-  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
-  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
-  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
-  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
-  Maybe2.tap = (f) => (data) => {
-    if ((0, Maybe2.isSome)(data)) {
+((Maybe3) => {
+  let make;
+  ((make2) => {
+    make2.some = (value) => ({ kind: "Some", value });
+    make2.none = () => _none;
+  })(make = Maybe3.make || (Maybe3.make = {}));
+  let is;
+  ((is2) => {
+    is2.some = (data) => data.kind === "Some";
+    is2.none = (data) => data.kind === "None";
+  })(is = Maybe3.is || (Maybe3.is = {}));
+  let to;
+  ((to2) => {
+    to2.nullable = (data) => is.some(data) ? data.value : null;
+    to2.undefined = (data) => is.some(data) ? data.value : globalThis.undefined;
+    to2.Result = (onNone) => (data) => is.some(data) ? Result.make.ok(data.value) : Result.make.err(onNone());
+  })(to = Maybe3.to || (Maybe3.to = {}));
+  let from;
+  ((from2) => {
+    from2.nullable = (value) => value === null || value === void 0 ? make.none() : make.some(value);
+    from2.Predicate = (pred) => (a) => pred(a) ? make.some(a) : make.none();
+    from2.Result = (data) => Result.is.ok(data) ? make.some(data.value) : make.none();
+  })(from = Maybe3.from || (Maybe3.from = {}));
+  Maybe3.map = (f) => (data) => is.some(data) ? make.some(f(data.value)) : data;
+  Maybe3.chain = (f) => (data) => is.some(data) ? f(data.value) : data;
+  Maybe3.fold = (onNone, onSome) => (data) => is.some(data) ? onSome(data.value) : onNone();
+  Maybe3.match = (cases) => (data) => is.some(data) ? cases.some(data.value) : cases.none();
+  Maybe3.getOrElse = (defaultValue) => (data) => is.some(data) ? data.value : defaultValue();
+  Maybe3.tap = (f) => (data) => {
+    if (is.some(data)) {
       f(data.value);
     }
     return data;
   };
-  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
-  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
-  Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
-  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
-  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
-    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  Maybe3.filter = (predicate) => (data) => is.some(data) ? predicate(data.value) ? data : make.none() : data;
+  Maybe3.recover = (fallback) => (data) => is.some(data) ? data : fallback();
+  Maybe3.ap = (arg) => (data) => is.some(data) && is.some(arg) ? make.some(data.value(arg.value)) : make.none();
+  Maybe3.bindTo = (key) => (data) => (0, Maybe3.map)((a) => ({ [key]: a }))(data);
+  Maybe3.bind = (key, f) => (data) => (0, Maybe3.chain)(
+    (a) => (0, Maybe3.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
-  Maybe2.struct = (fields) => {
+  Maybe3.struct = (fields) => {
     const result = {};
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if ((0, Maybe2.isNone)(res)) {
+        if (is.none(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return (0, Maybe2.some)(result);
+    return make.some(result);
   };
 })(Maybe || (Maybe = {}));
 
@@ -102,11 +120,14 @@ var Duration;
   Duration2.minutes = (m) => wrap(m * 60 * 1e3);
   Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
   Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
-  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
-  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
-  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
-  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
-  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  let to;
+  ((to2) => {
+    to2.milliseconds = (d) => Brand.unwrap(d);
+    to2.seconds = (d) => Brand.unwrap(d) / 1e3;
+    to2.minutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+    to2.hours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+    to2.days = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  })(to = Duration2.to || (Duration2.to = {}));
   Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
   Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
 })(Duration || (Duration = {}));
@@ -114,49 +135,61 @@ var Duration;
 // src/Core/Result.ts
 var Result;
 ((Result3) => {
-  Result3.ok = (value) => ({ kind: "Ok", value });
-  Result3.err = (e) => ({ kind: "Err", error: e });
-  Result3.isOk = (data) => data.kind === "Ok";
-  Result3.isErr = (data) => data.kind === "Err";
+  let make;
+  ((make2) => {
+    make2.ok = (value) => ({ kind: "Ok", value });
+    make2.err = (e) => ({ kind: "Err", error: e });
+  })(make = Result3.make || (Result3.make = {}));
+  let is;
+  ((is2) => {
+    is2.ok = (data) => data.kind === "Ok";
+    is2.err = (data) => data.kind === "Err";
+  })(is = Result3.is || (Result3.is = {}));
   Result3.tryCatch = (f, onError) => {
     try {
-      return (0, Result3.ok)(f());
+      return make.ok(f());
     } catch (error) {
-      return (0, Result3.err)(onError(error));
+      return make.err(onError(error));
     }
   };
-  Result3.map = (f) => (data) => (0, Result3.isOk)(data) ? (0, Result3.ok)(f(data.value)) : data;
-  Result3.mapError = (f) => (data) => (0, Result3.isErr)(data) ? (0, Result3.err)(f(data.error)) : data;
-  Result3.chain = (f) => (data) => (0, Result3.isOk)(data) ? f(data.value) : data;
-  Result3.fold = (onErr, onOk) => (data) => (0, Result3.isOk)(data) ? onOk(data.value) : onErr(data.error);
-  Result3.match = (cases) => (data) => (0, Result3.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
-  Result3.getOrElse = (defaultValue) => (data) => (0, Result3.isOk)(data) ? data.value : defaultValue();
+  Result3.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
+  Result3.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
+  Result3.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
+  Result3.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
+  Result3.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result3.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
   Result3.tap = (f) => (data) => {
-    if ((0, Result3.isOk)(data)) {
+    if (is.ok(data)) {
       f(data.value);
     }
     return data;
   };
   Result3.tapError = (f) => (data) => {
-    if ((0, Result3.isErr)(data)) {
+    if (is.err(data)) {
       f(data.error);
     }
     return data;
   };
-  Result3.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result3.ok)(a) : (0, Result3.err)(onFalse(a));
-  Result3.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result3.err)(onNull()) : (0, Result3.ok)(value);
-  Result3.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result3.err)(onNone()) : (0, Result3.ok)(maybe.value);
-  Result3.fromThrowable = (f, onError) => (...args) => {
-    try {
-      return (0, Result3.ok)(f(...args));
-    } catch (error) {
-      return (0, Result3.err)(onError(error));
-    }
-  };
-  Result3.recover = (fallback) => (data) => (0, Result3.isOk)(data) ? data : fallback(data.error);
-  Result3.recoverUnless = (isBlocked, fallback) => (data) => (0, Result3.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
-  Result3.toMaybe = (data) => (0, Result3.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result3.ap = (arg) => (data) => (0, Result3.isOk)(data) && (0, Result3.isOk)(arg) ? (0, Result3.ok)(data.value(arg.value)) : (0, Result3.isErr)(data) ? data : arg;
+  let from;
+  ((from2) => {
+    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.ok(a) : make.err(onFalse(a));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.err(onNull()) : make.ok(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.err(onNone()) : make.ok(maybe.value);
+    from2.throwable = (f, onError) => (...args) => {
+      try {
+        return make.ok(f(...args));
+      } catch (error) {
+        return make.err(onError(error));
+      }
+    };
+  })(from = Result3.from || (Result3.from = {}));
+  Result3.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
+  Result3.recoverUnless = (isBlocked, fallback) => (data) => is.err(data) && !isBlocked(data.error) ? fallback() : data;
+  let to;
+  ((to2) => {
+    to2.Maybe = (data) => is.ok(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+  })(to = Result3.to || (Result3.to = {}));
+  Result3.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
   Result3.bindTo = (key) => (data) => (0, Result3.map)((a) => ({ [key]: a }))(data);
   Result3.bind = (key, f) => (data) => (0, Result3.chain)(
     (a) => (0, Result3.map)((b) => ({ ...a, [key]: b }))(f(a))
@@ -166,30 +199,37 @@ var Result;
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if ((0, Result3.isErr)(res)) {
+        if (is.err(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return (0, Result3.ok)(result);
+    return make.ok(result);
   };
 })(Result || (Result = {}));
 
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
-  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
-  TaskMaybe2.none = () => Task.resolve(Maybe.none());
-  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
-  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
-  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
-  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
-  TaskMaybe2.tryCatch = (f) => Task.from((signal) => Promise.resolve(f(signal)).then(Maybe.some).catch(() => Maybe.none()));
+  TaskMaybe2.some = (value) => Task.resolve(Maybe.make.some(value));
+  TaskMaybe2.none = () => Task.resolve(Maybe.make.none());
+  let from;
+  ((from2) => {
+    from2.Maybe = (option) => Task.resolve(option);
+    from2.nullable = (value) => Task.resolve(Maybe.from.nullable(value));
+    from2.Result = (result) => Task.resolve(Result.to.Maybe(result));
+    from2.Task = (task) => Task.map(Maybe.make.some)(task);
+  })(from = TaskMaybe2.from || (TaskMaybe2.from = {}));
+  TaskMaybe2.tryCatch = (f) => Task.from.Promise(
+    (signal) => Promise.resolve(f(signal)).then(Maybe.make.some).catch(() => Maybe.make.none())
+  );
   TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
-  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
-  TaskMaybe2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+  TaskMaybe2.chain = (f) => (data) => Task.chain(
+    (option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none())
+  )(data);
+  TaskMaybe2.ap = (arg) => (data) => Task.from.Promise(
+    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([of_, oa]) => Maybe.ap(oa)(of_)
     )
   );
@@ -198,25 +238,30 @@ var TaskMaybe;
   TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
   TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
   TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
-  TaskMaybe2.toResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  let to;
+  ((to2) => {
+    to2.Result = (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data);
+  })(to = TaskMaybe2.to || (TaskMaybe2.to = {}));
   TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
   TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
     (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
-  TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.isNone(maybe) ? fallback() : Task.resolve(maybe))(data);
-  TaskMaybe2.struct = (fields) => Task.from((signal) => {
+  TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(
+    data
+  );
+  TaskMaybe2.struct = (fields) => Task.from.Promise((signal) => {
     const keys = Object.keys(fields);
-    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
       const record = {};
       for (let i = 0; i < keys.length; i++) {
         const res = results[i];
-        if (Maybe.isNone(res)) {
+        if (Maybe.is.none(res)) {
           return res;
         }
         record[keys[i]] = res.value;
       }
-      return Maybe.some(record);
+      return Maybe.make.some(record);
     });
   });
 })(TaskMaybe || (TaskMaybe = {}));
@@ -224,28 +269,35 @@ var TaskMaybe;
 // src/Core/TaskResult.ts
 var TaskResult;
 ((TaskResult2) => {
-  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.err(error));
-  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
-  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
-  TaskResult2.fromResult = (result) => Task.resolve(result);
-  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult2.tryCatch = (f, onError) => Task.from((signal) => Promise.resolve(f(signal)).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult2.ok = (value) => Task.resolve(Result.make.ok(value));
+  TaskResult2.err = (error) => Task.resolve(Result.make.err(error));
+  let from;
+  ((from2) => {
+    from2.nullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.make.err(onNull()) : Result.make.ok(value));
+    from2.Maybe = (onNone) => (maybe) => Task.resolve(Maybe.is.none(maybe) ? Result.make.err(onNone()) : Result.make.ok(maybe.value));
+    from2.Result = (result) => Task.resolve(result);
+    from2.throwable = (f, onError) => (...args) => Task.from.Promise(
+      () => f(...args).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+    );
+  })(from = TaskResult2.from || (TaskResult2.from = {}));
+  TaskResult2.tryCatch = (f, onError) => Task.from.Promise(
+    (signal) => Promise.resolve(f(signal)).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+  );
   TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-  TaskResult2.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
-    data
-  );
+  TaskResult2.chain = (f) => (data) => Task.chain(
+    (result) => Result.is.ok(result) ? f(result.value) : Task.resolve(Result.make.err(result.error))
+  )(data);
   TaskResult2.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
   TaskResult2.match = (cases) => (data) => Task.map(Result.match(cases))(data);
   TaskResult2.recover = (fallback) => (data) => Task.chain(
-    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
+    (result) => Result.is.err(result) ? fallback(result.error) : Task.resolve(result)
   )(data);
   TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
   TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
   TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+  TaskResult2.ap = (arg) => (data) => Task.from.Promise(
+    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([of_, oa]) => Result.ap(oa)(of_)
     )
   );
@@ -254,19 +306,19 @@ var TaskResult;
   TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
     (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
-  TaskResult2.struct = (fields) => Task.from((signal) => {
+  TaskResult2.struct = (fields) => Task.from.Promise((signal) => {
     const keys = Object.keys(fields);
-    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
       const record = {};
       for (let i = 0; i < keys.length; i++) {
         const res = results[i];
-        if (Result.isErr(res)) {
+        if (Result.is.err(res)) {
           return res;
         }
         record[keys[i]] = res.value;
       }
-      return Result.ok(record);
+      return Result.make.ok(record);
     });
   });
 })(TaskResult || (TaskResult = {}));
@@ -277,19 +329,28 @@ var isNonEmptyArr = (list) => list.length > 0;
 // src/Core/TaskValidation.ts
 var TaskValidation;
 ((TaskValidation2) => {
-  TaskValidation2.passed = (value) => Task.resolve(Validation.passed(value));
-  TaskValidation2.failed = (error) => Task.resolve(Validation.failed(error));
-  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.failedAll(errors));
-  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
-  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.failed(onNull()) : Validation.passed(value));
-  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.failed(onNone()) : Validation.passed(maybe.value));
-  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
-  TaskValidation2.tryCatch = (f, onError) => Task.from(
-    (signal) => Promise.resolve(f(signal)).then(Validation.passed).catch((error) => Validation.failed(onError(error)))
+  TaskValidation2.passed = (value) => Task.resolve(Validation.make.passed(value));
+  TaskValidation2.failed = (error) => Task.resolve(Validation.make.failed(error));
+  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+  let from;
+  ((from2) => {
+    from2.Validation = (validation) => Task.resolve(validation);
+    from2.nullable = (onNull) => (value) => Task.resolve(
+      value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)
+    );
+    from2.Maybe = (onNone) => (maybe) => Task.resolve(
+      Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)
+    );
+    from2.Result = (result) => Task.resolve(Validation.from.Result(result));
+  })(from = TaskValidation2.from || (TaskValidation2.from = {}));
+  TaskValidation2.tryCatch = (f, onError) => Task.from.Promise(
+    (signal) => Promise.resolve(f(signal)).then(Validation.make.passed).catch(
+      (error) => Validation.make.failed(onError(error))
+    )
   );
   TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+  TaskValidation2.ap = (arg) => (data) => Task.from.Promise(
+    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([vf, va]) => Validation.ap(va)(vf)
     )
   );
@@ -298,61 +359,64 @@ var TaskValidation;
   TaskValidation2.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
   TaskValidation2.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
   TaskValidation2.recover = (fallback) => (data) => Task.chain(
-    (validation) => Validation.isPassed(validation) ? Task.resolve(validation) : fallback(validation.errors)
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
-  TaskValidation2.product = (first, second) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(first(signal)), Deferred.toPromise(second(signal))]).then(
+  TaskValidation2.product = (first, second) => Task.from.Promise(
+    (signal) => Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
       ([va, vb]) => Validation.product(va, vb)
     )
   );
-  TaskValidation2.productAll = (data) => Task.from(
-    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => {
+  TaskValidation2.productAll = (data) => Task.from.Promise(
+    (signal) => Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
       const [first, ...rest] = results;
       return Validation.productAll([first, ...rest]);
     })
   );
   TaskValidation2.mapError = (f) => (data) => Task.map(Validation.mapError(f))(data);
   TaskValidation2.tapError = (f) => (data) => Task.map(Validation.tapError(f))(data);
-  TaskValidation2.struct = (fields) => Task.from((signal) => {
+  TaskValidation2.struct = (fields) => Task.from.Promise((signal) => {
     const keys = Object.keys(fields);
-    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
       const record = {};
       const errors = [];
       for (let i = 0; i < keys.length; i++) {
         const res = results[i];
-        if (Validation.isPassed(res)) {
+        if (Validation.is.passed(res)) {
           record[keys[i]] = res.value;
         } else {
           errors.push(...res.errors);
         }
       }
-      return isNonEmptyArr(errors) ? Validation.failedAll(errors) : Validation.passed(record);
+      return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
     });
   });
 })(TaskValidation || (TaskValidation = {}));
 
 // src/Core/Task.ts
-var toPromise = (task, signal) => Deferred.toPromise(task(signal));
-var getMs = (duration) => Duration.toMilliseconds(duration);
+var toPromise = (task, signal) => Deferred.to.Promise(task(signal));
+var getMs = (duration) => Duration.to.milliseconds(duration);
 var Task;
 ((Task2) => {
-  Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
-  Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
-  Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
-  Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
-  Task2.ap = (arg) => (data) => (0, Task2.from)((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
-  Task2.tap = (f) => (data) => (0, Task2.from)(
+  Task2.resolve = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
+  let from;
+  ((from2) => {
+    from2.Promise = (f) => (signal) => Deferred.from.Promise(f(signal));
+    from2.sync = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
+  })(from = Task2.from || (Task2.from = {}));
+  Task2.map = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
+  Task2.ap = (arg) => (data) => from.Promise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
+  Task2.tap = (f) => (data) => from.Promise(
     (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
-  Task2.all = (tasks) => (0, Task2.from)(
+  Task2.all = (tasks) => from.Promise(
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
-  Task2.delay = (duration) => (data) => (0, Task2.from)(
+  Task2.delay = (duration) => (data) => from.Promise(
     (signal) => new Promise((res) => {
       let timerId;
       const onAbort = () => {
@@ -371,7 +435,7 @@ var Task;
       }, getMs(duration));
     })
   );
-  Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
+  Task2.repeat = (options) => (task) => from.Promise((signal) => {
     const { times, delay: delayDuration } = options;
     if (times <= 0) {
       return Promise.resolve([]);
@@ -405,7 +469,7 @@ var Task;
     };
     return run2(times);
   });
-  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
+  Task2.repeatUntil = (options) => (task) => from.Promise((signal) => {
     const { when: predicate, delay: delayDuration, maxAttempts } = options;
     const wait = () => new Promise((r) => {
       let timerId;
@@ -442,10 +506,10 @@ var Task;
   });
   Task2.race = (tasks) => {
     if (tasks.length === 0) {
-      return () => Deferred.fromPromise(new Promise(() => {
+      return () => Deferred.from.Promise(new Promise(() => {
       }));
     }
-    return (0, Task2.from)((outerSignal) => {
+    return from.Promise((outerSignal) => {
       const controllers = tasks.map(() => new AbortController());
       const onOuterAbort = () => {
         for (const ctrl of controllers) {
@@ -474,8 +538,8 @@ var Task;
       return Promise.race(promises);
     });
   };
-  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
-  Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
+  Task2.sequence = (tasks) => from.Promise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
+  Task2.sequential = (tasks) => from.Promise(async (signal) => {
     const results = [];
     for (const task of tasks) {
       if (signal?.aborted) {
@@ -485,7 +549,7 @@ var Task;
     }
     return results;
   });
-  Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
+  Task2.timeout = (duration, onTimeout) => (task) => from.Promise((outerSignal) => {
     const controller = new AbortController();
     let timerId;
     let cleanUp = () => {
@@ -508,13 +572,13 @@ var Task;
     return Promise.race([
       toPromise(task, controller.signal).then((a) => {
         cleanUp();
-        return Result.ok(a);
+        return Result.make.ok(a);
       }),
       new Promise((res) => {
         timerId = setTimeout(() => {
           controller.abort();
           cleanUp();
-          res(Result.err(onTimeout()));
+          res(Result.make.err(onTimeout()));
         }, getMs(duration));
       })
     ]);
@@ -533,7 +597,7 @@ var Task;
           outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
         }
       }
-      return Deferred.fromPromise(factory(controller.signal));
+      return Deferred.from.Promise(factory(controller.signal));
     };
     return { task, abort };
   };
@@ -550,59 +614,71 @@ var Task;
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
-  Validation2.passed = (value) => ({ kind: "Passed", value });
-  Validation2.failed = (error) => ({ kind: "Failed", errors: [error] });
-  Validation2.failedAll = (errors) => ({ kind: "Failed", errors });
-  Validation2.isPassed = (data) => data.kind === "Passed";
-  Validation2.isFailed = (data) => data.kind === "Failed";
-  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.passed)(a) : (0, Validation2.failed)(onFalse(a));
-  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.failed)(onNull()) : (0, Validation2.passed)(value);
-  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.failed)(onNone()) : (0, Validation2.passed)(maybe.value);
-  Validation2.map = (f) => (data) => (0, Validation2.isPassed)(data) ? (0, Validation2.passed)(f(data.value)) : data;
-  Validation2.mapError = (f) => (data) => (0, Validation2.isFailed)(data) ? (0, Validation2.failedAll)(data.errors.map(f)) : data;
+  let make;
+  ((make2) => {
+    make2.passed = (value) => ({ kind: "Passed", value });
+    make2.failed = (error) => ({ kind: "Failed", errors: [error] });
+    make2.failedAll = (errors) => ({ kind: "Failed", errors });
+  })(make = Validation2.make || (Validation2.make = {}));
+  let is;
+  ((is2) => {
+    is2.passed = (data) => data.kind === "Passed";
+    is2.failed = (data) => data.kind === "Failed";
+  })(is = Validation2.is || (Validation2.is = {}));
+  let from;
+  ((from2) => {
+    from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.passed(a) : make.failed(onFalse(a));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.failed(onNull()) : make.passed(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.failed(onNone()) : make.passed(maybe.value);
+    from2.Result = (data) => data.kind === "Ok" ? make.passed(data.value) : make.failed(data.error);
+  })(from = Validation2.from || (Validation2.from = {}));
+  Validation2.map = (f) => (data) => is.passed(data) ? make.passed(f(data.value)) : data;
+  Validation2.mapError = (f) => (data) => is.failed(data) ? make.failedAll(data.errors.map(f)) : data;
   Validation2.ap = (arg) => (data) => {
-    if ((0, Validation2.isPassed)(data)) {
-      return (0, Validation2.isPassed)(arg) ? (0, Validation2.passed)(data.value(arg.value)) : (0, Validation2.failedAll)(arg.errors);
+    if (is.passed(data)) {
+      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
     }
-    return (0, Validation2.isPassed)(arg) ? (0, Validation2.failedAll)(data.errors) : (0, Validation2.failedAll)([...data.errors, ...arg.errors]);
+    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll([...data.errors, ...arg.errors]);
   };
-  Validation2.fold = (onFailed, onPassed) => (data) => (0, Validation2.isPassed)(data) ? onPassed(data.value) : onFailed(data.errors);
-  Validation2.match = (cases) => (data) => (0, Validation2.isPassed)(data) ? cases.passed(data.value) : cases.failed(data.errors);
-  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isPassed)(data) ? data.value : defaultValue();
+  Validation2.fold = (onFailed, onPassed) => (data) => is.passed(data) ? onPassed(data.value) : onFailed(data.errors);
+  Validation2.match = (cases) => (data) => is.passed(data) ? cases.passed(data.value) : cases.failed(data.errors);
+  Validation2.getOrElse = (defaultValue) => (data) => is.passed(data) ? data.value : defaultValue();
   Validation2.tap = (f) => (data) => {
-    if ((0, Validation2.isPassed)(data)) {
+    if (is.passed(data)) {
       f(data.value);
     }
     return data;
   };
   Validation2.tapError = (f) => (data) => {
-    if ((0, Validation2.isFailed)(data)) {
+    if (is.failed(data)) {
       f(data.errors);
     }
     return data;
   };
-  Validation2.recover = (fallback) => (data) => (0, Validation2.isPassed)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isFailed)(data) && !data.errors.some(isBlocked) ? fallback() : data;
-  Validation2.toResult = (data) => (0, Validation2.isPassed)(data) ? Result.ok(data.value) : Result.err(data.errors);
-  Validation2.toMaybe = (data) => (0, Validation2.isPassed)(data) ? Maybe.some(data.value) : Maybe.none();
-  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.passed)(data.value) : (0, Validation2.failed)(data.error);
+  Validation2.recover = (fallback) => (data) => is.passed(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  let to;
+  ((to2) => {
+    to2.Result = (data) => is.passed(data) ? Result.make.ok(data.value) : Result.make.err(data.errors);
+    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+  })(to = Validation2.to || (Validation2.to = {}));
   Validation2.product = (first, second) => {
-    if ((0, Validation2.isPassed)(first)) {
-      return (0, Validation2.isPassed)(second) ? (0, Validation2.passed)([first.value, second.value]) : (0, Validation2.failedAll)(second.errors);
+    if (is.passed(first)) {
+      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
     }
-    return (0, Validation2.isPassed)(second) ? (0, Validation2.failedAll)(first.errors) : (0, Validation2.failedAll)([...first.errors, ...second.errors]);
+    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
   };
   Validation2.productAll = (data) => {
     const values = [];
     const errors = [];
     for (const v of data) {
-      if ((0, Validation2.isPassed)(v)) {
+      if (is.passed(v)) {
         values.push(v.value);
       } else {
         errors.push(...v.errors);
       }
     }
-    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
   };
   Validation2.struct = (fields) => {
     const record = {};
@@ -610,14 +686,14 @@ var Validation;
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const val = fields[key];
-        if ((0, Validation2.isPassed)(val)) {
+        if (is.passed(val)) {
           record[key] = val.value;
         } else {
           errors.push(...val.errors);
         }
       }
     }
-    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
   };
 })(Validation || (Validation = {}));
 
@@ -630,11 +706,11 @@ var ArrMaybe;
     for (let i = 0; i < n; i++) {
       const mapped = f(data[i]);
       if (mapped.kind === "None") {
-        return Maybe.none();
+        return Maybe.make.none();
       }
       result[i] = mapped.value;
     }
-    return Maybe.some(result);
+    return Maybe.make.some(result);
   };
   ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
 })(ArrMaybe || (ArrMaybe = {}));
@@ -650,61 +726,69 @@ var ArrResult;
       }
       result[i] = mapped.value;
     }
-    return Result.ok(result);
+    return Result.make.ok(result);
   };
   ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
 })(ArrResult || (ArrResult = {}));
 var ArrTaskResult;
 ((ArrTaskResult2) => {
-  ArrTaskResult2.traverse = (f) => (data) => Task.from(async () => {
+  ArrTaskResult2.traverse = (f) => (data) => Task.from.Promise(async () => {
     const result = [];
     for (const a of data) {
-      const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) {
+      const r = await Deferred.to.Promise(f(a)());
+      if (Result.is.err(r)) {
         return r;
       }
       result.push(r.value);
     }
-    return Result.ok(result);
+    return Result.make.ok(result);
   });
   ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
 })(ArrTaskResult || (ArrTaskResult = {}));
 var ArrTask;
 ((ArrTask2) => {
-  ArrTask2.traverse = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
+  ArrTask2.traverse = (f) => (data) => Task.from.Promise(() => Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
   ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
   ArrTask2.Result = ArrTaskResult;
 })(ArrTask || (ArrTask = {}));
 var ArrNonEmpty;
 ((ArrNonEmpty2) => {
   ArrNonEmpty2.singleton = (value) => [value];
-  ArrNonEmpty2.fromArray = (data) => isNonEmptyArr(data) ? Maybe.some(data) : Maybe.none();
+  let from;
+  ((from2) => {
+    from2.Array = (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none();
+  })(from = ArrNonEmpty2.from || (ArrNonEmpty2.from = {}));
   ArrNonEmpty2.head = (data) => data[0];
   ArrNonEmpty2.last = (data) => data[data.length - 1];
   ArrNonEmpty2.tail = (data) => data.slice(1);
   ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
+  ArrNonEmpty2.map = (f) => (data) => Arr.map(f)(data);
+  ArrNonEmpty2.mapWithIndex = (f) => (data) => Arr.mapWithIndex(f)(data);
+  ArrNonEmpty2.intersperse = (sep) => (data) => Arr.intersperse(sep)(data);
+  ArrNonEmpty2.concat = (other) => (data) => Arr.concat(other)(data);
+  ArrNonEmpty2.reverse = (data) => Arr.reverse(data);
 })(ArrNonEmpty || (ArrNonEmpty = {}));
 var Arr;
 ((Arr2) => {
-  Arr2.head = (data) => data.length > 0 ? Maybe.some(data[0]) : Maybe.none();
-  Arr2.last = (data) => data.length > 0 ? Maybe.some(data[data.length - 1]) : Maybe.none();
-  Arr2.tail = (data) => data.length > 0 ? Maybe.some(data.slice(1)) : Maybe.none();
-  Arr2.init = (data) => data.length > 0 ? Maybe.some(data.slice(0, -1)) : Maybe.none();
+  Arr2.head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
+  Arr2.last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
+  Arr2.tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
+  Arr2.init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
   Arr2.findFirst = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.some(data[idx]) : Maybe.none();
+    return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
   };
   Arr2.findLast = (predicate) => (data) => {
     for (let i = data.length - 1; i >= 0; i--) {
       if (predicate(data[i])) {
-        return Maybe.some(data[i]);
+        return Maybe.make.some(data[i]);
       }
     }
-    return Maybe.none();
+    return Maybe.make.none();
   };
   Arr2.findIndex = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx !== -1 ? Maybe.some(idx) : Maybe.none();
+    return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
   };
   Arr2.map = (f) => (data) => {
     const n = data.length;
@@ -898,10 +982,29 @@ var Arr;
     return result;
   };
   Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
-  Arr2.Maybe = ArrMaybe;
-  Arr2.Result = ArrResult;
-  Arr2.Task = ArrTask;
-  Arr2.isNonEmpty = (data) => isNonEmptyArr(data);
+  const _traverseTask = Object.assign((f) => ArrTask.traverse(f), {
+    Result: ArrTaskResult.traverse
+  });
+  const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), {
+    Result: ArrTaskResult.sequence
+  });
+  let traverse;
+  ((traverse2) => {
+    traverse2.Maybe = ArrMaybe.traverse;
+    traverse2.Result = ArrResult.traverse;
+    traverse2.Task = _traverseTask;
+  })(traverse = Arr2.traverse || (Arr2.traverse = {}));
+  let sequence;
+  ((sequence2) => {
+    sequence2.Maybe = ArrMaybe.sequence;
+    sequence2.Result = ArrResult.sequence;
+    sequence2.Task = _sequenceTask;
+  })(sequence = Arr2.sequence || (Arr2.sequence = {}));
+  let is;
+  ((is2) => {
+    is2.empty = (data) => data.length === 0;
+    is2.nonEmpty = (data) => isNonEmptyArr(data);
+  })(is = Arr2.is || (Arr2.is = {}));
   Arr2.prepend = (value) => (data) => [value, ...data];
   Arr2.append = (value) => (data) => [...data, value];
   Arr2.size = (data) => data.length;
@@ -983,12 +1086,34 @@ var Arr;
 })(Arr || (Arr = {}));
 
 // src/Data/Dict.ts
+var DictNonEmpty;
+((DictNonEmpty2) => {
+  DictNonEmpty2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  let from;
+  ((from2) => {
+    from2.Map = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
+  })(from = DictNonEmpty2.from || (DictNonEmpty2.from = {}));
+  DictNonEmpty2.keys = (m) => Dict.keys(m);
+  DictNonEmpty2.values = (m) => Dict.values(m);
+  DictNonEmpty2.entries = (m) => Dict.entries(m);
+  DictNonEmpty2.reduce = (f) => (m) => (0, DictNonEmpty2.values)(m).reduce(f);
+  DictNonEmpty2.map = (f) => (m) => Dict.map(f)(m);
+  DictNonEmpty2.mapWithKey = (f) => (m) => Dict.mapWithKey(f)(m);
+})(DictNonEmpty || (DictNonEmpty = {}));
 var Dict;
 ((Dict2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (m) => m.size === 0;
+    is2.nonEmpty = (m) => m.size > 0;
+  })(is = Dict2.is || (Dict2.is = {}));
   Dict2.empty = () => new globalThis.Map();
   Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
-  Dict2.fromEntries = (entries2) => new globalThis.Map(entries2);
-  Dict2.fromRecord = (rec) => new globalThis.Map(Object.entries(rec));
+  let from;
+  ((from2) => {
+    from2.entries = (entries3) => new globalThis.Map(entries3);
+    from2.Record = (rec) => new globalThis.Map(Object.entries(rec));
+  })(from = Dict2.from || (Dict2.from = {}));
   Dict2.groupBy = (keyFn) => (items) => {
     const result = new globalThis.Map();
     for (const item of items) {
@@ -1003,9 +1128,8 @@ var Dict;
     return result;
   };
   Dict2.has = (key) => (m) => m.has(key);
-  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.some(m.get(key)) : Maybe.none();
+  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.make.some(m.get(key)) : Maybe.make.none();
   Dict2.size = (m) => m.size;
-  Dict2.isEmpty = (m) => m.size === 0;
   Dict2.keys = (m) => [...m.keys()];
   Dict2.values = (m) => [...m.values()];
   Dict2.entries = (m) => [...m.entries()];
@@ -1117,7 +1241,11 @@ var Dict;
     }
     return acc;
   };
-  Dict2.toRecord = (m) => Object.fromEntries(m);
+  let to;
+  ((to2) => {
+    to2.Record = (m) => Object.fromEntries(m);
+  })(to = Dict2.to || (Dict2.to = {}));
+  Dict2.NonEmpty = DictNonEmpty;
 })(Dict || (Dict = {}));
 
 // src/Data/Num.ts
@@ -1139,21 +1267,21 @@ var Num;
   Num2.inRange = (start, end) => (n) => n >= start && n < end;
   Num2.parse = (s) => {
     if (s.trim() === "") {
-      return Maybe.none();
+      return Maybe.make.none();
     }
     const n = Number(s);
-    return isNaN(n) ? Maybe.none() : Maybe.some(n);
+    return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
   };
   Num2.add = (b) => (a) => a + b;
   Num2.subtract = (b) => (a) => a - b;
   Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => b === 0 ? Maybe.none() : Maybe.some(a / b);
+  Num2.divide = (b) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b);
   Num2.abs = (n) => Math.abs(n);
   Num2.negate = (n) => -n;
   Num2.round = (n) => Math.round(n);
   Num2.floor = (n) => Math.floor(n);
   Num2.ceil = (n) => Math.ceil(n);
-  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.some(n % divisor);
+  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor);
   Num2.sum = (ns) => {
     let result = 0;
     for (let i = 0; i < ns.length; i++) {
@@ -1161,10 +1289,10 @@ var Num;
     }
     return result;
   };
-  Num2.mean = (ns) => ns.length === 0 ? Maybe.none() : Maybe.some((0, Num2.sum)(ns) / ns.length);
+  Num2.mean = (ns) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some((0, Num2.sum)(ns) / ns.length);
   Num2.min = (ns) => {
     if (ns.length === 0) {
-      return Maybe.none();
+      return Maybe.make.none();
     }
     let [result] = ns;
     for (let i = 1; i < ns.length; i++) {
@@ -1172,11 +1300,11 @@ var Num;
         result = ns[i];
       }
     }
-    return Maybe.some(result);
+    return Maybe.make.some(result);
   };
   Num2.max = (ns) => {
     if (ns.length === 0) {
-      return Maybe.none();
+      return Maybe.make.none();
     }
     let [result] = ns;
     for (let i = 1; i < ns.length; i++) {
@@ -1184,7 +1312,7 @@ var Num;
         result = ns[i];
       }
     }
-    return Maybe.some(result);
+    return Maybe.make.some(result);
   };
 })(Num || (Num = {}));
 
@@ -1227,32 +1355,43 @@ var RecResult;
 var RecNonEmpty;
 ((RecNonEmpty2) => {
   RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
-  RecNonEmpty2.fromRecord = (data) => _isNonEmpty(data) ? Maybe.some(data) : Maybe.none();
-  RecNonEmpty2.keys = (data) => Object.keys(data);
-  RecNonEmpty2.values = (data) => Object.values(data);
-  RecNonEmpty2.entries = (data) => Object.entries(data);
-  RecNonEmpty2.reduce = (f) => (data) => {
-    const recordVals = Object.values(data);
-    return recordVals.reduce(f);
-  };
+  let from;
+  ((from2) => {
+    from2.Record = (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none();
+  })(from = RecNonEmpty2.from || (RecNonEmpty2.from = {}));
+  RecNonEmpty2.keys = (data) => Rec.keys(data);
+  RecNonEmpty2.values = (data) => Rec.values(data);
+  RecNonEmpty2.entries = (data) => Rec.entries(data);
+  RecNonEmpty2.reduce = (f) => (data) => (0, RecNonEmpty2.values)(data).reduce(f);
+  RecNonEmpty2.map = (f) => (data) => Rec.map(f)(data);
+  RecNonEmpty2.mapWithKey = (f) => (data) => Rec.mapWithKey(f)(data);
 })(RecNonEmpty || (RecNonEmpty = {}));
 var Rec;
 ((Rec2) => {
-  Rec2.isNonEmpty = _isNonEmpty;
-  Rec2.map = (f) => ((data) => {
+  let is;
+  ((is2) => {
+    is2.empty = (data) => Object.keys(data).length === 0;
+    is2.nonEmpty = _isNonEmpty;
+  })(is = Rec2.is || (Rec2.is = {}));
+  Rec2.map = (f) => (data) => {
     const recordKeys = Object.keys(data);
     const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < recordKeys.length; i++) {
-      Object.defineProperty(result, recordKeys[i], {
-        value: f(recordValues[i]),
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
+      const key = recordKeys[i];
+      if (key === "__proto__") {
+        Object.defineProperty(result, "__proto__", {
+          value: f(recordValues[i]),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        result[key] = f(recordValues[i]);
+      }
     }
     return result;
-  });
+  };
   Rec2.filterMap = (f) => (data) => {
     const recordKeys = Object.keys(data);
     const recordValues = Object.values(data);
@@ -1270,20 +1409,25 @@ var Rec;
     }
     return result;
   };
-  Rec2.mapWithKey = (f) => ((data) => {
+  Rec2.mapWithKey = (f) => (data) => {
     const recordKeys = Object.keys(data);
     const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < recordKeys.length; i++) {
-      Object.defineProperty(result, recordKeys[i], {
-        value: f(recordKeys[i], recordValues[i]),
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
+      const key = recordKeys[i];
+      if (key === "__proto__") {
+        Object.defineProperty(result, "__proto__", {
+          value: f(key, recordValues[i]),
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        result[key] = f(key, recordValues[i]);
+      }
     }
     return result;
-  });
+  };
   Rec2.filter = (predicate) => (data) => {
     const recordKeys = Object.keys(data);
     const recordValues = Object.values(data);
@@ -1313,7 +1457,10 @@ var Rec;
   Rec2.keys = (data) => Object.keys(data);
   Rec2.values = (data) => Object.values(data);
   Rec2.entries = (data) => Object.entries(data);
-  Rec2.fromEntries = (data) => Object.fromEntries(data);
+  let from;
+  ((from2) => {
+    from2.entries = (data) => Object.fromEntries(data);
+  })(from = Rec2.from || (Rec2.from = {}));
   Rec2.groupBy = (keyFn) => (items) => {
     const result = {};
     for (const item of items) {
@@ -1354,7 +1501,6 @@ var Rec;
     ...data,
     ...other
   });
-  Rec2.isEmpty = (data) => Object.keys(data).length === 0;
   Rec2.size = (data) => Object.keys(data).length;
   Rec2.mapKeys = (f) => (data) => {
     const result = {};
@@ -1372,14 +1518,34 @@ var Rec;
     }
     return result;
   };
-  Rec2.Maybe = RecMaybe;
-  Rec2.Result = RecResult;
+  let traverse;
+  ((traverse2) => {
+    traverse2.Maybe = RecMaybe.traverse;
+    traverse2.Result = RecResult.traverse;
+  })(traverse = Rec2.traverse || (Rec2.traverse = {}));
+  let sequence;
+  ((sequence2) => {
+    sequence2.Maybe = RecMaybe.sequence;
+    sequence2.Result = RecResult.sequence;
+  })(sequence = Rec2.sequence || (Rec2.sequence = {}));
   Rec2.NonEmpty = RecNonEmpty;
 })(Rec || (Rec = {}));
 
 // src/Data/Str.ts
+var StrNonEmpty;
+((StrNonEmpty2) => {
+  let from;
+  ((from2) => {
+    from2.String = (s) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none();
+  })(from = StrNonEmpty2.from || (StrNonEmpty2.from = {}));
+})(StrNonEmpty || (StrNonEmpty = {}));
 var Str;
 ((Str2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (s) => s.length === 0;
+    is2.nonEmpty = (s) => s.length > 0;
+  })(is = Str2.is || (Str2.is = {}));
   Str2.split = (separator) => (s) => s.split(separator);
   Str2.trim = (s) => s.trim();
   Str2.includes = (substring) => (s) => s.includes(substring);
@@ -1392,7 +1558,6 @@ var Str;
   Str2.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
   Str2.lines = (s) => s.split(/\r?\n|\r/);
   Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
-  Str2.isEmpty = (s) => s.length === 0;
   Str2.isBlank = (s) => s.trim().length === 0;
   Str2.length = (s) => s.length;
   Str2.slice = (start, end) => (s) => s.slice(start, end);
@@ -1411,7 +1576,7 @@ var Str;
      */
     int: (s) => {
       const n = parseInt(s, 10);
-      return isNaN(n) ? Maybe.none() : Maybe.some(n);
+      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
     },
     /**
      * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
@@ -1425,27 +1590,49 @@ var Str;
      */
     float: (s) => {
       const n = parseFloat(s);
-      return isNaN(n) ? Maybe.none() : Maybe.some(n);
+      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
     }
   };
   Str2.parseJson = (s) => {
     try {
-      return Result.ok(JSON.parse(s));
+      return Result.make.ok(JSON.parse(s));
     } catch (error) {
-      return Result.err(error);
+      return Result.make.err(error);
     }
   };
+  Str2.NonEmpty = StrNonEmpty;
 })(Str || (Str = {}));
 
 // src/Data/Uniq.ts
+var UniqNonEmpty;
+((UniqNonEmpty2) => {
+  UniqNonEmpty2.singleton = (item) => new globalThis.Set([item]);
+  let from;
+  ((from2) => {
+    from2.Set = (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none();
+  })(from = UniqNonEmpty2.from || (UniqNonEmpty2.from = {}));
+  UniqNonEmpty2.reduce = (f) => (s) => to.Array(s).reduce(f);
+  UniqNonEmpty2.map = (f) => (s) => Uniq.map(f)(s);
+  let to;
+  ((to2) => {
+    to2.Array = (s) => Uniq.to.Array(s);
+  })(to = UniqNonEmpty2.to || (UniqNonEmpty2.to = {}));
+})(UniqNonEmpty || (UniqNonEmpty = {}));
 var Uniq;
 ((Uniq2) => {
+  let is;
+  ((is2) => {
+    is2.empty = (s) => s.size === 0;
+    is2.nonEmpty = (s) => s.size > 0;
+  })(is = Uniq2.is || (Uniq2.is = {}));
   Uniq2.empty = () => new globalThis.Set();
   Uniq2.singleton = (item) => new globalThis.Set([item]);
-  Uniq2.fromArray = (arr) => new globalThis.Set(arr);
+  let from;
+  ((from2) => {
+    from2.Array = (arr) => new globalThis.Set(arr);
+  })(from = Uniq2.from || (Uniq2.from = {}));
   Uniq2.has = (item) => (s) => s.has(item);
   Uniq2.size = (s) => s.size;
-  Uniq2.isEmpty = (s) => s.size === 0;
   Uniq2.isSubsetOf = (other) => (s) => {
     const set = s;
     if (typeof set.isSubsetOf === "function") {
@@ -1534,7 +1721,11 @@ var Uniq;
     }
     return acc;
   };
-  Uniq2.toArray = (s) => [...s];
+  let to;
+  ((to2) => {
+    to2.Array = (s) => [...s];
+  })(to = Uniq2.to || (Uniq2.to = {}));
+  Uniq2.NonEmpty = UniqNonEmpty;
 })(Uniq || (Uniq = {}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {