@nlozgachev/pipelined 0.44.0 → 0.46.0

package/dist/core.js

@@ -57,8 +57,8 @@ var Combinable;
   Combinable2.any = { empty: false, combine: (b) => (a) => a || b };
   Combinable2.array = () => ({ empty: [], combine: (b) => (a) => [...a, ...b] });
   Combinable2.maybe = (inner) => ({
-    empty: Maybe.none(),
-    combine: (b) => (a) => Maybe.isNone(a) ? b : Maybe.isNone(b) ? a : Maybe.some(inner.combine(b.value)(a.value))
+    empty: Maybe.make.none(),
+    combine: (b) => (a) => Maybe.is.none(a) ? b : Maybe.is.none(b) ? a : Maybe.make.some(inner.combine(b.value)(a.value))
   });
   Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
 })(Combinable || (Combinable = {}));
@@ -66,11 +66,17 @@ var Combinable;
 // 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/Equality.ts
@@ -114,12 +120,15 @@ var Lazy;
 // src/Core/Lens.ts
 var Lens;
 ((Lens3) => {
-  Lens3.make = (get2, set2) => ({ get: get2, set: set2 });
-  Lens3.prop = () => (key) => (0, Lens3.make)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
+  let from;
+  ((from2) => {
+    from2.accessors = (get2, set2) => ({ get: get2, set: set2 });
+    from2.property = () => (key) => (0, from2.accessors)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
+  })(from = Lens3.from || (Lens3.from = {}));
   Lens3.get = (lens) => (s) => lens.get(s);
   Lens3.set = (lens) => (a) => (s) => lens.set(a)(s);
   Lens3.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-  Lens3.andThen = (inner) => (outer) => (0, Lens3.make)((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
+  Lens3.andThen = (inner) => (outer) => from.accessors((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
   Lens3.andThenOptional = (inner) => (outer) => ({
     get: (s) => inner.get(outer.get(s)),
     set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
@@ -133,8 +142,11 @@ var Lens;
 // src/Core/Logged.ts
 var Logged;
 ((Logged2) => {
-  Logged2.make = (value) => ({ value, log: [] });
-  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
+  let from;
+  ((from2) => {
+    from2.value = (val) => ({ value: val, log: [] });
+    from2.entry = (logEntry) => ({ value: void 0, log: [logEntry] });
+  })(from = Logged2.from || (Logged2.from = {}));
   Logged2.map = (f) => (data) => ({
     value: f(data.value),
     log: data.log
@@ -161,47 +173,59 @@ var Logged;
 // 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 = {}));
 
@@ -221,11 +245,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 = {}));
@@ -239,7 +266,7 @@ var _idle = { kind: "Idle" };
 var _pending = { kind: "Pending" };
 var ok = (value) => ({ kind: "OpOk", value });
 var err = (error) => ({ kind: "OpErr", error });
-var getMs = (duration) => Duration.toMilliseconds(duration);
+var getMs = (duration) => Duration.to.milliseconds(duration);
 var cancellableWait = (duration, signal) => {
   const rawMs = getMs(duration);
   if (rawMs <= 0) {
@@ -262,7 +289,7 @@ var runWithRetry = (op, input, signal, options, onRetrying) => {
     return typeof backoff === "function" ? backoff(n) : backoff;
   };
   const attempt = async (left) => {
-    const result = await Deferred.toPromise(op._factory(input, signal));
+    const result = await Deferred.to.Promise(op._factory(input, signal));
     if (result === null || signal.aborted) {
       return null;
     }
@@ -297,12 +324,12 @@ var runWithRetry = (op, input, signal, options, onRetrying) => {
 var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying) => {
   const { signal } = controller;
   const toOutcome = (r) => r === null ? _abortedNil : r.kind === "Ok" ? ok(r.value) : err(r.error);
-  const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, input, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.toPromise(op._factory(input, signal)).then(toOutcome);
+  const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, input, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.to.Promise(op._factory(input, signal)).then(toOutcome);
   if (timeoutOptions === void 0) {
-    return Deferred.fromPromise(runPromise);
+    return Deferred.from.Promise(runPromise);
   }
   let timerId;
-  return Deferred.fromPromise(Promise.race([
+  return Deferred.from.Promise(Promise.race([
     runPromise.then((outcome) => {
       clearTimeout(timerId);
       return outcome;
@@ -326,7 +353,7 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
     currentState = state;
     subscribers.forEach((cb) => cb(state));
   };
-  const run = (input) => Deferred.fromPromise(
+  const run = (input) => Deferred.from.Promise(
     new Promise((resolve) => {
       waitController?.abort();
       waitController = void 0;
@@ -418,9 +445,9 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
   };
   const run = (input) => {
     if (currentController !== void 0 || cooldownTimer !== void 0) {
-      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
     }
-    return Deferred.fromPromise(
+    return Deferred.from.Promise(
       new Promise((resolve) => {
         currentResolve = resolve;
         currentController = new AbortController();
@@ -540,14 +567,14 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
       }
     }
     if (inFlight < maxConcurrency) {
-      return Deferred.fromPromise(
+      return Deferred.from.Promise(
         new Promise((resolve) => {
           startOne(input, resolve, myGeneration);
         })
       );
     }
     if (maxSize === void 0 || queue.length < maxSize) {
-      return Deferred.fromPromise(
+      return Deferred.from.Promise(
         new Promise((resolve) => {
           queue.push({ input, resolve });
           emit({ kind: "Queued", position: queue.length - 1 });
@@ -555,7 +582,7 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
       );
     }
     if (overflow === "replace-last") {
-      return Deferred.fromPromise(
+      return Deferred.from.Promise(
         new Promise((resolve) => {
           const tail = queue.pop();
           tail.resolve(_evictedNil);
@@ -564,7 +591,7 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
         })
       );
     }
-    return Deferred.fromPromise(Promise.resolve(_droppedNil));
+    return Deferred.from.Promise(Promise.resolve(_droppedNil));
   };
   const abort = () => {
     generation++;
@@ -636,7 +663,7 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
       }
     });
   };
-  const run = (input) => Deferred.fromPromise(
+  const run = (input) => Deferred.from.Promise(
     new Promise((resolve) => {
       if (currentController === void 0) {
         startRun(input, resolve);
@@ -762,7 +789,7 @@ var makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOption
     timerId = setTimeout(fireTrailing, delay);
   };
   const inDebounceWindow = () => timerId !== void 0 || leadingController !== void 0 || currentController !== void 0;
-  const run = (input) => Deferred.fromPromise(
+  const run = (input) => Deferred.from.Promise(
     new Promise((resolve) => {
       if (!inDebounceWindow()) {
         firstCallAt = Date.now();
@@ -877,9 +904,9 @@ var makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) => {
   const run = (input) => {
     if (cooldownTimer !== void 0) {
       if (!trailing) {
-        return Deferred.fromPromise(Promise.resolve(_droppedNil));
+        return Deferred.from.Promise(Promise.resolve(_droppedNil));
       }
-      return Deferred.fromPromise(
+      return Deferred.from.Promise(
         new Promise((resolve) => {
           const prev = pendingResolve;
           pendingInput = input;
@@ -888,7 +915,7 @@ var makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) => {
         })
       );
     }
-    return Deferred.fromPromise(
+    return Deferred.from.Promise(
       new Promise((resolve) => {
         fireOp(input, resolve);
         startCooldown();
@@ -979,16 +1006,16 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
   const run = (input) => {
     const myGeneration = generation;
     if (inflight < n) {
-      return Deferred.fromPromise(
+      return Deferred.from.Promise(
         new Promise((resolve) => {
           startOne(input, resolve, myGeneration);
         })
       );
     }
     if (overflow === "drop") {
-      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
     }
-    return Deferred.fromPromise(
+    return Deferred.from.Promise(
       new Promise((resolve) => {
         overflowQueue.push({ input, resolve });
         emit({ kind: "Queued", position: overflowQueue.length - 1 });
@@ -1041,7 +1068,7 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
     const k = keyFn(input);
     if (slots.has(k)) {
       if (perKey === "exclusive") {
-        return Deferred.fromPromise(Promise.resolve(_droppedNil));
+        return Deferred.from.Promise(Promise.resolve(_droppedNil));
       }
       const existing = slots.get(k);
       existing.controller.abort();
@@ -1049,7 +1076,7 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
       slots.delete(k);
       prev(_replacedNil);
     }
-    return Deferred.fromPromise(
+    return Deferred.from.Promise(
       new Promise((resolve) => {
         const controller = new AbortController();
         slots.set(k, { controller, resolve });
@@ -1129,9 +1156,9 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
   };
   const run = (input) => {
     if (currentState.kind !== "Idle") {
-      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+      return Deferred.from.Promise(Promise.resolve(_droppedNil));
     }
-    return Deferred.fromPromise(
+    return Deferred.from.Promise(
       new Promise((resolve) => {
         currentResolve = resolve;
         currentController = new AbortController();
@@ -1192,10 +1219,8 @@ var Op;
 ((Op2) => {
   Op2.nil = (reason) => ({ kind: "OpNil", reason });
   Op2.create = (factory, onError) => ({
-    _factory: (input, signal) => Deferred.fromPromise(
-      factory(signal)(input).then((value) => Result.ok(value)).catch(
-        (error) => signal.aborted ? null : Result.err(onError(error))
-      )
+    _factory: (input, signal) => Deferred.from.Promise(
+      factory(signal)(input).then((value) => Result.make.ok(value)).catch((error) => signal.aborted ? null : Result.make.err(onError(error)))
     )
   });
   Op2.lift = (f) => (0, Op2.create)((signal) => (input) => f(input, signal), (e) => e);
@@ -1237,18 +1262,21 @@ var Op;
     return outcome;
   };
   Op2.recover = (f) => (outcome) => outcome.kind === "OpErr" ? f(outcome.error) : outcome;
-  Op2.toResult = (onNil) => (outcome) => {
-    if (outcome.kind === "OpOk") {
-      return Result.ok(outcome.value);
-    }
-    if (outcome.kind === "OpErr") {
-      return Result.err(outcome.error);
-    }
-    return Result.err(onNil());
-  };
-  Op2.toMaybe = (outcome) => outcome.kind === "OpOk" ? Maybe.some(outcome.value) : Maybe.none();
-  Op2.all = (invocations) => Deferred.fromPromise(Promise.all(invocations.map(Deferred.toPromise)));
-  Op2.race = (invocations) => Deferred.fromPromise(Promise.race(invocations.map(Deferred.toPromise)));
+  let to;
+  ((to2) => {
+    to2.Result = (onNil) => (outcome) => {
+      if (outcome.kind === "OpOk") {
+        return Result.make.ok(outcome.value);
+      }
+      if (outcome.kind === "OpErr") {
+        return Result.make.err(outcome.error);
+      }
+      return Result.make.err(onNil());
+    };
+    to2.Maybe = (outcome) => outcome.kind === "OpOk" ? Maybe.make.some(outcome.value) : Maybe.make.none();
+  })(to = Op2.to || (Op2.to = {}));
+  Op2.all = (invocations) => Deferred.from.Promise(Promise.all(invocations.map(Deferred.to.Promise)));
+  Op2.race = (invocations) => Deferred.from.Promise(Promise.race(invocations.map(Deferred.to.Promise)));
   Op2.wire = (source, f) => source.subscribe((state) => {
     if ((0, Op2.isOk)(state)) {
       f(state.value);
@@ -1313,12 +1341,18 @@ var Op;
 // src/Core/Optional.ts
 var Optional;
 ((Optional2) => {
-  Optional2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Optional2.prop = () => (key) => (0, Optional2.make)((s) => {
-    const val = s[key];
-    return val !== null && val !== void 0 ? Maybe.some(val) : Maybe.none();
-  }, (a) => (s) => ({ ...s, [key]: a }));
-  Optional2.index = (i) => (0, Optional2.make)((arr) => i >= 0 && i < arr.length ? Maybe.some(arr[i]) : Maybe.none(), (a) => (arr) => {
+  let from;
+  ((from2) => {
+    from2.accessors = (get2, set2) => ({
+      get: get2,
+      set: set2
+    });
+    from2.property = () => (key) => (0, from2.accessors)((s) => {
+      const val = s[key];
+      return val !== null && val !== void 0 ? Maybe.make.some(val) : Maybe.make.none();
+    }, (a) => (s) => ({ ...s, [key]: a }));
+  })(from = Optional2.from || (Optional2.from = {}));
+  Optional2.index = (i) => from.accessors((arr) => i >= 0 && i < arr.length ? Maybe.make.some(arr[i]) : Maybe.make.none(), (a) => (arr) => {
     if (i < 0 || i >= arr.length) {
       return arr;
     }
@@ -1344,16 +1378,16 @@ var Optional;
     const val = opt.get(s);
     return val.kind === "Some" ? cases.some(val.value) : cases.none();
   };
-  Optional2.andThen = (inner) => (outer) => (0, Optional2.make)((s) => {
+  Optional2.andThen = (inner) => (outer) => from.accessors((s) => {
     const mid = outer.get(s);
-    return mid.kind === "None" ? Maybe.none() : inner.get(mid.value);
+    return mid.kind === "None" ? Maybe.make.none() : inner.get(mid.value);
   }, (b) => (s) => {
     const mid = outer.get(s);
     return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
   });
-  Optional2.andThenLens = (inner) => (outer) => (0, Optional2.make)((s) => {
+  Optional2.andThenLens = (inner) => (outer) => from.accessors((s) => {
     const mid = outer.get(s);
-    return mid.kind === "None" ? Maybe.none() : Maybe.some(inner.get(mid.value));
+    return mid.kind === "None" ? Maybe.make.none() : Maybe.make.some(inner.get(mid.value));
   }, (b) => (s) => {
     const mid = outer.get(s);
     return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
@@ -1383,7 +1417,10 @@ var Predicate;
   Predicate2.using = (f) => (p) => (b) => p(f(b));
   Predicate2.all = (predicates) => (a) => predicates.every((p) => p(a));
   Predicate2.any = (predicates) => (a) => predicates.some((p) => p(a));
-  Predicate2.fromRefinement = (r) => r;
+  let from;
+  ((from2) => {
+    from2.Refinement = (r) => r;
+  })(from = Predicate2.from || (Predicate2.from = {}));
 })(Predicate || (Predicate = {}));
 
 // src/Core/Reader.ts
@@ -1411,12 +1448,18 @@ var Reader;
 // src/Core/Refinement.ts
 var Refinement;
 ((Refinement2) => {
-  Refinement2.make = (f) => f;
+  let from;
+  ((from2) => {
+    from2.predicate = (f) => f;
+  })(from = Refinement2.from || (Refinement2.from = {}));
   Refinement2.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
-  Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
-  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
+  let to;
+  ((to2) => {
+    to2.Maybe = (r) => (a) => r(a) ? Maybe.make.some(a) : Maybe.make.none();
+    to2.Result = (r, onFail) => (a) => r(a) ? Result.make.ok(a) : Result.make.err(onFail(a));
+  })(to = Refinement2.to || (Refinement2.to = {}));
 })(Refinement || (Refinement = {}));
 
 // src/Core/RemoteData.ts
@@ -1424,31 +1467,37 @@ var _notAsked = { kind: "NotAsked" };
 var _loading = { kind: "Loading" };
 var RemoteData;
 ((RemoteData2) => {
-  RemoteData2.notAsked = () => _notAsked;
-  RemoteData2.loading = () => _loading;
-  RemoteData2.failure = (error) => ({ kind: "Failure", error });
-  RemoteData2.success = (value) => ({ kind: "Success", value });
-  RemoteData2.isNotAsked = (data) => data.kind === "NotAsked";
-  RemoteData2.isLoading = (data) => data.kind === "Loading";
-  RemoteData2.isFailure = (data) => data.kind === "Failure";
-  RemoteData2.isSuccess = (data) => data.kind === "Success";
-  RemoteData2.map = (f) => (data) => (0, RemoteData2.isSuccess)(data) ? (0, RemoteData2.success)(f(data.value)) : data;
-  RemoteData2.mapError = (f) => (data) => (0, RemoteData2.isFailure)(data) ? (0, RemoteData2.failure)(f(data.error)) : data;
-  RemoteData2.chain = (f) => (data) => (0, RemoteData2.isSuccess)(data) ? f(data.value) : data;
+  let make;
+  ((make2) => {
+    make2.notAsked = () => _notAsked;
+    make2.loading = () => _loading;
+    make2.failure = (error) => ({ kind: "Failure", error });
+    make2.success = (value) => ({ kind: "Success", value });
+  })(make = RemoteData2.make || (RemoteData2.make = {}));
+  let is;
+  ((is2) => {
+    is2.notAsked = (data) => data.kind === "NotAsked";
+    is2.loading = (data) => data.kind === "Loading";
+    is2.failure = (data) => data.kind === "Failure";
+    is2.success = (data) => data.kind === "Success";
+  })(is = RemoteData2.is || (RemoteData2.is = {}));
+  RemoteData2.map = (f) => (data) => is.success(data) ? make.success(f(data.value)) : data;
+  RemoteData2.mapError = (f) => (data) => is.failure(data) ? make.failure(f(data.error)) : data;
+  RemoteData2.chain = (f) => (data) => is.success(data) ? f(data.value) : data;
   RemoteData2.ap = (arg) => (data) => {
-    if ((0, RemoteData2.isSuccess)(data) && (0, RemoteData2.isSuccess)(arg)) {
-      return (0, RemoteData2.success)(data.value(arg.value));
+    if (is.success(data) && is.success(arg)) {
+      return make.success(data.value(arg.value));
     }
-    if ((0, RemoteData2.isFailure)(data)) {
+    if (is.failure(data)) {
       return data;
     }
-    if ((0, RemoteData2.isFailure)(arg)) {
+    if (is.failure(arg)) {
       return arg;
     }
-    if ((0, RemoteData2.isLoading)(data) || (0, RemoteData2.isLoading)(arg)) {
-      return (0, RemoteData2.loading)();
+    if (is.loading(data) || is.loading(arg)) {
+      return make.loading();
     }
-    return (0, RemoteData2.notAsked)();
+    return make.notAsked();
   };
   RemoteData2.fold = (onFailure, onNotAsked, onLoading, onSuccess) => (data) => {
     switch (data.kind) {
@@ -1482,69 +1531,78 @@ var RemoteData;
       }
     }
   };
-  RemoteData2.getOrElse = (defaultValue) => (data) => (0, RemoteData2.isSuccess)(data) ? data.value : defaultValue();
+  RemoteData2.getOrElse = (defaultValue) => (data) => is.success(data) ? data.value : defaultValue();
   RemoteData2.tap = (f) => (data) => {
-    if ((0, RemoteData2.isSuccess)(data)) {
+    if (is.success(data)) {
       f(data.value);
     }
     return data;
   };
   RemoteData2.tapError = (f) => (data) => {
-    if ((0, RemoteData2.isFailure)(data)) {
+    if (is.failure(data)) {
       f(data.error);
     }
     return data;
   };
-  RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
-  RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
-  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
-  RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
-  RemoteData2.fromMaybe = (onNone) => (data) => Maybe.isSome(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(onNone());
-  RemoteData2.filter = (pred, onFalse) => (data) => (0, RemoteData2.isSuccess)(data) ? pred(data.value) ? data : (0, RemoteData2.failure)(onFalse(data.value)) : data;
+  RemoteData2.recover = (fallback) => (data) => is.failure(data) ? fallback(data.error) : data;
+  let to;
+  ((to2) => {
+    to2.Maybe = (data) => is.success(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+    to2.Result = (onNotReady) => (data) => is.success(data) ? Result.make.ok(data.value) : Result.make.err(is.failure(data) ? data.error : onNotReady());
+  })(to = RemoteData2.to || (RemoteData2.to = {}));
+  let from;
+  ((from2) => {
+    from2.Result = (data) => Result.is.ok(data) ? make.success(data.value) : make.failure(data.error);
+    from2.Maybe = (onNone) => (data) => Maybe.is.some(data) ? make.success(data.value) : make.failure(onNone());
+  })(from = RemoteData2.from || (RemoteData2.from = {}));
+  RemoteData2.filter = (pred, onFalse) => (data) => is.success(data) ? pred(data.value) ? data : make.failure(onFalse(data.value)) : data;
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Resource.ts
 var Resource;
 ((Resource2) => {
-  Resource2.make = (acquire, release) => ({
-    acquire,
-    release
-  });
-  Resource2.fromTask = (acquire, release) => ({
-    acquire: Task.map((a) => Result.ok(a))(acquire),
-    release
-  });
-  Resource2.use = (f) => (resource) => Task.from(
-    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
-      if (Result.isErr(acquired)) {
+  let from;
+  ((from2) => {
+    from2.handlers = (acquire, release) => ({
+      acquire,
+      release
+    });
+    from2.Task = (acquire, release) => ({
+      acquire: Task.map((a) => Result.make.ok(a))(acquire),
+      release
+    });
+  })(from = Resource2.from || (Resource2.from = {}));
+  Resource2.use = (f) => (resource) => Task.from.Promise(
+    (signal) => Deferred.to.Promise(resource.acquire(signal)).then(async (acquired) => {
+      if (Result.is.err(acquired)) {
         return acquired;
       }
       const a = acquired.value;
       try {
-        const usageResult = await Deferred.toPromise(f(a)(signal));
+        const usageResult = await Deferred.to.Promise(f(a)(signal));
         return usageResult;
       } finally {
-        await Deferred.toPromise(resource.release(a)(signal));
+        await Deferred.to.Promise(resource.release(a)(signal));
       }
     })
   );
   Resource2.combine = (resourceA, resourceB) => ({
-    acquire: Task.from(
-      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
-        if (Result.isErr(acquiredA)) {
+    acquire: Task.from.Promise(
+      (signal) => Deferred.to.Promise(resourceA.acquire(signal)).then(async (acquiredA) => {
+        if (Result.is.err(acquiredA)) {
           return acquiredA;
         }
         const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
-        if (Result.isErr(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)(signal));
+        const acquiredB = await Deferred.to.Promise(resourceB.acquire(signal));
+        if (Result.is.err(acquiredB)) {
+          await Deferred.to.Promise(resourceA.release(a)(signal));
           return acquiredB;
         }
-        return Result.ok([a, acquiredB.value]);
+        return Result.make.ok([a, acquiredB.value]);
       })
     ),
-    release: ([a, b]) => Task.from(
-      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
+    release: ([a, b]) => Task.from.Promise(
+      (signal) => Deferred.to.Promise(resourceB.release(b)(signal)).then(() => Deferred.to.Promise(resourceA.release(a)(signal)))
     )
   });
 })(Resource || (Resource = {}));
@@ -1552,49 +1610,61 @@ var Resource;
 // src/Core/Result.ts
 var Result;
 ((Result4) => {
-  Result4.ok = (value) => ({ kind: "Ok", value });
-  Result4.err = (e) => ({ kind: "Err", error: e });
-  Result4.isOk = (data) => data.kind === "Ok";
-  Result4.isErr = (data) => data.kind === "Err";
+  let make;
+  ((make2) => {
+    make2.ok = (value) => ({ kind: "Ok", value });
+    make2.err = (e) => ({ kind: "Err", error: e });
+  })(make = Result4.make || (Result4.make = {}));
+  let is;
+  ((is2) => {
+    is2.ok = (data) => data.kind === "Ok";
+    is2.err = (data) => data.kind === "Err";
+  })(is = Result4.is || (Result4.is = {}));
   Result4.tryCatch = (f, onError) => {
     try {
-      return (0, Result4.ok)(f());
+      return make.ok(f());
     } catch (error) {
-      return (0, Result4.err)(onError(error));
+      return make.err(onError(error));
     }
   };
-  Result4.map = (f) => (data) => (0, Result4.isOk)(data) ? (0, Result4.ok)(f(data.value)) : data;
-  Result4.mapError = (f) => (data) => (0, Result4.isErr)(data) ? (0, Result4.err)(f(data.error)) : data;
-  Result4.chain = (f) => (data) => (0, Result4.isOk)(data) ? f(data.value) : data;
-  Result4.fold = (onErr, onOk) => (data) => (0, Result4.isOk)(data) ? onOk(data.value) : onErr(data.error);
-  Result4.match = (cases) => (data) => (0, Result4.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
-  Result4.getOrElse = (defaultValue) => (data) => (0, Result4.isOk)(data) ? data.value : defaultValue();
+  Result4.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
+  Result4.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
+  Result4.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
+  Result4.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
+  Result4.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result4.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
   Result4.tap = (f) => (data) => {
-    if ((0, Result4.isOk)(data)) {
+    if (is.ok(data)) {
       f(data.value);
     }
     return data;
   };
   Result4.tapError = (f) => (data) => {
-    if ((0, Result4.isErr)(data)) {
+    if (is.err(data)) {
       f(data.error);
     }
     return data;
   };
-  Result4.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result4.ok)(a) : (0, Result4.err)(onFalse(a));
-  Result4.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result4.err)(onNull()) : (0, Result4.ok)(value);
-  Result4.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result4.err)(onNone()) : (0, Result4.ok)(maybe.value);
-  Result4.fromThrowable = (f, onError) => (...args) => {
-    try {
-      return (0, Result4.ok)(f(...args));
-    } catch (error) {
-      return (0, Result4.err)(onError(error));
-    }
-  };
-  Result4.recover = (fallback) => (data) => (0, Result4.isOk)(data) ? data : fallback(data.error);
-  Result4.recoverUnless = (isBlocked, fallback) => (data) => (0, Result4.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
-  Result4.toMaybe = (data) => (0, Result4.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result4.ap = (arg) => (data) => (0, Result4.isOk)(data) && (0, Result4.isOk)(arg) ? (0, Result4.ok)(data.value(arg.value)) : (0, Result4.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 = Result4.from || (Result4.from = {}));
+  Result4.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
+  Result4.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 = Result4.to || (Result4.to = {}));
+  Result4.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
   Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
   Result4.bind = (key, f) => (data) => (0, Result4.chain)(
     (a) => (0, Result4.map)((b) => ({ ...a, [key]: b }))(f(a))
@@ -1604,13 +1674,13 @@ var Result;
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if ((0, Result4.isErr)(res)) {
+        if (is.err(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return (0, Result4.ok)(result);
+    return make.ok(result);
   };
 })(Result || (Result = {}));
 
@@ -1652,17 +1722,24 @@ var State;
 // 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_)
     )
   );
@@ -1671,25 +1748,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 = {}));
@@ -1697,28 +1779,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_)
     )
   );
@@ -1727,19 +1816,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 = {}));
@@ -1750,19 +1839,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)
     )
   );
@@ -1771,61 +1869,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 getMs2 = (duration) => Duration.toMilliseconds(duration);
+var toPromise = (task, signal) => Deferred.to.Promise(task(signal));
+var getMs2 = (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 = () => {
@@ -1844,7 +1945,7 @@ var Task;
       }, getMs2(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([]);
@@ -1878,7 +1979,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;
@@ -1915,10 +2016,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) {
@@ -1947,8 +2048,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) {
@@ -1958,7 +2059,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 = () => {
@@ -1981,13 +2082,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()));
         }, getMs2(duration));
       })
     ]);
@@ -2006,7 +2107,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 };
   };
@@ -2023,67 +2124,73 @@ var Task;
 // src/Core/These.ts
 var These;
 ((These2) => {
-  These2.first = (value) => ({ kind: "First", first: value });
-  These2.second = (value) => ({ kind: "Second", second: value });
-  These2.both = (f, s) => ({ kind: "Both", first: f, second: s });
-  These2.isFirst = (data) => data.kind === "First";
-  These2.isSecond = (data) => data.kind === "Second";
-  These2.isBoth = (data) => data.kind === "Both";
+  let make;
+  ((make2) => {
+    make2.first = (value) => ({ kind: "First", first: value });
+    make2.second = (value) => ({ kind: "Second", second: value });
+    make2.both = (f, s) => ({ kind: "Both", first: f, second: s });
+  })(make = These2.make || (These2.make = {}));
+  let is;
+  ((is2) => {
+    is2.first = (data) => data.kind === "First";
+    is2.second = (data) => data.kind === "Second";
+    is2.both = (data) => data.kind === "Both";
+  })(is = These2.is || (These2.is = {}));
   These2.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
   These2.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
   These2.mapFirst = (f) => (data) => {
-    if ((0, These2.isSecond)(data)) {
+    if (is.second(data)) {
       return data;
     }
-    if ((0, These2.isFirst)(data)) {
-      return (0, These2.first)(f(data.first));
+    if (is.first(data)) {
+      return make.first(f(data.first));
     }
-    return (0, These2.both)(f(data.first), data.second);
+    return make.both(f(data.first), data.second);
   };
   These2.mapSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) {
+    if (is.first(data)) {
       return data;
     }
-    if ((0, These2.isSecond)(data)) {
-      return (0, These2.second)(f(data.second));
+    if (is.second(data)) {
+      return make.second(f(data.second));
     }
-    return (0, These2.both)(data.first, f(data.second));
+    return make.both(data.first, f(data.second));
   };
   These2.mapBoth = (onFirst, onSecond) => (data) => {
-    if ((0, These2.isSecond)(data)) {
-      return (0, These2.second)(onSecond(data.second));
+    if (is.second(data)) {
+      return make.second(onSecond(data.second));
     }
-    if ((0, These2.isFirst)(data)) {
-      return (0, These2.first)(onFirst(data.first));
+    if (is.first(data)) {
+      return make.first(onFirst(data.first));
     }
-    return (0, These2.both)(onFirst(data.first), onSecond(data.second));
+    return make.both(onFirst(data.first), onSecond(data.second));
   };
   These2.chainFirst = (f) => (data) => {
-    if ((0, These2.isSecond)(data)) {
+    if (is.second(data)) {
       return data;
     }
     return f(data.first);
   };
   These2.chainSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) {
+    if (is.first(data)) {
       return data;
     }
     return f(data.second);
   };
   These2.fold = (onFirst, onSecond, onBoth) => (data) => {
-    if ((0, These2.isSecond)(data)) {
+    if (is.second(data)) {
       return onSecond(data.second);
     }
-    if ((0, These2.isFirst)(data)) {
+    if (is.first(data)) {
       return onFirst(data.first);
     }
     return onBoth(data.first, data.second);
   };
   These2.match = (cases) => (data) => {
-    if ((0, These2.isSecond)(data)) {
+    if (is.second(data)) {
       return cases.second(data.second);
     }
-    if ((0, These2.isFirst)(data)) {
+    if (is.first(data)) {
       return cases.first(data.first);
     }
     return cases.both(data.first, data.second);
@@ -2097,20 +2204,24 @@ var These;
     return data;
   };
   These2.swap = (data) => {
-    if ((0, These2.isSecond)(data)) {
-      return (0, These2.first)(data.second);
+    if (is.second(data)) {
+      return make.first(data.second);
     }
-    if ((0, These2.isFirst)(data)) {
-      return (0, These2.second)(data.first);
+    if (is.first(data)) {
+      return make.second(data.first);
     }
-    return (0, These2.both)(data.second, data.first);
+    return make.both(data.second, data.first);
   };
 })(These || (These = {}));
 
 // src/Core/Tuple.ts
 var Tuple;
 ((Tuple2) => {
-  Tuple2.make = (first2, second2) => [first2, second2];
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Tuple2.from || (Tuple2.from = {}));
   Tuple2.first = (tuple) => tuple[0];
   Tuple2.second = (tuple) => tuple[1];
   Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
@@ -2121,7 +2232,10 @@ var Tuple;
   ];
   Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
   Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  Tuple2.toArray = (tuple) => [...tuple];
+  let to;
+  ((to2) => {
+    to2.Array = (tuple) => [...tuple];
+  })(to = Tuple2.to || (Tuple2.to = {}));
   Tuple2.tap = (f) => (tuple) => {
     f(tuple[0], tuple[1]);
     return tuple;
@@ -2131,59 +2245,71 @@ var Tuple;
 // 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 = {};
@@ -2191,14 +2317,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 = {}));
 // Annotate the CommonJS export names for ESM import in node: