vviinn-widgets 2.7.2 → 2.8.0

package/dist/vviinn-widgets/NonEmptyArray-947ab7b3.js

@@ -0,0 +1,4411 @@
+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 = (0, 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 = (0, 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 = constant(true);
+/**
+ * A thunk that returns always `false`.
+ *
+ * @since 2.0.0
+ */
+exports.constFalse = constant(false);
+/**
+ * A thunk that returns always `null`.
+ *
+ * @since 2.0.0
+ */
+exports.constNull = constant(null);
+/**
+ * A thunk that returns always `undefined`.
+ *
+ * @since 2.0.0
+ */
+exports.constUndefined = 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 internal = createCommonjsModule(function (module, exports) {
+"use strict";
+var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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), true); };
+exports.fromReadonlyNonEmptyArray = fromReadonlyNonEmptyArray;
+});
+
+const internal$1 = /*@__PURE__*/getDefaultExportFromCjs(internal);
+
+var Apply = createCommonjsModule(function (module, exports) {
+"use strict";
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.sequenceS = exports.sequenceT = exports.getApplySemigroup = exports.apS = exports.apSecond = exports.apFirst = exports.ap = void 0;
+
+var _ = __importStar(internal);
+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 (!_.has.call(tupleConstructors, 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 (0, _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 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.chainFirstEitherK = 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 (0, _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 (0, _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 chainFirstEitherK(F, M) {
+    return (0, _function.flow)(fromEitherK(F), (0, Chain.chainFirst)(M));
+}
+exports.chainFirstEitherK = chainFirstEitherK;
+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 (0, 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 (0, 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 (0, _function.pipe)(fa, (0, exports.contramap)(f)); };
+// -------------------------------------------------------------------------------------
+// type class members
+// -------------------------------------------------------------------------------------
+/**
+ * @category Contravariant
+ * @since 2.0.0
+ */
+var contramap = function (f) { return function (fa) {
+    return (0, 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 (0, 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: (0, 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;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`
+ * (where `E` is from `import E from 'fp-ts/Eq'`)
+ *
+ * @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: (0, 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 (0, 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 (0, exports.fromCompare)(function (first, second) { return O.compare(second, first); }); };
+exports.reverse = reverse;
+// -------------------------------------------------------------------------------------
+// non-pipeables
+// -------------------------------------------------------------------------------------
+/* istanbul ignore next */
+var contramap_ = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.contramap)(f)); };
+// -------------------------------------------------------------------------------------
+// type class members
+// -------------------------------------------------------------------------------------
+/**
+ * @category Contravariant
+ * @since 2.0.0
+ */
+var contramap = function (f) { return function (fa) {
+    return (0, 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 (0, 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: (0, exports.getSemigroup)().concat,
+    empty: (0, 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__*/ (0, _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 = (0, exports.min)(O);
+    var maxO = (0, 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 = (0, exports.lt)(O);
+    var gtO = (0, exports.gt)(O);
+    return function (low, hi) { return function (a) { return (ltO(a, low) || gtO(a, hi) ? false : true); }; };
+};
+exports.between = between;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * 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 = (0, _function.pipe)(exports.ordNumber, 
+/*#__PURE__*/
+(0, 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 = (0, 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 = (0, 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 (0, _function.pipe)(fa, (0, exports.map)(f)); };
+var _mapLeft = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.mapLeft)(f)); };
+var _bimap = function (fa, g, f) { return (0, _function.pipe)(fa, (0, 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 (0, exports.separated)((0, exports.left)(fa), f((0, 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 (0, exports.separated)(f((0, exports.left)(fa)), (0, 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 (0, exports.separated)(f((0, exports.left)(fa)), g((0, 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 = (0, 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.filterWithIndex = exports.filter = exports.groupSort = exports.intercalate = 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 = exports.uncons = 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, true); }; };
+exports.prependW = prependW;
+/**
+ * @internal
+ */
+exports.prepend = exports.prependW;
+/**
+ * @internal
+ */
+var appendW = function (end) { return function (init) { return __spreadArray(__spreadArray([], init, true), [end], false); }; };
+exports.appendW = appendW;
+/**
+ * @internal
+ */
+exports.append = exports.appendW;
+/**
+ * @internal
+ */
+var unsafeInsertAt = function (i, a, as) {
+    if ((0, 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 = [(0, exports.head)(as)];
+    var rest = (0, 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 ((0, exports.isNonEmpty)(ords)) {
+        var M = (0, Ord.getMonoid)();
+        return (0, 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 = (0, exports.uniq)(E);
+    return function (second) { return function (first) { return uniqE((0, _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 ((0, exports.isOutOfBound)(Math.abs(m), as) || m === 0) {
+        return as;
+    }
+    if (m < 0) {
+        var _a = (0, exports.splitAt)(-m)(as), f = _a[0], s = _a[1];
+        return (0, _function.pipe)(s, concat(f));
+    }
+    else {
+        return (0, 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 (0, 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 (0, 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 ? (0, 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 [(0, exports.head)(as), (0, 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 [(0, exports.init)(as), (0, exports.last)(as)]; };
+exports.unappend = unappend;
+// -------------------------------------------------------------------------------------
+// interop
+// -------------------------------------------------------------------------------------
+/**
+ * @category interop
+ * @since 2.5.0
+ */
+var fromArray = function (as) { return (0, 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([(0, exports.last)(as)], as.slice(0, -1).reverse(), true);
+};
+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 (_.has.call(out, 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 (0, exports.modifyAt)(i, function () { return a; });
+};
+exports.updateAt = updateAt;
+/**
+ * @category combinators
+ * @since 2.5.0
+ */
+var modifyAt = function (i, f) { return function (as) { return ((0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, 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 (0, 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 = (0, exports.tail)(as);
+    return (0, exports.isNonEmpty)(rest) ? (0, _function.pipe)(rest, (0, exports.prependAll)(middle), (0, exports.prepend)((0, 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, (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 ((0, 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] : [(0, _function.pipe)(as.slice(1, m), (0, exports.prepend)((0, 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 (0, exports.chop)((0, exports.splitAt)(n)); };
+exports.chunksOf = chunksOf;
+// -------------------------------------------------------------------------------------
+// non-pipeables
+// -------------------------------------------------------------------------------------
+var _map = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.map)(f)); };
+/* istanbul ignore next */
+var _mapWithIndex = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.mapWithIndex)(f)); };
+var _ap = function (fab, fa) { return (0, _function.pipe)(fab, (0, exports.ap)(fa)); };
+var _chain = function (ma, f) { return (0, _function.pipe)(ma, (0, exports.chain)(f)); };
+/* istanbul ignore next */
+var _extend = function (wa, f) { return (0, _function.pipe)(wa, (0, exports.extend)(f)); };
+/* istanbul ignore next */
+var _reduce = function (fa, b, f) { return (0, _function.pipe)(fa, (0, exports.reduce)(b, f)); };
+/* istanbul ignore next */
+var _foldMap = function (M) {
+    var foldMapM = (0, exports.foldMap)(M);
+    return function (fa, f) { return (0, _function.pipe)(fa, foldMapM(f)); };
+};
+/* istanbul ignore next */
+var _reduceRight = function (fa, b, f) { return (0, _function.pipe)(fa, (0, exports.reduceRight)(b, f)); };
+/* istanbul ignore next */
+var _traverse = function (F) {
+    var traverseF = (0, exports.traverse)(F);
+    return function (ta, f) { return (0, _function.pipe)(ta, traverseF(f)); };
+};
+/* istanbul ignore next */
+var _alt = function (fa, that) { return (0, _function.pipe)(fa, (0, exports.alt)(that)); };
+/* istanbul ignore next */
+var _reduceWithIndex = function (fa, b, f) {
+    return (0, _function.pipe)(fa, (0, exports.reduceWithIndex)(b, f));
+};
+/* istanbul ignore next */
+var _foldMapWithIndex = function (M) {
+    var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);
+    return function (fa, f) { return (0, _function.pipe)(fa, foldMapWithIndexM(f)); };
+};
+/* istanbul ignore next */
+var _reduceRightWithIndex = function (fa, b, f) {
+    return (0, _function.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));
+};
+/* istanbul ignore next */
+var _traverseWithIndex = function (F) {
+    var traverseWithIndexF = (0, exports.traverseWithIndex)(F);
+    return function (ta, f) { return (0, _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 (0, _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 (0, exports.chain)(function (f) { return (0, _function.pipe)(as, (0, 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 (0, 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 = (0, exports.tail)(as);
+    var out = [f(as)];
+    while ((0, exports.isNonEmpty)(next)) {
+        out.push(f(next));
+        next = (0, exports.tail)(next);
+    }
+    return out;
+}; };
+exports.extend = extend;
+/**
+ * Derivable from `Extend`.
+ *
+ * @category combinators
+ * @since 2.5.0
+ */
+exports.duplicate = (0, exports.extend)(_function.identity);
+/**
+ * Derivable from `Chain`.
+ *
+ * @category combinators
+ * @since 2.5.0
+ */
+exports.flatten = (0, 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 (0, 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, (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 (0, 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 (0, 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 = (0, 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 (0, 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, (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 (0, _function.pipe)(bs, (0, 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 "[".concat(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 (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, exports.of)(_.emptyRecord);
+/**
+ * @since 2.8.0
+ */
+exports.bindTo = (0, Functor.bindTo)(exports.Functor);
+/**
+ * @since 2.8.0
+ */
+exports.bind = (0, Chain.bind)(exports.Chain);
+// -------------------------------------------------------------------------------------
+// pipeable sequence S
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+exports.apS = (0, 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((0, exports.head)(as), (0, 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((0, exports.init)(as), (0, 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((0, exports.head)(as))
+], (0, exports.tail)(as), true); }; };
+exports.modifyHead = modifyHead;
+/**
+ * Change the head, creating a new `ReadonlyNonEmptyArray`.
+ *
+ * @category combinators
+ * @since 2.11.0
+ */
+var updateHead = function (a) { return (0, 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 (0, _function.pipe)((0, exports.init)(as), (0, exports.append)(f((0, 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 (0, exports.modifyLast)(function () { return a; }); };
+exports.updateLast = updateLast;
+/**
+ * Places an element in between members of a `ReadonlyNonEmptyArray`, then folds the results using the provided `Semigroup`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { intercalate } from 'fp-ts/ReadonlyNonEmptyArray'
+ *
+ * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')
+ *
+ * @since 2.12.0
+ */
+var intercalate = function (S) {
+    var concatAllS = (0, exports.concatAll)(S);
+    return function (middle) { return (0, _function.flow)((0, exports.intersperse)(middle), concatAllS); };
+};
+exports.intercalate = intercalate;
+function groupSort(O) {
+    var sortO = (0, exports.sort)(O);
+    var groupO = group(O);
+    return function (as) { return ((0, exports.isNonEmpty)(as) ? groupO(sortO(as)) : exports.empty); };
+}
+exports.groupSort = groupSort;
+function filter(predicate) {
+    return (0, 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 (0, 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 ? (0, exports.prepend)(head) : (0, _function.pipe)(tail, (0, 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 (0, _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((0, 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;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `RNEA.Functor` instead of `RNEA.readonlyNonEmptyArray`
+ * (where `RNEA` is from `import RNEA from 'fp-ts/ReadonlyNonEmptyArray'`)
+ *
+ * @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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.filter = exports.groupSort = exports.intercalate = 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 = exports.filterWithIndex = 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, true); }; };
+exports.prependW = prependW;
+/**
+ * @internal
+ */
+exports.prepend = exports.prependW;
+/**
+ * @internal
+ */
+var appendW = function (end) { return function (init) { return __spreadArray(__spreadArray([], init, true), [end], false); }; };
+exports.appendW = appendW;
+/**
+ * @internal
+ */
+exports.append = exports.appendW;
+/**
+ * @internal
+ */
+var unsafeInsertAt = function (i, a, as) {
+    if ((0, exports.isNonEmpty)(as)) {
+        var xs = (0, exports.fromReadonlyNonEmptyArray)(as);
+        xs.splice(i, 0, a);
+        return xs;
+    }
+    return [a];
+};
+exports.unsafeInsertAt = unsafeInsertAt;
+/**
+ * @internal
+ */
+var unsafeUpdateAt = function (i, a, as) {
+    var xs = (0, 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 (0, exports.copy)(as);
+    }
+    var out = [(0, exports.head)(as)];
+    var rest = (0, 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 ((0, exports.isNonEmpty)(ords)) {
+        var M = (0, Ord.getMonoid)();
+        return (0, 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 = (0, exports.uniq)(E);
+    return function (second) { return function (first) { return uniqE((0, _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 ((0, exports.isOutOfBound)(Math.abs(m), as) || m === 0) {
+        return (0, exports.copy)(as);
+    }
+    if (m < 0) {
+        var _a = (0, exports.splitAt)(-m)(as), f = _a[0], s = _a[1];
+        return (0, _function.pipe)(s, concat(f));
+    }
+    else {
+        return (0, 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 ((0, 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 (0, 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 ? (0, 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 [(0, exports.head)(as), (0, 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 [(0, exports.init)(as), (0, 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([(0, exports.last)(as)], as.slice(0, -1).reverse(), true); };
+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 (_.has.call(out, 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((0, exports.unsafeInsertAt)(i, a, as));
+}; };
+exports.insertAt = insertAt;
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+var updateAt = function (i, a) {
+    return (0, exports.modifyAt)(i, function () { return a; });
+};
+exports.updateAt = updateAt;
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+var modifyAt = function (i, f) { return function (as) {
+    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, 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 (0, 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 = (0, exports.tail)(as);
+    return (0, exports.isNonEmpty)(rest) ? (0, _function.pipe)(rest, (0, exports.prependAll)(middle), (0, exports.prepend)((0, exports.head)(as))) : (0, 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 = (0, exports.fromReadonlyNonEmptyArray)(f(0, (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 ((0, 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 ? [(0, exports.copy)(as), []] : [(0, _function.pipe)(as.slice(1, m), (0, exports.prepend)((0, exports.head)(as))), as.slice(m)];
+}; };
+exports.splitAt = splitAt;
+/**
+ * @category combinators
+ * @since 2.10.0
+ */
+var chunksOf = function (n) { return (0, exports.chop)((0, exports.splitAt)(n)); };
+exports.chunksOf = chunksOf;
+// -------------------------------------------------------------------------------------
+// non-pipeables
+// -------------------------------------------------------------------------------------
+/* istanbul ignore next */
+var _map = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.map)(f)); };
+/* istanbul ignore next */
+var _mapWithIndex = function (fa, f) { return (0, _function.pipe)(fa, (0, exports.mapWithIndex)(f)); };
+/* istanbul ignore next */
+var _ap = function (fab, fa) { return (0, _function.pipe)(fab, (0, exports.ap)(fa)); };
+/* istanbul ignore next */
+var _chain = function (ma, f) { return (0, _function.pipe)(ma, (0, exports.chain)(f)); };
+/* istanbul ignore next */
+var _extend = function (wa, f) { return (0, _function.pipe)(wa, (0, exports.extend)(f)); };
+/* istanbul ignore next */
+var _reduce = function (fa, b, f) { return (0, _function.pipe)(fa, (0, exports.reduce)(b, f)); };
+/* istanbul ignore next */
+var _foldMap = function (M) {
+    var foldMapM = (0, exports.foldMap)(M);
+    return function (fa, f) { return (0, _function.pipe)(fa, foldMapM(f)); };
+};
+/* istanbul ignore next */
+var _reduceRight = function (fa, b, f) { return (0, _function.pipe)(fa, (0, exports.reduceRight)(b, f)); };
+/* istanbul ignore next */
+var _traverse = function (F) {
+    var traverseF = (0, exports.traverse)(F);
+    return function (ta, f) { return (0, _function.pipe)(ta, traverseF(f)); };
+};
+/* istanbul ignore next */
+var _alt = function (fa, that) { return (0, _function.pipe)(fa, (0, exports.alt)(that)); };
+/* istanbul ignore next */
+var _reduceWithIndex = function (fa, b, f) {
+    return (0, _function.pipe)(fa, (0, exports.reduceWithIndex)(b, f));
+};
+/* istanbul ignore next */
+var _foldMapWithIndex = function (M) {
+    var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);
+    return function (fa, f) { return (0, _function.pipe)(fa, foldMapWithIndexM(f)); };
+};
+/* istanbul ignore next */
+var _reduceRightWithIndex = function (fa, b, f) {
+    return (0, _function.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));
+};
+/* istanbul ignore next */
+var _traverseWithIndex = function (F) {
+    var traverseWithIndexF = (0, exports.traverseWithIndex)(F);
+    return function (ta, f) { return (0, _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 (0, _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 (0, exports.chain)(function (f) { return (0, _function.pipe)(as, (0, 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 (0, 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 = (0, exports.tail)(as);
+    var out = [f(as)];
+    while ((0, exports.isNonEmpty)(next)) {
+        out.push(f(next));
+        next = (0, exports.tail)(next);
+    }
+    return out;
+}; };
+exports.extend = extend;
+/**
+ * Derivable from `Extend`.
+ *
+ * @category combinators
+ * @since 2.5.0
+ */
+exports.duplicate = (0, exports.extend)(_function.identity);
+/**
+ * Derivable from `Chain`.
+ *
+ * @category combinators
+ * @since 2.5.0
+ */
+exports.flatten = (0, 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 (0, 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, (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 = (0, 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 (0, 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, (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 (0, _function.pipe)(bs, (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, 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 = (0, exports.of)(_.emptyRecord);
+/**
+ * @since 2.8.0
+ */
+exports.bindTo = (0, Functor.bindTo)(exports.Functor);
+/**
+ * @since 2.8.0
+ */
+exports.bind = (0, Chain.bind)(exports.Chain);
+// -------------------------------------------------------------------------------------
+// pipeable sequence S
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+exports.apS = (0, 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((0, exports.head)(as), (0, 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((0, exports.init)(as), (0, 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((0, exports.head)(as))
+], (0, exports.tail)(as), true); }; };
+exports.modifyHead = modifyHead;
+/**
+ * Change the head, creating a new `NonEmptyArray`.
+ *
+ * @category combinators
+ * @since 2.11.0
+ */
+var updateHead = function (a) { return (0, 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 (0, _function.pipe)((0, exports.init)(as), (0, exports.append)(f((0, 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 (0, exports.modifyLast)(function () { return a; }); };
+exports.updateLast = updateLast;
+/**
+ * Places an element in between members of a `NonEmptyArray`, then folds the results using the provided `Semigroup`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { intercalate } from 'fp-ts/NonEmptyArray'
+ *
+ * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')
+ *
+ * @since 2.12.0
+ */
+exports.intercalate = RNEA.intercalate;
+function groupSort(O) {
+    var sortO = (0, exports.sort)(O);
+    var groupO = group(O);
+    return function (as) { return ((0, exports.isNonEmpty)(as) ? groupO(sortO(as)) : []); };
+}
+exports.groupSort = groupSort;
+function filter(predicate) {
+    return (0, 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 (0, 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 ? (0, exports.prepend)(head) : (0, _function.pipe)(tail, (0, 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 (0, _function.pipe)(init, (0, 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;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `NEA.Functor` instead of `NEA.nonEmptyArray`
+ * (where `NEA` is from `import NEA from 'fp-ts/NonEmptyArray'`)
+ *
+ * @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, getAugmentedNamespace as e, getDefaultExportFromCjs as g, internal as i };