@nlozgachev/pipelined 0.44.0 → 0.46.0

package/dist/{chunk-LKTOK5IT.mjs → chunk-W2L244AS.mjs}

@@ -4,7 +4,7 @@ import {
   Result,
   Task,
   isNonEmptyArr
-} from "./chunk-ND476266.mjs";
+} from "./chunk-VSU36S2K.mjs";
 
 // src/Data/Arr.ts
 var ArrMaybe;
@@ -15,11 +15,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 = {}));
@@ -35,61 +35,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;
@@ -283,10 +291,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;
@@ -368,12 +395,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) {
@@ -388,9 +437,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()];
@@ -502,7 +550,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
@@ -524,21 +576,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++) {
@@ -546,10 +598,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++) {
@@ -557,11 +609,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++) {
@@ -569,7 +621,7 @@ var Num;
         result = ns[i];
       }
     }
-    return Maybe.some(result);
+    return Maybe.make.some(result);
   };
 })(Num || (Num = {}));
 
@@ -612,32 +664,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);
@@ -655,20 +718,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);
@@ -698,7 +766,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) {
@@ -739,7 +810,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 = {};
@@ -757,14 +827,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);
@@ -777,7 +867,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);
@@ -796,7 +885,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`.
@@ -810,27 +899,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") {
@@ -919,7 +1030,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 = {}));
 
 export {

package/dist/{chunk-74JKKJ4R.mjs → chunk-XTVF5R6R.mjs}

@@ -14,11 +14,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 = {}));

package/dist/composition.d.mts

@@ -1,4 +1,4 @@
-import { A as Awaitable, T as Thenable } from './InternalTypes-BL23H8Qr.mjs';
+import { A as Awaitable, T as Thenable } from './InternalTypes-CLE7qlOc.mjs';
 import { Duration } from './types.mjs';
 
 /**
@@ -110,13 +110,13 @@ declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A
  * ```ts
  * // Original data-last (for pipe)
  * pipe(
- *   Maybe.some(5),
+ *   Maybe.make.some(5),
  *   Maybe.map(n => n * 2)
  * ); // Some(10)
  *
  * // Flipped to data-first
  * const mapFirst = flip(Maybe.map);
- * mapFirst(Maybe.some(5))(n => n * 2); // Some(10)
+ * mapFirst(Maybe.make.some(5))(n => n * 2); // Some(10)
  * ```
  *
  * @see {@link uncurry} for converting curried functions to multi-argument functions
@@ -265,7 +265,7 @@ interface flow {
  * @example
  * ```ts
  * identity(42); // 42
- * pipe(Maybe.some(5), Maybe.fold(() => 0, identity)); // 5
+ * pipe(Maybe.make.some(5), Maybe.fold(() => 0, identity)); // 5
  * ```
  */
 declare const identity: <A>(a: A) => A;
@@ -496,7 +496,7 @@ declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a:
  *
  * // With library functions
  * const greeting = pipe(
- *   Maybe.some("Alice"),
+ *   Maybe.make.some("Alice"),
  *   Maybe.map(name => name.toUpperCase()),
  *   Maybe.map(name => `Hello, ${name}!`),
  *   Maybe.getOrElse(() => "Hello!")
@@ -599,7 +599,7 @@ interface pipe {
  * ```ts
  * // Debugging a pipeline
  * pipe(
- *   Maybe.some(5),
+ *   Maybe.make.some(5),
  *   tap(x => console.log("Before map:", x)),
  *   Maybe.map(n => n * 2),
  *   tap(x => console.log("After map:", x)),
@@ -739,7 +739,7 @@ declare namespace tap {
      * pipe(
      *   data,
      *   tap.time(fetchData, {
-     *     onFinish: (dur) => metrics.histogram("api.time", Duration.toMilliseconds(dur))
+     *     onFinish: (dur) => metrics.histogram("api.time", Duration.to.milliseconds(dur))
      *   })
      * );
      * ```
@@ -760,15 +760,15 @@ declare namespace tap {
  * uncurry(nested)(); // 42
  *
  * // Original curried function
- * Maybe.map(n => n * 2)(Maybe.some(5)); // Some(10)
+ * Maybe.map(n => n * 2)(Maybe.make.some(5)); // Some(10)
  *
  * // Uncurried - all arguments at once
  * const mapUncurried = uncurry(Maybe.map);
- * mapUncurried(n => n * 2, Maybe.some(5)); // Some(10)
+ * mapUncurried(n => n * 2, Maybe.make.some(5)); // Some(10)
  *
  * // Combined with flip for data-first uncurried
  * const mapDataFirst = uncurry(flip(Maybe.map));
- * mapDataFirst(Maybe.some(5), n => n * 2); // Some(10)
+ * mapDataFirst(Maybe.make.some(5), n => n * 2); // Some(10)
  * ```
  *
  * @see {@link flip} for reversing curried argument order

package/dist/composition.d.ts

@@ -1,4 +1,4 @@
-import { A as Awaitable, T as Thenable } from './InternalTypes-7o9-yrHq.js';
+import { A as Awaitable, T as Thenable } from './InternalTypes-Mssktd7z.js';
 import { Duration } from './types.js';
 
 /**
@@ -110,13 +110,13 @@ declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A
  * ```ts
  * // Original data-last (for pipe)
  * pipe(
- *   Maybe.some(5),
+ *   Maybe.make.some(5),
  *   Maybe.map(n => n * 2)
  * ); // Some(10)
  *
  * // Flipped to data-first
  * const mapFirst = flip(Maybe.map);
- * mapFirst(Maybe.some(5))(n => n * 2); // Some(10)
+ * mapFirst(Maybe.make.some(5))(n => n * 2); // Some(10)
  * ```
  *
  * @see {@link uncurry} for converting curried functions to multi-argument functions
@@ -265,7 +265,7 @@ interface flow {
  * @example
  * ```ts
  * identity(42); // 42
- * pipe(Maybe.some(5), Maybe.fold(() => 0, identity)); // 5
+ * pipe(Maybe.make.some(5), Maybe.fold(() => 0, identity)); // 5
  * ```
  */
 declare const identity: <A>(a: A) => A;
@@ -496,7 +496,7 @@ declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a:
  *
  * // With library functions
  * const greeting = pipe(
- *   Maybe.some("Alice"),
+ *   Maybe.make.some("Alice"),
  *   Maybe.map(name => name.toUpperCase()),
  *   Maybe.map(name => `Hello, ${name}!`),
  *   Maybe.getOrElse(() => "Hello!")
@@ -599,7 +599,7 @@ interface pipe {
  * ```ts
  * // Debugging a pipeline
  * pipe(
- *   Maybe.some(5),
+ *   Maybe.make.some(5),
  *   tap(x => console.log("Before map:", x)),
  *   Maybe.map(n => n * 2),
  *   tap(x => console.log("After map:", x)),
@@ -739,7 +739,7 @@ declare namespace tap {
      * pipe(
      *   data,
      *   tap.time(fetchData, {
-     *     onFinish: (dur) => metrics.histogram("api.time", Duration.toMilliseconds(dur))
+     *     onFinish: (dur) => metrics.histogram("api.time", Duration.to.milliseconds(dur))
      *   })
      * );
      * ```
@@ -760,15 +760,15 @@ declare namespace tap {
  * uncurry(nested)(); // 42
  *
  * // Original curried function
- * Maybe.map(n => n * 2)(Maybe.some(5)); // Some(10)
+ * Maybe.map(n => n * 2)(Maybe.make.some(5)); // Some(10)
  *
  * // Uncurried - all arguments at once
  * const mapUncurried = uncurry(Maybe.map);
- * mapUncurried(n => n * 2, Maybe.some(5)); // Some(10)
+ * mapUncurried(n => n * 2, Maybe.make.some(5)); // Some(10)
  *
  * // Combined with flip for data-first uncurried
  * const mapDataFirst = uncurry(flip(Maybe.map));
- * mapDataFirst(Maybe.some(5), n => n * 2); // Some(10)
+ * mapDataFirst(Maybe.make.some(5), n => n * 2); // Some(10)
  * ```
  *
  * @see {@link flip} for reversing curried argument order