@flarehr/apollo-benefits 1.2.100 → 1.3.54122

package/dist/lib/esm/Option-53ef163a.js

@@ -1,1982 +0,0 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-var _function = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hole = exports.pipe = exports.untupled = exports.tupled = exports.absurd = exports.decrement = exports.increment = exports.tuple = exports.flow = exports.flip = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.constant = exports.not = exports.unsafeCoerce = exports.identity = exports.getEndomorphismMonoid = exports.getRing = exports.getSemiring = exports.getMonoid = exports.getSemigroup = exports.getBooleanAlgebra = void 0;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.10.0
- */
-var getBooleanAlgebra = function (B) { return function () { return ({
-    meet: function (x, y) { return function (a) { return B.meet(x(a), y(a)); }; },
-    join: function (x, y) { return function (a) { return B.join(x(a), y(a)); }; },
-    zero: function () { return B.zero; },
-    one: function () { return B.one; },
-    implies: function (x, y) { return function (a) { return B.implies(x(a), y(a)); }; },
-    not: function (x) { return function (a) { return B.not(x(a)); }; }
-}); }; };
-exports.getBooleanAlgebra = getBooleanAlgebra;
-/**
- * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.
- *
- * @example
- * import { Predicate, getSemigroup } from 'fp-ts/function'
- * import * as B from 'fp-ts/boolean'
- *
- * const f: Predicate<number> = (n) => n <= 2
- * const g: Predicate<number> = (n) => n >= 0
- *
- * const S1 = getSemigroup(B.SemigroupAll)<number>()
- *
- * assert.deepStrictEqual(S1.concat(f, g)(1), true)
- * assert.deepStrictEqual(S1.concat(f, g)(3), false)
- *
- * const S2 = getSemigroup(B.SemigroupAny)<number>()
- *
- * assert.deepStrictEqual(S2.concat(f, g)(1), true)
- * assert.deepStrictEqual(S2.concat(f, g)(3), true)
- *
- * @category instances
- * @since 2.10.0
- */
-var getSemigroup = function (S) { return function () { return ({
-    concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }
-}); }; };
-exports.getSemigroup = getSemigroup;
-/**
- * Unary functions form a monoid as long as you can provide a monoid for the codomain.
- *
- * @example
- * import { Predicate, getMonoid } from 'fp-ts/function'
- * import * as B from 'fp-ts/boolean'
- *
- * const f: Predicate<number> = (n) => n <= 2
- * const g: Predicate<number> = (n) => n >= 0
- *
- * const M1 = getMonoid(B.MonoidAll)<number>()
- *
- * assert.deepStrictEqual(M1.concat(f, g)(1), true)
- * assert.deepStrictEqual(M1.concat(f, g)(3), false)
- *
- * const M2 = getMonoid(B.MonoidAny)<number>()
- *
- * assert.deepStrictEqual(M2.concat(f, g)(1), true)
- * assert.deepStrictEqual(M2.concat(f, g)(3), true)
- *
- * @category instances
- * @since 2.10.0
- */
-var getMonoid = function (M) {
-    var getSemigroupM = exports.getSemigroup(M);
-    return function () { return ({
-        concat: getSemigroupM().concat,
-        empty: function () { return M.empty; }
-    }); };
-};
-exports.getMonoid = getMonoid;
-/**
- * @category instances
- * @since 2.10.0
- */
-var getSemiring = function (S) { return ({
-    add: function (f, g) { return function (x) { return S.add(f(x), g(x)); }; },
-    zero: function () { return S.zero; },
-    mul: function (f, g) { return function (x) { return S.mul(f(x), g(x)); }; },
-    one: function () { return S.one; }
-}); };
-exports.getSemiring = getSemiring;
-/**
- * @category instances
- * @since 2.10.0
- */
-var getRing = function (R) {
-    var S = exports.getSemiring(R);
-    return {
-        add: S.add,
-        mul: S.mul,
-        one: S.one,
-        zero: S.zero,
-        sub: function (f, g) { return function (x) { return R.sub(f(x), g(x)); }; }
-    };
-};
-exports.getRing = getRing;
-/**
- * Endomorphism form a monoid where the `empty` value is the identity function.
- *
- * @category instances
- * @since 2.10.0
- */
-var getEndomorphismMonoid = function () { return ({
-    concat: function (x, y) { return function (a) { return y(x(a)); }; },
-    empty: identity
-}); };
-exports.getEndomorphismMonoid = getEndomorphismMonoid;
-/**
- * @since 2.0.0
- */
-function identity(a) {
-    return a;
-}
-exports.identity = identity;
-/**
- * @since 2.0.0
- */
-exports.unsafeCoerce = identity;
-/**
- * @since 2.0.0
- */
-function not(predicate) {
-    return function (a) { return !predicate(a); };
-}
-exports.not = not;
-/**
- * @since 2.0.0
- */
-function constant(a) {
-    return function () { return a; };
-}
-exports.constant = constant;
-/**
- * A thunk that returns always `true`.
- *
- * @since 2.0.0
- */
-exports.constTrue = 
-/*#__PURE__*/
-constant(true);
-/**
- * A thunk that returns always `false`.
- *
- * @since 2.0.0
- */
-exports.constFalse = 
-/*#__PURE__*/
-constant(false);
-/**
- * A thunk that returns always `null`.
- *
- * @since 2.0.0
- */
-exports.constNull = 
-/*#__PURE__*/
-constant(null);
-/**
- * A thunk that returns always `undefined`.
- *
- * @since 2.0.0
- */
-exports.constUndefined = 
-/*#__PURE__*/
-constant(undefined);
-/**
- * A thunk that returns always `void`.
- *
- * @since 2.0.0
- */
-exports.constVoid = exports.constUndefined;
-/**
- * Flips the order of the arguments of a function of two arguments.
- *
- * @since 2.0.0
- */
-function flip(f) {
-    return function (b, a) { return f(a, b); };
-}
-exports.flip = flip;
-function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
-    switch (arguments.length) {
-        case 1:
-            return ab;
-        case 2:
-            return function () {
-                return bc(ab.apply(this, arguments));
-            };
-        case 3:
-            return function () {
-                return cd(bc(ab.apply(this, arguments)));
-            };
-        case 4:
-            return function () {
-                return de(cd(bc(ab.apply(this, arguments))));
-            };
-        case 5:
-            return function () {
-                return ef(de(cd(bc(ab.apply(this, arguments)))));
-            };
-        case 6:
-            return function () {
-                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-            };
-        case 7:
-            return function () {
-                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-            };
-        case 8:
-            return function () {
-                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-            };
-        case 9:
-            return function () {
-                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-            };
-    }
-    return;
-}
-exports.flow = flow;
-/**
- * @since 2.0.0
- */
-function tuple() {
-    var t = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        t[_i] = arguments[_i];
-    }
-    return t;
-}
-exports.tuple = tuple;
-/**
- * @since 2.0.0
- */
-function increment(n) {
-    return n + 1;
-}
-exports.increment = increment;
-/**
- * @since 2.0.0
- */
-function decrement(n) {
-    return n - 1;
-}
-exports.decrement = decrement;
-/**
- * @since 2.0.0
- */
-function absurd(_) {
-    throw new Error('Called `absurd` function which should be uncallable');
-}
-exports.absurd = absurd;
-/**
- * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
- *
- * @example
- * import { tupled } from 'fp-ts/function'
- *
- * const add = tupled((x: number, y: number): number => x + y)
- *
- * assert.strictEqual(add([1, 2]), 3)
- *
- * @since 2.4.0
- */
-function tupled(f) {
-    return function (a) { return f.apply(void 0, a); };
-}
-exports.tupled = tupled;
-/**
- * Inverse function of `tupled`
- *
- * @since 2.4.0
- */
-function untupled(f) {
-    return function () {
-        var a = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            a[_i] = arguments[_i];
-        }
-        return f(a);
-    };
-}
-exports.untupled = untupled;
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st) {
-    switch (arguments.length) {
-        case 1:
-            return a;
-        case 2:
-            return ab(a);
-        case 3:
-            return bc(ab(a));
-        case 4:
-            return cd(bc(ab(a)));
-        case 5:
-            return de(cd(bc(ab(a))));
-        case 6:
-            return ef(de(cd(bc(ab(a)))));
-        case 7:
-            return fg(ef(de(cd(bc(ab(a))))));
-        case 8:
-            return gh(fg(ef(de(cd(bc(ab(a)))))));
-        case 9:
-            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-        case 10:
-            return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
-        case 11:
-            return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
-        case 12:
-            return kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))));
-        case 13:
-            return lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))));
-        case 14:
-            return mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))));
-        case 15:
-            return no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))));
-        case 16:
-            return op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))));
-        case 17:
-            return pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))));
-        case 18:
-            return qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))));
-        case 19:
-            return rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))))));
-        case 20:
-            return st(rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))))));
-    }
-    return;
-}
-exports.pipe = pipe;
-/**
- * Type hole simulation
- *
- * @since 2.7.0
- */
-exports.hole = absurd;
-});
-
-var Apply = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sequenceS = exports.sequenceT = exports.getApplySemigroup = exports.apS = exports.apSecond = exports.apFirst = exports.ap = void 0;
-
-function ap(F, G) {
-    return function (fa) { return function (fab) {
-        return F.ap(F.map(fab, function (gab) { return function (ga) { return G.ap(gab, ga); }; }), fa);
-    }; };
-}
-exports.ap = ap;
-function apFirst(A) {
-    return function (second) { return function (first) {
-        return A.ap(A.map(first, function (a) { return function () { return a; }; }), second);
-    }; };
-}
-exports.apFirst = apFirst;
-function apSecond(A) {
-    return function (second) { return function (first) {
-        return A.ap(A.map(first, function () { return function (b) { return b; }; }), second);
-    }; };
-}
-exports.apSecond = apSecond;
-function apS(F) {
-    return function (name, fb) { return function (fa) {
-        return F.ap(F.map(fa, function (a) { return function (b) {
-            var _a;
-            return Object.assign({}, a, (_a = {}, _a[name] = b, _a));
-        }; }), fb);
-    }; };
-}
-exports.apS = apS;
-function getApplySemigroup(F) {
-    return function (S) { return ({
-        concat: function (first, second) {
-            return F.ap(F.map(first, function (x) { return function (y) { return S.concat(x, y); }; }), second);
-        }
-    }); };
-}
-exports.getApplySemigroup = getApplySemigroup;
-function curried(f, n, acc) {
-    return function (x) {
-        var combined = Array(acc.length + 1);
-        for (var i = 0; i < acc.length; i++) {
-            combined[i] = acc[i];
-        }
-        combined[acc.length] = x;
-        return n === 0 ? f.apply(null, combined) : curried(f, n - 1, combined);
-    };
-}
-var tupleConstructors = {
-    1: function (a) { return [a]; },
-    2: function (a) { return function (b) { return [a, b]; }; },
-    3: function (a) { return function (b) { return function (c) { return [a, b, c]; }; }; },
-    4: function (a) { return function (b) { return function (c) { return function (d) { return [a, b, c, d]; }; }; }; },
-    5: function (a) { return function (b) { return function (c) { return function (d) { return function (e) { return [a, b, c, d, e]; }; }; }; }; }
-};
-function getTupleConstructor(len) {
-    if (!tupleConstructors.hasOwnProperty(len)) {
-        tupleConstructors[len] = curried(_function.tuple, len - 1, []);
-    }
-    return tupleConstructors[len];
-}
-function sequenceT(F) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var len = args.length;
-        var f = getTupleConstructor(len);
-        var fas = F.map(args[0], f);
-        for (var i = 1; i < len; i++) {
-            fas = F.ap(fas, args[i]);
-        }
-        return fas;
-    };
-}
-exports.sequenceT = sequenceT;
-function getRecordConstructor(keys) {
-    var len = keys.length;
-    switch (len) {
-        case 1:
-            return function (a) {
-                var _a;
-                return (_a = {}, _a[keys[0]] = a, _a);
-            };
-        case 2:
-            return function (a) { return function (b) {
-                var _a;
-                return (_a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a);
-            }; };
-        case 3:
-            return function (a) { return function (b) { return function (c) {
-                var _a;
-                return (_a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a);
-            }; }; };
-        case 4:
-            return function (a) { return function (b) { return function (c) { return function (d) {
-                var _a;
-                return (_a = {},
-                    _a[keys[0]] = a,
-                    _a[keys[1]] = b,
-                    _a[keys[2]] = c,
-                    _a[keys[3]] = d,
-                    _a);
-            }; }; }; };
-        case 5:
-            return function (a) { return function (b) { return function (c) { return function (d) { return function (e) {
-                var _a;
-                return (_a = {},
-                    _a[keys[0]] = a,
-                    _a[keys[1]] = b,
-                    _a[keys[2]] = c,
-                    _a[keys[3]] = d,
-                    _a[keys[4]] = e,
-                    _a);
-            }; }; }; }; };
-        default:
-            return curried(function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var r = {};
-                for (var i = 0; i < len; i++) {
-                    r[keys[i]] = args[i];
-                }
-                return r;
-            }, len - 1, []);
-    }
-}
-function sequenceS(F) {
-    return function (r) {
-        var keys = Object.keys(r);
-        var len = keys.length;
-        var f = getRecordConstructor(keys);
-        var fr = F.map(r[keys[0]], f);
-        for (var i = 1; i < len; i++) {
-            fr = F.ap(fr, r[keys[i]]);
-        }
-        return fr;
-    };
-}
-exports.sequenceS = sequenceS;
-});
-
-var Functor = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctorComposition = exports.bindTo = exports.flap = exports.map = void 0;
-/**
- * A `Functor` is a type constructor which supports a mapping operation `map`.
- *
- * `map` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return types use the type
- * constructor `f` to represent some computational context.
- *
- * Instances must satisfy the following laws:
- *
- * 1. Identity: `F.map(fa, a => a) <-> fa`
- * 2. Composition: `F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)`
- *
- * @since 2.0.0
- */
-
-function map(F, G) {
-    return function (f) { return function (fa) { return F.map(fa, function (ga) { return G.map(ga, f); }); }; };
-}
-exports.map = map;
-function flap(F) {
-    return function (a) { return function (fab) { return F.map(fab, function (f) { return f(a); }); }; };
-}
-exports.flap = flap;
-function bindTo(F) {
-    return function (name) { return function (fa) { return F.map(fa, function (a) {
-        var _a;
-        return (_a = {}, _a[name] = a, _a);
-    }); }; };
-}
-exports.bindTo = bindTo;
-/** @deprecated */
-function getFunctorComposition(F, G) {
-    var _map = map(F, G);
-    return {
-        map: function (fga, f) { return _function.pipe(fga, _map(f)); }
-    };
-}
-exports.getFunctorComposition = getFunctorComposition;
-});
-
-var Applicative = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApplicativeComposition = exports.getApplicativeMonoid = void 0;
-/**
- * The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values
- * of type `f a` from values of type `a`.
- *
- * Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are
- * wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the
- * function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for
- * any number of function arguments.
- *
- * Instances must satisfy the following laws in addition to the `Apply` laws:
- *
- * 1. Identity: `A.ap(A.of(a => a), fa) <-> fa`
- * 2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`
- * 3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`
- *
- * Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`
- *
- * @since 2.0.0
- */
-
-
-
-function getApplicativeMonoid(F) {
-    var f = Apply.getApplySemigroup(F);
-    return function (M) { return ({
-        concat: f(M).concat,
-        empty: F.of(M.empty)
-    }); };
-}
-exports.getApplicativeMonoid = getApplicativeMonoid;
-/** @deprecated */
-function getApplicativeComposition(F, G) {
-    var map = Functor.getFunctorComposition(F, G).map;
-    var _ap = Apply.ap(F, G);
-    return {
-        map: map,
-        of: function (a) { return F.of(G.of(a)); },
-        ap: function (fgab, fga) { return _function.pipe(fgab, _ap(fga)); }
-    };
-}
-exports.getApplicativeComposition = getApplicativeComposition;
-});
-
-var Chain = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bind = exports.chainFirst = void 0;
-function chainFirst(M) {
-    return function (f) { return function (first) { return M.chain(first, function (a) { return M.map(f(a), function () { return a; }); }); }; };
-}
-exports.chainFirst = chainFirst;
-function bind(M) {
-    return function (name, f) { return function (ma) { return M.chain(ma, function (a) { return M.map(f(a), function (b) {
-        var _a;
-        return Object.assign({}, a, (_a = {}, _a[name] = b, _a));
-    }); }); }; };
-}
-exports.bind = bind;
-});
-
-var internal = createCommonjsModule(function (module, exports) {
-var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromReadonlyNonEmptyArray = exports.has = exports.isLeft = exports.isSome = void 0;
-// -------------------------------------------------------------------------------------
-// Option
-// -------------------------------------------------------------------------------------
-/** @internal */
-var isSome = function (fa) { return fa._tag === 'Some'; };
-exports.isSome = isSome;
-// -------------------------------------------------------------------------------------
-// Either
-// -------------------------------------------------------------------------------------
-/** @internal */
-var isLeft = function (ma) { return ma._tag === 'Left'; };
-exports.isLeft = isLeft;
-// -------------------------------------------------------------------------------------
-// Record
-// -------------------------------------------------------------------------------------
-/** @internal */
-exports.has = Object.prototype.hasOwnProperty;
-// -------------------------------------------------------------------------------------
-// NonEmptyArray
-// -------------------------------------------------------------------------------------
-/** @internal */
-var fromReadonlyNonEmptyArray = function (as) { return __spreadArray([as[0]], as.slice(1)); };
-exports.fromReadonlyNonEmptyArray = fromReadonlyNonEmptyArray;
-});
-
-var Separated = createCommonjsModule(function (module, exports) {
-/**
- * ```ts
- * interface Separated<E, A> {
- *    readonly left: E
- *    readonly right: A
- * }
- * ```
- *
- * Represents a result of separating a whole into two parts.
- *
- * @since 2.10.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.right = exports.left = exports.flap = exports.Functor = exports.Bifunctor = exports.URI = exports.bimap = exports.mapLeft = exports.map = exports.separated = void 0;
-
-
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * @category constructors
- * @since 2.10.0
- */
-var separated = function (left, right) { return ({ left: left, right: right }); };
-exports.separated = separated;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-var _map = function (fa, f) { return _function.pipe(fa, exports.map(f)); };
-var _mapLeft = function (fa, f) { return _function.pipe(fa, exports.mapLeft(f)); };
-var _bimap = function (fa, g, f) { return _function.pipe(fa, exports.bimap(g, f)); };
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
- * use the type constructor `F` to represent some computational context.
- *
- * @category Functor
- * @since 2.10.0
- */
-var map = function (f) { return function (fa) {
-    return exports.separated(exports.left(fa), f(exports.right(fa)));
-}; };
-exports.map = map;
-/**
- * Map a function over the first type argument of a bifunctor.
- *
- * @category Bifunctor
- * @since 2.10.0
- */
-var mapLeft = function (f) { return function (fa) {
-    return exports.separated(f(exports.left(fa)), exports.right(fa));
-}; };
-exports.mapLeft = mapLeft;
-/**
- * Map a pair of functions over the two type arguments of the bifunctor.
- *
- * @category Bifunctor
- * @since 2.10.0
- */
-var bimap = function (f, g) { return function (fa) {
-    return exports.separated(f(exports.left(fa)), g(exports.right(fa)));
-}; };
-exports.bimap = bimap;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.URI = 'Separated';
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.Bifunctor = {
-    URI: exports.URI,
-    mapLeft: _mapLeft,
-    bimap: _bimap
-};
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.Functor = {
-    URI: exports.URI,
-    map: _map
-};
-/**
- * Derivable from `Functor`.
- *
- * @category combinators
- * @since 2.10.0
- */
-exports.flap = 
-/*#_PURE_*/
-Functor.flap(exports.Functor);
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.10.0
- */
-var left = function (s) { return s.left; };
-exports.left = left;
-/**
- * @since 2.10.0
- */
-var right = function (s) { return s.right; };
-exports.right = right;
-});
-
-var Option = createCommonjsModule(function (module, exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirstMonoid = exports.getOrd = exports.getEq = exports.getShow = exports.URI = exports.wilt = exports.wither = exports.sequence = exports.traverse = exports.partitionMap = exports.partition = exports.filterMap = exports.filter = exports.separate = exports.compact = exports.reduceRight = exports.foldMap = exports.reduce = exports.duplicate = exports.extend = exports.throwError = exports.zero = exports.alt = exports.altW = exports.flatten = exports.chain = exports.of = exports.ap = exports.map = exports.toUndefined = exports.toNullable = exports.chainNullableK = exports.fromNullableK = exports.tryCatchK = exports.tryCatch = exports.fromNullable = exports.getOrElse = exports.getOrElseW = exports.fold = exports.match = exports.foldW = exports.matchW = exports.fromEither = exports.getRight = exports.getLeft = exports.fromPredicate = exports.some = exports.none = exports.isNone = exports.isSome = void 0;
-exports.getApplyMonoid = exports.getApplySemigroup = exports.option = exports.mapNullable = exports.sequenceArray = exports.traverseArray = exports.traverseArrayWithIndex = exports.apS = exports.bind = exports.bindTo = exports.Do = exports.getRefinement = exports.exists = exports.elem = exports.MonadThrow = exports.Witherable = exports.Traversable = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.Alt = exports.Foldable = exports.chainFirst = exports.Monad = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.Pointed = exports.flap = exports.Functor = exports.getMonoid = exports.getLastMonoid = void 0;
-
-
-
-
-
-var _ = __importStar(internal);
-
-// -------------------------------------------------------------------------------------
-// guards
-// -------------------------------------------------------------------------------------
-/**
- * Returns `true` if the option is an instance of `Some`, `false` otherwise.
- *
- * @example
- * import { some, none, isSome } from 'fp-ts/Option'
- *
- * assert.strictEqual(isSome(some(1)), true)
- * assert.strictEqual(isSome(none), false)
- *
- * @category guards
- * @since 2.0.0
- */
-exports.isSome = _.isSome;
-/**
- * Returns `true` if the option is `None`, `false` otherwise.
- *
- * @example
- * import { some, none, isNone } from 'fp-ts/Option'
- *
- * assert.strictEqual(isNone(some(1)), false)
- * assert.strictEqual(isNone(none), true)
- *
- * @category guards
- * @since 2.0.0
- */
-var isNone = function (fa) { return fa._tag === 'None'; };
-exports.isNone = isNone;
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.
- *
- * @category constructors
- * @since 2.0.0
- */
-exports.none = { _tag: 'None' };
-/**
- * Constructs a `Some`. Represents an optional value that exists.
- *
- * @category constructors
- * @since 2.0.0
- */
-var some = function (a) { return ({ _tag: 'Some', value: a }); };
-exports.some = some;
-function fromPredicate(predicate) {
-    return function (a) { return (predicate(a) ? exports.some(a) : exports.none); };
-}
-exports.fromPredicate = fromPredicate;
-/**
- * Returns the `Left` value of an `Either` if possible.
- *
- * @example
- * import { getLeft, none, some } from 'fp-ts/Option'
- * import { right, left } from 'fp-ts/Either'
- *
- * assert.deepStrictEqual(getLeft(right(1)), none)
- * assert.deepStrictEqual(getLeft(left('a')), some('a'))
- *
- * @category constructors
- * @since 2.0.0
- */
-function getLeft(ma) {
-    return ma._tag === 'Right' ? exports.none : exports.some(ma.left);
-}
-exports.getLeft = getLeft;
-/**
- * Returns the `Right` value of an `Either` if possible.
- *
- * @example
- * import { getRight, none, some } from 'fp-ts/Option'
- * import { right, left } from 'fp-ts/Either'
- *
- * assert.deepStrictEqual(getRight(right(1)), some(1))
- * assert.deepStrictEqual(getRight(left('a')), none)
- *
- * @category constructors
- * @since 2.0.0
- */
-function getRight(ma) {
-    return ma._tag === 'Left' ? exports.none : exports.some(ma.right);
-}
-exports.getRight = getRight;
-/**
- * Transforms an `Either` to an `Option` discarding the error.
- *
- * Alias of [getRight](#getRight)
- *
- * @category constructors
- * @since 2.0.0
- */
-exports.fromEither = getRight;
-// -------------------------------------------------------------------------------------
-// destructors
-// -------------------------------------------------------------------------------------
-/**
- * Less strict version of [`match`](#match).
- *
- * @category destructors
- * @since 2.10.0
- */
-var matchW = function (onNone, onSome) { return function (ma) {
-    return exports.isNone(ma) ? onNone() : onSome(ma.value);
-}; };
-exports.matchW = matchW;
-/**
- * Alias of [`matchW`](#matchW).
- *
- * @category destructors
- * @since 2.10.0
- */
-exports.foldW = exports.matchW;
-/**
- * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is
- * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.
- *
- * @example
- * import { some, none, match } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     match(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a some containing 1'
- * )
- *
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     match(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a none'
- * )
- *
- * @category destructors
- * @since 2.10.0
- */
-exports.match = exports.matchW;
-/**
- * Alias of [`match`](#match).
- *
- * @category destructors
- * @since 2.0.0
- */
-exports.fold = exports.match;
-/**
- * Less strict version of [`getOrElse`](#getOrElse).
- *
- * @category destructors
- * @since 2.6.0
- */
-var getOrElseW = function (onNone) { return function (ma) { return (exports.isNone(ma) ? onNone() : ma.value); }; };
-exports.getOrElseW = getOrElseW;
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns the given default value
- *
- * @example
- * import { some, none, getOrElse } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     getOrElse(() => 0)
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     getOrElse(() => 0)
- *   ),
- *   0
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-exports.getOrElse = exports.getOrElseW;
-// -------------------------------------------------------------------------------------
-// interop
-// -------------------------------------------------------------------------------------
-/**
- * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise
- * returns the value wrapped in a `Some`.
- *
- * @example
- * import { none, some, fromNullable } from 'fp-ts/Option'
- *
- * assert.deepStrictEqual(fromNullable(undefined), none)
- * assert.deepStrictEqual(fromNullable(null), none)
- * assert.deepStrictEqual(fromNullable(1), some(1))
- *
- * @category interop
- * @since 2.0.0
- */
-var fromNullable = function (a) { return (a == null ? exports.none : exports.some(a)); };
-exports.fromNullable = fromNullable;
-/**
- * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a
- * `Some`.
- *
- * See also [`tryCatchK`](#tryCatchK).
- *
- * @example
- * import { none, some, tryCatch } from 'fp-ts/Option'
- *
- * assert.deepStrictEqual(
- *   tryCatch(() => {
- *     throw new Error()
- *   }),
- *   none
- * )
- * assert.deepStrictEqual(tryCatch(() => 1), some(1))
- *
- * @category interop
- * @since 2.0.0
- */
-var tryCatch = function (f) {
-    try {
-        return exports.some(f());
-    }
-    catch (e) {
-        return exports.none;
-    }
-};
-exports.tryCatch = tryCatch;
-/**
- * Converts a function that may throw to one returning a `Option`.
- *
- * @category interop
- * @since 2.10.0
- */
-var tryCatchK = function (f) { return function () {
-    var a = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        a[_i] = arguments[_i];
-    }
-    return exports.tryCatch(function () { return f.apply(void 0, a); });
-}; };
-exports.tryCatchK = tryCatchK;
-/**
- * Returns a *smart constructor* from a function that returns a nullable value.
- *
- * @example
- * import { fromNullableK, none, some } from 'fp-ts/Option'
- *
- * const f = (s: string): number | undefined => {
- *   const n = parseFloat(s)
- *   return isNaN(n) ? undefined : n
- * }
- *
- * const g = fromNullableK(f)
- *
- * assert.deepStrictEqual(g('1'), some(1))
- * assert.deepStrictEqual(g('a'), none)
- *
- * @category interop
- * @since 2.9.0
- */
-var fromNullableK = function (f) { return _function.flow(f, exports.fromNullable); };
-exports.fromNullableK = fromNullableK;
-/**
- * This is `chain` + `fromNullable`, useful when working with optional values.
- *
- * @example
- * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * interface Employee {
- *   readonly company?: {
- *     readonly address?: {
- *       readonly street?: {
- *         readonly name?: string
- *       }
- *     }
- *   }
- * }
- *
- * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     fromNullable(employee1.company),
- *     chainNullableK(company => company.address),
- *     chainNullableK(address => address.street),
- *     chainNullableK(street => street.name)
- *   ),
- *   some('high street')
- * )
- *
- * const employee2: Employee = { company: { address: { street: {} } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     fromNullable(employee2.company),
- *     chainNullableK(company => company.address),
- *     chainNullableK(address => address.street),
- *     chainNullableK(street => street.name)
- *   ),
- *   none
- * )
- *
- * @category interop
- * @since 2.9.0
- */
-var chainNullableK = function (f) { return function (ma) {
-    return exports.isNone(ma) ? exports.none : exports.fromNullable(f(ma.value));
-}; };
-exports.chainNullableK = chainNullableK;
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns `null`.
- *
- * @example
- * import { some, none, toNullable } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     toNullable
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     toNullable
- *   ),
- *   null
- * )
- *
- * @category interop
- * @since 2.0.0
- */
-exports.toNullable = 
-/*#__PURE__*/
-exports.match(_function.constNull, _function.identity);
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.
- *
- * @example
- * import { some, none, toUndefined } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     toUndefined
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     toUndefined
- *   ),
- *   undefined
- * )
- *
- * @category interop
- * @since 2.0.0
- */
-exports.toUndefined = 
-/*#__PURE__*/
-exports.match(_function.constUndefined, _function.identity);
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-var _map = function (fa, f) { return _function.pipe(fa, exports.map(f)); };
-var _ap = function (fab, fa) { return _function.pipe(fab, exports.ap(fa)); };
-var _chain = function (ma, f) { return _function.pipe(ma, exports.chain(f)); };
-var _reduce = function (fa, b, f) { return _function.pipe(fa, exports.reduce(b, f)); };
-var _foldMap = function (M) {
-    var foldMapM = exports.foldMap(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapM(f)); };
-};
-var _reduceRight = function (fa, b, f) { return _function.pipe(fa, exports.reduceRight(b, f)); };
-var _traverse = function (F) {
-    var traverseF = exports.traverse(F);
-    return function (ta, f) { return _function.pipe(ta, traverseF(f)); };
-};
-/* istanbul ignore next */
-var _alt = function (fa, that) { return _function.pipe(fa, exports.alt(that)); };
-var _filter = function (fa, predicate) { return _function.pipe(fa, exports.filter(predicate)); };
-/* istanbul ignore next */
-var _filterMap = function (fa, f) { return _function.pipe(fa, exports.filterMap(f)); };
-/* istanbul ignore next */
-var _extend = function (wa, f) { return _function.pipe(wa, exports.extend(f)); };
-/* istanbul ignore next */
-var _partition = function (fa, predicate) {
-    return _function.pipe(fa, exports.partition(predicate));
-};
-/* istanbul ignore next */
-var _partitionMap = function (fa, f) { return _function.pipe(fa, exports.partitionMap(f)); };
-/* istanbul ignore next */
-var _wither = function (F) {
-    var witherF = exports.wither(F);
-    return function (fa, f) { return _function.pipe(fa, witherF(f)); };
-};
-/* istanbul ignore next */
-var _wilt = function (F) {
-    var wiltF = exports.wilt(F);
-    return function (fa, f) { return _function.pipe(fa, wiltF(f)); };
-};
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
- * use the type constructor `F` to represent some computational context.
- *
- * @category Functor
- * @since 2.0.0
- */
-var map = function (f) { return function (fa) {
-    return exports.isNone(fa) ? exports.none : exports.some(f(fa.value));
-}; };
-exports.map = map;
-/**
- * Apply a function to an argument under a type constructor.
- *
- * @category Apply
- * @since 2.0.0
- */
-var ap = function (fa) { return function (fab) {
-    return exports.isNone(fab) ? exports.none : exports.isNone(fa) ? exports.none : exports.some(fab.value(fa.value));
-}; };
-exports.ap = ap;
-/**
- * @category Pointed
- * @since 2.7.0
- */
-exports.of = exports.some;
-/**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
- *
- * @category Monad
- * @since 2.0.0
- */
-var chain = function (f) { return function (ma) {
-    return exports.isNone(ma) ? exports.none : f(ma.value);
-}; };
-exports.chain = chain;
-/**
- * Derivable from `Chain`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.flatten = 
-/*#__PURE__*/
-exports.chain(_function.identity);
-/**
- * Less strict version of [`alt`](#alt).
- *
- * @category Alt
- * @since 2.9.0
- */
-var altW = function (that) { return function (fa) {
-    return exports.isNone(fa) ? that() : fa;
-}; };
-exports.altW = altW;
-/**
- * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to
- * types of kind `* -> *`.
- *
- * In case of `Option` returns the left-most non-`None` value.
- *
- * @example
- * import * as O from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     O.some('a'),
- *     O.alt(() => O.some('b'))
- *   ),
- *   O.some('a')
- * )
- * assert.deepStrictEqual(
- *   pipe(
- *     O.none,
- *     O.alt(() => O.some('b'))
- *   ),
- *   O.some('b')
- * )
- *
- * @category Alt
- * @since 2.0.0
- */
-exports.alt = exports.altW;
-/**
- * @category Alternative
- * @since 2.7.0
- */
-var zero = function () { return exports.none; };
-exports.zero = zero;
-/**
- * @category MonadThrow
- * @since 2.7.0
- */
-var throwError = function () { return exports.none; };
-exports.throwError = throwError;
-/**
- * @category Extend
- * @since 2.0.0
- */
-var extend = function (f) { return function (wa) {
-    return exports.isNone(wa) ? exports.none : exports.some(f(wa));
-}; };
-exports.extend = extend;
-/**
- * Derivable from `Extend`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.duplicate = 
-/*#__PURE__*/
-exports.extend(_function.identity);
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var reduce = function (b, f) { return function (fa) {
-    return exports.isNone(fa) ? b : f(b, fa.value);
-}; };
-exports.reduce = reduce;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var foldMap = function (M) { return function (f) { return function (fa) {
-    return exports.isNone(fa) ? M.empty : f(fa.value);
-}; }; };
-exports.foldMap = foldMap;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var reduceRight = function (b, f) { return function (fa) {
-    return exports.isNone(fa) ? b : f(fa.value, b);
-}; };
-exports.reduceRight = reduceRight;
-/**
- * @category Compactable
- * @since 2.0.0
- */
-exports.compact = exports.flatten;
-var defaultSeparated = 
-/*#__PURE__*/
-Separated.separated(exports.none, exports.none);
-/**
- * @category Compactable
- * @since 2.0.0
- */
-var separate = function (ma) {
-    return exports.isNone(ma) ? defaultSeparated : Separated.separated(getLeft(ma.value), getRight(ma.value));
-};
-exports.separate = separate;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var filter = function (predicate) { return function (fa) { return (exports.isNone(fa) ? exports.none : predicate(fa.value) ? fa : exports.none); }; };
-exports.filter = filter;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var filterMap = function (f) { return function (fa) {
-    return exports.isNone(fa) ? exports.none : f(fa.value);
-}; };
-exports.filterMap = filterMap;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var partition = function (predicate) { return function (fa) {
-    return Separated.separated(_filter(fa, function (a) { return !predicate(a); }), _filter(fa, predicate));
-}; };
-exports.partition = partition;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var partitionMap = function (f) { return _function.flow(exports.map(f), exports.separate); };
-exports.partitionMap = partitionMap;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var traverse = function (F) { return function (f) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(f(ta.value), exports.some)); }; }; };
-exports.traverse = traverse;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var sequence = function (F) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(ta.value, exports.some)); }; };
-exports.sequence = sequence;
-/**
- * @category Witherable
- * @since 2.6.5
- */
-var wither = function (F) { return function (f) { return function (fa) { return (exports.isNone(fa) ? F.of(exports.none) : f(fa.value)); }; }; };
-exports.wither = wither;
-/**
- * @category Witherable
- * @since 2.6.5
- */
-var wilt = function (F) { return function (f) { return function (fa) {
-    return exports.isNone(fa) ? F.of(defaultSeparated) : F.map(f(fa.value), function (e) { return Separated.separated(getLeft(e), getRight(e)); });
-}; }; };
-exports.wilt = wilt;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.URI = 'Option';
-/**
- * @category instances
- * @since 2.0.0
- */
-function getShow(S) {
-    return {
-        show: function (ma) { return (exports.isNone(ma) ? 'none' : "some(" + S.show(ma.value) + ")"); }
-    };
-}
-exports.getShow = getShow;
-/**
- * @example
- * import { none, some, getEq } from 'fp-ts/Option'
- * import * as N from 'fp-ts/number'
- *
- * const E = getEq(N.Eq)
- * assert.strictEqual(E.equals(none, none), true)
- * assert.strictEqual(E.equals(none, some(1)), false)
- * assert.strictEqual(E.equals(some(1), none), false)
- * assert.strictEqual(E.equals(some(1), some(2)), false)
- * assert.strictEqual(E.equals(some(1), some(1)), true)
- *
- * @category instances
- * @since 2.0.0
- */
-function getEq(E) {
-    return {
-        equals: function (x, y) { return x === y || (exports.isNone(x) ? exports.isNone(y) : exports.isNone(y) ? false : E.equals(x.value, y.value)); }
-    };
-}
-exports.getEq = getEq;
-/**
- * The `Ord` instance allows `Option` values to be compared with
- * `compare`, whenever there is an `Ord` instance for
- * the type the `Option` contains.
- *
- * `None` is considered to be less than any `Some` value.
- *
- *
- * @example
- * import { none, some, getOrd } from 'fp-ts/Option'
- * import * as N from 'fp-ts/number'
- *
- * const O = getOrd(N.Ord)
- * assert.strictEqual(O.compare(none, none), 0)
- * assert.strictEqual(O.compare(none, some(1)), -1)
- * assert.strictEqual(O.compare(some(1), none), 1)
- * assert.strictEqual(O.compare(some(1), some(2)), -1)
- * assert.strictEqual(O.compare(some(1), some(1)), 0)
- *
- * @category instances
- * @since 2.0.0
- */
-function getOrd(O) {
-    return {
-        equals: getEq(O).equals,
-        compare: function (x, y) { return (x === y ? 0 : exports.isSome(x) ? (exports.isSome(y) ? O.compare(x.value, y.value) : 1) : -1); }
-    };
-}
-exports.getOrd = getOrd;
-/**
- * Monoid returning the left-most non-`None` value
- *
- * | x       | y       | concat(x, y) |
- * | ------- | ------- | ------------ |
- * | none    | none    | none         |
- * | some(a) | none    | some(a)      |
- * | none    | some(a) | some(a)      |
- * | some(a) | some(b) | some(a)      |
- *
- * @example
- * import { getFirstMonoid, some, none } from 'fp-ts/Option'
- *
- * const M = getFirstMonoid<number>()
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))
- *
- * @category instances
- * @since 2.0.0
- */
-function getFirstMonoid() {
-    return {
-        concat: function (x, y) { return (exports.isNone(x) ? y : x); },
-        empty: exports.none
-    };
-}
-exports.getFirstMonoid = getFirstMonoid;
-/**
- * Monoid returning the right-most non-`None` value
- *
- * | x       | y       | concat(x, y) |
- * | ------- | ------- | ------------ |
- * | none    | none    | none         |
- * | some(a) | none    | some(a)      |
- * | none    | some(a) | some(a)      |
- * | some(a) | some(b) | some(b)      |
- *
- * @example
- * import { getLastMonoid, some, none } from 'fp-ts/Option'
- *
- * const M = getLastMonoid<number>()
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))
- *
- * @category instances
- * @since 2.0.0
- */
-function getLastMonoid() {
-    return {
-        concat: function (x, y) { return (exports.isNone(y) ? x : y); },
-        empty: exports.none
-    };
-}
-exports.getLastMonoid = getLastMonoid;
-/**
- * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are
- * concatenated using the provided `Semigroup`
- *
- * | x       | y       | concat(x, y)       |
- * | ------- | ------- | ------------------ |
- * | none    | none    | none               |
- * | some(a) | none    | some(a)            |
- * | none    | some(a) | some(a)            |
- * | some(a) | some(b) | some(concat(a, b)) |
- *
- * @example
- * import { getMonoid, some, none } from 'fp-ts/Option'
- * import { SemigroupSum } from 'fp-ts/number'
- *
- * const M = getMonoid(SemigroupSum)
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))
- *
- * @category instances
- * @since 2.0.0
- */
-function getMonoid(S) {
-    return {
-        concat: function (x, y) { return (exports.isNone(x) ? y : exports.isNone(y) ? x : exports.some(S.concat(x.value, y.value))); },
-        empty: exports.none
-    };
-}
-exports.getMonoid = getMonoid;
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Functor = {
-    URI: exports.URI,
-    map: _map
-};
-/**
- * Derivable from `Functor`.
- *
- * @category combinators
- * @since 2.10.0
- */
-exports.flap = 
-/*#__PURE__*/
-Functor.flap(exports.Functor);
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.Pointed = {
-    URI: exports.URI,
-    of: exports.of
-};
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.Apply = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap
-};
-/**
- * Combine two effectful actions, keeping only the result of the first.
- *
- * Derivable from `Apply`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.apFirst = 
-/*#__PURE__*/
-Apply.apFirst(exports.Apply);
-/**
- * Combine two effectful actions, keeping only the result of the second.
- *
- * Derivable from `Apply`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.apSecond = 
-/*#__PURE__*/
-Apply.apSecond(exports.Apply);
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Applicative = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of
-};
-/**
- * @category instances
- * @since 2.10.0
- */
-exports.Chain = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    chain: _chain
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Monad = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of,
-    chain: _chain
-};
-/**
- * Composes computations in sequence, using the return value of one computation to determine the next computation and
- * keeping only the result of the first.
- *
- * Derivable from `Chain`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.chainFirst = 
-/*#__PURE__*/
-Chain.chainFirst(exports.Chain);
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Foldable = {
-    URI: exports.URI,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alt = {
-    URI: exports.URI,
-    map: _map,
-    alt: _alt
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alternative = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of,
-    alt: _alt,
-    zero: exports.zero
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Extend = {
-    URI: exports.URI,
-    map: _map,
-    extend: _extend
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Compactable = {
-    URI: exports.URI,
-    compact: exports.compact,
-    separate: exports.separate
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Filterable = {
-    URI: exports.URI,
-    map: _map,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: _filter,
-    filterMap: _filterMap,
-    partition: _partition,
-    partitionMap: _partitionMap
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Traversable = {
-    URI: exports.URI,
-    map: _map,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Witherable = {
-    URI: exports.URI,
-    map: _map,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: _filter,
-    filterMap: _filterMap,
-    partition: _partition,
-    partitionMap: _partitionMap,
-    wither: _wither,
-    wilt: _wilt
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.MonadThrow = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of,
-    chain: _chain,
-    throwError: exports.throwError
-};
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * Returns `true` if `ma` contains `a`
- *
- * @example
- * import { some, none, elem } from 'fp-ts/Option'
- * import * as N from 'fp-ts/number'
- *
- * assert.strictEqual(elem(N.Eq)(1, some(1)), true)
- * assert.strictEqual(elem(N.Eq)(2, some(1)), false)
- * assert.strictEqual(elem(N.Eq)(1, none), false)
- *
- * @since 2.0.0
- */
-function elem(E) {
-    return function (a, ma) { return (exports.isNone(ma) ? false : E.equals(a, ma.value)); };
-}
-exports.elem = elem;
-/**
- * Returns `true` if the predicate is satisfied by the wrapped value
- *
- * @example
- * import { some, none, exists } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 0)
- *   ),
- *   true
- * )
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 1)
- *   ),
- *   false
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     exists(n => n > 0)
- *   ),
- *   false
- * )
- *
- * @since 2.0.0
- */
-function exists(predicate) {
-    return function (ma) { return (exports.isNone(ma) ? false : predicate(ma.value)); };
-}
-exports.exists = exists;
-/**
- * Returns a `Refinement` (i.e. a custom type guard) from a `Option` returning function.
- * This function ensures that a custom type guard definition is type-safe.
- *
- * ```ts
- * import { some, none, getRefinement } from 'fp-ts/Option'
- *
- * type A = { type: 'A' }
- * type B = { type: 'B' }
- * type C = A | B
- *
- * const isA = (c: C): c is A => c.type === 'B' // <= typo but typescript doesn't complain
- * const isA = getRefinement<C, A>(c => (c.type === 'B' ? some(c) : none)) // static error: Type '"B"' is not assignable to type '"A"'
- * ```
- *
- * @since 2.0.0
- */
-function getRefinement(getOption) {
-    return function (a) { return exports.isSome(getOption(a)); };
-}
-exports.getRefinement = getRefinement;
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.9.0
- */
-exports.Do = 
-/*#__PURE__*/
-exports.of({});
-/**
- * @since 2.8.0
- */
-exports.bindTo = 
-/*#__PURE__*/
-Functor.bindTo(exports.Functor);
-/**
- * @since 2.8.0
- */
-exports.bind = 
-/*#__PURE__*/
-Chain.bind(exports.Chain);
-// -------------------------------------------------------------------------------------
-// pipeable sequence S
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.8.0
- */
-exports.apS = 
-/*#__PURE__*/
-Apply.apS(exports.Apply);
-// -------------------------------------------------------------------------------------
-// array utils
-// -------------------------------------------------------------------------------------
-/**
- * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
- *
- * @since 2.9.0
- */
-var traverseArrayWithIndex = function (f) { return function (as) {
-    var out = [];
-    for (var i = 0; i < as.length; i++) {
-        var b = f(i, as[i]);
-        if (exports.isNone(b)) {
-            return exports.none;
-        }
-        out.push(b.value);
-    }
-    return exports.some(out);
-}; };
-exports.traverseArrayWithIndex = traverseArrayWithIndex;
-/**
- * Equivalent to `ReadonlyArray#traverse(Applicative)`.
- *
- * @since 2.9.0
- */
-var traverseArray = function (f) {
-    return exports.traverseArrayWithIndex(function (_, a) { return f(a); });
-};
-exports.traverseArray = traverseArray;
-/**
- * Equivalent to `ReadonlyArray#sequence(Applicative)`.
- *
- * @since 2.9.0
- */
-exports.sequenceArray = 
-/*#__PURE__*/
-exports.traverseArray(_function.identity);
-// -------------------------------------------------------------------------------------
-// deprecated
-// -------------------------------------------------------------------------------------
-/**
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.mapNullable = exports.chainNullableK;
-/**
- * Use small, specific instances instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.option = {
-    URI: exports.URI,
-    map: _map,
-    of: exports.of,
-    ap: _ap,
-    chain: _chain,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    zero: exports.zero,
-    alt: _alt,
-    extend: _extend,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: _filter,
-    filterMap: _filterMap,
-    partition: _partition,
-    partitionMap: _partitionMap,
-    wither: _wither,
-    wilt: _wilt,
-    throwError: exports.throwError
-};
-/**
- * Use `Apply.getApplySemigroup` instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.getApplySemigroup = 
-/*#__PURE__*/
-Apply.getApplySemigroup(exports.Apply);
-/**
- * Use `Applicative.getApplicativeMonoid` instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.getApplyMonoid = 
-/*#__PURE__*/
-Applicative.getApplicativeMonoid(exports.Applicative);
-});
-
-export { Option as O, _function as _, commonjsGlobal as a, createCommonjsModule as c, getDefaultExportFromCjs as g };