vviinn-widgets 2.1.0 → 2.2.2

package/www/build/NonEmptyArray-6ef0d207.js

@@ -1,4370 +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(path, (base === undefined || base === null) ? module.path : base);
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function getDefaultExportFromNamespaceIfPresent (n) {
-	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
-}
-
-function getDefaultExportFromNamespaceIfNotNamed (n) {
-	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
-}
-
-function getAugmentedNamespace(n) {
-	if (n.__esModule) return n;
-	var a = Object.defineProperty({}, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-var _function = createCommonjsModule(function (module, exports) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEndomorphismMonoid = exports.not = exports.SK = 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.unsafeCoerce = exports.identity = exports.apply = 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 } from 'fp-ts/Predicate'
- * import { 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;
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.11.0
- */
-var apply = function (a) { return function (f) { return f(a); }; };
-exports.apply = apply;
-/**
- * @since 2.0.0
- */
-function identity(a) {
-    return a;
-}
-exports.identity = identity;
-/**
- * @since 2.0.0
- */
-exports.unsafeCoerce = identity;
-/**
- * @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) {
-    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))))))));
-        default:
-            var ret = arguments[0];
-            for (var i = 1; i < arguments.length; i++) {
-                ret = arguments[i](ret);
-            }
-            return ret;
-    }
-}
-exports.pipe = pipe;
-/**
- * Type hole simulation
- *
- * @since 2.7.0
- */
-exports.hole = absurd;
-/**
- * @since 2.11.0
- */
-var SK = function (_, b) { return b; };
-exports.SK = SK;
-/**
- * Use `Predicate` module instead.
- *
- * @since 2.0.0
- * @deprecated
- */
-function not(predicate) {
-    return function (a) { return !predicate(a); };
-}
-exports.not = not;
-/**
- * Use `Endomorphism` module instead.
- *
- * @category instances
- * @since 2.10.0
- * @deprecated
- */
-var getEndomorphismMonoid = function () { return ({
-    concat: function (first, second) { return flow(first, second); },
-    empty: identity
-}); };
-exports.getEndomorphismMonoid = getEndomorphismMonoid;
-});
-
-const _function$1 = /*@__PURE__*/getDefaultExportFromCjs(_function);
-
-var Apply = createCommonjsModule(function (module, exports) {
-"use strict";
-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;
-});
-
-const Apply$1 = /*@__PURE__*/getDefaultExportFromCjs(Apply);
-
-var Functor = createCommonjsModule(function (module, exports) {
-"use strict";
-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;
-});
-
-const Functor$1 = /*@__PURE__*/getDefaultExportFromCjs(Functor);
-
-var Chain = createCommonjsModule(function (module, exports) {
-"use strict";
-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;
-});
-
-const Chain$1 = /*@__PURE__*/getDefaultExportFromCjs(Chain);
-
-var internal = createCommonjsModule(function (module, exports) {
-"use strict";
-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.emptyRecord = exports.emptyReadonlyArray = exports.tail = exports.head = exports.isNonEmpty = exports.singleton = exports.right = exports.left = exports.isRight = exports.isLeft = exports.some = exports.none = exports.isSome = exports.isNone = void 0;
-// -------------------------------------------------------------------------------------
-// Option
-// -------------------------------------------------------------------------------------
-/** @internal */
-var isNone = function (fa) { return fa._tag === 'None'; };
-exports.isNone = isNone;
-/** @internal */
-var isSome = function (fa) { return fa._tag === 'Some'; };
-exports.isSome = isSome;
-/** @internal */
-exports.none = { _tag: 'None' };
-/** @internal */
-var some = function (a) { return ({ _tag: 'Some', value: a }); };
-exports.some = some;
-// -------------------------------------------------------------------------------------
-// Either
-// -------------------------------------------------------------------------------------
-/** @internal */
-var isLeft = function (ma) { return ma._tag === 'Left'; };
-exports.isLeft = isLeft;
-/** @internal */
-var isRight = function (ma) { return ma._tag === 'Right'; };
-exports.isRight = isRight;
-/** @internal */
-var left = function (e) { return ({ _tag: 'Left', left: e }); };
-exports.left = left;
-/** @internal */
-var right = function (a) { return ({ _tag: 'Right', right: a }); };
-exports.right = right;
-// -------------------------------------------------------------------------------------
-// ReadonlyNonEmptyArray
-// -------------------------------------------------------------------------------------
-/** @internal */
-var singleton = function (a) { return [a]; };
-exports.singleton = singleton;
-/** @internal */
-var isNonEmpty = function (as) { return as.length > 0; };
-exports.isNonEmpty = isNonEmpty;
-/** @internal */
-var head = function (as) { return as[0]; };
-exports.head = head;
-/** @internal */
-var tail = function (as) { return as.slice(1); };
-exports.tail = tail;
-// -------------------------------------------------------------------------------------
-// empty
-// -------------------------------------------------------------------------------------
-/** @internal */
-exports.emptyReadonlyArray = [];
-/** @internal */
-exports.emptyRecord = {};
-// -------------------------------------------------------------------------------------
-// Record
-// -------------------------------------------------------------------------------------
-/** @internal */
-exports.has = Object.prototype.hasOwnProperty;
-// -------------------------------------------------------------------------------------
-// NonEmptyArray
-// -------------------------------------------------------------------------------------
-/** @internal */
-var fromReadonlyNonEmptyArray = function (as) { return __spreadArray([as[0]], as.slice(1)); };
-exports.fromReadonlyNonEmptyArray = fromReadonlyNonEmptyArray;
-});
-
-const internal$1 = /*@__PURE__*/getDefaultExportFromCjs(internal);
-
-var FromEither = createCommonjsModule(function (module, exports) {
-"use strict";
-/**
- * The `FromEither` type class represents those data types which support errors.
- *
- * @since 2.10.0
- */
-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.filterOrElse = exports.chainEitherK = exports.fromEitherK = exports.chainOptionK = exports.fromOptionK = exports.fromPredicate = exports.fromOption = void 0;
-
-var _ = __importStar(internal);
-function fromOption(F) {
-    return function (onNone) { return function (ma) { return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value)); }; };
-}
-exports.fromOption = fromOption;
-function fromPredicate(F) {
-    return function (predicate, onFalse) { return function (a) {
-        return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));
-    }; };
-}
-exports.fromPredicate = fromPredicate;
-function fromOptionK(F) {
-    var fromOptionF = fromOption(F);
-    return function (onNone) {
-        var from = fromOptionF(onNone);
-        return function (f) { return _function.flow(f, from); };
-    };
-}
-exports.fromOptionK = fromOptionK;
-function chainOptionK(F, M) {
-    var fromOptionKF = fromOptionK(F);
-    return function (onNone) {
-        var from = fromOptionKF(onNone);
-        return function (f) { return function (ma) { return M.chain(ma, from(f)); }; };
-    };
-}
-exports.chainOptionK = chainOptionK;
-function fromEitherK(F) {
-    return function (f) { return _function.flow(f, F.fromEither); };
-}
-exports.fromEitherK = fromEitherK;
-function chainEitherK(F, M) {
-    var fromEitherKF = fromEitherK(F);
-    return function (f) { return function (ma) { return M.chain(ma, fromEitherKF(f)); }; };
-}
-exports.chainEitherK = chainEitherK;
-function filterOrElse(F, M) {
-    return function (predicate, onFalse) { return function (ma) {
-        return M.chain(ma, function (a) { return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a))); });
-    }; };
-}
-exports.filterOrElse = filterOrElse;
-});
-
-const FromEither$1 = /*@__PURE__*/getDefaultExportFromCjs(FromEither);
-
-var Magma = createCommonjsModule(function (module, exports) {
-"use strict";
-/**
- * A `Magma` is a pair `(A, concat)` in which `A` is a non-empty set and `concat` is a binary operation on `A`
- *
- * See [Semigroup](https://gcanti.github.io/fp-ts/modules/Semigroup.ts.html) for some instances.
- *
- * @since 2.0.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.concatAll = exports.endo = exports.filterSecond = exports.filterFirst = exports.reverse = void 0;
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-/**
- * The dual of a `Magma`, obtained by swapping the arguments of `concat`.
- *
- * @example
- * import { reverse, concatAll } from 'fp-ts/Magma'
- * import * as N from 'fp-ts/number'
- *
- * const subAll = concatAll(reverse(N.MagmaSub))(0)
- *
- * assert.deepStrictEqual(subAll([1, 2, 3]), 2)
- *
- * @category combinators
- * @since 2.11.0
- */
-var reverse = function (M) { return ({
-    concat: function (first, second) { return M.concat(second, first); }
-}); };
-exports.reverse = reverse;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var filterFirst = function (predicate) { return function (M) { return ({
-    concat: function (first, second) { return (predicate(first) ? M.concat(first, second) : second); }
-}); }; };
-exports.filterFirst = filterFirst;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var filterSecond = function (predicate) { return function (M) { return ({
-    concat: function (first, second) { return (predicate(second) ? M.concat(first, second) : first); }
-}); }; };
-exports.filterSecond = filterSecond;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var endo = function (f) { return function (M) { return ({
-    concat: function (first, second) { return M.concat(f(first), f(second)); }
-}); }; };
-exports.endo = endo;
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * Given a sequence of `as`, concat them and return the total.
- *
- * If `as` is empty, return the provided `startWith` value.
- *
- * @example
- * import { concatAll } from 'fp-ts/Magma'
- * import * as N from 'fp-ts/number'
- *
- * const subAll = concatAll(N.MagmaSub)(0)
- *
- * assert.deepStrictEqual(subAll([1, 2, 3]), -6)
- *
- * @since 2.11.0
- */
-var concatAll = function (M) { return function (startWith) { return function (as) {
-    return as.reduce(function (a, acc) { return M.concat(a, acc); }, startWith);
-}; }; };
-exports.concatAll = concatAll;
-});
-
-const Magma$1 = /*@__PURE__*/getDefaultExportFromCjs(Magma);
-
-var Eq = createCommonjsModule(function (module, exports) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.eqDate = exports.eqNumber = exports.eqString = exports.eqBoolean = exports.eq = exports.strictEqual = exports.getStructEq = exports.getTupleEq = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.eqStrict = exports.URI = exports.contramap = exports.tuple = exports.struct = exports.fromEquals = void 0;
-
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * @category constructors
- * @since 2.0.0
- */
-var fromEquals = function (equals) { return ({
-    equals: function (x, y) { return x === y || equals(x, y); }
-}); };
-exports.fromEquals = fromEquals;
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-/**
- * @category combinators
- * @since 2.10.0
- */
-var struct = function (eqs) {
-    return exports.fromEquals(function (first, second) {
-        for (var key in eqs) {
-            if (!eqs[key].equals(first[key], second[key])) {
-                return false;
-            }
-        }
-        return true;
-    });
-};
-exports.struct = struct;
-/**
- * Given a tuple of `Eq`s returns a `Eq` for the tuple
- *
- * @example
- * import { tuple } from 'fp-ts/Eq'
- * import * as S from 'fp-ts/string'
- * import * as N from 'fp-ts/number'
- * import * as B from 'fp-ts/boolean'
- *
- * const E = tuple(S.Eq, N.Eq, B.Eq)
- * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
- * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
- * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
- * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
- *
- * @category combinators
- * @since 2.10.0
- */
-var tuple = function () {
-    var eqs = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        eqs[_i] = arguments[_i];
-    }
-    return exports.fromEquals(function (first, second) { return eqs.every(function (E, i) { return E.equals(first[i], second[i]); }); });
-};
-exports.tuple = tuple;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-/* istanbul ignore next */
-var contramap_ = function (fa, f) { return _function.pipe(fa, exports.contramap(f)); };
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * @category Contravariant
- * @since 2.0.0
- */
-var contramap = function (f) { return function (fa) {
-    return exports.fromEquals(function (x, y) { return fa.equals(f(x), f(y)); });
-}; };
-exports.contramap = contramap;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.URI = 'Eq';
-/**
- * @category instances
- * @since 2.5.0
- */
-exports.eqStrict = {
-    equals: function (a, b) { return a === b; }
-};
-var empty = {
-    equals: function () { return true; }
-};
-/**
- * @category instances
- * @since 2.10.0
- */
-var getSemigroup = function () { return ({
-    concat: function (x, y) { return exports.fromEquals(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); }
-}); };
-exports.getSemigroup = getSemigroup;
-/**
- * @category instances
- * @since 2.6.0
- */
-var getMonoid = function () { return ({
-    concat: exports.getSemigroup().concat,
-    empty: empty
-}); };
-exports.getMonoid = getMonoid;
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Contravariant = {
-    URI: exports.URI,
-    contramap: contramap_
-};
-// -------------------------------------------------------------------------------------
-// deprecated
-// -------------------------------------------------------------------------------------
-/**
- * Use [`tuple`](#tuple) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getTupleEq = exports.tuple;
-/**
- * Use [`struct`](#struct) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getStructEq = exports.struct;
-/**
- * Use [`eqStrict`](#eqstrict) instead
- *
- * @since 2.0.0
- * @deprecated
- */
-exports.strictEqual = exports.eqStrict.equals;
-/**
- * Use small, specific instances instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.eq = exports.Contravariant;
-/**
- * Use [`Eq`](./boolean.ts.html#eq) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.eqBoolean = exports.eqStrict;
-/**
- * Use [`Eq`](./string.ts.html#eq) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.eqString = exports.eqStrict;
-/**
- * Use [`Eq`](./number.ts.html#eq) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.eqNumber = exports.eqStrict;
-/**
- * Use [`Eq`](./Date.ts.html#eq) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.eqDate = {
-    equals: function (first, second) { return first.valueOf() === second.valueOf(); }
-};
-});
-
-const Eq$1 = /*@__PURE__*/getDefaultExportFromCjs(Eq);
-
-var Ord = createCommonjsModule(function (module, exports) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ordDate = exports.ordNumber = exports.ordString = exports.ordBoolean = exports.ord = exports.getDualOrd = exports.getTupleOrd = exports.between = exports.clamp = exports.max = exports.min = exports.geq = exports.leq = exports.gt = exports.lt = exports.equals = exports.trivial = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.URI = exports.contramap = exports.reverse = exports.tuple = exports.fromCompare = exports.equalsDefault = void 0;
-
-
-// -------------------------------------------------------------------------------------
-// defaults
-// -------------------------------------------------------------------------------------
-/**
- * @category defaults
- * @since 2.10.0
- */
-var equalsDefault = function (compare) { return function (first, second) {
-    return first === second || compare(first, second) === 0;
-}; };
-exports.equalsDefault = equalsDefault;
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * @category constructors
- * @since 2.0.0
- */
-var fromCompare = function (compare) { return ({
-    equals: exports.equalsDefault(compare),
-    compare: function (first, second) { return (first === second ? 0 : compare(first, second)); }
-}); };
-exports.fromCompare = fromCompare;
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-/**
- * Given a tuple of `Ord`s returns an `Ord` for the tuple.
- *
- * @example
- * import { tuple } from 'fp-ts/Ord'
- * import * as B from 'fp-ts/boolean'
- * import * as S from 'fp-ts/string'
- * import * as N from 'fp-ts/number'
- *
- * const O = tuple(S.Ord, N.Ord, B.Ord)
- * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)
- * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)
- * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)
- *
- * @category combinators
- * @since 2.10.0
- */
-var tuple = function () {
-    var ords = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        ords[_i] = arguments[_i];
-    }
-    return exports.fromCompare(function (first, second) {
-        var i = 0;
-        for (; i < ords.length - 1; i++) {
-            var r = ords[i].compare(first[i], second[i]);
-            if (r !== 0) {
-                return r;
-            }
-        }
-        return ords[i].compare(first[i], second[i]);
-    });
-};
-exports.tuple = tuple;
-/**
- * @category combinators
- * @since 2.10.0
- */
-var reverse = function (O) { return exports.fromCompare(function (first, second) { return O.compare(second, first); }); };
-exports.reverse = reverse;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-/* istanbul ignore next */
-var contramap_ = function (fa, f) { return _function.pipe(fa, exports.contramap(f)); };
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * @category Contravariant
- * @since 2.0.0
- */
-var contramap = function (f) { return function (fa) {
-    return exports.fromCompare(function (first, second) { return fa.compare(f(first), f(second)); });
-}; };
-exports.contramap = contramap;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.URI = 'Ord';
-/**
- * @category instances
- * @since 2.0.0
- */
-var getSemigroup = function () { return ({
-    concat: function (first, second) {
-        return exports.fromCompare(function (a, b) {
-            var ox = first.compare(a, b);
-            return ox !== 0 ? ox : second.compare(a, b);
-        });
-    }
-}); };
-exports.getSemigroup = getSemigroup;
-/**
- * Returns a `Monoid` such that:
- *
- * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`
- * - its `empty` value is an `Ord` that always considers compared elements equal
- *
- * @example
- * import { sort } from 'fp-ts/Array'
- * import { contramap, reverse, getMonoid } from 'fp-ts/Ord'
- * import * as S from 'fp-ts/string'
- * import * as B from 'fp-ts/boolean'
- * import { pipe } from 'fp-ts/function'
- * import { concatAll } from 'fp-ts/Monoid'
- * import * as N from 'fp-ts/number'
- *
- * interface User {
- *   readonly id: number
- *   readonly name: string
- *   readonly age: number
- *   readonly rememberMe: boolean
- * }
- *
- * const byName = pipe(
- *   S.Ord,
- *   contramap((p: User) => p.name)
- * )
- *
- * const byAge = pipe(
- *   N.Ord,
- *   contramap((p: User) => p.age)
- * )
- *
- * const byRememberMe = pipe(
- *   B.Ord,
- *   contramap((p: User) => p.rememberMe)
- * )
- *
- * const M = getMonoid<User>()
- *
- * const users: Array<User> = [
- *   { id: 1, name: 'Guido', age: 47, rememberMe: false },
- *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
- *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
- *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }
- * ]
- *
- * // sort by name, then by age, then by `rememberMe`
- * const O1 = concatAll(M)([byName, byAge, byRememberMe])
- * assert.deepStrictEqual(sort(O1)(users), [
- *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
- *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },
- *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
- *   { id: 1, name: 'Guido', age: 47, rememberMe: false }
- * ])
- *
- * // now `rememberMe = true` first, then by name, then by age
- * const O2 = concatAll(M)([reverse(byRememberMe), byName, byAge])
- * assert.deepStrictEqual(sort(O2)(users), [
- *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },
- *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
- *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
- *   { id: 1, name: 'Guido', age: 47, rememberMe: false }
- * ])
- *
- * @category instances
- * @since 2.4.0
- */
-var getMonoid = function () { return ({
-    concat: exports.getSemigroup().concat,
-    empty: exports.fromCompare(function () { return 0; })
-}); };
-exports.getMonoid = getMonoid;
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Contravariant = {
-    URI: exports.URI,
-    contramap: contramap_
-};
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.11.0
- */
-exports.trivial = {
-    equals: _function.constTrue,
-    compare: 
-    /*#__PURE__*/
-    _function.constant(0)
-};
-/**
- * @since 2.11.0
- */
-var equals = function (O) { return function (second) { return function (first) {
-    return first === second || O.compare(first, second) === 0;
-}; }; };
-exports.equals = equals;
-// TODO: curry in v3
-/**
- * Test whether one value is _strictly less than_ another
- *
- * @since 2.0.0
- */
-var lt = function (O) { return function (first, second) { return O.compare(first, second) === -1; }; };
-exports.lt = lt;
-// TODO: curry in v3
-/**
- * Test whether one value is _strictly greater than_ another
- *
- * @since 2.0.0
- */
-var gt = function (O) { return function (first, second) { return O.compare(first, second) === 1; }; };
-exports.gt = gt;
-// TODO: curry in v3
-/**
- * Test whether one value is _non-strictly less than_ another
- *
- * @since 2.0.0
- */
-var leq = function (O) { return function (first, second) { return O.compare(first, second) !== 1; }; };
-exports.leq = leq;
-// TODO: curry in v3
-/**
- * Test whether one value is _non-strictly greater than_ another
- *
- * @since 2.0.0
- */
-var geq = function (O) { return function (first, second) { return O.compare(first, second) !== -1; }; };
-exports.geq = geq;
-// TODO: curry in v3
-/**
- * Take the minimum of two values. If they are considered equal, the first argument is chosen
- *
- * @since 2.0.0
- */
-var min = function (O) { return function (first, second) {
-    return first === second || O.compare(first, second) < 1 ? first : second;
-}; };
-exports.min = min;
-// TODO: curry in v3
-/**
- * Take the maximum of two values. If they are considered equal, the first argument is chosen
- *
- * @since 2.0.0
- */
-var max = function (O) { return function (first, second) {
-    return first === second || O.compare(first, second) > -1 ? first : second;
-}; };
-exports.max = max;
-/**
- * Clamp a value between a minimum and a maximum
- *
- * @since 2.0.0
- */
-var clamp = function (O) {
-    var minO = exports.min(O);
-    var maxO = exports.max(O);
-    return function (low, hi) { return function (a) { return maxO(minO(a, hi), low); }; };
-};
-exports.clamp = clamp;
-/**
- * Test whether a value is between a minimum and a maximum (inclusive)
- *
- * @since 2.0.0
- */
-var between = function (O) {
-    var ltO = exports.lt(O);
-    var gtO = exports.gt(O);
-    return function (low, hi) { return function (a) { return (ltO(a, low) || gtO(a, hi) ? false : true); }; };
-};
-exports.between = between;
-// -------------------------------------------------------------------------------------
-// deprecated
-// -------------------------------------------------------------------------------------
-// tslint:disable: deprecation
-/**
- * Use [`tuple`](#tuple) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getTupleOrd = exports.tuple;
-/**
- * Use [`reverse`](#reverse) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getDualOrd = exports.reverse;
-/**
- * Use [`Contravariant`](#contravariant) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.ord = exports.Contravariant;
-// default compare for primitive types
-function compare(first, second) {
-    return first < second ? -1 : first > second ? 1 : 0;
-}
-var strictOrd = {
-    equals: Eq.eqStrict.equals,
-    compare: compare
-};
-/**
- * Use [`Ord`](./boolean.ts.html#ord) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.ordBoolean = strictOrd;
-/**
- * Use [`Ord`](./string.ts.html#ord) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.ordString = strictOrd;
-/**
- * Use [`Ord`](./number.ts.html#ord) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.ordNumber = strictOrd;
-/**
- * Use [`Ord`](./Date.ts.html#ord) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.ordDate = 
-/*#__PURE__*/
-_function.pipe(exports.ordNumber, 
-/*#__PURE__*/
-exports.contramap(function (date) { return date.valueOf(); }));
-});
-
-const Ord$1 = /*@__PURE__*/getDefaultExportFromCjs(Ord);
-
-var Semigroup = createCommonjsModule(function (module, exports) {
-"use strict";
-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.semigroupProduct = exports.semigroupSum = exports.semigroupString = exports.getFunctionSemigroup = exports.semigroupAny = exports.semigroupAll = exports.fold = exports.getIntercalateSemigroup = exports.getMeetSemigroup = exports.getJoinSemigroup = exports.getDualSemigroup = exports.getStructSemigroup = exports.getTupleSemigroup = exports.getFirstSemigroup = exports.getLastSemigroup = exports.getObjectSemigroup = exports.semigroupVoid = exports.concatAll = exports.last = exports.first = exports.intercalate = exports.tuple = exports.struct = exports.reverse = exports.constant = exports.max = exports.min = void 0;
-/**
- * If a type `A` can form a `Semigroup` it has an **associative** binary operation.
- *
- * ```ts
- * interface Semigroup<A> {
- *   readonly concat: (x: A, y: A) => A
- * }
- * ```
- *
- * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.
- *
- * ```ts
- * concat(x, concat(y, z)) = concat(concat(x, y), z)
- * ```
- *
- * A common example of a semigroup is the type `string` with the operation `+`.
- *
- * ```ts
- * import { Semigroup } from 'fp-ts/Semigroup'
- *
- * const semigroupString: Semigroup<string> = {
- *   concat: (x, y) => x + y
- * }
- *
- * const x = 'x'
- * const y = 'y'
- * const z = 'z'
- *
- * semigroupString.concat(x, y) // 'xy'
- *
- * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'
- *
- * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'
- * ```
- *
- * *Adapted from https://typelevel.org/cats*
- *
- * @since 2.0.0
- */
-
-var _ = __importStar(internal);
-var M = __importStar(Magma);
-var Or = __importStar(Ord);
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * Get a semigroup where `concat` will return the minimum, based on the provided order.
- *
- * @example
- * import * as N from 'fp-ts/number'
- * import * as S from 'fp-ts/Semigroup'
- *
- * const S1 = S.min(N.Ord)
- *
- * assert.deepStrictEqual(S1.concat(1, 2), 1)
- *
- * @category constructors
- * @since 2.10.0
- */
-var min = function (O) { return ({
-    concat: Or.min(O)
-}); };
-exports.min = min;
-/**
- * Get a semigroup where `concat` will return the maximum, based on the provided order.
- *
- * @example
- * import * as N from 'fp-ts/number'
- * import * as S from 'fp-ts/Semigroup'
- *
- * const S1 = S.max(N.Ord)
- *
- * assert.deepStrictEqual(S1.concat(1, 2), 2)
- *
- * @category constructors
- * @since 2.10.0
- */
-var max = function (O) { return ({
-    concat: Or.max(O)
-}); };
-exports.max = max;
-/**
- * @category constructors
- * @since 2.10.0
- */
-var constant = function (a) { return ({
-    concat: function () { return a; }
-}); };
-exports.constant = constant;
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-/**
- * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.
- *
- * @example
- * import { reverse } from 'fp-ts/Semigroup'
- * import * as S from 'fp-ts/string'
- *
- * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')
- *
- * @category combinators
- * @since 2.10.0
- */
-exports.reverse = M.reverse;
-/**
- * Given a struct of semigroups returns a semigroup for the struct.
- *
- * @example
- * import { struct } from 'fp-ts/Semigroup'
- * import * as N from 'fp-ts/number'
- *
- * interface Point {
- *   readonly x: number
- *   readonly y: number
- * }
- *
- * const S = struct<Point>({
- *   x: N.SemigroupSum,
- *   y: N.SemigroupSum
- * })
- *
- * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })
- *
- * @category combinators
- * @since 2.10.0
- */
-var struct = function (semigroups) { return ({
-    concat: function (first, second) {
-        var r = {};
-        for (var k in semigroups) {
-            if (_.has.call(semigroups, k)) {
-                r[k] = semigroups[k].concat(first[k], second[k]);
-            }
-        }
-        return r;
-    }
-}); };
-exports.struct = struct;
-/**
- * Given a tuple of semigroups returns a semigroup for the tuple.
- *
- * @example
- * import { tuple } from 'fp-ts/Semigroup'
- * import * as B from 'fp-ts/boolean'
- * import * as N from 'fp-ts/number'
- * import * as S from 'fp-ts/string'
- *
- * const S1 = tuple(S.Semigroup, N.SemigroupSum)
- * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])
- *
- * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)
- * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])
- *
- * @category combinators
- * @since 2.10.0
- */
-var tuple = function () {
-    var semigroups = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        semigroups[_i] = arguments[_i];
-    }
-    return ({
-        concat: function (first, second) { return semigroups.map(function (s, i) { return s.concat(first[i], second[i]); }); }
-    });
-};
-exports.tuple = tuple;
-/**
- * Between each pair of elements insert `middle`.
- *
- * @example
- * import { intercalate } from 'fp-ts/Semigroup'
- * import * as S from 'fp-ts/string'
- * import { pipe } from 'fp-ts/function'
- *
- * const S1 = pipe(S.Semigroup, intercalate(' + '))
- *
- * assert.strictEqual(S1.concat('a', 'b'), 'a + b')
- *
- * @category combinators
- * @since 2.10.0
- */
-var intercalate = function (middle) { return function (S) { return ({
-    concat: function (x, y) { return S.concat(x, S.concat(middle, y)); }
-}); }; };
-exports.intercalate = intercalate;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * Always return the first argument.
- *
- * @example
- * import * as S from 'fp-ts/Semigroup'
- *
- * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)
- *
- * @category instances
- * @since 2.10.0
- */
-var first = function () { return ({ concat: _function.identity }); };
-exports.first = first;
-/**
- * Always return the last argument.
- *
- * @example
- * import * as S from 'fp-ts/Semigroup'
- *
- * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)
- *
- * @category instances
- * @since 2.10.0
- */
-var last = function () { return ({ concat: function (_, y) { return y; } }); };
-exports.last = last;
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * Given a sequence of `as`, concat them and return the total.
- *
- * If `as` is empty, return the provided `startWith` value.
- *
- * @example
- * import { concatAll } from 'fp-ts/Semigroup'
- * import * as N from 'fp-ts/number'
- *
- * const sum = concatAll(N.SemigroupSum)(0)
- *
- * assert.deepStrictEqual(sum([1, 2, 3]), 6)
- * assert.deepStrictEqual(sum([]), 0)
- *
- * @since 2.10.0
- */
-exports.concatAll = M.concatAll;
-// -------------------------------------------------------------------------------------
-// deprecated
-// -------------------------------------------------------------------------------------
-/**
- * Use `void` module instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupVoid = exports.constant(undefined);
-/**
- * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-var getObjectSemigroup = function () { return ({
-    concat: function (first, second) { return Object.assign({}, first, second); }
-}); };
-exports.getObjectSemigroup = getObjectSemigroup;
-/**
- * Use [`last`](#last) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.getLastSemigroup = exports.last;
-/**
- * Use [`first`](#first) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.getFirstSemigroup = exports.first;
-/**
- * Use [`tuple`](#tuple) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getTupleSemigroup = exports.tuple;
-/**
- * Use [`struct`](#struct) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getStructSemigroup = exports.struct;
-/**
- * Use [`reverse`](#reverse) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.getDualSemigroup = exports.reverse;
-/**
- * Use [`max`](#max) instead.
- *
- * @category constructors
- * @since 2.0.0
- * @deprecated
- */
-exports.getJoinSemigroup = exports.max;
-/**
- * Use [`min`](#min) instead.
- *
- * @category constructors
- * @since 2.0.0
- * @deprecated
- */
-exports.getMeetSemigroup = exports.min;
-/**
- * Use [`intercalate`](#intercalate) instead.
- *
- * @category combinators
- * @since 2.5.0
- * @deprecated
- */
-exports.getIntercalateSemigroup = exports.intercalate;
-function fold(S) {
-    var concatAllS = exports.concatAll(S);
-    return function (startWith, as) { return (as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as)); };
-}
-exports.fold = fold;
-/**
- * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupAll = {
-    concat: function (x, y) { return x && y; }
-};
-/**
- * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupAny = {
-    concat: function (x, y) { return x || y; }
-};
-/**
- * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.getFunctionSemigroup = _function.getSemigroup;
-/**
- * Use [`Semigroup`](./string.ts.html#Semigroup) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupString = {
-    concat: function (x, y) { return x + y; }
-};
-/**
- * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupSum = {
-    concat: function (x, y) { return x + y; }
-};
-/**
- * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.semigroupProduct = {
-    concat: function (x, y) { return x * y; }
-};
-});
-
-const Semigroup$1 = /*@__PURE__*/getDefaultExportFromCjs(Semigroup);
-
-var Separated = createCommonjsModule(function (module, exports) {
-"use strict";
-/**
- * ```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;
-});
-
-const Separated$1 = /*@__PURE__*/getDefaultExportFromCjs(Separated);
-
-var Witherable = createCommonjsModule(function (module, exports) {
-"use strict";
-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.filterE = exports.witherDefault = exports.wiltDefault = void 0;
-var _ = __importStar(internal);
-function wiltDefault(T, C) {
-    return function (F) {
-        var traverseF = T.traverse(F);
-        return function (wa, f) { return F.map(traverseF(wa, f), C.separate); };
-    };
-}
-exports.wiltDefault = wiltDefault;
-function witherDefault(T, C) {
-    return function (F) {
-        var traverseF = T.traverse(F);
-        return function (wa, f) { return F.map(traverseF(wa, f), C.compact); };
-    };
-}
-exports.witherDefault = witherDefault;
-function filterE(W) {
-    return function (F) {
-        var witherF = W.wither(F);
-        return function (predicate) { return function (ga) { return witherF(ga, function (a) { return F.map(predicate(a), function (b) { return (b ? _.some(a) : _.none); }); }); }; };
-    };
-}
-exports.filterE = filterE;
-});
-
-const Witherable$1 = /*@__PURE__*/getDefaultExportFromCjs(Witherable);
-
-var Zero = createCommonjsModule(function (module, exports) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.guard = void 0;
-function guard(F, P) {
-    return function (b) { return (b ? P.of(undefined) : F.zero()); };
-}
-exports.guard = guard;
-});
-
-const Zero$1 = /*@__PURE__*/getDefaultExportFromCjs(Zero);
-
-var ReadonlyNonEmptyArray = createCommonjsModule(function (module, exports) {
-"use strict";
-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;
-};
-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.reduceRight = exports.foldMap = exports.reduce = exports.mapWithIndex = exports.map = exports.flatten = exports.duplicate = exports.extend = exports.chain = exports.ap = exports.alt = exports.altW = exports.of = exports.chunksOf = exports.splitAt = exports.chop = exports.chainWithIndex = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.modifyAt = exports.updateAt = exports.sort = exports.groupBy = exports.group = exports.reverse = exports.concat = exports.concatW = exports.fromArray = exports.unappend = exports.unprepend = exports.range = exports.replicate = exports.makeBy = exports.fromReadonlyArray = exports.rotate = exports.union = exports.sortBy = exports.uniq = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.append = exports.appendW = exports.prepend = exports.prependW = exports.isOutOfBound = exports.isNonEmpty = exports.empty = void 0;
-exports.uncons = exports.filterWithIndex = exports.filter = exports.groupSort = exports.updateLast = exports.modifyLast = exports.updateHead = exports.modifyHead = exports.matchRight = exports.matchLeft = exports.concatAll = exports.max = exports.min = exports.init = exports.last = exports.tail = exports.head = exports.apS = exports.bind = exports.bindTo = exports.Do = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getUnionSemigroup = exports.getEq = exports.getSemigroup = exports.getShow = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.foldMapWithIndex = exports.reduceWithIndex = void 0;
-exports.readonlyNonEmptyArray = exports.fold = exports.prependToAll = exports.insertAt = exports.snoc = exports.cons = exports.unsnoc = void 0;
-
-
-
-
-
-var _ = __importStar(internal);
-
-var Se = __importStar(Semigroup);
-// -------------------------------------------------------------------------------------
-// internal
-// -------------------------------------------------------------------------------------
-/**
- * @internal
- */
-exports.empty = _.emptyReadonlyArray;
-/**
- * @internal
- */
-exports.isNonEmpty = _.isNonEmpty;
-/**
- * @internal
- */
-var isOutOfBound = function (i, as) { return i < 0 || i >= as.length; };
-exports.isOutOfBound = isOutOfBound;
-/**
- * @internal
- */
-var prependW = function (head) { return function (tail) { return __spreadArray([head], tail); }; };
-exports.prependW = prependW;
-/**
- * @internal
- */
-exports.prepend = exports.prependW;
-/**
- * @internal
- */
-var appendW = function (end) { return function (init) { return __spreadArray(__spreadArray([], init), [end]); }; };
-exports.appendW = appendW;
-/**
- * @internal
- */
-exports.append = exports.appendW;
-/**
- * @internal
- */
-var unsafeInsertAt = function (i, a, as) {
-    if (exports.isNonEmpty(as)) {
-        var xs = _.fromReadonlyNonEmptyArray(as);
-        xs.splice(i, 0, a);
-        return xs;
-    }
-    return [a];
-};
-exports.unsafeInsertAt = unsafeInsertAt;
-/**
- * @internal
- */
-var unsafeUpdateAt = function (i, a, as) {
-    if (as[i] === a) {
-        return as;
-    }
-    else {
-        var xs = _.fromReadonlyNonEmptyArray(as);
-        xs[i] = a;
-        return xs;
-    }
-};
-exports.unsafeUpdateAt = unsafeUpdateAt;
-/**
- * Remove duplicates from a `ReadonlyNonEmptyArray`, keeping the first occurrence of an element.
- *
- * @example
- * import { uniq } from 'fp-ts/ReadonlyNonEmptyArray'
- * import * as N from 'fp-ts/number'
- *
- * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])
- *
- * @category combinators
- * @since 2.11.0
- */
-var uniq = function (E) { return function (as) {
-    if (as.length === 1) {
-        return as;
-    }
-    var out = [exports.head(as)];
-    var rest = exports.tail(as);
-    var _loop_1 = function (a) {
-        if (out.every(function (o) { return !E.equals(o, a); })) {
-            out.push(a);
-        }
-    };
-    for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {
-        var a = rest_1[_i];
-        _loop_1(a);
-    }
-    return out;
-}; };
-exports.uniq = uniq;
-/**
- * Sort the elements of a `ReadonlyNonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,
- * etc...
- *
- * @example
- * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'
- * import { contramap } from 'fp-ts/Ord'
- * import * as S from 'fp-ts/string'
- * import * as N from 'fp-ts/number'
- * import { pipe } from 'fp-ts/function'
- *
- * interface Person {
- *   name: string
- *   age: number
- * }
- *
- * const byName = pipe(S.Ord, contramap((p: Person) => p.name))
- *
- * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))
- *
- * const sortByNameByAge = RNEA.sortBy([byName, byAge])
- *
- * const persons: RNEA.ReadonlyNonEmptyArray<Person> = [
- *   { name: 'a', age: 1 },
- *   { name: 'b', age: 3 },
- *   { name: 'c', age: 2 },
- *   { name: 'b', age: 2 }
- * ]
- *
- * assert.deepStrictEqual(sortByNameByAge(persons), [
- *   { name: 'a', age: 1 },
- *   { name: 'b', age: 2 },
- *   { name: 'b', age: 3 },
- *   { name: 'c', age: 2 }
- * ])
- *
- * @category combinators
- * @since 2.11.0
- */
-var sortBy = function (ords) {
-    if (exports.isNonEmpty(ords)) {
-        var M = Ord.getMonoid();
-        return exports.sort(ords.reduce(M.concat, M.empty));
-    }
-    return _function.identity;
-};
-exports.sortBy = sortBy;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var union = function (E) {
-    var uniqE = exports.uniq(E);
-    return function (second) { return function (first) { return uniqE(_function.pipe(first, concat(second))); }; };
-};
-exports.union = union;
-/**
- * Rotate a `ReadonlyNonEmptyArray` by `n` steps.
- *
- * @example
- * import { rotate } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
- * assert.deepStrictEqual(rotate(-2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
- *
- * @category combinators
- * @since 2.11.0
- */
-var rotate = function (n) { return function (as) {
-    var len = as.length;
-    var m = Math.round(n) % len;
-    if (exports.isOutOfBound(Math.abs(m), as) || m === 0) {
-        return as;
-    }
-    if (m < 0) {
-        var _a = exports.splitAt(-m)(as), f = _a[0], s = _a[1];
-        return _function.pipe(s, concat(f));
-    }
-    else {
-        return exports.rotate(m - len)(as);
-    }
-}; };
-exports.rotate = rotate;
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * Return a `ReadonlyNonEmptyArray` from a `ReadonlyArray` returning `none` if the input is empty.
- *
- * @category constructors
- * @since 2.5.0
- */
-var fromReadonlyArray = function (as) {
-    return exports.isNonEmpty(as) ? _.some(as) : _.none;
-};
-exports.fromReadonlyArray = fromReadonlyArray;
-/**
- * Return a `ReadonlyNonEmptyArray` of length `n` with element `i` initialized with `f(i)`.
- *
- * **Note**. `n` is normalized to a natural number.
- *
- * @example
- * import { makeBy } from 'fp-ts/ReadonlyNonEmptyArray'
- * import { pipe } from 'fp-ts/function'
- *
- * const double = (n: number): number => n * 2
- * assert.deepStrictEqual(pipe(5, makeBy(double)), [0, 2, 4, 6, 8])
- *
- * @category constructors
- * @since 2.11.0
- */
-var makeBy = function (f) { return function (n) {
-    var j = Math.max(0, Math.floor(n));
-    var out = [f(0)];
-    for (var i = 1; i < j; i++) {
-        out.push(f(i));
-    }
-    return out;
-}; };
-exports.makeBy = makeBy;
-/**
- * Create a `ReadonlyNonEmptyArray` containing a value repeated the specified number of times.
- *
- * **Note**. `n` is normalized to a natural number.
- *
- * @example
- * import { replicate } from 'fp-ts/ReadonlyNonEmptyArray'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.deepStrictEqual(pipe(3, replicate('a')), ['a', 'a', 'a'])
- *
- * @category constructors
- * @since 2.11.0
- */
-var replicate = function (a) { return exports.makeBy(function () { return a; }); };
-exports.replicate = replicate;
-/**
- * Create a `ReadonlyNonEmptyArray` containing a range of integers, including both endpoints.
- *
- * @example
- * import { range } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])
- *
- * @category constructors
- * @since 2.11.0
- */
-var range = function (start, end) {
-    return start <= end ? exports.makeBy(function (i) { return start + i; })(end - start + 1) : [start];
-};
-exports.range = range;
-// -------------------------------------------------------------------------------------
-// destructors
-// -------------------------------------------------------------------------------------
-/**
- * Return the tuple of the `head` and the `tail`.
- *
- * @example
- * import { unprepend } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])
- *
- * @category destructors
- * @since 2.9.0
- */
-var unprepend = function (as) { return [exports.head(as), exports.tail(as)]; };
-exports.unprepend = unprepend;
-/**
- * Return the tuple of the `init` and the `last`.
- *
- * @example
- * import { unappend } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(unappend([1, 2, 3, 4]), [[1, 2, 3], 4])
- *
- * @category destructors
- * @since 2.9.0
- */
-var unappend = function (as) { return [exports.init(as), exports.last(as)]; };
-exports.unappend = unappend;
-// -------------------------------------------------------------------------------------
-// interop
-// -------------------------------------------------------------------------------------
-/**
- * @category interop
- * @since 2.5.0
- */
-var fromArray = function (as) { return exports.fromReadonlyArray(as.slice()); };
-exports.fromArray = fromArray;
-function concatW(second) {
-    return function (first) { return first.concat(second); };
-}
-exports.concatW = concatW;
-function concat(x, y) {
-    return y ? x.concat(y) : function (y) { return y.concat(x); };
-}
-exports.concat = concat;
-/**
- * @category combinators
- * @since 2.5.0
- */
-var reverse = function (as) {
-    return as.length === 1 ? as : __spreadArray([exports.last(as)], as.slice(0, -1).reverse());
-};
-exports.reverse = reverse;
-function group(E) {
-    return function (as) {
-        var len = as.length;
-        if (len === 0) {
-            return exports.empty;
-        }
-        var out = [];
-        var head = as[0];
-        var nea = [head];
-        for (var i = 1; i < len; i++) {
-            var a = as[i];
-            if (E.equals(a, head)) {
-                nea.push(a);
-            }
-            else {
-                out.push(nea);
-                head = a;
-                nea = [head];
-            }
-        }
-        out.push(nea);
-        return out;
-    };
-}
-exports.group = group;
-/**
- * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
- * function on each element, and grouping the results according to values returned
- *
- * @example
- * import { groupBy } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['a', 'b', 'ab']), {
- *   '1': ['a', 'b'],
- *   '2': ['ab']
- * })
- *
- * @category combinators
- * @since 2.5.0
- */
-var groupBy = function (f) { return function (as) {
-    var out = {};
-    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {
-        var a = as_1[_i];
-        var k = f(a);
-        if (out.hasOwnProperty(k)) {
-            out[k].push(a);
-        }
-        else {
-            out[k] = [a];
-        }
-    }
-    return out;
-}; };
-exports.groupBy = groupBy;
-/**
- * @category combinators
- * @since 2.5.0
- */
-var sort = function (O) { return function (as) {
-    return as.length === 1 ? as : as.slice().sort(O.compare);
-}; };
-exports.sort = sort;
-/**
- * @category combinators
- * @since 2.5.0
- */
-var updateAt = function (i, a) {
-    return exports.modifyAt(i, function () { return a; });
-};
-exports.updateAt = updateAt;
-/**
- * @category combinators
- * @since 2.5.0
- */
-var modifyAt = function (i, f) { return function (as) { return (exports.isOutOfBound(i, as) ? _.none : _.some(exports.unsafeUpdateAt(i, f(as[i]), as))); }; };
-exports.modifyAt = modifyAt;
-/**
- * @category combinators
- * @since 2.5.1
- */
-var zipWith = function (as, bs, f) {
-    var cs = [f(as[0], bs[0])];
-    var len = Math.min(as.length, bs.length);
-    for (var i = 1; i < len; i++) {
-        cs[i] = f(as[i], bs[i]);
-    }
-    return cs;
-};
-exports.zipWith = zipWith;
-function zip(as, bs) {
-    if (bs === undefined) {
-        return function (bs) { return zip(bs, as); };
-    }
-    return exports.zipWith(as, bs, function (a, b) { return [a, b]; });
-}
-exports.zip = zip;
-/**
- * @category combinators
- * @since 2.5.1
- */
-var unzip = function (abs) {
-    var fa = [abs[0][0]];
-    var fb = [abs[0][1]];
-    for (var i = 1; i < abs.length; i++) {
-        fa[i] = abs[i][0];
-        fb[i] = abs[i][1];
-    }
-    return [fa, fb];
-};
-exports.unzip = unzip;
-/**
- * Prepend an element to every member of a `ReadonlyNonEmptyArray`.
- *
- * @example
- * import { prependAll } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
- *
- * @category combinators
- * @since 2.10.0
- */
-var prependAll = function (middle) { return function (as) {
-    var out = [middle, as[0]];
-    for (var i = 1; i < as.length; i++) {
-        out.push(middle, as[i]);
-    }
-    return out;
-}; };
-exports.prependAll = prependAll;
-/**
- * Places an element in between members of a `ReadonlyNonEmptyArray`.
- *
- * @example
- * import { intersperse } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
- *
- * @category combinators
- * @since 2.9.0
- */
-var intersperse = function (middle) { return function (as) {
-    var rest = exports.tail(as);
-    return exports.isNonEmpty(rest) ? _function.pipe(rest, exports.prependAll(middle), exports.prepend(exports.head(as))) : as;
-}; };
-exports.intersperse = intersperse;
-/**
- * @category combinators
- * @since 2.10.0
- */
-var chainWithIndex = function (f) { return function (as) {
-    var out = _.fromReadonlyNonEmptyArray(f(0, exports.head(as)));
-    for (var i = 1; i < as.length; i++) {
-        out.push.apply(out, f(i, as[i]));
-    }
-    return out;
-}; };
-exports.chainWithIndex = chainWithIndex;
-/**
- * A useful recursion pattern for processing a `ReadonlyNonEmptyArray` to produce a new `ReadonlyNonEmptyArray`, often used for "chopping" up the input
- * `ReadonlyNonEmptyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `ReadonlyNonEmptyArray` and produce a
- * value and the tail of the `ReadonlyNonEmptyArray`.
- *
- * @category combinators
- * @since 2.10.0
- */
-var chop = function (f) { return function (as) {
-    var _a = f(as), b = _a[0], rest = _a[1];
-    var out = [b];
-    var next = rest;
-    while (exports.isNonEmpty(next)) {
-        var _b = f(next), b_1 = _b[0], rest_2 = _b[1];
-        out.push(b_1);
-        next = rest_2;
-    }
-    return out;
-}; };
-exports.chop = chop;
-/**
- * Splits a `ReadonlyNonEmptyArray` into two pieces, the first piece has max `n` elements.
- *
- * @category combinators
- * @since 2.10.0
- */
-var splitAt = function (n) { return function (as) {
-    var m = Math.max(1, n);
-    return m >= as.length ? [as, exports.empty] : [_function.pipe(as.slice(1, m), exports.prepend(exports.head(as))), as.slice(m)];
-}; };
-exports.splitAt = splitAt;
-/**
- * Splits a `ReadonlyNonEmptyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
- * the `ReadonlyNonEmptyArray`.
- *
- * @category combinators
- * @since 2.10.0
- */
-var chunksOf = function (n) { return exports.chop(exports.splitAt(n)); };
-exports.chunksOf = chunksOf;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-var _map = function (fa, f) { return _function.pipe(fa, exports.map(f)); };
-/* istanbul ignore next */
-var _mapWithIndex = function (fa, f) { return _function.pipe(fa, exports.mapWithIndex(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)); };
-/* istanbul ignore next */
-var _extend = function (wa, f) { return _function.pipe(wa, exports.extend(f)); };
-/* istanbul ignore next */
-var _reduce = function (fa, b, f) { return _function.pipe(fa, exports.reduce(b, f)); };
-/* istanbul ignore next */
-var _foldMap = function (M) {
-    var foldMapM = exports.foldMap(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapM(f)); };
-};
-/* istanbul ignore next */
-var _reduceRight = function (fa, b, f) { return _function.pipe(fa, exports.reduceRight(b, f)); };
-/* istanbul ignore next */
-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)); };
-/* istanbul ignore next */
-var _reduceWithIndex = function (fa, b, f) {
-    return _function.pipe(fa, exports.reduceWithIndex(b, f));
-};
-/* istanbul ignore next */
-var _foldMapWithIndex = function (M) {
-    var foldMapWithIndexM = exports.foldMapWithIndex(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapWithIndexM(f)); };
-};
-/* istanbul ignore next */
-var _reduceRightWithIndex = function (fa, b, f) {
-    return _function.pipe(fa, exports.reduceRightWithIndex(b, f));
-};
-/* istanbul ignore next */
-var _traverseWithIndex = function (F) {
-    var traverseWithIndexF = exports.traverseWithIndex(F);
-    return function (ta, f) { return _function.pipe(ta, traverseWithIndexF(f)); };
-};
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * @category Pointed
- * @since 2.5.0
- */
-exports.of = _.singleton;
-/**
- * Less strict version of [`alt`](#alt).
- *
- * @category Alt
- * @since 2.9.0
- */
-var altW = function (that) { return function (as) { return _function.pipe(as, concatW(that())); }; };
-exports.altW = altW;
-/**
- * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to
- * types of kind `* -> *`.
- *
- * @category Alt
- * @since 2.6.2
- */
-exports.alt = exports.altW;
-/**
- * @category Apply
- * @since 2.5.0
- */
-var ap = function (as) { return exports.chain(function (f) { return _function.pipe(as, exports.map(f)); }); };
-exports.ap = ap;
-/**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
- *
- * @category Monad
- * @since 2.5.0
- */
-var chain = function (f) { return exports.chainWithIndex(function (_, a) { return f(a); }); };
-exports.chain = chain;
-/**
- * @category Extend
- * @since 2.5.0
- */
-var extend = function (f) { return function (as) {
-    var next = exports.tail(as);
-    var out = [f(as)];
-    while (exports.isNonEmpty(next)) {
-        out.push(f(next));
-        next = exports.tail(next);
-    }
-    return out;
-}; };
-exports.extend = extend;
-/**
- * Derivable from `Extend`.
- *
- * @category combinators
- * @since 2.5.0
- */
-exports.duplicate = 
-/*#__PURE__*/
-exports.extend(_function.identity);
-/**
- * Derivable from `Chain`.
- *
- * @category combinators
- * @since 2.5.0
- */
-exports.flatten = 
-/*#__PURE__*/
-exports.chain(_function.identity);
-/**
- * `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.5.0
- */
-var map = function (f) {
-    return exports.mapWithIndex(function (_, a) { return f(a); });
-};
-exports.map = map;
-/**
- * @category FunctorWithIndex
- * @since 2.5.0
- */
-var mapWithIndex = function (f) { return function (as) {
-    var out = [f(0, exports.head(as))];
-    for (var i = 1; i < as.length; i++) {
-        out.push(f(i, as[i]));
-    }
-    return out;
-}; };
-exports.mapWithIndex = mapWithIndex;
-/**
- * @category Foldable
- * @since 2.5.0
- */
-var reduce = function (b, f) {
-    return exports.reduceWithIndex(b, function (_, b, a) { return f(b, a); });
-};
-exports.reduce = reduce;
-/**
- * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.
- *
- * @category Foldable
- * @since 2.5.0
- */
-var foldMap = function (S) { return function (f) { return function (as) {
-    return as.slice(1).reduce(function (s, a) { return S.concat(s, f(a)); }, f(as[0]));
-}; }; };
-exports.foldMap = foldMap;
-/**
- * @category Foldable
- * @since 2.5.0
- */
-var reduceRight = function (b, f) {
-    return exports.reduceRightWithIndex(b, function (_, b, a) { return f(b, a); });
-};
-exports.reduceRight = reduceRight;
-/**
- * @category FoldableWithIndex
- * @since 2.5.0
- */
-var reduceWithIndex = function (b, f) { return function (as) {
-    return as.reduce(function (b, a, i) { return f(i, b, a); }, b);
-}; };
-exports.reduceWithIndex = reduceWithIndex;
-/**
- * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.
- *
- * @category FoldableWithIndex
- * @since 2.5.0
- */
-var foldMapWithIndex = function (S) { return function (f) { return function (as) { return as.slice(1).reduce(function (s, a, i) { return S.concat(s, f(i + 1, a)); }, f(0, as[0])); }; }; };
-exports.foldMapWithIndex = foldMapWithIndex;
-/**
- * @category FoldableWithIndex
- * @since 2.5.0
- */
-var reduceRightWithIndex = function (b, f) { return function (as) { return as.reduceRight(function (b, a, i) { return f(i, a, b); }, b); }; };
-exports.reduceRightWithIndex = reduceRightWithIndex;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var traverse = function (F) {
-    var traverseWithIndexF = exports.traverseWithIndex(F);
-    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };
-};
-exports.traverse = traverse;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var sequence = function (F) { return exports.traverseWithIndex(F)(_function.SK); };
-exports.sequence = sequence;
-/**
- * @category TraversableWithIndex
- * @since 2.6.3
- */
-var traverseWithIndex = function (F) { return function (f) { return function (as) {
-    var out = F.map(f(0, exports.head(as)), exports.of);
-    for (var i = 1; i < as.length; i++) {
-        out = F.ap(F.map(out, function (bs) { return function (b) { return _function.pipe(bs, exports.append(b)); }; }), f(i, as[i]));
-    }
-    return out;
-}; }; };
-exports.traverseWithIndex = traverseWithIndex;
-/**
- * @category Comonad
- * @since 2.6.3
- */
-exports.extract = _.head;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.5.0
- */
-exports.URI = 'ReadonlyNonEmptyArray';
-/**
- * @category instances
- * @since 2.5.0
- */
-var getShow = function (S) { return ({
-    show: function (as) { return "[" + as.map(S.show).join(', ') + "]"; }
-}); };
-exports.getShow = getShow;
-/**
- * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`
- *
- * @category instances
- * @since 2.5.0
- */
-var getSemigroup = function () { return ({
-    concat: concat
-}); };
-exports.getSemigroup = getSemigroup;
-/**
- * @example
- * import { getEq } from 'fp-ts/ReadonlyNonEmptyArray'
- * import * as N from 'fp-ts/number'
- *
- * const E = getEq(N.Eq)
- * assert.strictEqual(E.equals([1, 2], [1, 2]), true)
- * assert.strictEqual(E.equals([1, 2], [1, 3]), false)
- *
- * @category instances
- * @since 2.5.0
- */
-var getEq = function (E) {
-    return Eq.fromEquals(function (xs, ys) { return xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); }); });
-};
-exports.getEq = getEq;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var getUnionSemigroup = function (E) {
-    var unionE = exports.union(E);
-    return {
-        concat: function (first, second) { return unionE(second)(first); }
-    };
-};
-exports.getUnionSemigroup = getUnionSemigroup;
-/**
- * @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.7.0
- */
-exports.FunctorWithIndex = {
-    URI: exports.URI,
-    map: _map,
-    mapWithIndex: _mapWithIndex
-};
-/**
- * @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.5.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.5.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
-};
-/**
- * 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.5.0
- */
-exports.chainFirst = 
-/*#__PURE__*/
-Chain.chainFirst(exports.Chain);
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Monad = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of,
-    chain: _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.FoldableWithIndex = {
-    URI: exports.URI,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex
-};
-/**
- * @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.TraversableWithIndex = {
-    URI: exports.URI,
-    map: _map,
-    mapWithIndex: _mapWithIndex,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex,
-    traverseWithIndex: _traverseWithIndex
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alt = {
-    URI: exports.URI,
-    map: _map,
-    alt: _alt
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Comonad = {
-    URI: exports.URI,
-    map: _map,
-    extend: _extend,
-    extract: exports.extract
-};
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.9.0
- */
-exports.Do = 
-/*#__PURE__*/
-exports.of(_.emptyRecord);
-/**
- * @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);
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.5.0
- */
-exports.head = exports.extract;
-/**
- * @since 2.5.0
- */
-exports.tail = _.tail;
-/**
- * @since 2.5.0
- */
-var last = function (as) { return as[as.length - 1]; };
-exports.last = last;
-/**
- * Get all but the last element of a non empty array, creating a new array.
- *
- * @example
- * import { init } from 'fp-ts/ReadonlyNonEmptyArray'
- *
- * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])
- * assert.deepStrictEqual(init([1]), [])
- *
- * @since 2.5.0
- */
-var init = function (as) { return as.slice(0, -1); };
-exports.init = init;
-/**
- * @since 2.5.0
- */
-var min = function (O) {
-    var S = Se.min(O);
-    return function (as) { return as.reduce(S.concat); };
-};
-exports.min = min;
-/**
- * @since 2.5.0
- */
-var max = function (O) {
-    var S = Se.max(O);
-    return function (as) { return as.reduce(S.concat); };
-};
-exports.max = max;
-/**
- * @since 2.10.0
- */
-var concatAll = function (S) { return function (as) { return as.reduce(S.concat); }; };
-exports.concatAll = concatAll;
-/**
- * Break a `ReadonlyArray` into its first element and remaining elements.
- *
- * @category destructors
- * @since 2.11.0
- */
-var matchLeft = function (f) { return function (as) {
-    return f(exports.head(as), exports.tail(as));
-}; };
-exports.matchLeft = matchLeft;
-/**
- * Break a `ReadonlyArray` into its initial elements and the last element.
- *
- * @category destructors
- * @since 2.11.0
- */
-var matchRight = function (f) { return function (as) {
-    return f(exports.init(as), exports.last(as));
-}; };
-exports.matchRight = matchRight;
-/**
- * Apply a function to the head, creating a new `ReadonlyNonEmptyArray`.
- *
- * @since 2.11.0
- */
-var modifyHead = function (f) { return function (as) { return __spreadArray([
-    f(exports.head(as))
-], exports.tail(as)); }; };
-exports.modifyHead = modifyHead;
-/**
- * Change the head, creating a new `ReadonlyNonEmptyArray`.
- *
- * @category combinators
- * @since 2.11.0
- */
-var updateHead = function (a) { return exports.modifyHead(function () { return a; }); };
-exports.updateHead = updateHead;
-/**
- * Apply a function to the last element, creating a new `ReadonlyNonEmptyArray`.
- *
- * @since 2.11.0
- */
-var modifyLast = function (f) { return function (as) {
-    return _function.pipe(exports.init(as), exports.append(f(exports.last(as))));
-}; };
-exports.modifyLast = modifyLast;
-/**
- * Change the last element, creating a new `ReadonlyNonEmptyArray`.
- *
- * @category combinators
- * @since 2.11.0
- */
-var updateLast = function (a) { return exports.modifyLast(function () { return a; }); };
-exports.updateLast = updateLast;
-function groupSort(O) {
-    var sortO = exports.sort(O);
-    var groupO = group(O);
-    return function (as) { return (exports.isNonEmpty(as) ? groupO(sortO(as)) : exports.empty); };
-}
-exports.groupSort = groupSort;
-function filter(predicate) {
-    return exports.filterWithIndex(function (_, a) { return predicate(a); });
-}
-exports.filter = filter;
-/**
- * Use [`filterWithIndex`](./ReadonlyArray.ts.html#filterwithindex) instead.
- *
- * @category combinators
- * @since 2.5.0
- * @deprecated
- */
-var filterWithIndex = function (predicate) { return function (as) { return exports.fromReadonlyArray(as.filter(function (a, i) { return predicate(i, a); })); }; };
-exports.filterWithIndex = filterWithIndex;
-/**
- * Use [`unprepend`](#unprepend) instead.
- *
- * @category destructors
- * @since 2.10.0
- * @deprecated
- */
-exports.uncons = exports.unprepend;
-/**
- * Use [`unappend`](#unappend) instead.
- *
- * @category destructors
- * @since 2.10.0
- * @deprecated
- */
-exports.unsnoc = exports.unappend;
-function cons(head, tail) {
-    return tail === undefined ? exports.prepend(head) : _function.pipe(tail, exports.prepend(head));
-}
-exports.cons = cons;
-/**
- * Use [`append`](./ReadonlyArray.ts.html#append) instead.
- *
- * @category constructors
- * @since 2.5.0
- * @deprecated
- */
-var snoc = function (init, end) { return _function.pipe(init, concat([end])); };
-exports.snoc = snoc;
-/**
- * Use [`insertAt`](./ReadonlyArray.ts.html#insertat) instead.
- *
- * @category combinators
- * @since 2.5.0
- * @deprecated
- */
-var insertAt = function (i, a) { return function (as) {
-    return i < 0 || i > as.length ? _.none : _.some(exports.unsafeInsertAt(i, a, as));
-}; };
-exports.insertAt = insertAt;
-/**
- * Use [`prependAll`](#prependall) instead.
- *
- * @category combinators
- * @since 2.9.0
- * @deprecated
- */
-exports.prependToAll = exports.prependAll;
-/**
- * Use [`concatAll`](#concatall) instead.
- *
- * @since 2.5.0
- * @deprecated
- */
-exports.fold = exports.concatAll;
-/**
- * Use small, specific instances instead.
- *
- * @category instances
- * @since 2.5.0
- * @deprecated
- */
-exports.readonlyNonEmptyArray = {
-    URI: exports.URI,
-    of: exports.of,
-    map: _map,
-    mapWithIndex: _mapWithIndex,
-    ap: _ap,
-    chain: _chain,
-    extend: _extend,
-    extract: exports.extract,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex,
-    traverseWithIndex: _traverseWithIndex,
-    alt: _alt
-};
-});
-
-const ReadonlyNonEmptyArray$1 = /*@__PURE__*/getDefaultExportFromCjs(ReadonlyNonEmptyArray);
-
-var NonEmptyArray = createCommonjsModule(function (module, exports) {
-"use strict";
-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;
-};
-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.mapWithIndex = exports.map = exports.flatten = exports.duplicate = exports.extend = exports.chain = exports.ap = exports.alt = exports.altW = exports.chunksOf = exports.splitAt = exports.chop = exports.chainWithIndex = exports.foldMap = exports.foldMapWithIndex = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.of = exports.copy = exports.modifyAt = exports.updateAt = exports.insertAt = exports.sort = exports.groupBy = exports.group = exports.reverse = exports.concat = exports.concatW = exports.unappend = exports.unprepend = exports.range = exports.replicate = exports.makeBy = exports.fromArray = exports.fromReadonlyNonEmptyArray = exports.rotate = exports.union = exports.sortBy = exports.uniq = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.append = exports.appendW = exports.prepend = exports.prependW = exports.isOutOfBound = exports.isNonEmpty = void 0;
-exports.filterWithIndex = exports.filter = exports.groupSort = exports.updateLast = exports.modifyLast = exports.updateHead = exports.modifyHead = exports.matchRight = exports.matchLeft = exports.concatAll = exports.max = exports.min = exports.init = exports.last = exports.tail = exports.head = exports.apS = exports.bind = exports.bindTo = exports.Do = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getUnionSemigroup = exports.getEq = exports.getSemigroup = exports.getShow = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.reduce = void 0;
-exports.nonEmptyArray = exports.fold = exports.prependToAll = exports.snoc = exports.cons = exports.unsnoc = exports.uncons = void 0;
-
-
-
-
-var _ = __importStar(internal);
-
-var RNEA = __importStar(ReadonlyNonEmptyArray);
-// -------------------------------------------------------------------------------------
-// internal
-// -------------------------------------------------------------------------------------
-/**
- * @internal
- */
-var isNonEmpty = function (as) { return as.length > 0; };
-exports.isNonEmpty = isNonEmpty;
-/**
- * @internal
- */
-var isOutOfBound = function (i, as) { return i < 0 || i >= as.length; };
-exports.isOutOfBound = isOutOfBound;
-/**
- * @internal
- */
-var prependW = function (head) { return function (tail) { return __spreadArray([head], tail); }; };
-exports.prependW = prependW;
-/**
- * @internal
- */
-exports.prepend = exports.prependW;
-/**
- * @internal
- */
-var appendW = function (end) { return function (init) { return __spreadArray(__spreadArray([], init), [end]); }; };
-exports.appendW = appendW;
-/**
- * @internal
- */
-exports.append = exports.appendW;
-/**
- * @internal
- */
-var unsafeInsertAt = function (i, a, as) {
-    if (exports.isNonEmpty(as)) {
-        var xs = exports.fromReadonlyNonEmptyArray(as);
-        xs.splice(i, 0, a);
-        return xs;
-    }
-    return [a];
-};
-exports.unsafeInsertAt = unsafeInsertAt;
-/**
- * @internal
- */
-var unsafeUpdateAt = function (i, a, as) {
-    var xs = exports.fromReadonlyNonEmptyArray(as);
-    xs[i] = a;
-    return xs;
-};
-exports.unsafeUpdateAt = unsafeUpdateAt;
-/**
- * Remove duplicates from a `NonEmptyArray`, keeping the first occurrence of an element.
- *
- * @example
- * import { uniq } from 'fp-ts/NonEmptyArray'
- * import * as N from 'fp-ts/number'
- *
- * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])
- *
- * @category combinators
- * @since 2.11.0
- */
-var uniq = function (E) { return function (as) {
-    if (as.length === 1) {
-        return exports.copy(as);
-    }
-    var out = [exports.head(as)];
-    var rest = exports.tail(as);
-    var _loop_1 = function (a) {
-        if (out.every(function (o) { return !E.equals(o, a); })) {
-            out.push(a);
-        }
-    };
-    for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {
-        var a = rest_1[_i];
-        _loop_1(a);
-    }
-    return out;
-}; };
-exports.uniq = uniq;
-/**
- * Sort the elements of a `NonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,
- * etc...
- *
- * @example
- * import * as NEA from 'fp-ts/NonEmptyArray'
- * import { contramap } from 'fp-ts/Ord'
- * import * as S from 'fp-ts/string'
- * import * as N from 'fp-ts/number'
- * import { pipe } from 'fp-ts/function'
- *
- * interface Person {
- *   name: string
- *   age: number
- * }
- *
- * const byName = pipe(S.Ord, contramap((p: Person) => p.name))
- *
- * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))
- *
- * const sortByNameByAge = NEA.sortBy([byName, byAge])
- *
- * const persons: NEA.NonEmptyArray<Person> = [
- *   { name: 'a', age: 1 },
- *   { name: 'b', age: 3 },
- *   { name: 'c', age: 2 },
- *   { name: 'b', age: 2 }
- * ]
- *
- * assert.deepStrictEqual(sortByNameByAge(persons), [
- *   { name: 'a', age: 1 },
- *   { name: 'b', age: 2 },
- *   { name: 'b', age: 3 },
- *   { name: 'c', age: 2 }
- * ])
- *
- * @category combinators
- * @since 2.11.0
- */
-var sortBy = function (ords) {
-    if (exports.isNonEmpty(ords)) {
-        var M = Ord.getMonoid();
-        return exports.sort(ords.reduce(M.concat, M.empty));
-    }
-    return exports.copy;
-};
-exports.sortBy = sortBy;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var union = function (E) {
-    var uniqE = exports.uniq(E);
-    return function (second) { return function (first) { return uniqE(_function.pipe(first, concat(second))); }; };
-};
-exports.union = union;
-/**
- * Rotate a `NonEmptyArray` by `n` steps.
- *
- * @example
- * import { rotate } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
- * assert.deepStrictEqual(rotate(-2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
- *
- * @category combinators
- * @since 2.11.0
- */
-var rotate = function (n) { return function (as) {
-    var len = as.length;
-    var m = Math.round(n) % len;
-    if (exports.isOutOfBound(Math.abs(m), as) || m === 0) {
-        return exports.copy(as);
-    }
-    if (m < 0) {
-        var _a = exports.splitAt(-m)(as), f = _a[0], s = _a[1];
-        return _function.pipe(s, concat(f));
-    }
-    else {
-        return exports.rotate(m - len)(as);
-    }
-}; };
-exports.rotate = rotate;
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * @category constructors
- * @since 2.10.0
- */
-exports.fromReadonlyNonEmptyArray = _.fromReadonlyNonEmptyArray;
-/**
- * Builds a `NonEmptyArray` from an `Array` returning `none` if `as` is an empty array
- *
- * @category constructors
- * @since 2.0.0
- */
-var fromArray = function (as) { return (exports.isNonEmpty(as) ? _.some(as) : _.none); };
-exports.fromArray = fromArray;
-/**
- * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`.
- *
- * **Note**. `n` is normalized to a natural number.
- *
- * @example
- * import { makeBy } from 'fp-ts/NonEmptyArray'
- * import { pipe } from 'fp-ts/function'
- *
- * const double = (n: number): number => n * 2
- * assert.deepStrictEqual(pipe(5, makeBy(double)), [0, 2, 4, 6, 8])
- *
- * @category constructors
- * @since 2.11.0
- */
-var makeBy = function (f) { return function (n) {
-    var j = Math.max(0, Math.floor(n));
-    var out = [f(0)];
-    for (var i = 1; i < j; i++) {
-        out.push(f(i));
-    }
-    return out;
-}; };
-exports.makeBy = makeBy;
-/**
- * Create a `NonEmptyArray` containing a value repeated the specified number of times.
- *
- * **Note**. `n` is normalized to a natural number.
- *
- * @example
- * import { replicate } from 'fp-ts/NonEmptyArray'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.deepStrictEqual(pipe(3, replicate('a')), ['a', 'a', 'a'])
- *
- * @category constructors
- * @since 2.11.0
- */
-var replicate = function (a) { return exports.makeBy(function () { return a; }); };
-exports.replicate = replicate;
-/**
- * Create a `NonEmptyArray` containing a range of integers, including both endpoints.
- *
- * @example
- * import { range } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])
- *
- * @category constructors
- * @since 2.11.0
- */
-var range = function (start, end) {
-    return start <= end ? exports.makeBy(function (i) { return start + i; })(end - start + 1) : [start];
-};
-exports.range = range;
-// -------------------------------------------------------------------------------------
-// destructors
-// -------------------------------------------------------------------------------------
-/**
- * Return the tuple of the `head` and the `tail`.
- *
- * @example
- * import { unprepend } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(unprepend([1, 2, 3]), [1, [2, 3]])
- *
- * @category destructors
- * @since 2.9.0
- */
-var unprepend = function (as) { return [exports.head(as), exports.tail(as)]; };
-exports.unprepend = unprepend;
-/**
- * Return the tuple of the `init` and the `last`.
- *
- * @example
- * import { unappend } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(unappend([1, 2, 3, 4]), [[1, 2, 3], 4])
- *
- * @category destructors
- * @since 2.9.0
- */
-var unappend = function (as) { return [exports.init(as), exports.last(as)]; };
-exports.unappend = unappend;
-function concatW(second) {
-    return function (first) { return first.concat(second); };
-}
-exports.concatW = concatW;
-function concat(x, y) {
-    return y ? x.concat(y) : function (y) { return y.concat(x); };
-}
-exports.concat = concat;
-/**
- * @category combinators
- * @since 2.0.0
- */
-var reverse = function (as) { return __spreadArray([exports.last(as)], as.slice(0, -1).reverse()); };
-exports.reverse = reverse;
-function group(E) {
-    return function (as) {
-        var len = as.length;
-        if (len === 0) {
-            return [];
-        }
-        var out = [];
-        var head = as[0];
-        var nea = [head];
-        for (var i = 1; i < len; i++) {
-            var a = as[i];
-            if (E.equals(a, head)) {
-                nea.push(a);
-            }
-            else {
-                out.push(nea);
-                head = a;
-                nea = [head];
-            }
-        }
-        out.push(nea);
-        return out;
-    };
-}
-exports.group = group;
-/**
- * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
- * function on each element, and grouping the results according to values returned
- *
- * @example
- * import { groupBy } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['a', 'b', 'ab']), {
- *   '1': ['a', 'b'],
- *   '2': ['ab']
- * })
- *
- * @category combinators
- * @since 2.0.0
- */
-var groupBy = function (f) { return function (as) {
-    var out = {};
-    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {
-        var a = as_1[_i];
-        var k = f(a);
-        if (out.hasOwnProperty(k)) {
-            out[k].push(a);
-        }
-        else {
-            out[k] = [a];
-        }
-    }
-    return out;
-}; };
-exports.groupBy = groupBy;
-/**
- * @category combinators
- * @since 2.0.0
- */
-var sort = function (O) { return function (as) {
-    return as.slice().sort(O.compare);
-}; };
-exports.sort = sort;
-/**
- * @category combinators
- * @since 2.0.0
- */
-var insertAt = function (i, a) { return function (as) {
-    return i < 0 || i > as.length ? _.none : _.some(exports.unsafeInsertAt(i, a, as));
-}; };
-exports.insertAt = insertAt;
-/**
- * @category combinators
- * @since 2.0.0
- */
-var updateAt = function (i, a) {
-    return exports.modifyAt(i, function () { return a; });
-};
-exports.updateAt = updateAt;
-/**
- * @category combinators
- * @since 2.0.0
- */
-var modifyAt = function (i, f) { return function (as) {
-    return exports.isOutOfBound(i, as) ? _.none : _.some(exports.unsafeUpdateAt(i, f(as[i]), as));
-}; };
-exports.modifyAt = modifyAt;
-/**
- * @category combinators
- * @since 2.0.0
- */
-exports.copy = exports.fromReadonlyNonEmptyArray;
-/**
- * @category Pointed
- * @since 2.0.0
- */
-var of = function (a) { return [a]; };
-exports.of = of;
-/**
- * @category combinators
- * @since 2.5.1
- */
-var zipWith = function (as, bs, f) {
-    var cs = [f(as[0], bs[0])];
-    var len = Math.min(as.length, bs.length);
-    for (var i = 1; i < len; i++) {
-        cs[i] = f(as[i], bs[i]);
-    }
-    return cs;
-};
-exports.zipWith = zipWith;
-function zip(as, bs) {
-    if (bs === undefined) {
-        return function (bs) { return zip(bs, as); };
-    }
-    return exports.zipWith(as, bs, function (a, b) { return [a, b]; });
-}
-exports.zip = zip;
-/**
- * @category combinators
- * @since 2.5.1
- */
-var unzip = function (abs) {
-    var fa = [abs[0][0]];
-    var fb = [abs[0][1]];
-    for (var i = 1; i < abs.length; i++) {
-        fa[i] = abs[i][0];
-        fb[i] = abs[i][1];
-    }
-    return [fa, fb];
-};
-exports.unzip = unzip;
-/**
- * Prepend an element to every member of an array
- *
- * @example
- * import { prependAll } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
- *
- * @category combinators
- * @since 2.10.0
- */
-var prependAll = function (middle) { return function (as) {
-    var out = [middle, as[0]];
-    for (var i = 1; i < as.length; i++) {
-        out.push(middle, as[i]);
-    }
-    return out;
-}; };
-exports.prependAll = prependAll;
-/**
- * Places an element in between members of an array
- *
- * @example
- * import { intersperse } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
- *
- * @category combinators
- * @since 2.9.0
- */
-var intersperse = function (middle) { return function (as) {
-    var rest = exports.tail(as);
-    return exports.isNonEmpty(rest) ? _function.pipe(rest, exports.prependAll(middle), exports.prepend(exports.head(as))) : exports.copy(as);
-}; };
-exports.intersperse = intersperse;
-/**
- * @category combinators
- * @since 2.0.0
- */
-exports.foldMapWithIndex = RNEA.foldMapWithIndex;
-/**
- * @category combinators
- * @since 2.0.0
- */
-exports.foldMap = RNEA.foldMap;
-/**
- * @category combinators
- * @since 2.10.0
- */
-var chainWithIndex = function (f) { return function (as) {
-    var out = exports.fromReadonlyNonEmptyArray(f(0, exports.head(as)));
-    for (var i = 1; i < as.length; i++) {
-        out.push.apply(out, f(i, as[i]));
-    }
-    return out;
-}; };
-exports.chainWithIndex = chainWithIndex;
-/**
- * @category combinators
- * @since 2.10.0
- */
-var chop = function (f) { return function (as) {
-    var _a = f(as), b = _a[0], rest = _a[1];
-    var out = [b];
-    var next = rest;
-    while (exports.isNonEmpty(next)) {
-        var _b = f(next), b_1 = _b[0], rest_2 = _b[1];
-        out.push(b_1);
-        next = rest_2;
-    }
-    return out;
-}; };
-exports.chop = chop;
-/**
- * Splits a `NonEmptyArray` into two pieces, the first piece has max `n` elements.
- *
- * @category combinators
- * @since 2.10.0
- */
-var splitAt = function (n) { return function (as) {
-    var m = Math.max(1, n);
-    return m >= as.length ? [exports.copy(as), []] : [_function.pipe(as.slice(1, m), exports.prepend(exports.head(as))), as.slice(m)];
-}; };
-exports.splitAt = splitAt;
-/**
- * @category combinators
- * @since 2.10.0
- */
-var chunksOf = function (n) { return exports.chop(exports.splitAt(n)); };
-exports.chunksOf = chunksOf;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-/* istanbul ignore next */
-var _map = function (fa, f) { return _function.pipe(fa, exports.map(f)); };
-/* istanbul ignore next */
-var _mapWithIndex = function (fa, f) { return _function.pipe(fa, exports.mapWithIndex(f)); };
-/* istanbul ignore next */
-var _ap = function (fab, fa) { return _function.pipe(fab, exports.ap(fa)); };
-/* istanbul ignore next */
-var _chain = function (ma, f) { return _function.pipe(ma, exports.chain(f)); };
-/* istanbul ignore next */
-var _extend = function (wa, f) { return _function.pipe(wa, exports.extend(f)); };
-/* istanbul ignore next */
-var _reduce = function (fa, b, f) { return _function.pipe(fa, exports.reduce(b, f)); };
-/* istanbul ignore next */
-var _foldMap = function (M) {
-    var foldMapM = exports.foldMap(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapM(f)); };
-};
-/* istanbul ignore next */
-var _reduceRight = function (fa, b, f) { return _function.pipe(fa, exports.reduceRight(b, f)); };
-/* istanbul ignore next */
-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)); };
-/* istanbul ignore next */
-var _reduceWithIndex = function (fa, b, f) {
-    return _function.pipe(fa, exports.reduceWithIndex(b, f));
-};
-/* istanbul ignore next */
-var _foldMapWithIndex = function (M) {
-    var foldMapWithIndexM = exports.foldMapWithIndex(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapWithIndexM(f)); };
-};
-/* istanbul ignore next */
-var _reduceRightWithIndex = function (fa, b, f) {
-    return _function.pipe(fa, exports.reduceRightWithIndex(b, f));
-};
-/* istanbul ignore next */
-var _traverseWithIndex = function (F) {
-    var traverseWithIndexF = exports.traverseWithIndex(F);
-    return function (ta, f) { return _function.pipe(ta, traverseWithIndexF(f)); };
-};
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-/**
- * Less strict version of [`alt`](#alt).
- *
- * @category Alt
- * @since 2.9.0
- */
-var altW = function (that) { return function (as) {
-    return _function.pipe(as, concatW(that()));
-}; };
-exports.altW = altW;
-/**
- * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to
- * types of kind `* -> *`.
- *
- * @category Alt
- * @since 2.6.2
- */
-exports.alt = exports.altW;
-/**
- * Apply a function to an argument under a type constructor.
- *
- * @category Apply
- * @since 2.0.0
- */
-var ap = function (as) {
-    return exports.chain(function (f) { return _function.pipe(as, exports.map(f)); });
-};
-exports.ap = ap;
-/**
- * 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 exports.chainWithIndex(function (_, a) { return f(a); });
-};
-exports.chain = chain;
-/**
- * @category Extend
- * @since 2.0.0
- */
-var extend = function (f) { return function (as) {
-    var next = exports.tail(as);
-    var out = [f(as)];
-    while (exports.isNonEmpty(next)) {
-        out.push(f(next));
-        next = exports.tail(next);
-    }
-    return out;
-}; };
-exports.extend = extend;
-/**
- * Derivable from `Extend`.
- *
- * @category combinators
- * @since 2.5.0
- */
-exports.duplicate = 
-/*#__PURE__*/
-exports.extend(_function.identity);
-/**
- * Derivable from `Chain`.
- *
- * @category combinators
- * @since 2.5.0
- */
-exports.flatten = 
-/*#__PURE__*/
-exports.chain(_function.identity);
-/**
- * `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 exports.mapWithIndex(function (_, a) { return f(a); }); };
-exports.map = map;
-/**
- * @category FunctorWithIndex
- * @since 2.0.0
- */
-var mapWithIndex = function (f) { return function (as) {
-    var out = [f(0, exports.head(as))];
-    for (var i = 1; i < as.length; i++) {
-        out.push(f(i, as[i]));
-    }
-    return out;
-}; };
-exports.mapWithIndex = mapWithIndex;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-exports.reduce = RNEA.reduce;
-/**
- * @category FoldableWithIndex
- * @since 2.0.0
- */
-exports.reduceWithIndex = RNEA.reduceWithIndex;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-exports.reduceRight = RNEA.reduceRight;
-/**
- * @category FoldableWithIndex
- * @since 2.0.0
- */
-exports.reduceRightWithIndex = RNEA.reduceRightWithIndex;
-/**
- * @since 2.6.3
- */
-var traverse = function (F) {
-    var traverseWithIndexF = exports.traverseWithIndex(F);
-    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };
-};
-exports.traverse = traverse;
-/**
- * @since 2.6.3
- */
-var sequence = function (F) { return exports.traverseWithIndex(F)(function (_, a) { return a; }); };
-exports.sequence = sequence;
-/**
- * @since 2.6.3
- */
-var traverseWithIndex = function (F) { return function (f) { return function (as) {
-    var out = F.map(f(0, exports.head(as)), exports.of);
-    for (var i = 1; i < as.length; i++) {
-        out = F.ap(F.map(out, function (bs) { return function (b) { return _function.pipe(bs, exports.append(b)); }; }), f(i, as[i]));
-    }
-    return out;
-}; }; };
-exports.traverseWithIndex = traverseWithIndex;
-/**
- * @since 2.7.0
- */
-exports.extract = RNEA.head;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.URI = 'NonEmptyArray';
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.getShow = RNEA.getShow;
-/**
- * Builds a `Semigroup` instance for `NonEmptyArray`
- *
- * @category instances
- * @since 2.0.0
- */
-var getSemigroup = function () { return ({
-    concat: concat
-}); };
-exports.getSemigroup = getSemigroup;
-/**
- * @example
- * import { getEq } from 'fp-ts/NonEmptyArray'
- * import * as N from 'fp-ts/number'
- *
- * const E = getEq(N.Eq)
- * assert.strictEqual(E.equals([1, 2], [1, 2]), true)
- * assert.strictEqual(E.equals([1, 2], [1, 3]), false)
- *
- * @category instances
- * @since 2.0.0
- */
-exports.getEq = RNEA.getEq;
-/**
- * @category combinators
- * @since 2.11.0
- */
-var getUnionSemigroup = function (E) {
-    var unionE = exports.union(E);
-    return {
-        concat: function (first, second) { return unionE(second)(first); }
-    };
-};
-exports.getUnionSemigroup = getUnionSemigroup;
-/**
- * @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.7.0
- */
-exports.FunctorWithIndex = {
-    URI: exports.URI,
-    map: _map,
-    mapWithIndex: _mapWithIndex
-};
-/**
- * @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.5.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.5.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
-};
-/**
- * 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.5.0
- */
-exports.chainFirst = 
-/*#__PURE__*/
-Chain.chainFirst(exports.Chain);
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Monad = {
-    URI: exports.URI,
-    map: _map,
-    ap: _ap,
-    of: exports.of,
-    chain: _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.FoldableWithIndex = {
-    URI: exports.URI,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex
-};
-/**
- * @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.TraversableWithIndex = {
-    URI: exports.URI,
-    map: _map,
-    mapWithIndex: _mapWithIndex,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex,
-    traverseWithIndex: _traverseWithIndex
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alt = {
-    URI: exports.URI,
-    map: _map,
-    alt: _alt
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Comonad = {
-    URI: exports.URI,
-    map: _map,
-    extend: _extend,
-    extract: exports.extract
-};
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.9.0
- */
-exports.Do = 
-/*#__PURE__*/
-exports.of(_.emptyRecord);
-/**
- * @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);
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.0.0
- */
-exports.head = RNEA.head;
-/**
- * @since 2.0.0
- */
-var tail = function (as) { return as.slice(1); };
-exports.tail = tail;
-/**
- * @since 2.0.0
- */
-exports.last = RNEA.last;
-/**
- * Get all but the last element of a non empty array, creating a new array.
- *
- * @example
- * import { init } from 'fp-ts/NonEmptyArray'
- *
- * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])
- * assert.deepStrictEqual(init([1]), [])
- *
- * @since 2.2.0
- */
-var init = function (as) { return as.slice(0, -1); };
-exports.init = init;
-/**
- * @since 2.0.0
- */
-exports.min = RNEA.min;
-/**
- * @since 2.0.0
- */
-exports.max = RNEA.max;
-/**
- * @since 2.10.0
- */
-var concatAll = function (S) { return function (as) { return as.reduce(S.concat); }; };
-exports.concatAll = concatAll;
-/**
- * Break an `Array` into its first element and remaining elements.
- *
- * @category destructors
- * @since 2.11.0
- */
-var matchLeft = function (f) { return function (as) { return f(exports.head(as), exports.tail(as)); }; };
-exports.matchLeft = matchLeft;
-/**
- * Break an `Array` into its initial elements and the last element.
- *
- * @category destructors
- * @since 2.11.0
- */
-var matchRight = function (f) { return function (as) {
-    return f(exports.init(as), exports.last(as));
-}; };
-exports.matchRight = matchRight;
-/**
- * Apply a function to the head, creating a new `NonEmptyArray`.
- *
- * @since 2.11.0
- */
-var modifyHead = function (f) { return function (as) { return __spreadArray([
-    f(exports.head(as))
-], exports.tail(as)); }; };
-exports.modifyHead = modifyHead;
-/**
- * Change the head, creating a new `NonEmptyArray`.
- *
- * @category combinators
- * @since 2.11.0
- */
-var updateHead = function (a) { return exports.modifyHead(function () { return a; }); };
-exports.updateHead = updateHead;
-/**
- * Apply a function to the last element, creating a new `NonEmptyArray`.
- *
- * @since 2.11.0
- */
-var modifyLast = function (f) { return function (as) {
-    return _function.pipe(exports.init(as), exports.append(f(exports.last(as))));
-}; };
-exports.modifyLast = modifyLast;
-/**
- * Change the last element, creating a new `NonEmptyArray`.
- *
- * @category combinators
- * @since 2.11.0
- */
-var updateLast = function (a) { return exports.modifyLast(function () { return a; }); };
-exports.updateLast = updateLast;
-function groupSort(O) {
-    var sortO = exports.sort(O);
-    var groupO = group(O);
-    return function (as) { return (exports.isNonEmpty(as) ? groupO(sortO(as)) : []); };
-}
-exports.groupSort = groupSort;
-function filter(predicate) {
-    return exports.filterWithIndex(function (_, a) { return predicate(a); });
-}
-exports.filter = filter;
-/**
- * Use [`filterWithIndex`](./Array.ts.html#filterwithindex) instead.
- *
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-var filterWithIndex = function (predicate) { return function (as) { return exports.fromArray(as.filter(function (a, i) { return predicate(i, a); })); }; };
-exports.filterWithIndex = filterWithIndex;
-/**
- * Use [`unprepend`](#unprepend) instead.
- *
- * @category destructors
- * @since 2.9.0
- * @deprecated
- */
-exports.uncons = exports.unprepend;
-/**
- * Use [`unappend`](#unappend) instead.
- *
- * @category destructors
- * @since 2.9.0
- * @deprecated
- */
-exports.unsnoc = exports.unappend;
-function cons(head, tail) {
-    return tail === undefined ? exports.prepend(head) : _function.pipe(tail, exports.prepend(head));
-}
-exports.cons = cons;
-/**
- * Use [`append`](./Array.ts.html#append) instead.
- *
- * @category constructors
- * @since 2.0.0
- * @deprecated
- */
-var snoc = function (init, end) { return _function.pipe(init, exports.append(end)); };
-exports.snoc = snoc;
-/**
- * Use [`prependAll`](#prependall) instead.
- *
- * @category combinators
- * @since 2.9.0
- * @deprecated
- */
-exports.prependToAll = exports.prependAll;
-/**
- * Use [`concatAll`](#concatall) instead.
- *
- * @since 2.5.0
- * @deprecated
- */
-exports.fold = RNEA.concatAll;
-/**
- * Use small, specific instances instead.
- *
- * @category instances
- * @since 2.0.0
- * @deprecated
- */
-exports.nonEmptyArray = {
-    URI: exports.URI,
-    of: exports.of,
-    map: _map,
-    mapWithIndex: _mapWithIndex,
-    ap: _ap,
-    chain: _chain,
-    extend: _extend,
-    extract: exports.extract,
-    reduce: _reduce,
-    foldMap: _foldMap,
-    reduceRight: _reduceRight,
-    traverse: _traverse,
-    sequence: exports.sequence,
-    reduceWithIndex: _reduceWithIndex,
-    foldMapWithIndex: _foldMapWithIndex,
-    reduceRightWithIndex: _reduceRightWithIndex,
-    traverseWithIndex: _traverseWithIndex,
-    alt: _alt
-};
-});
-
-const NonEmptyArray$1 = /*@__PURE__*/getDefaultExportFromCjs(NonEmptyArray);
-
-export { Apply as A, Chain as C, Eq as E, Functor as F, NonEmptyArray as N, Ord as O, ReadonlyNonEmptyArray as R, Separated as S, Witherable as W, Zero as Z, _function as _, commonjsGlobal as a, FromEither as b, createCommonjsModule as c, Semigroup as d, getDefaultExportFromCjs as g, internal as i };