@nlozgachev/pipelined 0.20.0 → 0.22.0

package/dist/chunk-7COGDULU.mjs

@@ -1,603 +0,0 @@
-import {
-  Deferred,
-  Maybe,
-  Result,
-  Task
-} from "./chunk-RUDOUVQR.mjs";
-
-// src/Core/Lens.ts
-var Lens;
-((Lens2) => {
-  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Lens2.prop = () => (key) => (0, Lens2.make)(
-    (s) => s[key],
-    (a) => (s) => ({ ...s, [key]: a })
-  );
-  Lens2.get = (lens) => (s) => lens.get(s);
-  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
-  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
-    (s) => inner.get(outer.get(s)),
-    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  );
-  Lens2.andThenOptional = (inner) => (outer) => ({
-    get: (s) => inner.get(outer.get(s)),
-    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  });
-  Lens2.toOptional = (lens) => ({
-    get: (s) => ({ kind: "Some", value: lens.get(s) }),
-    set: lens.set
-  });
-})(Lens || (Lens = {}));
-
-// src/Core/Logged.ts
-var Logged;
-((Logged2) => {
-  Logged2.make = (value) => ({ value, log: [] });
-  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
-  Logged2.map = (f) => (data) => ({
-    value: f(data.value),
-    log: data.log
-  });
-  Logged2.chain = (f) => (data) => {
-    const next = f(data.value);
-    return { value: next.value, log: [...data.log, ...next.log] };
-  };
-  Logged2.ap = (arg) => (data) => ({
-    value: data.value(arg.value),
-    log: [...data.log, ...arg.log]
-  });
-  Logged2.tap = (f) => (data) => {
-    f(data.value);
-    return data;
-  };
-  Logged2.run = (data) => [data.value, data.log];
-})(Logged || (Logged = {}));
-
-// 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) => {
-      if (i < 0 || i >= arr.length) return arr;
-      const copy = [...arr];
-      copy[i] = a;
-      return copy;
-    }
-  );
-  Optional2.get = (opt) => (s) => opt.get(s);
-  Optional2.set = (opt) => (a) => (s) => opt.set(a)(s);
-  Optional2.modify = (opt) => (f) => (s) => {
-    const val = opt.get(s);
-    return val.kind === "None" ? s : opt.set(f(val.value))(s);
-  };
-  Optional2.getOrElse = (opt) => (defaultValue) => (s) => {
-    const val = opt.get(s);
-    return val.kind === "Some" ? val.value : defaultValue();
-  };
-  Optional2.fold = (opt) => (onNone, onSome) => (s) => {
-    const val = opt.get(s);
-    return val.kind === "Some" ? onSome(val.value) : onNone();
-  };
-  Optional2.match = (opt) => (cases) => (s) => {
-    const val = opt.get(s);
-    return val.kind === "Some" ? cases.some(val.value) : cases.none();
-  };
-  Optional2.andThen = (inner) => (outer) => (0, Optional2.make)(
-    (s) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? Maybe.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) => {
-      const mid = outer.get(s);
-      return mid.kind === "None" ? Maybe.none() : Maybe.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);
-    }
-  );
-})(Optional || (Optional = {}));
-
-// src/Core/Predicate.ts
-var Predicate;
-((Predicate2) => {
-  Predicate2.not = (p) => (a) => !p(a);
-  Predicate2.and = (second) => (first) => (a) => first(a) && second(a);
-  Predicate2.or = (second) => (first) => (a) => first(a) || second(a);
-  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;
-})(Predicate || (Predicate = {}));
-
-// src/Core/Reader.ts
-var Reader;
-((Reader2) => {
-  Reader2.resolve = (value) => (_env) => value;
-  Reader2.ask = () => (env) => env;
-  Reader2.asks = (f) => (env) => f(env);
-  Reader2.map = (f) => (data) => (env) => f(data(env));
-  Reader2.chain = (f) => (data) => (env) => f(data(env))(env);
-  Reader2.ap = (arg) => (data) => (env) => data(env)(arg(env));
-  Reader2.tap = (f) => (data) => (env) => {
-    const a = data(env);
-    f(a);
-    return a;
-  };
-  Reader2.local = (f) => (data) => (env) => data(f(env));
-  Reader2.run = (env) => (data) => data(env);
-})(Reader || (Reader = {}));
-
-// src/Core/Refinement.ts
-var Refinement;
-((Refinement2) => {
-  Refinement2.make = (f) => f;
-  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));
-})(Refinement || (Refinement = {}));
-
-// src/Core/RemoteData.ts
-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;
-  RemoteData2.ap = (arg) => (data) => {
-    if ((0, RemoteData2.isSuccess)(data) && (0, RemoteData2.isSuccess)(arg)) {
-      return (0, RemoteData2.success)(data.value(arg.value));
-    }
-    if ((0, RemoteData2.isFailure)(data)) return data;
-    if ((0, RemoteData2.isFailure)(arg)) return arg;
-    if ((0, RemoteData2.isLoading)(data) || (0, RemoteData2.isLoading)(arg)) return (0, RemoteData2.loading)();
-    return (0, RemoteData2.notAsked)();
-  };
-  RemoteData2.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
-    switch (data.kind) {
-      case "NotAsked":
-        return onNotAsked();
-      case "Loading":
-        return onLoading();
-      case "Failure":
-        return onFailure(data.error);
-      case "Success":
-        return onSuccess(data.value);
-    }
-  };
-  RemoteData2.match = (cases) => (data) => {
-    switch (data.kind) {
-      case "NotAsked":
-        return cases.notAsked();
-      case "Loading":
-        return cases.loading();
-      case "Failure":
-        return cases.failure(data.error);
-      case "Success":
-        return cases.success(data.value);
-    }
-  };
-  RemoteData2.getOrElse = (defaultValue) => (data) => (0, RemoteData2.isSuccess)(data) ? data.value : defaultValue();
-  RemoteData2.tap = (f) => (data) => {
-    if ((0, RemoteData2.isSuccess)(data)) f(data.value);
-    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());
-})(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(
-    () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
-      if (Result.isErr(acquired)) return acquired;
-      const a = acquired.value;
-      const usageResult = await Deferred.toPromise(f(a)());
-      await Deferred.toPromise(resource.release(a)());
-      return usageResult;
-    })
-  );
-  Resource2.combine = (resourceA, resourceB) => ({
-    acquire: Task.from(
-      () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
-        if (Result.isErr(acquiredA)) return acquiredA;
-        const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire());
-        if (Result.isErr(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)());
-          return acquiredB;
-        }
-        return Result.ok([a, acquiredB.value]);
-      })
-    ),
-    release: ([a, b]) => Task.from(() => Deferred.toPromise(resourceB.release(b)()).then(() => Deferred.toPromise(resourceA.release(a)())))
-  });
-})(Resource || (Resource = {}));
-
-// src/Core/State.ts
-var State;
-((State2) => {
-  State2.resolve = (value) => (s) => [value, s];
-  State2.get = () => (s) => [s, s];
-  State2.gets = (f) => (s) => [f(s), s];
-  State2.put = (newState) => (_s) => [void 0, newState];
-  State2.modify = (f) => (s) => [void 0, f(s)];
-  State2.map = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    return [f(a), s1];
-  };
-  State2.chain = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    return f(a)(s1);
-  };
-  State2.ap = (arg) => (fn) => (s) => {
-    const [f, s1] = fn(s);
-    const [a, s2] = arg(s1);
-    return [f(a), s2];
-  };
-  State2.tap = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    f(a);
-    return [a, s1];
-  };
-  State2.run = (initialState) => (st) => st(initialState);
-  State2.evaluate = (initialState) => (st) => st(initialState)[0];
-  State2.execute = (initialState) => (st) => st(initialState)[1];
-})(State || (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.fromTask = (task) => Task.map(Maybe.some)(task);
-  TaskMaybe2.tryCatch = (f) => Task.from(
-    () => f().then(Maybe.some).catch(() => Maybe.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(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
-    ]).then(([of_, oa]) => Maybe.ap(oa)(of_))
-  );
-  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
-  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
-  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.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
-})(TaskMaybe || (TaskMaybe = {}));
-
-// src/Core/TaskResult.ts
-var cancellableWait = (ms, signal) => {
-  if (ms <= 0) return Promise.resolve();
-  if (!signal) return new Promise((r) => setTimeout(r, ms));
-  return new Promise((resolve) => {
-    const id = setTimeout(resolve, ms);
-    signal.addEventListener("abort", () => {
-      clearTimeout(id);
-      resolve();
-    }, { once: true });
-  });
-};
-var TaskResult;
-((TaskResult2) => {
-  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.err(error));
-  TaskResult2.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Result.ok).catch((e) => Result.err(onError(e)))
-  );
-  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.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)
-  )(data);
-  TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-  TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult2.retry = (options) => (data) => Task.from((signal) => {
-    const { attempts, backoff, when: shouldRetry } = options;
-    const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
-    const run = (left) => Deferred.toPromise(data(signal)).then((result) => {
-      if (Result.isOk(result)) return result;
-      if (left <= 1) return result;
-      if (shouldRetry !== void 0 && !shouldRetry(result.error)) {
-        return result;
-      }
-      if (signal?.aborted) return result;
-      const ms = getDelay(attempts - left + 1);
-      return cancellableWait(ms, signal).then(() => {
-        if (signal?.aborted) return result;
-        return run(left - 1);
-      });
-    });
-    return run(attempts);
-  });
-  TaskResult2.pollUntil = (options) => (task) => Task.from((signal) => {
-    const { when: predicate, delay } = options;
-    const getDelay = (attempt) => delay === void 0 ? 0 : typeof delay === "function" ? delay(attempt) : delay;
-    const run = (attempt) => Deferred.toPromise(task(signal)).then((result) => {
-      if (Result.isErr(result)) return result;
-      if (predicate(result.value)) return result;
-      if (signal?.aborted) return result;
-      const ms = getDelay(attempt);
-      return cancellableWait(ms, signal).then(() => {
-        if (signal?.aborted) return result;
-        return run(attempt + 1);
-      });
-    });
-    return run(1);
-  });
-  TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from((outerSignal) => {
-    const controller = new AbortController();
-    const onOuterAbort = () => controller.abort();
-    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
-    let timerId;
-    return Promise.race([
-      Deferred.toPromise(data(controller.signal)).then((result) => {
-        clearTimeout(timerId);
-        outerSignal?.removeEventListener("abort", onOuterAbort);
-        return result;
-      }),
-      new Promise((resolve) => {
-        timerId = setTimeout(() => {
-          controller.abort();
-          outerSignal?.removeEventListener("abort", onOuterAbort);
-          resolve(Result.err(onTimeout()));
-        }, ms);
-      })
-    ]);
-  });
-  TaskResult2.abortable = (factory, onError) => {
-    const controller = new AbortController();
-    const task = (outerSignal) => {
-      if (outerSignal) {
-        if (outerSignal.aborted) {
-          controller.abort(outerSignal.reason);
-        } else {
-          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
-        }
-      }
-      return Deferred.fromPromise(
-        factory(controller.signal).then(Result.ok).catch((e) => Result.err(onError(e)))
-      );
-    };
-    return { task, abort: () => controller.abort() };
-  };
-})(TaskResult || (TaskResult = {}));
-
-// src/Core/Validation.ts
-var Validation;
-((Validation2) => {
-  Validation2.valid = (value) => ({
-    kind: "Valid",
-    value
-  });
-  Validation2.invalid = (error) => ({
-    kind: "Invalid",
-    errors: [error]
-  });
-  Validation2.invalidAll = (errors) => ({
-    kind: "Invalid",
-    errors
-  });
-  Validation2.isValid = (data) => data.kind === "Valid";
-  Validation2.isInvalid = (data) => data.kind === "Invalid";
-  Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
-  Validation2.ap = (arg) => (data) => {
-    if ((0, Validation2.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
-    const errors = [
-      ...(0, Validation2.isInvalid)(data) ? data.errors : [],
-      ...(0, Validation2.isInvalid)(arg) ? arg.errors : []
-    ];
-    return (0, Validation2.invalidAll)(errors);
-  };
-  Validation2.fold = (onInvalid, onValid) => (data) => (0, Validation2.isValid)(data) ? onValid(data.value) : onInvalid(data.errors);
-  Validation2.match = (cases) => (data) => (0, Validation2.isValid)(data) ? cases.valid(data.value) : cases.invalid(data.errors);
-  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isValid)(data) ? data.value : defaultValue();
-  Validation2.tap = (f) => (data) => {
-    if ((0, Validation2.isValid)(data)) f(data.value);
-    return data;
-  };
-  Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err) => blockedErrors.includes(err)) ? fallback() : data;
-  Validation2.product = (first, second) => {
-    if ((0, Validation2.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
-    const errors = [
-      ...(0, Validation2.isInvalid)(first) ? first.errors : [],
-      ...(0, Validation2.isInvalid)(second) ? second.errors : []
-    ];
-    return (0, Validation2.invalidAll)(errors);
-  };
-  Validation2.productAll = (data) => {
-    const values = [];
-    const errors = [];
-    for (const v of data) {
-      if ((0, Validation2.isValid)(v)) values.push(v.value);
-      else errors.push(...v.errors);
-    }
-    return errors.length > 0 ? (0, Validation2.invalidAll)(errors) : (0, Validation2.valid)(values);
-  };
-})(Validation || (Validation = {}));
-
-// src/Core/TaskValidation.ts
-var TaskValidation;
-((TaskValidation2) => {
-  TaskValidation2.valid = (value) => Task.resolve(Validation.valid(value));
-  TaskValidation2.invalid = (error) => Task.resolve(Validation.invalid(error));
-  TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
-  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
-  TaskValidation2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
-  );
-  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
-    ]).then(([vf, va]) => Validation.ap(va)(vf))
-  );
-  TaskValidation2.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(data);
-  TaskValidation2.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
-  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.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors)
-  )(data);
-  TaskValidation2.product = (first, second) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(first()),
-      Deferred.toPromise(second())
-    ]).then(([va, vb]) => Validation.product(va, vb))
-  );
-  TaskValidation2.productAll = (data) => Task.from(
-    () => Promise.all(data.map((t) => Deferred.toPromise(t()))).then((results) => Validation.productAll(results))
-  );
-})(TaskValidation || (TaskValidation = {}));
-
-// src/Core/These.ts
-var These;
-((These2) => {
-  These2.first = (value) => ({ kind: "First", first: value });
-  These2.second = (value) => ({ kind: "Second", second: value });
-  These2.both = (first2, second2) => ({
-    kind: "Both",
-    first: first2,
-    second: second2
-  });
-  These2.isFirst = (data) => data.kind === "First";
-  These2.isSecond = (data) => data.kind === "Second";
-  These2.isBoth = (data) => data.kind === "Both";
-  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)) return data;
-    if ((0, These2.isFirst)(data)) return (0, These2.first)(f(data.first));
-    return (0, These2.both)(f(data.first), data.second);
-  };
-  These2.mapSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) return data;
-    if ((0, These2.isSecond)(data)) return (0, These2.second)(f(data.second));
-    return (0, These2.both)(data.first, f(data.second));
-  };
-  These2.mapBoth = (onFirst, onSecond) => (data) => {
-    if ((0, These2.isSecond)(data)) return (0, These2.second)(onSecond(data.second));
-    if ((0, These2.isFirst)(data)) return (0, These2.first)(onFirst(data.first));
-    return (0, These2.both)(onFirst(data.first), onSecond(data.second));
-  };
-  These2.chainFirst = (f) => (data) => {
-    if ((0, These2.isSecond)(data)) return data;
-    return f(data.first);
-  };
-  These2.chainSecond = (f) => (data) => {
-    if ((0, These2.isFirst)(data)) return data;
-    return f(data.second);
-  };
-  These2.fold = (onFirst, onSecond, onBoth) => (data) => {
-    if ((0, These2.isSecond)(data)) return onSecond(data.second);
-    if ((0, These2.isFirst)(data)) return onFirst(data.first);
-    return onBoth(data.first, data.second);
-  };
-  These2.match = (cases) => (data) => {
-    if ((0, These2.isSecond)(data)) return cases.second(data.second);
-    if ((0, These2.isFirst)(data)) return cases.first(data.first);
-    return cases.both(data.first, data.second);
-  };
-  These2.getFirstOrElse = (defaultValue) => (data) => (0, These2.hasFirst)(data) ? data.first : defaultValue();
-  These2.getSecondOrElse = (defaultValue) => (data) => (0, These2.hasSecond)(data) ? data.second : defaultValue();
-  These2.tap = (f) => (data) => {
-    if ((0, These2.hasFirst)(data)) f(data.first);
-    return data;
-  };
-  These2.swap = (data) => {
-    if ((0, These2.isSecond)(data)) return (0, These2.first)(data.second);
-    if ((0, These2.isFirst)(data)) return (0, These2.second)(data.first);
-    return (0, These2.both)(data.second, data.first);
-  };
-})(These || (These = {}));
-
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  Tuple2.make = (first2, second2) => [first2, second2];
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  Tuple2.toArray = (tuple) => [...tuple];
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
-export {
-  Lens,
-  Logged,
-  Optional,
-  Predicate,
-  Reader,
-  Refinement,
-  RemoteData,
-  Resource,
-  State,
-  TaskMaybe,
-  TaskResult,
-  Validation,
-  TaskValidation,
-  These,
-  Tuple
-};