{"version":3,"file":"js/3196-2318dcc790303cfa769c.js","mappings":"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","sources":["webpack://uk-b2c/./node_modules/classnames/index.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Applicative.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Apply.js","webpack://uk-b2c/./node_modules/fp-ts/es6/number.js","webpack://uk-b2c/./node_modules/fp-ts/es6/ReadonlyArray.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Array.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Chain.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Eq.js","webpack://uk-b2c/./node_modules/fp-ts/es6/FromEither.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Functor.js","webpack://uk-b2c/./node_modules/fp-ts/es6/NonEmptyArray.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Option.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Predicate.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Ord.js","webpack://uk-b2c/./node_modules/fp-ts/es6/ReadonlyNonEmptyArray.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Semigroup.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Separated.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Witherable.js","webpack://uk-b2c/./node_modules/fp-ts/es6/Zero.js","webpack://uk-b2c/./node_modules/fp-ts/es6/function.js","webpack://uk-b2c/./node_modules/fp-ts/es6/internal.js","webpack://uk-b2c/./node_modules/fp-ts/lib/function.js"],"sourcesContent":["/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n  'use strict';\n\n  var hasOwn = {}.hasOwnProperty;\n  var nativeCodeString = '[native code]';\n  function classNames() {\n    var classes = [];\n    for (var i = 0; i < arguments.length; i++) {\n      var arg = arguments[i];\n      if (!arg) continue;\n      var argType = typeof arg;\n      if (argType === 'string' || argType === 'number') {\n        classes.push(arg);\n      } else if (Array.isArray(arg)) {\n        if (arg.length) {\n          var inner = classNames.apply(null, arg);\n          if (inner) {\n            classes.push(inner);\n          }\n        }\n      } else if (argType === 'object') {\n        if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n          classes.push(arg.toString());\n          continue;\n        }\n        for (var key in arg) {\n          if (hasOwn.call(arg, key) && arg[key]) {\n            classes.push(key);\n          }\n        }\n      }\n    }\n    return classes.join(' ');\n  }\n  if (typeof module !== 'undefined' && module.exports) {\n    classNames.default = classNames;\n    module.exports = classNames;\n  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n    // register as 'classnames', consistent with npm package name\n    define('classnames', [], function () {\n      return classNames;\n    });\n  } else {\n    window.classNames = classNames;\n  }\n})();","/**\n * The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values\n * of type `f a` from values of type `a`.\n *\n * Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are\n * wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the\n * function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for\n * any number of function arguments.\n *\n * Instances must satisfy the following laws in addition to the `Apply` laws:\n *\n * 1. Identity: `A.ap(A.of(a => a), fa) <-> fa`\n * 2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`\n * 3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`\n *\n * Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`\n *\n * @since 2.0.0\n */\nimport { ap, getApplySemigroup } from './Apply';\nimport { pipe } from './function';\nimport { getFunctorComposition } from './Functor';\nexport function getApplicativeMonoid(F) {\n  var f = getApplySemigroup(F);\n  return function (M) {\n    return {\n      concat: f(M).concat,\n      empty: F.of(M.empty)\n    };\n  };\n}\n/** @deprecated */\nexport function getApplicativeComposition(F, G) {\n  var map = getFunctorComposition(F, G).map;\n  var _ap = ap(F, G);\n  return {\n    map: map,\n    of: function (a) {\n      return F.of(G.of(a));\n    },\n    ap: function (fgab, fga) {\n      return pipe(fgab, _ap(fga));\n    }\n  };\n}","/**\n * The `Apply` class provides the `ap` which is used to apply a function to an argument under a type constructor.\n *\n * `Apply` can be used to lift functions of two or more arguments to work on values wrapped with the type constructor\n * `f`.\n *\n * Instances must satisfy the following law in addition to the `Functor` laws:\n *\n * 1. Associative composition: `F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))`\n *\n * Formally, `Apply` represents a strong lax semi-monoidal endofunctor.\n *\n * @example\n * import * as O from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (a: string) => (b: number) => (c: boolean) => a + String(b) + String(c)\n * const fa: O.Option<string> = O.some('s')\n * const fb: O.Option<number> = O.some(1)\n * const fc: O.Option<boolean> = O.some(true)\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     // lift a function\n *     O.some(f),\n *     // apply the first argument\n *     O.ap(fa),\n *     // apply the second argument\n *     O.ap(fb),\n *     // apply the third argument\n *     O.ap(fc)\n *   ),\n *   O.some('s1true')\n * )\n *\n * @since 2.0.0\n */\nimport { tuple } from './function';\nimport * as _ from './internal';\nexport function ap(F, G) {\n  return function (fa) {\n    return function (fab) {\n      return F.ap(F.map(fab, function (gab) {\n        return function (ga) {\n          return G.ap(gab, ga);\n        };\n      }), fa);\n    };\n  };\n}\nexport function apFirst(A) {\n  return function (second) {\n    return function (first) {\n      return A.ap(A.map(first, function (a) {\n        return function () {\n          return a;\n        };\n      }), second);\n    };\n  };\n}\nexport function apSecond(A) {\n  return function (second) {\n    return function (first) {\n      return A.ap(A.map(first, function () {\n        return function (b) {\n          return b;\n        };\n      }), second);\n    };\n  };\n}\nexport function apS(F) {\n  return function (name, fb) {\n    return function (fa) {\n      return F.ap(F.map(fa, function (a) {\n        return function (b) {\n          var _a;\n          return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n        };\n      }), fb);\n    };\n  };\n}\nexport function getApplySemigroup(F) {\n  return function (S) {\n    return {\n      concat: function (first, second) {\n        return F.ap(F.map(first, function (x) {\n          return function (y) {\n            return S.concat(x, y);\n          };\n        }), second);\n      }\n    };\n  };\n}\nfunction curried(f, n, acc) {\n  return function (x) {\n    var combined = Array(acc.length + 1);\n    for (var i = 0; i < acc.length; i++) {\n      combined[i] = acc[i];\n    }\n    combined[acc.length] = x;\n    return n === 0 ? f.apply(null, combined) : curried(f, n - 1, combined);\n  };\n}\nvar tupleConstructors = {\n  1: function (a) {\n    return [a];\n  },\n  2: function (a) {\n    return function (b) {\n      return [a, b];\n    };\n  },\n  3: function (a) {\n    return function (b) {\n      return function (c) {\n        return [a, b, c];\n      };\n    };\n  },\n  4: function (a) {\n    return function (b) {\n      return function (c) {\n        return function (d) {\n          return [a, b, c, d];\n        };\n      };\n    };\n  },\n  5: function (a) {\n    return function (b) {\n      return function (c) {\n        return function (d) {\n          return function (e) {\n            return [a, b, c, d, e];\n          };\n        };\n      };\n    };\n  }\n};\nfunction getTupleConstructor(len) {\n  if (!_.has.call(tupleConstructors, len)) {\n    tupleConstructors[len] = curried(tuple, len - 1, []);\n  }\n  return tupleConstructors[len];\n}\nexport function sequenceT(F) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    var len = args.length;\n    var f = getTupleConstructor(len);\n    var fas = F.map(args[0], f);\n    for (var i = 1; i < len; i++) {\n      fas = F.ap(fas, args[i]);\n    }\n    return fas;\n  };\n}\nfunction getRecordConstructor(keys) {\n  var len = keys.length;\n  switch (len) {\n    case 1:\n      return function (a) {\n        var _a;\n        return _a = {}, _a[keys[0]] = a, _a;\n      };\n    case 2:\n      return function (a) {\n        return function (b) {\n          var _a;\n          return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a;\n        };\n      };\n    case 3:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            var _a;\n            return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a;\n          };\n        };\n      };\n    case 4:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            return function (d) {\n              var _a;\n              return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a[keys[3]] = d, _a;\n            };\n          };\n        };\n      };\n    case 5:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            return function (d) {\n              return function (e) {\n                var _a;\n                return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a[keys[3]] = d, _a[keys[4]] = e, _a;\n              };\n            };\n          };\n        };\n      };\n    default:\n      return curried(function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\n        var r = {};\n        for (var i = 0; i < len; i++) {\n          r[keys[i]] = args[i];\n        }\n        return r;\n      }, len - 1, []);\n  }\n}\nexport function sequenceS(F) {\n  return function (r) {\n    var keys = Object.keys(r);\n    var len = keys.length;\n    var f = getRecordConstructor(keys);\n    var fr = F.map(r[keys[0]], f);\n    for (var i = 1; i < len; i++) {\n      fr = F.ap(fr, r[keys[i]]);\n    }\n    return fr;\n  };\n}","// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * @category refinements\n * @since 2.11.0\n */\nexport var isNumber = function (u) {\n  return typeof u === 'number';\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Eq = {\n  equals: function (first, second) {\n    return first === second;\n  }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Ord = {\n  equals: Eq.equals,\n  compare: function (first, second) {\n    return first < second ? -1 : first > second ? 1 : 0;\n  }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Bounded = {\n  equals: Eq.equals,\n  compare: Ord.compare,\n  top: Infinity,\n  bottom: -Infinity\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Show = {\n  show: function (n) {\n    return JSON.stringify(n);\n  }\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var MagmaSub = {\n  concat: function (first, second) {\n    return first - second;\n  }\n};\n/**\n * `number` semigroup under addition.\n *\n * @example\n * import { SemigroupSum } from 'fp-ts/number'\n *\n * assert.deepStrictEqual(SemigroupSum.concat(2, 3), 5)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupSum = {\n  concat: function (first, second) {\n    return first + second;\n  }\n};\n/**\n * `number` semigroup under multiplication.\n *\n * @example\n * import { SemigroupProduct } from 'fp-ts/number'\n *\n * assert.deepStrictEqual(SemigroupProduct.concat(2, 3), 6)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupProduct = {\n  concat: function (first, second) {\n    return first * second;\n  }\n};\n/**\n * `number` monoid under addition.\n *\n * The `empty` value is `0`.\n *\n * @example\n * import { MonoidSum } from 'fp-ts/number'\n *\n * assert.deepStrictEqual(MonoidSum.concat(2, MonoidSum.empty), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidSum = {\n  concat: SemigroupSum.concat,\n  empty: 0\n};\n/**\n * `number` monoid under multiplication.\n *\n * The `empty` value is `1`.\n *\n * @example\n * import { MonoidProduct } from 'fp-ts/number'\n *\n * assert.deepStrictEqual(MonoidProduct.concat(2, MonoidProduct.empty), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidProduct = {\n  concat: SemigroupProduct.concat,\n  empty: 1\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Field = {\n  add: SemigroupSum.concat,\n  zero: 0,\n  mul: SemigroupProduct.concat,\n  one: 1,\n  sub: MagmaSub.concat,\n  degree: function (_) {\n    return 1;\n  },\n  div: function (first, second) {\n    return first / second;\n  },\n  mod: function (first, second) {\n    return first % second;\n  }\n};","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEquals } from './Eq';\nimport { fromEitherK as fromEitherK_ } from './FromEither';\nimport { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport * as N from './number';\nimport { fromCompare } from './Ord';\nimport * as RNEA from './ReadonlyNonEmptyArray';\nimport { separated } from './Separated';\nimport { filterE as filterE_, wiltDefault, witherDefault } from './Witherable';\nimport { guard as guard_ } from './Zero';\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Test whether a `ReadonlyArray` is empty.\n *\n * @example\n * import { isEmpty } from 'fp-ts/ReadonlyArray'\n *\n * assert.strictEqual(isEmpty([]), true)\n *\n * @category refinements\n * @since 2.5.0\n */\nexport var isEmpty = function (as) {\n  return as.length === 0;\n};\n/**\n * Test whether a `ReadonlyArray` is non empty.\n *\n * @category refinements\n * @since 2.5.0\n */\nexport var isNonEmpty = RNEA.isNonEmpty;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Prepend an element to the front of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { prepend } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([2, 3, 4], prepend(1)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexport var prepend = RNEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @since 2.11.0\n */\nexport var prependW = RNEA.prependW;\n/**\n * Append an element to the end of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { append } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], append(4)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexport var append = RNEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @since 2.11.0\n */\nexport var appendW = RNEA.appendW;\n/**\n * Return a `ReadonlyArray` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { makeBy } from 'fp-ts/ReadonlyArray'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport var makeBy = function (n, f) {\n  return n <= 0 ? empty : RNEA.makeBy(f)(n);\n};\n/**\n * Create a `ReadonlyArray` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { replicate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport var replicate = function (n, a) {\n  return makeBy(n, function () {\n    return a;\n  });\n};\nexport function fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? [a] : empty;\n  };\n}\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.11.0\n */\nexport var fromOption = function (ma) {\n  return _.isNone(ma) ? empty : [ma.value];\n};\n/**\n * Transforms an `Either` to a `ReadonlyArray`.\n *\n * @category conversions\n * @since 2.11.0\n */\nexport var fromEither = function (e) {\n  return _.isLeft(e) ? empty : [e.right];\n};\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(as) : onEmpty();\n  };\n};\n/**\n * @category pattern matching\n * @since 2.11.0\n */\nexport var match = matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeftW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(RNEA.head(as), RNEA.tail(as)) : onEmpty();\n  };\n};\n/**\n * Break a `ReadonlyArray` into its first element and remaining elements.\n *\n * @example\n * import { matchLeft } from 'fp-ts/ReadonlyArray'\n *\n * const len: <A>(as: ReadonlyArray<A>) => number = matchLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchLeft = matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexport var foldLeft = matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRightW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(RNEA.init(as), RNEA.last(as)) : onEmpty();\n  };\n};\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchRight = matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexport var foldRight = matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category sequencing\n * @since 2.7.0\n */\nexport var chainWithIndex = function (f) {\n  return function (as) {\n    if (isEmpty(as)) {\n      return empty;\n    }\n    var out = [];\n    for (var i = 0; i < as.length; i++) {\n      out.push.apply(out, f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * Same as `reduce` but it carries over the intermediate steps.\n *\n * @example\n * import { scanLeft } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])\n *\n * @since 2.5.0\n */\nexport var scanLeft = function (b, f) {\n  return function (as) {\n    var len = as.length;\n    var out = new Array(len + 1);\n    out[0] = b;\n    for (var i = 0; i < len; i++) {\n      out[i + 1] = f(out[i], as[i]);\n    }\n    return out;\n  };\n};\n/**\n * Fold an array from the right, keeping all intermediate results instead of only the final result\n *\n * @example\n * import { scanRight } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])\n *\n * @since 2.5.0\n */\nexport var scanRight = function (b, f) {\n  return function (as) {\n    var len = as.length;\n    var out = new Array(len + 1);\n    out[len] = b;\n    for (var i = len - 1; i >= 0; i--) {\n      out[i] = f(as[i], out[i + 1]);\n    }\n    return out;\n  };\n};\n/**\n * Calculate the number of elements in a `ReadonlyArray`.\n *\n * @since 2.10.0\n */\nexport var size = function (as) {\n  return as.length;\n};\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.5.0\n */\nexport var isOutOfBound = RNEA.isOutOfBound;\nexport function lookup(i, as) {\n  return as === undefined ? function (as) {\n    return lookup(i, as);\n  } : isOutOfBound(i, as) ? _.none : _.some(as[i]);\n}\n/**\n * Get the first element in an array, or `None` if the array is empty\n *\n * @example\n * import { head } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(head([1, 2, 3]), some(1))\n * assert.deepStrictEqual(head([]), none)\n *\n * @since 2.5.0\n */\nexport var head = function (as) {\n  return isNonEmpty(as) ? _.some(RNEA.head(as)) : _.none;\n};\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @since 2.5.0\n */\nexport var last = function (as) {\n  return isNonEmpty(as) ? _.some(RNEA.last(as)) : _.none;\n};\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @since 2.5.0\n */\nexport var tail = function (as) {\n  return isNonEmpty(as) ? _.some(RNEA.tail(as)) : _.none;\n};\n/**\n * Get all but the last element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @since 2.5.0\n */\nexport var init = function (as) {\n  return isNonEmpty(as) ? _.some(RNEA.init(as)) : _.none;\n};\n/**\n * Keep only a max number of elements from the start of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.takeLeft(2)), [1, 2])\n *\n * // out of bounds\n * assert.strictEqual(pipe(input, RA.takeLeft(4)), input)\n * assert.strictEqual(pipe(input, RA.takeLeft(-1)), input)\n *\n * @since 2.5.0\n */\nexport var takeLeft = function (n) {\n  return function (as) {\n    return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(0, n);\n  };\n};\n/**\n * Keep only a max number of elements from the end of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.takeRight(2)), [2, 3])\n *\n * // out of bounds\n * assert.strictEqual(pipe(input, RA.takeRight(4)), input)\n * assert.strictEqual(pipe(input, RA.takeRight(-1)), input)\n *\n * @since 2.5.0\n */\nexport var takeRight = function (n) {\n  return function (as) {\n    return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(-n);\n  };\n};\nexport function takeLeftWhile(predicate) {\n  return function (as) {\n    var out = [];\n    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n      var a = as_1[_i];\n      if (!predicate(a)) {\n        break;\n      }\n      out.push(a);\n    }\n    var len = out.length;\n    return len === as.length ? as : len === 0 ? empty : out;\n  };\n}\nvar spanLeftIndex = function (as, predicate) {\n  var l = as.length;\n  var i = 0;\n  for (; i < l; i++) {\n    if (!predicate(as[i])) {\n      break;\n    }\n  }\n  return i;\n};\nexport function spanLeft(predicate) {\n  return function (as) {\n    var _a = splitAt(spanLeftIndex(as, predicate))(as),\n      init = _a[0],\n      rest = _a[1];\n    return {\n      init: init,\n      rest: rest\n    };\n  };\n}\n/**\n * Drop a max number of elements from the start of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.dropLeft(2)), [3])\n * assert.strictEqual(pipe(input, RA.dropLeft(0)), input)\n * assert.strictEqual(pipe(input, RA.dropLeft(-1)), input)\n *\n * @since 2.5.0\n */\nexport var dropLeft = function (n) {\n  return function (as) {\n    return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(n, as.length);\n  };\n};\n/**\n * Drop a max number of elements from the end of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.dropRight(2)), [1])\n * assert.strictEqual(pipe(input, RA.dropRight(0)), input)\n * assert.strictEqual(pipe(input, RA.dropRight(-1)), input)\n *\n * @since 2.5.0\n */\nexport var dropRight = function (n) {\n  return function (as) {\n    return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(0, as.length - n);\n  };\n};\nexport function dropLeftWhile(predicate) {\n  return function (as) {\n    var i = spanLeftIndex(as, predicate);\n    return i === 0 ? as : i === as.length ? empty : as.slice(i);\n  };\n}\n/**\n * Find the first index for which a predicate holds\n *\n * @example\n * import { findIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.5.0\n */\nexport var findIndex = function (predicate) {\n  return function (as) {\n    for (var i = 0; i < as.length; i++) {\n      if (predicate(as[i])) {\n        return _.some(i);\n      }\n    }\n    return _.none;\n  };\n};\nexport function findFirst(predicate) {\n  return function (as) {\n    for (var i = 0; i < as.length; i++) {\n      if (predicate(as[i])) {\n        return _.some(as[i]);\n      }\n    }\n    return _.none;\n  };\n}\n/**\n * Find the first element returned by an option based selector function\n *\n * @example\n * import { findFirstMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string\n *   readonly age?: number\n * }\n *\n * const persons: ReadonlyArray<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the first person that has an age\n * assert.deepStrictEqual(findFirstMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Mary'))\n *\n * @since 2.5.0\n */\nexport var findFirstMap = function (f) {\n  return function (as) {\n    for (var i = 0; i < as.length; i++) {\n      var out = f(as[i]);\n      if (_.isSome(out)) {\n        return out;\n      }\n    }\n    return _.none;\n  };\n};\nexport function findLast(predicate) {\n  return function (as) {\n    for (var i = as.length - 1; i >= 0; i--) {\n      if (predicate(as[i])) {\n        return _.some(as[i]);\n      }\n    }\n    return _.none;\n  };\n}\n/**\n * Find the last element returned by an option based selector function\n *\n * @example\n * import { findLastMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string\n *   readonly age?: number\n * }\n *\n * const persons: ReadonlyArray<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the last person that has an age\n * assert.deepStrictEqual(findLastMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Joey'))\n *\n * @since 2.5.0\n */\nexport var findLastMap = function (f) {\n  return function (as) {\n    for (var i = as.length - 1; i >= 0; i--) {\n      var out = f(as[i]);\n      if (_.isSome(out)) {\n        return out;\n      }\n    }\n    return _.none;\n  };\n};\n/**\n * Returns the index of the last element of the list which matches the predicate\n *\n * @example\n * import { findLastIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   readonly a: number\n *   readonly b: number\n * }\n * const xs: ReadonlyArray<X> = [{ a: 1, b: 0 }, { a: 1, b: 1 }]\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 1)(xs), some(1))\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 4)(xs), none)\n *\n *\n * @since 2.5.0\n */\nexport var findLastIndex = function (predicate) {\n  return function (as) {\n    for (var i = as.length - 1; i >= 0; i--) {\n      if (predicate(as[i])) {\n        return _.some(i);\n      }\n    }\n    return _.none;\n  };\n};\n/**\n * Insert an element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { insertAt } from 'fp-ts/ReadonlyArray'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.5.0\n */\nexport var insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as));\n  };\n};\n/**\n * Change the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { updateAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.5.0\n */\nexport var updateAt = function (i, a) {\n  return modifyAt(i, function () {\n    return a;\n  });\n};\n/**\n * Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { deleteAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.5.0\n */\nexport var deleteAt = function (i) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeDeleteAt(i, as));\n  };\n};\n/**\n * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out\n * of bounds\n *\n * @example\n * import { modifyAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * const double = (x: number): number => x * 2\n * assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))\n * assert.deepStrictEqual(modifyAt(1, double)([]), none)\n *\n * @since 2.5.0\n */\nexport var modifyAt = function (i, f) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n  };\n};\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @since 2.5.0\n */\nexport var reverse = function (as) {\n  return as.length <= 1 ? as : as.slice().reverse();\n};\n/**\n * Extracts from an array of `Either` all the `Right` elements. All the `Right` elements are extracted in order\n *\n * @example\n * import { rights } from 'fp-ts/ReadonlyArray'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @since 2.5.0\n */\nexport var rights = function (as) {\n  var r = [];\n  for (var i = 0; i < as.length; i++) {\n    var a = as[i];\n    if (a._tag === 'Right') {\n      r.push(a.right);\n    }\n  }\n  return r;\n};\n/**\n * Extracts from an array of `Either` all the `Left` elements. All the `Left` elements are extracted in order\n *\n * @example\n * import { lefts } from 'fp-ts/ReadonlyArray'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @since 2.5.0\n */\nexport var lefts = function (as) {\n  var r = [];\n  for (var i = 0; i < as.length; i++) {\n    var a = as[i];\n    if (a._tag === 'Left') {\n      r.push(a.left);\n    }\n  }\n  return r;\n};\n/**\n * Sort the elements of an array in increasing order, creating a new array\n *\n * @example\n * import { sort } from 'fp-ts/ReadonlyArray'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(sort(N.Ord)([3, 2, 1]), [1, 2, 3])\n *\n * @since 2.5.0\n */\nexport var sort = function (O) {\n  return function (as) {\n    return as.length <= 1 ? as : as.slice().sort(O.compare);\n  };\n};\n// TODO: curry and make data-last in v3\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @since 2.5.0\n */\nexport var zipWith = function (fa, fb, f) {\n  var fc = [];\n  var len = Math.min(fa.length, fb.length);\n  for (var i = 0; i < len; i++) {\n    fc[i] = f(fa[i], fb[i]);\n  }\n  return fc;\n};\nexport function zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return zipWith(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\n/**\n * The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays\n *\n * @example\n * import { unzip } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.5.0\n */\nexport var unzip = function (as) {\n  var fa = [];\n  var fb = [];\n  for (var i = 0; i < as.length; i++) {\n    fa[i] = as[i][0];\n    fb[i] = as[i][1];\n  }\n  return [fa, fb];\n};\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependAll } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.10.0\n */\nexport var prependAll = function (middle) {\n  var f = RNEA.prependAll(middle);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : as;\n  };\n};\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { intersperse } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.9.0\n */\nexport var intersperse = function (middle) {\n  var f = RNEA.intersperse(middle);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : as;\n  };\n};\n/**\n * Rotate a `ReadonlyArray` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @since 2.5.0\n */\nexport var rotate = function (n) {\n  var f = RNEA.rotate(n);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : as;\n  };\n};\nexport function elem(E) {\n  return function (a, as) {\n    if (as === undefined) {\n      var elemE_1 = elem(E);\n      return function (as) {\n        return elemE_1(a, as);\n      };\n    }\n    var predicate = function (element) {\n      return E.equals(element, a);\n    };\n    var i = 0;\n    for (; i < as.length; i++) {\n      if (predicate(as[i])) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n/**\n * Remove duplicates from an array, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyArray'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.5.0\n */\nexport var uniq = function (E) {\n  var f = RNEA.uniq(E);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : as;\n  };\n};\n/**\n * Sort the elements of an array in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import { sortBy } from 'fp-ts/ReadonlyArray'\n * import { contramap } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Person {\n *   readonly name: string\n *   readonly age: number\n * }\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))\n *\n * const sortByNameByAge = sortBy([byName, byAge])\n *\n * const persons = [{ name: 'a', age: 1 }, { name: 'b', age: 3 }, { name: 'c', age: 2 }, { name: 'b', age: 2 }]\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @since 2.5.0\n */\nexport var sortBy = function (ords) {\n  var f = RNEA.sortBy(ords);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : as;\n  };\n};\n/**\n * A useful recursion pattern for processing a `ReadonlyArray` to produce a new `ReadonlyArray`, often used for \"chopping\" up the input\n * `ReadonlyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `ReadonlyArray` and produce a\n * value and the tail of the `ReadonlyArray`.\n *\n * @example\n * import { Eq } from 'fp-ts/Eq'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * const group = <A>(S: Eq<A>): ((as: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>>) => {\n *   return RA.chop(as => {\n *     const { init, rest } = pipe(as, RA.spanLeft((a: A) => S.equals(a, as[0])))\n *     return [init, rest]\n *   })\n * }\n * assert.deepStrictEqual(group(N.Eq)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])\n *\n * @since 2.5.0\n */\nexport var chop = function (f) {\n  var g = RNEA.chop(f);\n  return function (as) {\n    return isNonEmpty(as) ? g(as) : empty;\n  };\n};\n/**\n * Splits a `ReadonlyArray` into two pieces, the first piece has max `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.5.0\n */\nexport var splitAt = function (n) {\n  return function (as) {\n    return n >= 1 && isNonEmpty(as) ? RNEA.splitAt(n)(as) : isEmpty(as) ? [as, empty] : [empty, as];\n  };\n};\n/**\n * Splits a `ReadonlyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the `ReadonlyArray`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive\n * definition of `chunksOf`; it satisfies the property that:\n *\n * ```ts\n * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))\n * ```\n *\n * whenever `n` evenly divides the length of `as`.\n *\n * @example\n * import { chunksOf } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n * @since 2.5.0\n */\nexport var chunksOf = function (n) {\n  var f = RNEA.chunksOf(n);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : empty;\n  };\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromOptionK = function (f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return fromOption(f.apply(void 0, a));\n  };\n};\nexport function comprehension(input, f, g) {\n  if (g === void 0) {\n    g = function () {\n      return true;\n    };\n  }\n  var go = function (scope, input) {\n    return isNonEmpty(input) ? flatMap(RNEA.head(input), function (a) {\n      return go(pipe(scope, append(a)), RNEA.tail(input));\n    }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : empty;\n  };\n  return go(empty, input);\n}\n/**\n * @since 2.11.0\n */\nexport var concatW = function (second) {\n  return function (first) {\n    return isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second);\n  };\n};\n/**\n * @since 2.11.0\n */\nexport var concat = concatW;\nexport function union(E) {\n  var unionE = RNEA.union(E);\n  return function (first, second) {\n    if (second === undefined) {\n      var unionE_1 = union(E);\n      return function (second) {\n        return unionE_1(second, first);\n      };\n    }\n    return isNonEmpty(first) && isNonEmpty(second) ? unionE(second)(first) : isNonEmpty(first) ? first : second;\n  };\n}\nexport function intersection(E) {\n  var elemE = elem(E);\n  return function (xs, ys) {\n    if (ys === undefined) {\n      var intersectionE_1 = intersection(E);\n      return function (ys) {\n        return intersectionE_1(ys, xs);\n      };\n    }\n    return xs.filter(function (a) {\n      return elemE(a, ys);\n    });\n  };\n}\nexport function difference(E) {\n  var elemE = elem(E);\n  return function (xs, ys) {\n    if (ys === undefined) {\n      var differenceE_1 = difference(E);\n      return function (ys) {\n        return differenceE_1(ys, xs);\n      };\n    }\n    return xs.filter(function (a) {\n      return !elemE(a, ys);\n    });\n  };\n}\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\nvar _mapWithIndex = function (fa, f) {\n  return pipe(fa, mapWithIndex(f));\n};\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\nvar _filter = function (fa, predicate) {\n  return pipe(fa, filter(predicate));\n};\nvar _filterMap = function (fa, f) {\n  return pipe(fa, filterMap(f));\n};\nvar _partition = function (fa, predicate) {\n  return pipe(fa, partition(predicate));\n};\nvar _partitionMap = function (fa, f) {\n  return pipe(fa, partitionMap(f));\n};\nvar _partitionWithIndex = function (fa, predicateWithIndex) {\n  return pipe(fa, partitionWithIndex(predicateWithIndex));\n};\nvar _partitionMapWithIndex = function (fa, f) {\n  return pipe(fa, partitionMapWithIndex(f));\n};\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\nvar _foldMap = function (M) {\n  var foldMapM = foldMap(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapM(f));\n  };\n};\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\nvar _reduceWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceWithIndex(b, f));\n};\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = foldMapWithIndex(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapWithIndexM(f));\n  };\n};\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceRightWithIndex(b, f));\n};\nvar _filterMapWithIndex = function (fa, f) {\n  return pipe(fa, filterMapWithIndex(f));\n};\nvar _filterWithIndex = function (fa, predicateWithIndex) {\n  return pipe(fa, filterWithIndex(predicateWithIndex));\n};\nvar _extend = function (fa, f) {\n  return pipe(fa, extend(f));\n};\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (ta, f) {\n    return pipe(ta, traverseWithIndexF(f));\n  };\n};\n/** @internal */\nexport var _chainRecDepthFirst = function (a, f) {\n  return pipe(a, chainRecDepthFirst(f));\n};\n/** @internal */\nexport var _chainRecBreadthFirst = function (a, f) {\n  return pipe(a, chainRecBreadthFirst(f));\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var of = RNEA.of;\n/**\n * @since 2.7.0\n */\nexport var zero = function () {\n  return empty;\n};\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n  return function (fa) {\n    return fa.concat(that());\n  };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `ReadonlyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.5.0\n */\nexport var alt = altW;\n/**\n * @since 2.5.0\n */\nexport var ap = function (fa) {\n  return flatMap(function (f) {\n    return pipe(fa, map(f));\n  });\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.flatMap((n) => [`a${n}`, `b${n}`])\n *   ),\n *   ['a1', 'b1', 'a2', 'b2', 'a3', 'b3']\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.flatMap(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return pipe(ma, chainWithIndex(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.5.0\n */\nexport var map = function (f) {\n  return function (fa) {\n    return fa.map(function (a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @category mapping\n * @since 2.5.0\n */\nexport var mapWithIndex = function (f) {\n  return function (fa) {\n    return fa.map(function (a, i) {\n      return f(i, a);\n    });\n  };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var separate = function (fa) {\n  var left = [];\n  var right = [];\n  for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {\n    var e = fa_1[_i];\n    if (e._tag === 'Left') {\n      left.push(e.left);\n    } else {\n      right.push(e.right);\n    }\n  }\n  return separated(left, right);\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filter = function (predicate) {\n  return function (as) {\n    return as.filter(predicate);\n  };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filterMapWithIndex = function (f) {\n  return function (fa) {\n    var out = [];\n    for (var i = 0; i < fa.length; i++) {\n      var optionB = f(i, fa[i]);\n      if (_.isSome(optionB)) {\n        out.push(optionB.value);\n      }\n    }\n    return out;\n  };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filterMap = function (f) {\n  return filterMapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var compact = /*#__PURE__*/filterMap(identity);\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partition = function (predicate) {\n  return partitionWithIndex(function (_, a) {\n    return predicate(a);\n  });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partitionWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    var left = [];\n    var right = [];\n    for (var i = 0; i < as.length; i++) {\n      var a = as[i];\n      if (predicateWithIndex(i, a)) {\n        right.push(a);\n      } else {\n        left.push(a);\n      }\n    }\n    return separated(left, right);\n  };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partitionMap = function (f) {\n  return partitionMapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partitionMapWithIndex = function (f) {\n  return function (fa) {\n    var left = [];\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n      var e = f(i, fa[i]);\n      if (e._tag === 'Left') {\n        left.push(e.left);\n      } else {\n        right.push(e.right);\n      }\n    }\n    return separated(left, right);\n  };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filterWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    return as.filter(function (a, i) {\n      return predicateWithIndex(i, a);\n    });\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var extend = function (f) {\n  return function (wa) {\n    return wa.map(function (_, i) {\n      return f(wa.slice(i));\n    });\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (M) {\n  return function (f) {\n    return function (fa) {\n      return fa.reduce(function (b, a, i) {\n        return M.concat(b, f(i, a));\n      }, M.empty);\n    };\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n  return reduceWithIndex(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var foldMap = function (M) {\n  var foldMapWithIndexM = foldMapWithIndex(M);\n  return function (f) {\n    return foldMapWithIndexM(function (_, a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceWithIndex = function (b, f) {\n  return function (fa) {\n    var len = fa.length;\n    var out = b;\n    for (var i = 0; i < len; i++) {\n      out = f(i, out, fa[i]);\n    }\n    return out;\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n  return reduceRightWithIndex(b, function (_, a, b) {\n    return f(a, b);\n  });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = function (b, f) {\n  return function (fa) {\n    return fa.reduceRight(function (b, a, i) {\n      return f(i, a, b);\n    }, b);\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return function (ta) {\n    return _reduce(ta, F.of(zero()), function (fas, fa) {\n      return F.ap(F.map(fas, function (as) {\n        return function (a) {\n          return pipe(as, append(a));\n        };\n      }), fa);\n    });\n  };\n};\n/**\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n  return function (f) {\n    return reduceWithIndex(F.of(zero()), function (i, fbs, a) {\n      return F.ap(F.map(fbs, function (bs) {\n        return function (b) {\n          return pipe(bs, append(b));\n        };\n      }), f(i, a));\n    });\n  };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n  var _witherF = _wither(F);\n  return function (f) {\n    return function (fa) {\n      return _witherF(fa, f);\n    };\n  };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n  var _wiltF = _wilt(F);\n  return function (f) {\n    return function (fa) {\n      return _wiltF(fa, f);\n    };\n  };\n};\n/**\n * @since 2.6.6\n */\nexport var unfold = function (b, f) {\n  var out = [];\n  var bb = b;\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    var mt = f(bb);\n    if (_.isSome(mt)) {\n      var _a = mt.value,\n        a = _a[0],\n        b_1 = _a[1];\n      out.push(a);\n      bb = b_1;\n    } else {\n      break;\n    }\n  }\n  return out;\n};\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getShow = function (S) {\n  return {\n    show: function (as) {\n      return \"[\".concat(as.map(S.show).join(', '), \"]\");\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second);\n    }\n  };\n};\n/**\n * Returns a `Monoid` for `ReadonlyArray<A>`.\n *\n * @example\n * import { getMonoid } from 'fp-ts/ReadonlyArray'\n *\n * const M = getMonoid<number>()\n * assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getMonoid = function () {\n  return {\n    concat: getSemigroup().concat,\n    empty: empty\n  };\n};\n/**\n * Derives an `Eq` over the `ReadonlyArray` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { getEq } from 'fp-ts/ReadonlyArray'\n *\n * const E = getEq(S.Eq)\n * assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)\n * assert.strictEqual(E.equals(['a'], []), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getEq = function (E) {\n  return fromEquals(function (xs, ys) {\n    return xs.length === ys.length && xs.every(function (x, i) {\n      return E.equals(x, ys[i]);\n    });\n  });\n};\n/**\n * Derives an `Ord` over the `ReadonlyArray` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/ReadonlyArray'\n * import * as S from 'fp-ts/string'\n *\n * const O = getOrd(S.Ord)\n * assert.strictEqual(O.compare(['b'], ['a']), 1)\n * assert.strictEqual(O.compare(['a'], ['a']), 0)\n * assert.strictEqual(O.compare(['a'], ['b']), -1)\n *\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getOrd = function (O) {\n  return fromCompare(function (a, b) {\n    var aLen = a.length;\n    var bLen = b.length;\n    var len = Math.min(aLen, bLen);\n    for (var i = 0; i < len; i++) {\n      var ordering = O.compare(a[i], b[i]);\n      if (ordering !== 0) {\n        return ordering;\n      }\n    }\n    return N.Ord.compare(aLen, bLen);\n  });\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionMonoid = function (E) {\n  return {\n    concat: getUnionSemigroup(E).concat,\n    empty: empty\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getIntersectionSemigroup = function (E) {\n  var intersectionE = intersection(E);\n  return {\n    concat: function (first, second) {\n      return intersectionE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getDifferenceMagma = function (E) {\n  var differenceE = difference(E);\n  return {\n    concat: function (first, second) {\n      return differenceE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = /*#__PURE__*/chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Unfoldable = {\n  URI: URI,\n  unfold: unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Zero = {\n  URI: URI,\n  zero: zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexport var guard = /*#__PURE__*/guard_(Zero, Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  alt: _alt,\n  zero: zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n  URI: URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n  URI: URI,\n  compact: compact,\n  separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n  URI: URI,\n  map: _map,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  partitionMapWithIndex: _partitionMapWithIndex,\n  partitionWithIndex: _partitionWithIndex,\n  filterMapWithIndex: _filterMapWithIndex,\n  filterWithIndex: _filterWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverse: _traverse,\n  sequence: sequence,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecDepthFirst = function (f) {\n  return function (a) {\n    var todo = __spreadArray([], f(a), true);\n    var out = [];\n    while (todo.length > 0) {\n      var e = todo.shift();\n      if (_.isLeft(e)) {\n        todo.unshift.apply(todo, f(e.left));\n      } else {\n        out.push(e.right);\n      }\n    }\n    return out;\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecDepthFirst = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap,\n  chainRec: _chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecBreadthFirst = function (f) {\n  return function (a) {\n    var initial = f(a);\n    var todo = [];\n    var out = [];\n    function go(e) {\n      if (_.isLeft(e)) {\n        f(e.left).forEach(function (v) {\n          return todo.push(v);\n        });\n      } else {\n        out.push(e.right);\n      }\n    }\n    for (var _i = 0, initial_1 = initial; _i < initial_1.length; _i++) {\n      var e = initial_1[_i];\n      go(e);\n    }\n    while (todo.length > 0) {\n      go(todo.shift());\n    }\n    return out;\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecBreadthFirst = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap,\n  chainRec: _chainRecBreadthFirst\n};\nvar _wither = /*#__PURE__*/witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/wiltDefault(Traversable, Compactable);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n  URI: URI,\n  map: _map,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  wither: _wither,\n  wilt: _wilt\n};\n/**\n * Filter values inside a context.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as T from 'fp-ts/Task'\n *\n * const filterE = RA.filterE(T.ApplicativePar)\n * async function test() {\n *   assert.deepStrictEqual(\n *     await pipe(\n *       [-1, 2, 3],\n *       filterE((n) => T.of(n > 0))\n *     )(),\n *     [2, 3]\n *   )\n * }\n * test()\n *\n * @since 2.11.0\n */\nexport var filterE = /*#__PURE__*/filterE_(Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var FromEither = {\n  URI: URI,\n  fromEither: fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = /*#__PURE__*/fromEitherK_(FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeInsertAt = RNEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n  return isNonEmpty(as) ? RNEA.unsafeUpdateAt(i, a, as) : as;\n};\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeDeleteAt = function (i, as) {\n  var xs = as.slice();\n  xs.splice(i, 1);\n  return xs;\n};\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var toArray = function (as) {\n  return as.slice();\n};\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var fromArray = function (as) {\n  return isEmpty(as) ? empty : as.slice();\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexport var empty = RNEA.empty;\nexport function every(predicate) {\n  return function (as) {\n    return as.every(predicate);\n  };\n}\n/**\n * Check if a predicate holds true for any array member.\n *\n * @example\n * import { some } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([-1, -2, 3], some(isPositive)), true)\n * assert.deepStrictEqual(pipe([-1, -2, -3], some(isPositive)), false)\n *\n * @since 2.9.0\n */\nexport var some = function (predicate) {\n  return function (as) {\n    return as.some(predicate);\n  };\n};\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexport var exists = some;\n/**\n * Places an element in between members of a `ReadonlyArray`, then folds the results using the provided `Monoid`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Monoid)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = function (M) {\n  var intercalateM = RNEA.intercalate(M);\n  return function (middle) {\n    return match(function () {\n      return M.empty;\n    }, intercalateM(middle));\n  };\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexport var chain = flatMap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `ReadonlyNonEmptyArray` module instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var range = RNEA.range;\n/**\n * Use [`prepend`](#prepend) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var cons = RNEA.cons;\n/**\n * Use [`append`](#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var snoc = RNEA.snoc;\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `RA.Functor` instead of `RA.readonlyArray`\n * (where `RA` is from `import RA from 'fp-ts/ReadonlyArray'`)\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var readonlyArray = {\n  URI: URI,\n  compact: compact,\n  separate: separate,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  mapWithIndex: _mapWithIndex,\n  partitionMapWithIndex: _partitionMapWithIndex,\n  partitionWithIndex: _partitionWithIndex,\n  filterMapWithIndex: _filterMapWithIndex,\n  filterWithIndex: _filterWithIndex,\n  alt: _alt,\n  zero: zero,\n  unfold: unfold,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  extend: _extend,\n  wither: _wither,\n  wilt: _wilt\n};","import { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEitherK as fromEitherK_ } from './FromEither';\nimport { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport * as NEA from './NonEmptyArray';\nimport * as RA from './ReadonlyArray';\nimport { separated } from './Separated';\nimport { filterE as filterE_, wiltDefault, witherDefault } from './Witherable';\nimport { guard as guard_ } from './Zero';\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Test whether an array is empty\n *\n * @example\n * import { isEmpty } from 'fp-ts/Array'\n *\n * assert.strictEqual(isEmpty([]), true)\n * assert.strictEqual(isEmpty(['a']), false)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isEmpty = function (as) {\n  return as.length === 0;\n};\n/**\n * Test whether an array is non empty narrowing down the type to `NonEmptyArray<A>`\n *\n * @example\n * import { isNonEmpty } from 'fp-ts/Array'\n *\n * assert.strictEqual(isNonEmpty([]), false)\n * assert.strictEqual(isNonEmpty(['a']), true)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isNonEmpty = NEA.isNonEmpty;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Prepend an element to the front of a `Array`, creating a new `NonEmptyArray`.\n *\n * @example\n * import { prepend } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([2, 3, 4], prepend(1)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexport var prepend = NEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @example\n * import { prependW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([2, 3, 4], prependW(\"a\")), [\"a\", 2, 3, 4]);\n *\n * @since 2.11.0\n */\nexport var prependW = NEA.prependW;\n/**\n * Append an element to the end of a `Array`, creating a new `NonEmptyArray`.\n *\n * @example\n * import { append } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], append(4)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexport var append = NEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @example\n * import { appendW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], appendW(\"d\")), [1, 2, 3, \"d\"]);\n *\n * @since 2.11.0\n */\nexport var appendW = NEA.appendW;\n/**\n * Return a `Array` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { makeBy } from 'fp-ts/Array'\n *\n * const double = (i: number): number => i * 2\n * assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])\n * assert.deepStrictEqual(makeBy(-3, double), [])\n * assert.deepStrictEqual(makeBy(4.32164, double), [0, 2, 4, 6])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var makeBy = function (n, f) {\n  return n <= 0 ? [] : NEA.makeBy(f)(n);\n};\n/**\n * Create a `Array` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { replicate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n * assert.deepStrictEqual(replicate(-3, 'a'), [])\n * assert.deepStrictEqual(replicate(2.985647, 'a'), ['a', 'a'])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var replicate = function (n, a) {\n  return makeBy(n, function () {\n    return a;\n  });\n};\nexport function fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? [a] : [];\n  };\n}\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * Create an array from an `Option`. The resulting array will contain the content of the\n * `Option` if it is `Some` and it will be empty if the `Option` is `None`.\n *\n * @example\n * import { fromOption } from 'fp-ts/Array'\n * import { option } from \"fp-ts\";\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(option.some(\"a\"), fromOption),[\"a\"])\n * assert.deepStrictEqual(pipe(option.none, fromOption),[])\n *\n * @category conversions\n * @since 2.11.0\n */\nexport var fromOption = function (ma) {\n  return _.isNone(ma) ? [] : [ma.value];\n};\n/**\n * Create an array from an `Either`. The resulting array will contain the content of the\n * `Either` if it is `Right` and it will be empty if the `Either` is `Left`.\n *\n * @example\n * import { fromEither } from 'fp-ts/Array'\n * import { either } from \"fp-ts\";\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(either.right(\"r\"), fromEither), [\"r\"]);\n * assert.deepStrictEqual(pipe(either.left(\"l\"), fromEither), []);\n *\n * @category conversions\n * @since 2.11.0\n */\nexport var fromEither = function (e) {\n  return _.isLeft(e) ? [] : [e.right];\n};\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @example\n * import { matchW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const matcherW = matchW(\n *   () => \"No elements\",\n *   (as) => as.length\n * );\n * assert.deepStrictEqual(pipe([1, 2, 3, 4], matcherW), 4);\n * assert.deepStrictEqual(pipe([], matcherW), \"No elements\");\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(as) : onEmpty();\n  };\n};\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` and returns the result.\n *\n * @example\n * import { match } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const matcher = match(\n *   () => \"No elements\",\n *   (as) => `Found ${as.length} element(s)`\n * );\n * assert.deepStrictEqual(pipe([1, 2, 3, 4], matcher), \"Found 4 element(s)\");\n * assert.deepStrictEqual(pipe([], matcher), \"No elements\");\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var match = matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft). It will work when `onEmpty` and\n * `onNonEmpty` have different return types.\n *\n * @example\n * import { matchLeftW } from 'fp-ts/Array'\n *\n * const f = matchLeftW(\n *   () => 0,\n *   (head: string, tail: string[]) => `Found \"${head}\" followed by ${tail.length} elements`\n * );\n * assert.strictEqual(f([\"a\", \"b\", \"c\"]), 'Found \"a\" followed by 2 elements');\n * assert.strictEqual(f([]), 0);\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeftW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(NEA.head(as), NEA.tail(as)) : onEmpty();\n  };\n};\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` broken into its first element and remaining elements.\n *\n * @example\n * import { matchLeft } from 'fp-ts/Array'\n *\n * const len: <A>(as: Array<A>) => number = matchLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchLeft = matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var foldLeft = matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright). It will work when `onEmpty` and\n * `onNonEmpty` have different return types.\n *\n * @example\n * import { matchRightW } from 'fp-ts/Array'\n *\n * const f = matchRightW(\n *   () => 0,\n *   (head: string[], tail: string) => `Found ${head.length} elements folllowed by \"${tail}\"`\n * );\n * assert.strictEqual(f([\"a\", \"b\", \"c\"]), 'Found 2 elements folllowed by \"c\"');\n * assert.strictEqual(f([]), 0);\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRightW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return isNonEmpty(as) ? onNonEmpty(NEA.init(as), NEA.last(as)) : onEmpty();\n  };\n};\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` broken  into its initial elements and the last element.\n *\n * @example\n * import { matchRight } from 'fp-ts/Array'\n *\n * const len: <A>(as: Array<A>) => number = matchRight(\n *   () => 0,\n *   (head, _) => 1 + len(head)\n * );\n * assert.strictEqual(len([1, 2, 3]), 3);\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchRight = matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var foldRight = matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Same as [`chain`](#chain), but passing also the index to the iterating function.\n *\n * @example\n * import { chainWithIndex, replicate } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (index: number, x: string) => replicate(2, `${x}${index}`);\n * assert.deepStrictEqual(pipe([\"a\", \"b\", \"c\"], chainWithIndex(f)), [\"a0\", \"a0\", \"b1\", \"b1\", \"c2\", \"c2\"]);\n *\n * @category sequencing\n * @since 2.7.0\n */\nexport var chainWithIndex = function (f) {\n  return function (as) {\n    var out = [];\n    for (var i = 0; i < as.length; i++) {\n      out.push.apply(out, f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * Same as `reduce` but it carries over the intermediate steps\n *\n * @example\n * import { scanLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])\n *\n * @since 2.0.0\n */\nexport var scanLeft = function (b, f) {\n  return function (as) {\n    var len = as.length;\n    var out = new Array(len + 1);\n    out[0] = b;\n    for (var i = 0; i < len; i++) {\n      out[i + 1] = f(out[i], as[i]);\n    }\n    return out;\n  };\n};\n/**\n * Fold an array from the right, keeping all intermediate results instead of only the final result\n *\n * @example\n * import { scanRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])\n *\n * @since 2.0.0\n */\nexport var scanRight = function (b, f) {\n  return function (as) {\n    var len = as.length;\n    var out = new Array(len + 1);\n    out[len] = b;\n    for (var i = len - 1; i >= 0; i--) {\n      out[i] = f(as[i], out[i + 1]);\n    }\n    return out;\n  };\n};\n/**\n * Calculate the number of elements in a `Array`.\n *\n * @example\n * import { size } from 'fp-ts/Array'\n *\n * assert.strictEqual(size([\"a\",\"b\",\"c\"]),3)\n *\n * @since 2.10.0\n */\nexport var size = function (as) {\n  return as.length;\n};\n/**\n * Test whether an array contains a particular index\n *\n * @example\n * import { isOutOfBound } from 'fp-ts/Array'\n *\n * assert.strictEqual(isOutOfBound(1,[\"a\",\"b\",\"c\"]),false)\n * assert.strictEqual(isOutOfBound(-1,[\"a\",\"b\",\"c\"]),true)\n * assert.strictEqual(isOutOfBound(3,[\"a\",\"b\",\"c\"]),true)\n *\n * @since 2.0.0\n */\nexport var isOutOfBound = NEA.isOutOfBound;\n// TODO: remove non-curried overloading in v3\n/**\n * This function provides a safe way to read a value at a particular index from an array.\n * It returns a `none` if the index is out of bounds, and a `some` of the element if the\n * index is valid.\n *\n * @example\n * import { lookup } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(1)), some(2))\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(3)), none)\n *\n * @since 2.0.0\n */\nexport var lookup = RA.lookup;\n/**\n * Get the first element in an array, or `None` if the array is empty\n *\n * @example\n * import { head } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(head([1, 2, 3]), some(1))\n * assert.deepStrictEqual(head([]), none)\n *\n * @since 2.0.0\n */\nexport var head = RA.head;\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @since 2.0.0\n */\nexport var last = RA.last;\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @since 2.0.0\n */\nexport var tail = function (as) {\n  return isNonEmpty(as) ? _.some(NEA.tail(as)) : _.none;\n};\n/**\n * Get all but the last element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { init } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @since 2.0.0\n */\nexport var init = function (as) {\n  return isNonEmpty(as) ? _.some(NEA.init(as)) : _.none;\n};\n/**\n * Keep only a max number of elements from the start of an `Array`, creating a new `Array`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { takeLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeLeft(2)([1, 2, 3, 4, 5]), [1, 2]);\n * assert.deepStrictEqual(takeLeft(7)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n * assert.deepStrictEqual(takeLeft(0)([1, 2, 3, 4, 5]), []);\n * assert.deepStrictEqual(takeLeft(-1)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n *\n * @since 2.0.0\n */\nexport var takeLeft = function (n) {\n  return function (as) {\n    return isOutOfBound(n, as) ? copy(as) : as.slice(0, n);\n  };\n};\n/**\n * Keep only a max number of elements from the end of an `Array`, creating a new `Array`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { takeRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5]);\n * assert.deepStrictEqual(takeRight(7)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n * assert.deepStrictEqual(takeRight(0)([1, 2, 3, 4, 5]), []);\n * assert.deepStrictEqual(takeRight(-1)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n *\n * @since 2.0.0\n */\nexport var takeRight = function (n) {\n  return function (as) {\n    return isOutOfBound(n, as) ? copy(as) : n === 0 ? [] : as.slice(-n);\n  };\n};\nexport function takeLeftWhile(predicate) {\n  return function (as) {\n    var out = [];\n    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n      var a = as_1[_i];\n      if (!predicate(a)) {\n        break;\n      }\n      out.push(a);\n    }\n    return out;\n  };\n}\nvar spanLeftIndex = function (as, predicate) {\n  var l = as.length;\n  var i = 0;\n  for (; i < l; i++) {\n    if (!predicate(as[i])) {\n      break;\n    }\n  }\n  return i;\n};\nexport function spanLeft(predicate) {\n  return function (as) {\n    var _a = splitAt(spanLeftIndex(as, predicate))(as),\n      init = _a[0],\n      rest = _a[1];\n    return {\n      init: init,\n      rest: rest\n    };\n  };\n}\n/**\n * Creates a new `Array` which is a copy of the input dropping a max number of elements from the start.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { dropLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3]);\n * assert.deepStrictEqual(dropLeft(5)([1, 2, 3]), []);\n * assert.deepStrictEqual(dropLeft(0)([1, 2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(dropLeft(-2)([1, 2, 3]), [1, 2, 3]);\n *\n * @since 2.0.0\n */\nexport var dropLeft = function (n) {\n  return function (as) {\n    return n <= 0 || isEmpty(as) ? copy(as) : n >= as.length ? [] : as.slice(n, as.length);\n  };\n};\n/**\n * Creates a new `Array` which is a copy of the input dropping a max number of elements from the end.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { dropRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropRight(2)([1, 2, 3]), [1]);\n * assert.deepStrictEqual(dropRight(5)([1, 2, 3]), []);\n * assert.deepStrictEqual(dropRight(0)([1, 2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(dropRight(-2)([1, 2, 3]), [1, 2, 3]);\n *\n * @since 2.0.0\n */\nexport var dropRight = function (n) {\n  return function (as) {\n    return n <= 0 || isEmpty(as) ? copy(as) : n >= as.length ? [] : as.slice(0, as.length - n);\n  };\n};\nexport function dropLeftWhile(predicate) {\n  return function (as) {\n    return as.slice(spanLeftIndex(as, predicate));\n  };\n}\n/**\n * `findIndex` returns an `Option` containing the first index for which a predicate holds.\n * It returns `None` if no element satisfies the predicate.\n * Similar to [`findFirst`](#findFirst) but returning the index instead of the element.\n *\n * @example\n * import { findIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.0.0\n */\nexport var findIndex = RA.findIndex;\nexport function findFirst(predicate) {\n  return RA.findFirst(predicate);\n}\n/**\n * Given a selector function which takes an element and returns an option,\n * this function applies the selector to each element of the array and\n * returns the first `Some` result. Otherwise it returns `None`.\n *\n * @example\n * import { findFirstMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string;\n *   readonly age: number;\n * }\n *\n * const persons: Array<Person> = [\n *   { name: \"John\", age: 16 },\n *   { name: \"Mary\", age: 45 },\n *   { name: \"Joey\", age: 28 },\n * ];\n *\n * const nameOfPersonAbove18 = (p: Person) => (p.age <= 18 ? none : some(p.name));\n * const nameOfPersonAbove70 = (p: Person) => (p.age <= 70 ? none : some(p.name));\n * assert.deepStrictEqual(findFirstMap(nameOfPersonAbove18)(persons), some(\"Mary\"));\n * assert.deepStrictEqual(findFirstMap(nameOfPersonAbove70)(persons), none);\n *\n * @since 2.0.0\n */\nexport var findFirstMap = RA.findFirstMap;\nexport function findLast(predicate) {\n  return RA.findLast(predicate);\n}\n/**\n * Given a selector function which takes an element and returns an option,\n * this function applies the selector to each element of the array starting from the\n * end and returns the last `Some` result. Otherwise it returns `None`.\n *\n * @example\n * import { findLastMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string;\n *   readonly age: number;\n * }\n *\n * const persons: Array<Person> = [\n *   { name: \"John\", age: 16 },\n *   { name: \"Mary\", age: 45 },\n *   { name: \"Joey\", age: 28 },\n * ];\n *\n * const nameOfPersonAbove18 = (p: Person) => (p.age <= 18 ? none : some(p.name));\n * const nameOfPersonAbove70 = (p: Person) => (p.age <= 70 ? none : some(p.name));\n * assert.deepStrictEqual(findLastMap(nameOfPersonAbove18)(persons), some(\"Joey\"));\n * assert.deepStrictEqual(findLastMap(nameOfPersonAbove70)(persons), none);\n *\n * @since 2.0.0\n */\nexport var findLastMap = RA.findLastMap;\n/**\n * Returns the index of the last element of the list which matches the predicate.\n * It returns an `Option` containing the index or `None` if not found.\n *\n * @example\n * import { findLastIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   readonly a: number\n *   readonly b: number\n * }\n * const xs: Array<X> = [{ a: 1, b: 0 }, { a: 1, b: 1 }]\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 1)(xs), some(1))\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 4)(xs), none)\n *\n * @since 2.0.0\n */\nexport var findLastIndex = RA.findLastIndex;\n/**\n * This function takes an array and makes a new array containing the same elements.\n *\n * @since 2.0.0\n */\nexport var copy = function (as) {\n  return as.slice();\n};\n/**\n * Insert an element at the specified index, creating a new array,\n * or returning `None` if the index is out of bounds.\n *\n * @example\n * import { insertAt } from 'fp-ts/Array'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.0.0\n */\nexport var insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some(unsafeInsertAt(i, a, as));\n  };\n};\n/**\n * Change the element at the specified index, creating a new array,\n * or returning `None` if the index is out of bounds.\n *\n * @example\n * import { updateAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.0.0\n */\nexport var updateAt = function (i, a) {\n  return modifyAt(i, function () {\n    return a;\n  });\n};\n/**\n * Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds.\n *\n * @example\n * import { deleteAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.0.0\n */\nexport var deleteAt = function (i) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeDeleteAt(i, as));\n  };\n};\n/**\n * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out\n * of bounds.\n *\n * @example\n * import { modifyAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * const double = (x: number): number => x * 2\n * assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))\n * assert.deepStrictEqual(modifyAt(1, double)([]), none)\n *\n * @since 2.0.0\n */\nexport var modifyAt = function (i, f) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n  };\n};\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @since 2.0.0\n */\nexport var reverse = function (as) {\n  return isEmpty(as) ? [] : as.slice().reverse();\n};\n/**\n * Takes an `Array` of `Either` and produces a new `Array` containing\n * the values of all the `Right` elements in the same order.\n *\n * @example\n * import { rights } from 'fp-ts/Array'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @since 2.0.0\n */\nexport var rights = function (as) {\n  var r = [];\n  for (var i = 0; i < as.length; i++) {\n    var a = as[i];\n    if (a._tag === 'Right') {\n      r.push(a.right);\n    }\n  }\n  return r;\n};\n/**\n * Takes an `Array` of `Either` and produces a new `Array` containing\n * the values of all the `Left` elements in the same order.\n *\n * @example\n * import { lefts } from 'fp-ts/Array'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @since 2.0.0\n */\nexport var lefts = function (as) {\n  var r = [];\n  for (var i = 0; i < as.length; i++) {\n    var a = as[i];\n    if (a._tag === 'Left') {\n      r.push(a.left);\n    }\n  }\n  return r;\n};\n/**\n * Sort the elements of an array in increasing order, creating a new array\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(sort(N.Ord)([3, 2, 1]), [1, 2, 3])\n *\n * @since 2.0.0\n */\nexport var sort = function (O) {\n  return function (as) {\n    return as.length <= 1 ? copy(as) : as.slice().sort(O.compare);\n  };\n};\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @since 2.0.0\n */\nexport var zipWith = function (fa, fb, f) {\n  var fc = [];\n  var len = Math.min(fa.length, fb.length);\n  for (var i = 0; i < len; i++) {\n    fc[i] = f(fa[i], fb[i]);\n  }\n  return fc;\n};\nexport function zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return zipWith(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\n/**\n * The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays\n *\n * @example\n * import { unzip } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.0.0\n */\nexport var unzip = function (as) {\n  var fa = [];\n  var fb = [];\n  for (var i = 0; i < as.length; i++) {\n    fa[i] = as[i][0];\n    fb[i] = as[i][1];\n  }\n  return [fa, fb];\n};\n/**\n * Creates a new `Array`, prepending an element to every member of the input `Array`.\n *\n * @example\n * import { prependAll } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.10.0\n */\nexport var prependAll = function (middle) {\n  var f = NEA.prependAll(middle);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : [];\n  };\n};\n/**\n * Creates a new `Array` placing an element in between members of the input `Array`.\n *\n * @example\n * import { intersperse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.9.0\n */\nexport var intersperse = function (middle) {\n  var f = NEA.intersperse(middle);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : copy(as);\n  };\n};\n/**\n * Creates a new `Array` rotating the input `Array` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @since 2.0.0\n */\nexport var rotate = function (n) {\n  var f = NEA.rotate(n);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : copy(as);\n  };\n};\n// TODO: remove non-curried overloading in v3\n/**\n * Test if a value is a member of an `Array`. Takes a `Eq<A>` as a single\n * argument which returns the function to use to search for a value of type `A` in\n * an `Array<A>`.\n *\n * @example\n * import { elem } from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(2)), true)\n * assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(0)), false)\n *\n * @since 2.0.0\n */\nexport var elem = RA.elem;\n/**\n * Creates a new `Array` removing duplicate elements, keeping the first occurrence of an element,\n * based on a `Eq<A>`.\n *\n * @example\n * import { uniq } from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.0.0\n */\nexport var uniq = function (E) {\n  var f = NEA.uniq(E);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : copy(as);\n  };\n};\n/**\n * Sort the elements of an array in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import { sortBy } from 'fp-ts/Array'\n * import { contramap } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Person {\n *   readonly name: string\n *   readonly age: number\n * }\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))\n *\n * const sortByNameByAge = sortBy([byName, byAge])\n *\n * const persons = [{ name: 'a', age: 1 }, { name: 'b', age: 3 }, { name: 'c', age: 2 }, { name: 'b', age: 2 }]\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @since 2.0.0\n */\nexport var sortBy = function (ords) {\n  var f = NEA.sortBy(ords);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : copy(as);\n  };\n};\n/**\n * A useful recursion pattern for processing an array to produce a new array, often used for \"chopping\" up the input\n * array. Typically chop is called with some function that will consume an initial prefix of the array and produce a\n * value and the rest of the array.\n *\n * @example\n * import { Eq } from 'fp-ts/Eq'\n * import * as A from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * const group = <A>(S: Eq<A>): ((as: Array<A>) => Array<Array<A>>) => {\n *   return A.chop(as => {\n *     const { init, rest } = pipe(as, A.spanLeft((a: A) => S.equals(a, as[0])))\n *     return [init, rest]\n *   })\n * }\n * assert.deepStrictEqual(group(N.Eq)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])\n *\n * @since 2.0.0\n */\nexport var chop = function (f) {\n  var g = NEA.chop(f);\n  return function (as) {\n    return isNonEmpty(as) ? g(as) : [];\n  };\n};\n/**\n * Splits an `Array` into two pieces, the first piece has max `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.0.0\n */\nexport var splitAt = function (n) {\n  return function (as) {\n    return n >= 1 && isNonEmpty(as) ? NEA.splitAt(n)(as) : isEmpty(as) ? [copy(as), []] : [[], copy(as)];\n  };\n};\n/**\n * Splits an array into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the array. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive\n * definition of `chunksOf`; it satisfies the property that\n *\n * ```ts\n * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))\n * ```\n *\n * whenever `n` evenly divides the length of `xs`.\n *\n * @example\n * import { chunksOf } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n * @since 2.0.0\n */\nexport var chunksOf = function (n) {\n  var f = NEA.chunksOf(n);\n  return function (as) {\n    return isNonEmpty(as) ? f(as) : [];\n  };\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromOptionK = function (f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return fromOption(f.apply(void 0, a));\n  };\n};\nexport function comprehension(input, f, g) {\n  if (g === void 0) {\n    g = function () {\n      return true;\n    };\n  }\n  var go = function (scope, input) {\n    return isNonEmpty(input) ? flatMap(NEA.head(input), function (a) {\n      return go(pipe(scope, append(a)), NEA.tail(input));\n    }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : [];\n  };\n  return go([], input);\n}\n/**\n * @since 2.11.0\n */\nexport var concatW = function (second) {\n  return function (first) {\n    return isEmpty(first) ? copy(second) : isEmpty(second) ? copy(first) : first.concat(second);\n  };\n};\n/**\n * @since 2.11.0\n */\nexport var concat = concatW;\nexport function union(E) {\n  var unionE = NEA.union(E);\n  return function (first, second) {\n    if (second === undefined) {\n      var unionE_1 = union(E);\n      return function (second) {\n        return unionE_1(second, first);\n      };\n    }\n    return isNonEmpty(first) && isNonEmpty(second) ? unionE(second)(first) : isNonEmpty(first) ? copy(first) : copy(second);\n  };\n}\nexport function intersection(E) {\n  var elemE = elem(E);\n  return function (xs, ys) {\n    if (ys === undefined) {\n      var intersectionE_1 = intersection(E);\n      return function (ys) {\n        return intersectionE_1(ys, xs);\n      };\n    }\n    return xs.filter(function (a) {\n      return elemE(a, ys);\n    });\n  };\n}\nexport function difference(E) {\n  var elemE = elem(E);\n  return function (xs, ys) {\n    if (ys === undefined) {\n      var differenceE_1 = difference(E);\n      return function (ys) {\n        return differenceE_1(ys, xs);\n      };\n    }\n    return xs.filter(function (a) {\n      return !elemE(a, ys);\n    });\n  };\n}\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return pipe(fa, mapWithIndex(f));\n};\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\n/* istanbul ignore next */\nvar _filter = function (fa, predicate) {\n  return pipe(fa, filter(predicate));\n};\n/* istanbul ignore next */\nvar _filterMap = function (fa, f) {\n  return pipe(fa, filterMap(f));\n};\n/* istanbul ignore next */\nvar _partition = function (fa, predicate) {\n  return pipe(fa, partition(predicate));\n};\n/* istanbul ignore next */\nvar _partitionMap = function (fa, f) {\n  return pipe(fa, partitionMap(f));\n};\n/* istanbul ignore next */\nvar _partitionWithIndex = function (fa, predicateWithIndex) {\n  return pipe(fa, partitionWithIndex(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar _partitionMapWithIndex = function (fa, f) {\n  return pipe(fa, partitionMapWithIndex(f));\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = foldMap(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = foldMapWithIndex(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceRightWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _filterMapWithIndex = function (fa, f) {\n  return pipe(fa, filterMapWithIndex(f));\n};\n/* istanbul ignore next */\nvar _filterWithIndex = function (fa, predicateWithIndex) {\n  return pipe(fa, filterWithIndex(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar _extend = function (fa, f) {\n  return pipe(fa, extend(f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (ta, f) {\n    return pipe(ta, traverseWithIndexF(f));\n  };\n};\nvar _chainRecDepthFirst = RA._chainRecDepthFirst;\nvar _chainRecBreadthFirst = RA._chainRecBreadthFirst;\n/**\n * Given an element of the base type, `of` builds an `Array` containing just that\n * element of the base type (this is useful for building a `Monad`).\n *\n * @example\n * import { of } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(of(\"a\"), [\"a\"]);\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var of = NEA.of;\n/**\n * Makes an empty `Array`, useful for building a [`Monoid`](#Monoid)\n *\n * @since 2.7.0\n */\nexport var zero = function () {\n  return [];\n};\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: Array<A>) => Array<B>`.\n * In practice it applies the base function to each element of the array and collects the\n * results in a new array.\n *\n * @example\n * import { map } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (n: number) => n * 2;\n * assert.deepStrictEqual(pipe([1, 2, 3], map(f)), [2, 4, 6]);\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) {\n  return function (fa) {\n    return fa.map(function (a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @example\n * import { ap, map, of } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * // a curried function with 3 input parameteres\n * const f = (s1: string) => (n: number) => (s2: string) => s1 + n + s2;\n *\n * // let's use `ap` to iterate `f` over an array for each input parameter\n * assert.deepStrictEqual(pipe([\"a\", \"b\"], map(f), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"])), [\n *   \"a1😀\", \"a1😫\", \"a1😎\",\n *   \"a2😀\", \"a2😫\", \"a2😎\",\n *   \"b1😀\", \"b1😫\", \"b1😎\",\n *   \"b2😀\", \"b2😫\", \"b2😎\",\n * ]);\n *\n * // given Array implements the Applicative interface with the `of` method,\n * // we can write exactly the same thing in a more symmetric way\n * // using `of` on `f` and `ap` on each array in input\n * assert.deepStrictEqual(\n *   pipe(of(f), ap([\"a\", \"b\"]), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"])),\n *   pipe([\"a\", \"b\"], map(f), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"]))\n * );\n *\n * @since 2.0.0\n */\nexport var ap = function (fa) {\n  return flatMap(function (f) {\n    return pipe(fa, map(f));\n  });\n};\n/**\n * Composes computations in sequence, using the return value of one computation to\n * determine the next computation.\n *\n * In other words it takes a function `f` that produces an array from a single element of\n * the base type `A` and returns a new function which applies `f` to each element of the\n * input array (like [`map`](#map)) and, instead of returning an array of arrays, concatenates the\n * results into a single array (like [`flatten`](#flatten)).\n *\n * @example\n * import { flatMap, map, replicate } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (n: number) => replicate(n, `${n}`);\n * assert.deepStrictEqual(pipe([1, 2, 3], map(f)), [[\"1\"], [\"2\", \"2\"], [\"3\", \"3\", \"3\"]]);\n * assert.deepStrictEqual(pipe([1, 2, 3], flatMap(f)), [\"1\", \"2\", \"2\", \"3\", \"3\", \"3\"]);\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return pipe(ma, chainWithIndex(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * Takes an array of arrays of `A` and flattens them into an array of `A`\n * by concatenating the elements of each array in order.\n *\n * @example\n * import { flatten } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(flatten([[\"a\"], [\"b\", \"c\"], [\"d\", \"e\", \"f\"]]), [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]);\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/flatMap(identity);\n/**\n * Same as [`map`](#map), but the iterating function takes both the index and the value\n * of the element.\n *\n * @example\n * import { mapWithIndex } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (i: number, s: string) => `${s} - ${i}`;\n * assert.deepStrictEqual(pipe([\"a\", \"b\", \"c\"], mapWithIndex(f)), [\"a - 0\", \"b - 1\", \"c - 2\"]);\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var mapWithIndex = function (f) {\n  return function (fa) {\n    return fa.map(function (a, i) {\n      return f(i, a);\n    });\n  };\n};\n/**\n * Maps an array with an iterating function that takes the index and the value of\n * each element and returns an `Option`. It keeps only the `Some` values discarding\n * the `None`s.\n *\n * Same as [`filterMap`](#filterMap), but with an iterating function which takes also\n * the index as input.\n *\n * @example\n * import { filterMapWithIndex } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n * import { option } from \"fp-ts\";\n *\n * const f = (i: number, s: string) => (i % 2 === 1 ? option.some(s.toUpperCase()) : option.none);\n * assert.deepStrictEqual(pipe([\"a\", \"no\", \"neither\", \"b\"], filterMapWithIndex(f)), [\"NO\", \"B\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filterMapWithIndex = function (f) {\n  return function (fa) {\n    var out = [];\n    for (var i = 0; i < fa.length; i++) {\n      var optionB = f(i, fa[i]);\n      if (_.isSome(optionB)) {\n        out.push(optionB.value);\n      }\n    }\n    return out;\n  };\n};\n/**\n * Maps an array with an iterating function that returns an `Option`\n * and it keeps only the `Some` values discarding the `None`s.\n *\n * @example\n * import { filterMap } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n * import { option } from \"fp-ts\";\n *\n * const f = (s: string) => s.length === 1 ? option.some(s.toUpperCase()) : option.none;\n * assert.deepStrictEqual(pipe([\"a\", \"no\", \"neither\", \"b\"], filterMap(f)), [\"A\", \"B\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filterMap = function (f) {\n  return filterMapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * Compact an array of `Option`s discarding the `None` values and\n * keeping the `Some` values. It returns a new array containing the values of\n * the `Some` options.\n *\n * @example\n * import { compact } from 'fp-ts/Array'\n * import { option } from \"fp-ts\";\n *\n * assert.deepStrictEqual(compact([option.some(\"a\"), option.none, option.some(\"b\")]), [\"a\", \"b\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var compact = /*#__PURE__*/filterMap(identity);\n/**\n * Separate an array of `Either`s into `Left`s and `Right`s, creating two new arrays:\n * one containing all the left values and one containing all the right values.\n *\n * @example\n * import { separate } from 'fp-ts/Array'\n * import { either } from \"fp-ts\";\n *\n * assert.deepStrictEqual(separate([either.right(\"r1\"), either.left(\"l1\"), either.right(\"r2\")]), {\n *   left: [\"l1\"],\n *   right: [\"r1\", \"r2\"],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var separate = function (fa) {\n  var left = [];\n  var right = [];\n  for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {\n    var e = fa_1[_i];\n    if (e._tag === 'Left') {\n      left.push(e.left);\n    } else {\n      right.push(e.right);\n    }\n  }\n  return separated(left, right);\n};\n/**\n * Given an iterating function that is a `Predicate` or a `Refinement`,\n * `filter` creates a new `Array` containing the elements of the original\n * `Array` for which the iterating function is `true`.\n *\n * @example\n * import { filter } from 'fp-ts/Array'\n * import { isString } from \"fp-ts/lib/string\";\n *\n * assert.deepStrictEqual(filter(isString)([\"a\", 1, {}, \"b\", 5]), [\"a\", \"b\"]);\n * assert.deepStrictEqual(filter((x:number) => x > 0)([-3, 1, -2, 5]), [1, 5]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filter = function (predicate) {\n  return function (as) {\n    return as.filter(predicate);\n  };\n};\n/**\n * Given an iterating function that is a `Predicate` or a `Refinement`,\n * `partition` creates two new `Array`s: `right` containing the elements of the original\n * `Array` for which the iterating function is `true`, `left` containing the elements\n * for which it is false.\n *\n * @example\n * import { partition } from 'fp-ts/Array'\n * import { isString } from \"fp-ts/lib/string\";\n *\n * assert.deepStrictEqual(partition(isString)([\"a\", 1, {}, \"b\", 5]), { left: [1, {}, 5], right: [\"a\", \"b\"] });\n * assert.deepStrictEqual(partition((x: number) => x > 0)([-3, 1, -2, 5]), { left: [-3, -2], right: [1, 5] });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partition = function (predicate) {\n  return partitionWithIndex(function (_, a) {\n    return predicate(a);\n  });\n};\n/**\n * Same as [`partition`](#partition), but passing also the index to the iterating function.\n *\n * @example\n * import { partitionWithIndex } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(partitionWithIndex((index, x: number) => index < 3 && x > 0)([-2, 5, 6, 7]), {\n *   left: [-2, 7],\n *   right: [5, 6],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    var left = [];\n    var right = [];\n    for (var i = 0; i < as.length; i++) {\n      var b = as[i];\n      if (predicateWithIndex(i, b)) {\n        right.push(b);\n      } else {\n        left.push(b);\n      }\n    }\n    return separated(left, right);\n  };\n};\n/**\n * Given an iterating function that returns an `Either`,\n * `partitionMap` applies the iterating function to each element and it creates two `Array`s:\n * `right` containing the values of `Right` results, `left` containing the values of `Left` results.\n *\n * @example\n * import { partitionMap } from 'fp-ts/Array'\n * import { Either, left, right } from \"fp-ts/lib/Either\";\n *\n * const upperIfString = <B>(x: B): Either<B, string> =>\n *   typeof x === \"string\" ? right(x.toUpperCase()) : left(x);\n * assert.deepStrictEqual(partitionMap(upperIfString)([-2, \"hello\", 6, 7, \"world\"]), {\n *   left: [-2, 6, 7],\n *   right: [ 'HELLO', 'WORLD' ],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionMap = function (f) {\n  return partitionMapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * Same as [`partitionMap`](#partitionMap), but passing also the index to the iterating function.\n *\n * @example\n * import { partitionMapWithIndex } from 'fp-ts/Array'\n * import { Either, left, right } from \"fp-ts/lib/Either\";\n *\n * const upperIfStringBefore3 = <B>(index: number, x: B): Either<B, string> =>\n *   index < 3 && typeof x === \"string\" ? right(x.toUpperCase()) : left(x);\n * assert.deepStrictEqual(partitionMapWithIndex(upperIfStringBefore3)([-2, \"hello\", 6, 7, \"world\"]), {\n *   left: [-2, 6, 7, \"world\"],\n *   right: [\"HELLO\"],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionMapWithIndex = function (f) {\n  return function (fa) {\n    var left = [];\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n      var e = f(i, fa[i]);\n      if (e._tag === 'Left') {\n        left.push(e.left);\n      } else {\n        right.push(e.right);\n      }\n    }\n    return separated(left, right);\n  };\n};\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n  return function (fa) {\n    return fa.concat(that());\n  };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `Array` concatenates the inputs into a single array.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var alt = altW;\n/**\n * Same as [`filter`](#filter), but passing also the index to the iterating function.\n *\n * @example\n * import { filterWithIndex } from 'fp-ts/Array';\n *\n * const f = (index: number, x: number) => x > 0 && index <= 2;\n * assert.deepStrictEqual(filterWithIndex(f)([-3, 1, -2, 5]), [1]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filterWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    return as.filter(function (b, i) {\n      return predicateWithIndex(i, b);\n    });\n  };\n};\n/**\n * Given an iterating function that takes `Array<A>` as input, `extend` returns\n * an array containing the results of the iterating function applied to the whole input\n * `Array`, then to the input `Array` without the first element, then to the input\n * `Array` without the first two elements, etc.\n *\n * @example\n * import { extend } from 'fp-ts/Array'\n *\n * const f = (a: string[]) => a.join(\",\");\n * assert.deepStrictEqual(extend(f)([\"a\", \"b\", \"c\"]), [\"a,b,c\", \"b,c\", \"c\"]);\n *\n * @since 2.0.0\n */\nexport var extend = function (f) {\n  return function (wa) {\n    return wa.map(function (_, i) {\n      return f(wa.slice(i));\n    });\n  };\n};\n/**\n * `duplicate` returns an array containing the whole input `Array`,\n * then to the input `Array` dropping the first element, then to the input\n * `Array` dropping the first two elements, etc.\n *\n * @example\n * import { duplicate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(duplicate([\"a\", \"b\", \"c\"]), [[\"a\", \"b\", \"c\"], [\"b\", \"c\"], [\"c\"]]);\n *\n * @since 2.0.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * Map and fold an `Array`.\n * Map the `Array` passing each value to the iterating function.\n * Then fold the results using the provided `Monoid`.\n *\n * @example\n * import { foldMap } from 'fp-ts/Array'\n *\n * const monoid = { concat: (a: string, b: string) => a + b, empty: \"\" };\n * const f = (s: string) => s.toUpperCase()\n * assert.deepStrictEqual(foldMap(monoid)(f)([\"a\", \"b\", \"c\"]), \"ABC\");\n *\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = RA.foldMap;\n/**\n * Same as [`foldMap`](#foldMap) but passing also the index to the iterating function.\n *\n * @example\n * import { foldMapWithIndex } from 'fp-ts/Array'\n *\n * const monoid = { concat: (a: string, b: string) => a + b, empty: \"\" };\n * const f = (index:number, s: string) => `${s.toUpperCase()}(${index})`\n * assert.deepStrictEqual(foldMapWithIndex(monoid)(f)([\"a\", \"b\", \"c\"]), \"A(0)B(1)C(2)\");\n *\n * @category folding\n * @since 2.0.0\n */\nexport var foldMapWithIndex = RA.foldMapWithIndex;\n/**\n * Reduces an `Array`.\n *\n * `reduce` executes the supplied iterating function on each element of the array,\n * in order, passing in the element and the return value from the calculation on the preceding element.\n *\n * The first time that the iterating function is called there is no \"return value of the\n * previous calculation\", the initial value is used in its place.\n *\n * @example\n * import { reduce } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reduce(5, (acc: number, cur: number) => acc * cur)([2, 3]), 5 * 2 * 3);\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = RA.reduce;\n/**\n * Same as [`reduce`](#reduce) but passing also the index to the iterating function.\n *\n * @example\n * import { reduceWithIndex } from 'fp-ts/Array'\n *\n * const f = (index: number, acc: string, cur: unknown) =>\n *   acc + (typeof cur === \"string\" ? cur.toUpperCase() + index : \"\");\n * assert.deepStrictEqual(reduceWithIndex(\"\", f)([2, \"a\", \"b\", null]), \"A1B2\");\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduceWithIndex = RA.reduceWithIndex;\n/**\n * Same as [`reduce`](#reduce) but applied from the end to the start.\n *\n * *Note*: the iterating function in this case takes the accumulator as the last argument.\n *\n * @example\n * import { reduceRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reduceRight(\"\", (cur: string, acc: string) => acc + cur)([\"a\", \"b\", \"c\"]), \"cba\");\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = RA.reduceRight;\n/**\n * Same as [`reduceRight`](#reduceRight) but passing also the index to the iterating function.\n *\n * @example\n * import { reduceRightWithIndex } from 'fp-ts/Array'\n *\n * const f = (index: number, cur: unknown, acc: string) =>\n *   acc + (typeof cur === \"string\" ? cur.toUpperCase() + index : \"\");\n * assert.deepStrictEqual(reduceRightWithIndex(\"\", f)([2, \"a\", \"b\", null]), \"B2A1\");\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRightWithIndex = RA.reduceRightWithIndex;\n/**\n * Given an iterating function that returns a `HKT` (higher kinded type), `traverse`\n * applies the iterating function to each element of the `Array` and then [`sequence`](#sequence)-s\n * the results using the provided `Applicative`.\n *\n * E.g. suppose you have an `Array` and you want to format each element with a function\n * that returns a result or an error as `f = (a: A) => Either<Error, B>`, using `traverse`\n * you can apply `f` to all elements and directly obtain as a result an `Either<Error,Array<B>>`\n * i.e. an `Array<B>` if all the results are `B`, or an `Error` if some of the results\n * are `Error`s.\n *\n * @example\n * import { traverse } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * const f = (x: unknown) =>\n *   typeof x === \"string\" ? right(x.toUpperCase()) : left(new Error(\"not a string\"));\n * assert.deepStrictEqual(traverse(Applicative)(f)([\"a\", \"b\"]), right([\"A\", \"B\"]));\n * assert.deepStrictEqual(traverse(Applicative)(f)([\"a\", 5]), left(new Error(\"not a string\")));\n *\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\n/**\n * `sequence` takes an `Array` where elements are `HKT<A>` (higher kinded type) and,\n * using an applicative of that `HKT`, returns an `HKT` of `Array<A>`.\n * E.g. it can turn an `Array<Either<Error, string>>` into an `Either<Error, Array<string>>`.\n *\n * `sequence` requires an `Applicative` of the `HKT` you are targeting, e.g. to turn an\n * `Array<Either<E, A>>` into an `Either<E, Array<A>>`, it needs an\n * `Applicative` for `Either`, to to turn an `Array<Option<A>>` into an `Option<Array<A>>`,\n * it needs an `Applicative` for `Option`.\n *\n * @example\n * import { sequence } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * assert.deepStrictEqual(sequence(Applicative)([right(\"a\"), right(\"b\")]), right([\"a\", \"b\"]));\n * assert.deepStrictEqual(\n *   sequence(Applicative)([right(\"a\"), left(new Error(\"not a string\"))]),\n *   left(new Error(\"not a string\"))\n * );\n *\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return function (ta) {\n    return _reduce(ta, F.of(zero()), function (fas, fa) {\n      return F.ap(F.map(fas, function (as) {\n        return function (a) {\n          return pipe(as, append(a));\n        };\n      }), fa);\n    });\n  };\n};\n/**\n * Same as [`traverse`](#traverse) but passing also the index to the iterating function.\n *\n * @example\n * import { traverseWithIndex } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * const f = (index:number, x:unknown) =>\n *   typeof x === \"string\" ? right(x.toUpperCase() + index) : left(new Error(\"not a string\"));\n * assert.deepStrictEqual(traverseWithIndex(Applicative)(f)([\"a\", \"b\"]), right([\"A0\", \"B1\"]));\n * assert.deepStrictEqual(traverseWithIndex(Applicative)(f)([\"a\", 5]), left(new Error(\"not a string\")));\n *\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n  return function (f) {\n    return reduceWithIndex(F.of(zero()), function (i, fbs, a) {\n      return F.ap(F.map(fbs, function (bs) {\n        return function (b) {\n          return pipe(bs, append(b));\n        };\n      }), f(i, a));\n    });\n  };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n  var _witherF = _wither(F);\n  return function (f) {\n    return function (fa) {\n      return _witherF(fa, f);\n    };\n  };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n  var _wiltF = _wilt(F);\n  return function (f) {\n    return function (fa) {\n      return _wiltF(fa, f);\n    };\n  };\n};\n/**\n * `unfold` takes a function `f` which returns an `Option` of a tuple containing an outcome\n * value and an input for the following iteration.\n * `unfold` applies `f` to the initial value `b` and then recursively to the second\n * element of the tuple contained in the returned `option` of the previous\n * calculation until `f` returns `Option.none`.\n *\n * @example\n * import { unfold } from 'fp-ts/Array'\n * import { option } from 'fp-ts'\n *\n * const f = (n: number) => {\n *   if (n <= 0) return option.none;\n *   const returnValue = n * 2;\n *   const inputForNextRound = n - 1;\n *   return option.some([returnValue, inputForNextRound] as const);\n * };\n * assert.deepStrictEqual(unfold(5, f), [10, 8, 6, 4, 2]);\n *\n * @since 2.6.6\n */\nexport var unfold = function (b, f) {\n  var out = [];\n  var bb = b;\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    var mt = f(bb);\n    if (_.isSome(mt)) {\n      var _a = mt.value,\n        a = _a[0],\n        b_1 = _a[1];\n      out.push(a);\n      bb = b_1;\n    } else {\n      break;\n    }\n  }\n  return out;\n};\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Array';\n/**\n * `getShow` makes a `Show` for an `Array<A>` from a `Show` for\n * an `A`.\n *\n * @example\n * import { getShow } from 'fp-ts/Array'\n *\n * const numShow = { show: (n: number) => (n >= 0 ? `${n}` : `(${-n})`) };\n * assert.deepStrictEqual(getShow(numShow).show([-2, -1, 0, 1]), \"[(2), (1), 0, 1]\");\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RA.getShow;\n/**\n * Get a `Semigroup` based on the concatenation of `Array`s.\n * See also [`getMonoid`](#getMonoid).\n *\n * @example\n * import { getSemigroup } from 'fp-ts/Array'\n *\n * const S = getSemigroup<number>();\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1, 2, 2, 3]);\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return first.concat(second);\n    }\n  };\n};\n/**\n * Returns a `Monoid` for `Array<A>` based on the concatenation of `Array`s.\n *\n * @example\n * import { getMonoid } from 'fp-ts/Array'\n *\n * const M = getMonoid<number>()\n * assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = function () {\n  return {\n    concat: getSemigroup().concat,\n    empty: []\n  };\n};\n/**\n * Derives an `Eq` over the `Array` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { getEq } from 'fp-ts/Array'\n *\n * const E = getEq(S.Eq)\n * assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)\n * assert.strictEqual(E.equals(['a'], []), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RA.getEq;\n/**\n * Derives an `Ord` over the `Array` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/Array'\n * import * as S from 'fp-ts/string'\n *\n * const O = getOrd(S.Ord)\n * assert.strictEqual(O.compare(['b'], ['a']), 1)\n * assert.strictEqual(O.compare(['a'], ['a']), 0)\n * assert.strictEqual(O.compare(['a'], ['b']), -1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getOrd = RA.getOrd;\n/**\n * Get a `Semigroup` based on the union of the elements of `Array`s.\n * Elements which equal according to the provided `Eq` are included\n * only once in the result.\n * See also [`getUnionMonoid`](#getUnionMonoid).\n *\n * @example\n * import { getUnionSemigroup } from 'fp-ts/Array';\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getUnionSemigroup<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1, 2, 3]);\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\n/**\n * Get a `Monoid` based on the union of the elements of `Array`s.\n * Elements which equal according to the provided `Eq` are included\n * only once in the result.\n *\n * @example\n * import { getUnionMonoid } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const M = getUnionMonoid<number>(Eq);\n * assert.deepStrictEqual(M.concat([1, 2], [2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(M.empty,[]);\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionMonoid = function (E) {\n  return {\n    concat: getUnionSemigroup(E).concat,\n    empty: []\n  };\n};\n/**\n * Get a `Semigroup` based on the intersection of the elements of `Array`s.\n * Only elements present in the two arrays which are equal according to the\n * provided `Eq` are included in the result.\n *\n * @example\n * import { getIntersectionSemigroup } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getIntersectionSemigroup<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [2]);\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getIntersectionSemigroup = function (E) {\n  var intersectionE = intersection(E);\n  return {\n    concat: function (first, second) {\n      return intersectionE(second)(first);\n    }\n  };\n};\n/**\n * Get a `Magma` for `Array` where the `concat` function is the differnce between\n * the first and the second array, i.e. the result contains all the elements of the\n * first array for which their is no equal element in the second array according\n * to the `Eq` provided.\n *\n *\n * @example\n * import { getDifferenceMagma } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getDifferenceMagma<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1]);\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getDifferenceMagma = function (E) {\n  var differenceE = difference(E);\n  return {\n    concat: function (first, second) {\n      return differenceE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * Given an input an `Array` of functions, `flap` returns an `Array` containing\n * the results of applying each function to the given input.\n *\n * @example\n * import { flap } from 'fp-ts/Array'\n *\n * const funs = [\n *   (n: number) => `Double: ${n * 2}`,\n *   (n: number) => `Triple: ${n * 3}`,\n *   (n: number) => `Square: ${n * n}`,\n * ];\n * assert.deepStrictEqual(flap(4)(funs), ['Double: 8', 'Triple: 12', 'Square: 16']);\n *\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.chainFirst(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport var chainFirst = /*#__PURE__*/chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Unfoldable = {\n  URI: URI,\n  unfold: unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Zero = {\n  URI: URI,\n  zero: zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexport var guard = /*#__PURE__*/guard_(Zero, Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  alt: _alt,\n  zero: zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n  URI: URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n  URI: URI,\n  compact: compact,\n  separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n  URI: URI,\n  map: _map,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  partitionMapWithIndex: _partitionMapWithIndex,\n  partitionWithIndex: _partitionWithIndex,\n  filterMapWithIndex: _filterMapWithIndex,\n  filterWithIndex: _filterWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverse: _traverse,\n  sequence: sequence,\n  traverseWithIndex: _traverseWithIndex\n};\nvar _wither = /*#__PURE__*/witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/wiltDefault(Traversable, Compactable);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n  URI: URI,\n  map: _map,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  wither: _wither,\n  wilt: _wilt\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecDepthFirst = RA.chainRecDepthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecDepthFirst = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap,\n  chainRec: _chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecBreadthFirst = RA.chainRecBreadthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecBreadthFirst = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap,\n  chainRec: _chainRecBreadthFirst\n};\n/**\n * Filter values inside a context.\n *\n * @since 2.11.0\n */\nexport var filterE = /*#__PURE__*/filterE_(Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var FromEither = {\n  URI: URI,\n  fromEither: fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = /*#__PURE__*/fromEitherK_(FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeInsertAt = NEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n  return isNonEmpty(as) ? NEA.unsafeUpdateAt(i, a, as) : [];\n};\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeDeleteAt = function (i, as) {\n  var xs = as.slice();\n  xs.splice(i, 1);\n  return xs;\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * `every` tells if the provided predicate holds true for every element in the `Array`.\n *\n * @example\n * import { every } from 'fp-ts/Array'\n *\n * assert.equal(every((x: number) => x >= 0)([1, 2, 3]), true);\n * assert.equal(every((x: number) => x >= 0)([-1, 2, 3]), false);\n *\n * @since 2.9.0\n */\nexport var every = RA.every;\n/**\n * `some` tells if the provided predicate holds true at least for one element in the `Array`.\n *\n * @example\n * import { some } from 'fp-ts/Array'\n *\n * assert.equal(some((x: number) => x >= 0)([1, 2, 3]), true);\n * assert.equal(some((x: number) => x >= 10)([1, 2, 3]), false);\n *\n * @since 2.9.0\n */\nexport var some = function (predicate) {\n  return function (as) {\n    return as.some(predicate);\n  };\n};\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexport var exists = some;\n/**\n * Places an element in between members of an `Array`, then folds the results using the provided `Monoid`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(intercalate(S.Monoid)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = RA.intercalate;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `NonEmptyArray` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var range = NEA.range;\n/**\n * Use a new `[]` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var empty = [];\n/**\n * Use `prepend` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var cons = NEA.cons;\n/**\n * Use `append` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var snoc = NEA.snoc;\n/**\n * Use `prependAll` instead\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `A.Functor` instead of `A.array`\n * (where `A` is from `import A from 'fp-ts/Array'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var array = {\n  URI: URI,\n  compact: compact,\n  separate: separate,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  mapWithIndex: _mapWithIndex,\n  partitionMapWithIndex: _partitionMapWithIndex,\n  partitionWithIndex: _partitionWithIndex,\n  filterMapWithIndex: _filterMapWithIndex,\n  filterWithIndex: _filterWithIndex,\n  alt: _alt,\n  zero: zero,\n  unfold: unfold,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  extend: _extend,\n  wither: _wither,\n  wilt: _wilt\n};","export function chainFirst(M) {\n  var tapM = tap(M);\n  return function (f) {\n    return function (first) {\n      return tapM(first, f);\n    };\n  };\n}\n/** @internal */\nexport function tap(M) {\n  return function (first, f) {\n    return M.chain(first, function (a) {\n      return M.map(f(a), function () {\n        return a;\n      });\n    });\n  };\n}\nexport function bind(M) {\n  return function (name, f) {\n    return function (ma) {\n      return M.chain(ma, function (a) {\n        return M.map(f(a), function (b) {\n          var _a;\n          return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n        });\n      });\n    };\n  };\n}","import { pipe } from './function';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromEquals = function (equals) {\n  return {\n    equals: function (x, y) {\n      return x === y || equals(x, y);\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.10.0\n */\nexport var struct = function (eqs) {\n  return fromEquals(function (first, second) {\n    for (var key in eqs) {\n      if (!eqs[key].equals(first[key], second[key])) {\n        return false;\n      }\n    }\n    return true;\n  });\n};\n/**\n * Given a tuple of `Eq`s returns a `Eq` for the tuple\n *\n * @example\n * import { tuple } from 'fp-ts/Eq'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import * as B from 'fp-ts/boolean'\n *\n * const E = tuple(S.Eq, N.Eq, B.Eq)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)\n * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n  var eqs = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    eqs[_i] = arguments[_i];\n  }\n  return fromEquals(function (first, second) {\n    return eqs.every(function (E, i) {\n      return E.equals(first[i], second[i]);\n    });\n  });\n};\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) {\n  return pipe(fa, contramap(f));\n};\n/**\n * A typical use case for `contramap` would be like, given some `User` type, to construct an `Eq<User>`.\n *\n * We can do so with a function from `User -> X` where `X` is some value that we know how to compare\n * for equality (meaning we have an `Eq<X>`)\n *\n * For example, given the following `User` type, we want to construct an `Eq<User>` that just looks at the `key` field\n * for each user (since it's known to be unique).\n *\n * If we have a way of comparing `UUID`s for equality (`eqUUID: Eq<UUID>`) and we know how to go from `User -> UUID`,\n * using `contramap` we can do this\n *\n * @example\n * import { contramap, Eq } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/string'\n *\n * type UUID = string\n *\n * interface User {\n *   readonly key: UUID\n *   readonly firstName: string\n *   readonly lastName: string\n * }\n *\n * const eqUUID: Eq<UUID> = S.Eq\n *\n * const eqUserByKey: Eq<User> = pipe(\n *   eqUUID,\n *   contramap((user) => user.key)\n * )\n *\n * assert.deepStrictEqual(\n *   eqUserByKey.equals(\n *     { key: 'k1', firstName: 'a1', lastName: 'b1' },\n *     { key: 'k2', firstName: 'a1', lastName: 'b1' }\n *   ),\n *   false\n * )\n * assert.deepStrictEqual(\n *   eqUserByKey.equals(\n *     { key: 'k1', firstName: 'a1', lastName: 'b1' },\n *     { key: 'k1', firstName: 'a2', lastName: 'b1' }\n *   ),\n *   true\n * )\n *\n * @since 2.0.0\n */\nexport var contramap = function (f) {\n  return function (fa) {\n    return fromEquals(function (x, y) {\n      return fa.equals(f(x), f(y));\n    });\n  };\n};\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Eq';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var eqStrict = {\n  equals: function (a, b) {\n    return a === b;\n  }\n};\nvar empty = {\n  equals: function () {\n    return true;\n  }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: function (x, y) {\n      return fromEquals(function (a, b) {\n        return x.equals(a, b) && y.equals(a, b);\n      });\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.6.0\n */\nexport var getMonoid = function () {\n  return {\n    concat: getSemigroup().concat,\n    empty: empty\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Contravariant = {\n  URI: URI,\n  contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleEq = tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getStructEq = struct;\n/**\n * Use [`eqStrict`](#eqstrict) instead\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var strictEqual = eqStrict.equals;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`\n * (where `E` is from `import E from 'fp-ts/Eq'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var eq = Contravariant;\n/**\n * Use [`Eq`](./boolean.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var eqBoolean = eqStrict;\n/**\n * Use [`Eq`](./string.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var eqString = eqStrict;\n/**\n * Use [`Eq`](./number.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var eqNumber = eqStrict;\n/**\n * Use [`Eq`](./Date.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var eqDate = {\n  equals: function (first, second) {\n    return first.valueOf() === second.valueOf();\n  }\n};","/**\n * The `FromEither` type class represents those data types which support errors.\n *\n * @since 2.10.0\n */\nimport { tap } from './Chain';\nimport { flow } from './function';\nimport * as _ from './internal';\nexport function fromOption(F) {\n  return function (onNone) {\n    return function (ma) {\n      return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value));\n    };\n  };\n}\nexport function fromPredicate(F) {\n  return function (predicate, onFalse) {\n    return function (a) {\n      return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));\n    };\n  };\n}\nexport function fromOptionK(F) {\n  var fromOptionF = fromOption(F);\n  return function (onNone) {\n    var from = fromOptionF(onNone);\n    return function (f) {\n      return flow(f, from);\n    };\n  };\n}\nexport function chainOptionK(F, M) {\n  var fromOptionKF = fromOptionK(F);\n  return function (onNone) {\n    var from = fromOptionKF(onNone);\n    return function (f) {\n      return function (ma) {\n        return M.chain(ma, from(f));\n      };\n    };\n  };\n}\nexport function fromEitherK(F) {\n  return function (f) {\n    return flow(f, F.fromEither);\n  };\n}\nexport function chainEitherK(F, M) {\n  var fromEitherKF = fromEitherK(F);\n  return function (f) {\n    return function (ma) {\n      return M.chain(ma, fromEitherKF(f));\n    };\n  };\n}\nexport function chainFirstEitherK(F, M) {\n  var tapEitherM = tapEither(F, M);\n  return function (f) {\n    return function (ma) {\n      return tapEitherM(ma, f);\n    };\n  };\n}\nexport function filterOrElse(F, M) {\n  return function (predicate, onFalse) {\n    return function (ma) {\n      return M.chain(ma, function (a) {\n        return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));\n      });\n    };\n  };\n}\n/** @internal */\nexport function tapEither(F, M) {\n  var fromEither = fromEitherK(F);\n  var tapM = tap(M);\n  return function (self, f) {\n    return tapM(self, fromEither(f));\n  };\n}","/**\n * A `Functor` is a type constructor which supports a mapping operation `map`.\n *\n * `map` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return types use the type\n * constructor `f` to represent some computational context.\n *\n * Instances must satisfy the following laws:\n *\n * 1. Identity: `F.map(fa, a => a) <-> fa`\n * 2. Composition: `F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)`\n *\n * @since 2.0.0\n */\nimport { pipe } from './function';\nexport function map(F, G) {\n  return function (f) {\n    return function (fa) {\n      return F.map(fa, function (ga) {\n        return G.map(ga, f);\n      });\n    };\n  };\n}\nexport function flap(F) {\n  return function (a) {\n    return function (fab) {\n      return F.map(fab, function (f) {\n        return f(a);\n      });\n    };\n  };\n}\nexport function bindTo(F) {\n  return function (name) {\n    return function (fa) {\n      return F.map(fa, function (a) {\n        var _a;\n        return _a = {}, _a[name] = a, _a;\n      });\n    };\n  };\n}\nfunction let_(F) {\n  return function (name, f) {\n    return function (fa) {\n      return F.map(fa, function (a) {\n        var _a;\n        return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));\n      });\n    };\n  };\n}\nexport {\n/**\n * @since 2.13.0\n */\nlet_ as let };\n/** @deprecated */\nexport function getFunctorComposition(F, G) {\n  var _map = map(F, G);\n  return {\n    map: function (fga, f) {\n      return pipe(fga, _map(f));\n    }\n  };\n}\n/** @internal */\nexport function as(F) {\n  return function (self, b) {\n    return F.map(self, function () {\n      return b;\n    });\n  };\n}\n/** @internal */\nexport function asUnit(F) {\n  var asM = as(F);\n  return function (self) {\n    return asM(self, undefined);\n  };\n}","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { getMonoid } from './Ord';\nimport * as RNEA from './ReadonlyNonEmptyArray';\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nexport var isNonEmpty = function (as) {\n  return as.length > 0;\n};\n/**\n * @internal\n */\nexport var isOutOfBound = function (i, as) {\n  return i < 0 || i >= as.length;\n};\n/**\n * @internal\n */\nexport var prependW = function (head) {\n  return function (tail) {\n    return __spreadArray([head], tail, true);\n  };\n};\n/**\n * @internal\n */\nexport var prepend = prependW;\n/**\n * @internal\n */\nexport var appendW = function (end) {\n  return function (init) {\n    return __spreadArray(__spreadArray([], init, true), [end], false);\n  };\n};\n/**\n * @internal\n */\nexport var append = appendW;\n/**\n * @internal\n */\nexport var unsafeInsertAt = function (i, a, as) {\n  if (isNonEmpty(as)) {\n    var xs = fromReadonlyNonEmptyArray(as);\n    xs.splice(i, 0, a);\n    return xs;\n  }\n  return [a];\n};\n/**\n * @internal\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n  var xs = fromReadonlyNonEmptyArray(as);\n  xs[i] = a;\n  return xs;\n};\n/**\n * Remove duplicates from a `NonEmptyArray`, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/NonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.11.0\n */\nexport var uniq = function (E) {\n  return function (as) {\n    if (as.length === 1) {\n      return copy(as);\n    }\n    var out = [head(as)];\n    var rest = tail(as);\n    var _loop_1 = function (a) {\n      if (out.every(function (o) {\n        return !E.equals(o, a);\n      })) {\n        out.push(a);\n      }\n    };\n    for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {\n      var a = rest_1[_i];\n      _loop_1(a);\n    }\n    return out;\n  };\n};\n/**\n * Sort the elements of a `NonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { contramap } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n *\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n *\n * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))\n *\n * const sortByNameByAge = NEA.sortBy([byName, byAge])\n *\n * const persons: NEA.NonEmptyArray<Person> = [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 },\n *   { name: 'b', age: 2 }\n * ]\n *\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @since 2.11.0\n */\nexport var sortBy = function (ords) {\n  if (isNonEmpty(ords)) {\n    var M = getMonoid();\n    return sort(ords.reduce(M.concat, M.empty));\n  }\n  return copy;\n};\n/**\n * @since 2.11.0\n */\nexport var union = function (E) {\n  var uniqE = uniq(E);\n  return function (second) {\n    return function (first) {\n      return uniqE(pipe(first, concat(second)));\n    };\n  };\n};\n/**\n * Rotate a `NonEmptyArray` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n * assert.deepStrictEqual(rotate(-2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])\n *\n * @since 2.11.0\n */\nexport var rotate = function (n) {\n  return function (as) {\n    var len = as.length;\n    var m = Math.round(n) % len;\n    if (isOutOfBound(Math.abs(m), as) || m === 0) {\n      return copy(as);\n    }\n    if (m < 0) {\n      var _a = splitAt(-m)(as),\n        f = _a[0],\n        s = _a[1];\n      return pipe(s, concat(f));\n    } else {\n      return rotate(m - len)(as);\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.10.0\n */\nexport var fromReadonlyNonEmptyArray = _.fromReadonlyNonEmptyArray;\n/**\n * Builds a `NonEmptyArray` from an `Array` returning `none` if `as` is an empty array\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromArray = function (as) {\n  return isNonEmpty(as) ? _.some(as) : _.none;\n};\n/**\n * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { makeBy } from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(pipe(5, makeBy(double)), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var makeBy = function (f) {\n  return function (n) {\n    var j = Math.max(0, Math.floor(n));\n    var out = [f(0)];\n    for (var i = 1; i < j; i++) {\n      out.push(f(i));\n    }\n    return out;\n  };\n};\n/**\n * Create a `NonEmptyArray` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { replicate } from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(3, replicate('a')), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var replicate = function (a) {\n  return makeBy(function () {\n    return a;\n  });\n};\n/**\n * Create a `NonEmptyArray` containing a range of integers, including both endpoints.\n *\n * @example\n * import { range } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var range = function (start, end) {\n  return start <= end ? makeBy(function (i) {\n    return start + i;\n  })(end - start + 1) : [start];\n};\n/**\n * Return the tuple of the `head` and the `tail`.\n *\n * @example\n * import { unprepend } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(unprepend([1, 2, 3]), [1, [2, 3]])\n *\n * @since 2.9.0\n */\nexport var unprepend = function (as) {\n  return [head(as), tail(as)];\n};\n/**\n * Return the tuple of the `init` and the `last`.\n *\n * @example\n * import { unappend } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(unappend([1, 2, 3, 4]), [[1, 2, 3], 4])\n *\n * @since 2.9.0\n */\nexport var unappend = function (as) {\n  return [init(as), last(as)];\n};\nexport function concatW(second) {\n  return function (first) {\n    return first.concat(second);\n  };\n}\nexport function concat(x, y) {\n  return y ? x.concat(y) : function (y) {\n    return y.concat(x);\n  };\n}\n/**\n * @since 2.0.0\n */\nexport var reverse = function (as) {\n  return __spreadArray([last(as)], as.slice(0, -1).reverse(), true);\n};\nexport function group(E) {\n  return function (as) {\n    var len = as.length;\n    if (len === 0) {\n      return [];\n    }\n    var out = [];\n    var head = as[0];\n    var nea = [head];\n    for (var i = 1; i < len; i++) {\n      var a = as[i];\n      if (E.equals(a, head)) {\n        nea.push(a);\n      } else {\n        out.push(nea);\n        head = a;\n        nea = [head];\n      }\n    }\n    out.push(nea);\n    return out;\n  };\n}\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { groupBy } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['a', 'b', 'ab']), {\n *   '1': ['a', 'b'],\n *   '2': ['ab']\n * })\n *\n * @since 2.0.0\n */\nexport var groupBy = function (f) {\n  return function (as) {\n    var out = {};\n    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n      var a = as_1[_i];\n      var k = f(a);\n      if (_.has.call(out, k)) {\n        out[k].push(a);\n      } else {\n        out[k] = [a];\n      }\n    }\n    return out;\n  };\n};\n/**\n * @since 2.0.0\n */\nexport var sort = function (O) {\n  return function (as) {\n    return as.slice().sort(O.compare);\n  };\n};\n/**\n * @since 2.0.0\n */\nexport var insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some(unsafeInsertAt(i, a, as));\n  };\n};\n/**\n * @since 2.0.0\n */\nexport var updateAt = function (i, a) {\n  return modifyAt(i, function () {\n    return a;\n  });\n};\n/**\n * @since 2.0.0\n */\nexport var modifyAt = function (i, f) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n  };\n};\n/**\n * @since 2.0.0\n */\nexport var copy = fromReadonlyNonEmptyArray;\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var of = function (a) {\n  return [a];\n};\n/**\n * @since 2.5.1\n */\nexport var zipWith = function (as, bs, f) {\n  var cs = [f(as[0], bs[0])];\n  var len = Math.min(as.length, bs.length);\n  for (var i = 1; i < len; i++) {\n    cs[i] = f(as[i], bs[i]);\n  }\n  return cs;\n};\nexport function zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return zipWith(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\n/**\n * @since 2.5.1\n */\nexport var unzip = function (abs) {\n  var fa = [abs[0][0]];\n  var fb = [abs[0][1]];\n  for (var i = 1; i < abs.length; i++) {\n    fa[i] = abs[i][0];\n    fb[i] = abs[i][1];\n  }\n  return [fa, fb];\n};\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependAll } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.10.0\n */\nexport var prependAll = function (middle) {\n  return function (as) {\n    var out = [middle, as[0]];\n    for (var i = 1; i < as.length; i++) {\n      out.push(middle, as[i]);\n    }\n    return out;\n  };\n};\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { intersperse } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.9.0\n */\nexport var intersperse = function (middle) {\n  return function (as) {\n    var rest = tail(as);\n    return isNonEmpty(rest) ? pipe(rest, prependAll(middle), prepend(head(as))) : copy(as);\n  };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMapWithIndex = RNEA.foldMapWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = RNEA.foldMap;\n/**\n * @category sequencing\n * @since 2.10.0\n */\nexport var chainWithIndex = function (f) {\n  return function (as) {\n    var out = fromReadonlyNonEmptyArray(f(0, head(as)));\n    for (var i = 1; i < as.length; i++) {\n      out.push.apply(out, f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * @since 2.10.0\n */\nexport var chop = function (f) {\n  return function (as) {\n    var _a = f(as),\n      b = _a[0],\n      rest = _a[1];\n    var out = [b];\n    var next = rest;\n    while (isNonEmpty(next)) {\n      var _b = f(next),\n        b_1 = _b[0],\n        rest_2 = _b[1];\n      out.push(b_1);\n      next = rest_2;\n    }\n    return out;\n  };\n};\n/**\n * Splits a `NonEmptyArray` into two pieces, the first piece has max `n` elements.\n *\n * @since 2.10.0\n */\nexport var splitAt = function (n) {\n  return function (as) {\n    var m = Math.max(1, n);\n    return m >= as.length ? [copy(as), []] : [pipe(as.slice(1, m), prepend(head(as))), as.slice(m)];\n  };\n};\n/**\n * @since 2.10.0\n */\nexport var chunksOf = function (n) {\n  return chop(splitAt(n));\n};\n/* istanbul ignore next */\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return pipe(fa, mapWithIndex(f));\n};\n/* istanbul ignore next */\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return pipe(wa, extend(f));\n};\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = foldMap(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = foldMapWithIndex(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceRightWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (ta, f) {\n    return pipe(ta, traverseWithIndexF(f));\n  };\n};\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3] as NEA.NonEmptyArray<number>,\n *     NEA.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n  return function (as) {\n    return pipe(as, concatW(that()));\n  };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `NonEmptyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     NEA.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.6.2\n */\nexport var alt = altW;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @since 2.0.0\n */\nexport var ap = function (as) {\n  return flatMap(function (f) {\n    return pipe(as, map(f));\n  });\n};\n/**\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     NEA.flatMap((n) => [`a${n}`, `b${n}`])\n *   ),\n *   ['a1', 'b1', 'a2', 'b2', 'a3', 'b3']\n * )\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return pipe(ma, chainWithIndex(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @since 2.0.0\n */\nexport var extend = function (f) {\n  return function (as) {\n    var next = tail(as);\n    var out = [f(as)];\n    while (isNonEmpty(next)) {\n      out.push(f(next));\n      next = tail(next);\n    }\n    return out;\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) {\n  return mapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * @category mapping\n * @since 2.0.0\n */\nexport var mapWithIndex = function (f) {\n  return function (as) {\n    var out = [f(0, head(as))];\n    for (var i = 1; i < as.length; i++) {\n      out.push(f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = RNEA.reduce;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceWithIndex = RNEA.reduceWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = RNEA.reduceRight;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRightWithIndex = RNEA.reduceRightWithIndex;\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return traverseWithIndex(F)(function (_, a) {\n    return a;\n  });\n};\n/**\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n  return function (f) {\n    return function (as) {\n      var out = F.map(f(0, head(as)), of);\n      for (var i = 1; i < as.length; i++) {\n        out = F.ap(F.map(out, function (bs) {\n          return function (b) {\n            return pipe(bs, append(b));\n          };\n        }), f(i, as[i]));\n      }\n      return out;\n    };\n  };\n};\n/**\n * @since 2.7.0\n */\nexport var extract = RNEA.head;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'NonEmptyArray';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RNEA.getShow;\n/**\n * Builds a `Semigroup` instance for `NonEmptyArray`\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: concat\n  };\n};\n/**\n * @example\n * import { getEq } from 'fp-ts/NonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals([1, 2], [1, 2]), true)\n * assert.strictEqual(E.equals([1, 2], [1, 3]), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RNEA.getEq;\n/**\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = /*#__PURE__*/chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n  URI: URI,\n  map: _map,\n  extend: _extend,\n  extract: extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.0.0\n */\nexport var head = RNEA.head;\n/**\n * @since 2.0.0\n */\nexport var tail = function (as) {\n  return as.slice(1);\n};\n/**\n * @since 2.0.0\n */\nexport var last = RNEA.last;\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.2.0\n */\nexport var init = function (as) {\n  return as.slice(0, -1);\n};\n/**\n * @since 2.0.0\n */\nexport var min = RNEA.min;\n/**\n * @since 2.0.0\n */\nexport var max = RNEA.max;\n/**\n * @since 2.10.0\n */\nexport var concatAll = function (S) {\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\n/**\n * Break an `Array` into its first element and remaining elements.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeft = function (f) {\n  return function (as) {\n    return f(head(as), tail(as));\n  };\n};\n/**\n * Break an `Array` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRight = function (f) {\n  return function (as) {\n    return f(init(as), last(as));\n  };\n};\n/**\n * Apply a function to the head, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyHead = function (f) {\n  return function (as) {\n    return __spreadArray([f(head(as))], tail(as), true);\n  };\n};\n/**\n * Change the head, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateHead = function (a) {\n  return modifyHead(function () {\n    return a;\n  });\n};\n/**\n * Apply a function to the last element, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyLast = function (f) {\n  return function (as) {\n    return pipe(init(as), append(f(last(as))));\n  };\n};\n/**\n * Change the last element, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateLast = function (a) {\n  return modifyLast(function () {\n    return a;\n  });\n};\n/**\n * Places an element in between members of a `NonEmptyArray`, then folds the results using the provided `Semigroup`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = RNEA.intercalate;\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\nexport function groupSort(O) {\n  var sortO = sort(O);\n  var groupO = group(O);\n  return function (as) {\n    return isNonEmpty(as) ? groupO(sortO(as)) : [];\n  };\n}\nexport function filter(predicate) {\n  return filterWithIndex(function (_, a) {\n    return predicate(a);\n  });\n}\n/**\n * Use [`filterWithIndex`](./Array.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var filterWithIndex = function (predicate) {\n  return function (as) {\n    return fromArray(as.filter(function (a, i) {\n      return predicate(i, a);\n    }));\n  };\n};\n/**\n * Use [`unprepend`](#unprepend) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var uncons = unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var unsnoc = unappend;\nexport function cons(head, tail) {\n  return tail === undefined ? prepend(head) : pipe(tail, prepend(head));\n}\n/**\n * Use [`append`](./Array.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var snoc = function (init, end) {\n  return pipe(init, append(end));\n};\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * Use [`concatAll`](#concatall) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var fold = RNEA.concatAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `NEA.Functor` instead of `NEA.nonEmptyArray`\n * (where `NEA` is from `import NEA from 'fp-ts/NonEmptyArray'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var nonEmptyArray = {\n  URI: URI,\n  of: of,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  ap: _ap,\n  chain: flatMap,\n  extend: _extend,\n  extract: extract,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  alt: _alt\n};","import { getApplicativeMonoid } from './Applicative';\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_, getApplySemigroup as getApplySemigroup_ } from './Apply';\nimport * as chainable from './Chain';\nimport { chainEitherK as chainEitherK_, fromEitherK as fromEitherK_, tapEither as tapEither_ } from './FromEither';\nimport { constNull, constUndefined, dual, flow, identity, pipe } from './function';\nimport { as as as_, asUnit as asUnit_, bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { not } from './Predicate';\nimport { first, last } from './Semigroup';\nimport { separated } from './Separated';\nimport { wiltDefault, witherDefault } from './Witherable';\nimport { guard as guard_ } from './Zero';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var none = _.none;\n/**\n * Constructs a `Some`. Represents an optional value that exists.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var some = _.some;\nexport function fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? some(a) : none;\n  };\n}\n/**\n * Returns the `Left` value of an `Either` if possible.\n *\n * @example\n * import { getLeft, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getLeft(right(1)), none)\n * assert.deepStrictEqual(getLeft(left('a')), some('a'))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var getLeft = function (ma) {\n  return ma._tag === 'Right' ? none : some(ma.left);\n};\n/**\n * Returns the `Right` value of an `Either` if possible.\n *\n * @example\n * import { getRight, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getRight(right(1)), some(1))\n * assert.deepStrictEqual(getRight(left('a')), none)\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var getRight = function (ma) {\n  return ma._tag === 'Left' ? none : some(ma.right);\n};\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\nvar _foldMap = function (M) {\n  var foldMapM = foldMap(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapM(f));\n  };\n};\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\nvar _filter = function (fa, predicate) {\n  return pipe(fa, filter(predicate));\n};\n/* istanbul ignore next */\nvar _filterMap = function (fa, f) {\n  return pipe(fa, filterMap(f));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return pipe(wa, extend(f));\n};\n/* istanbul ignore next */\nvar _partition = function (fa, predicate) {\n  return pipe(fa, partition(predicate));\n};\n/* istanbul ignore next */\nvar _partitionMap = function (fa, f) {\n  return pipe(fa, partitionMap(f));\n};\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Option';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = function (S) {\n  return {\n    show: function (ma) {\n      return isNone(ma) ? 'none' : \"some(\".concat(S.show(ma.value), \")\");\n    }\n  };\n};\n/**\n * @example\n * import { none, some, getEq } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals(none, none), true)\n * assert.strictEqual(E.equals(none, some(1)), false)\n * assert.strictEqual(E.equals(some(1), none), false)\n * assert.strictEqual(E.equals(some(1), some(2)), false)\n * assert.strictEqual(E.equals(some(1), some(1)), true)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = function (E) {\n  return {\n    equals: function (x, y) {\n      return x === y || (isNone(x) ? isNone(y) : isNone(y) ? false : E.equals(x.value, y.value));\n    }\n  };\n};\n/**\n * The `Ord` instance allows `Option` values to be compared with\n * `compare`, whenever there is an `Ord` instance for\n * the type the `Option` contains.\n *\n * `None` is considered to be less than any `Some` value.\n *\n *\n * @example\n * import { none, some, getOrd } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const O = getOrd(N.Ord)\n * assert.strictEqual(O.compare(none, none), 0)\n * assert.strictEqual(O.compare(none, some(1)), -1)\n * assert.strictEqual(O.compare(some(1), none), 1)\n * assert.strictEqual(O.compare(some(1), some(2)), -1)\n * assert.strictEqual(O.compare(some(1), some(1)), 0)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getOrd = function (O) {\n  return {\n    equals: getEq(O).equals,\n    compare: function (x, y) {\n      return x === y ? 0 : isSome(x) ? isSome(y) ? O.compare(x.value, y.value) : 1 : -1;\n    }\n  };\n};\n/**\n * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | some(a)            |\n * | none    | some(b) | some(b)            |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getMonoid, some, none } from 'fp-ts/Option'\n * import { SemigroupSum } from 'fp-ts/number'\n *\n * const M = getMonoid(SemigroupSum)\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = function (S) {\n  return {\n    concat: function (x, y) {\n      return isNone(x) ? y : isNone(y) ? x : some(S.concat(x.value, y.value));\n    },\n    empty: none\n  };\n};\n/**\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) {\n  return function (fa) {\n    return isNone(fa) ? none : some(f(fa.value));\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * Maps the `Some` value of this `Option` to the specified constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var as = dual(2, as_(Functor));\n/**\n * Maps the `Some` value of this `Option` to the void constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var asUnit = asUnit_(Functor);\n/**\n * @category constructors\n * @since 2.7.0\n */\nexport var of = some;\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * @since 2.0.0\n */\nexport var ap = function (fa) {\n  return function (fab) {\n    return isNone(fab) ? none : isNone(fa) ? none : some(fab.value(fa.value));\n  };\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return isNone(ma) ? none : f(ma.value);\n});\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = function (b, f) {\n  return function (fa) {\n    return isNone(fa) ? b : f(b, fa.value);\n  };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = function (M) {\n  return function (f) {\n    return function (fa) {\n      return isNone(fa) ? M.empty : f(fa.value);\n    };\n  };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) {\n  return function (fa) {\n    return isNone(fa) ? b : f(fa.value, b);\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * Returns the provided `Option` `that` if `self` is `None`, otherwise returns `self`.\n *\n * @param self - The first `Option` to be checked.\n * @param that - The `Option` to return if `self` is `None`.\n *\n * @example\n * import * as O from \"fp-ts/Option\"\n *\n * assert.deepStrictEqual(O.orElse(O.none, () => O.none), O.none)\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.none), O.some(1))\n * assert.deepStrictEqual(O.orElse(O.none, () => O.some('b')), O.some('b'))\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.some('b')), O.some(1))\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var orElse = dual(2, function (self, that) {\n  return isNone(self) ? that() : self;\n});\n/**\n * Alias of `orElse`.\n *\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @category legacy\n * @since 2.9.0\n */\nexport var altW = orElse;\n/**\n * Alias of `orElse`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var alt = orElse;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @since 2.7.0\n */\nexport var zero = function () {\n  return none;\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Zero = {\n  URI: URI,\n  zero: zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexport var guard = /*#__PURE__*/guard_(Zero, Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  alt: _alt,\n  zero: zero\n};\n/**\n * @since 2.0.0\n */\nexport var extend = function (f) {\n  return function (wa) {\n    return isNone(wa) ? none : some(f(wa));\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n  URI: URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var compact = /*#__PURE__*/flatMap(identity);\nvar defaultSeparated = /*#__PURE__*/separated(none, none);\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var separate = function (ma) {\n  return isNone(ma) ? defaultSeparated : separated(getLeft(ma.value), getRight(ma.value));\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n  URI: URI,\n  compact: compact,\n  separate: separate\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var filter = function (predicate) {\n  return function (fa) {\n    return isNone(fa) ? none : predicate(fa.value) ? fa : none;\n  };\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var filterMap = function (f) {\n  return function (fa) {\n    return isNone(fa) ? none : f(fa.value);\n  };\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var partition = function (predicate) {\n  return function (fa) {\n    return separated(_filter(fa, not(predicate)), _filter(fa, predicate));\n  };\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionMap = function (f) {\n  return flow(map(f), separate);\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n  URI: URI,\n  map: _map,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  return function (f) {\n    return function (ta) {\n      return isNone(ta) ? F.of(none) : F.map(f(ta.value), some);\n    };\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return function (ta) {\n    return isNone(ta) ? F.of(none) : F.map(ta.value, some);\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\nvar _wither = /*#__PURE__*/witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/wiltDefault(Traversable, Compactable);\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n  var _witherF = _wither(F);\n  return function (f) {\n    return function (fa) {\n      return _witherF(fa, f);\n    };\n  };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n  var _wiltF = _wilt(F);\n  return function (f) {\n    return function (fa) {\n      return _wiltF(fa, f);\n    };\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  wither: _wither,\n  wilt: _wilt\n};\n/**\n * @since 2.7.0\n */\nexport var throwError = function () {\n  return none;\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadThrow = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap,\n  throwError: throwError\n};\n/**\n * Transforms an `Either` to an `Option` discarding the error.\n *\n * Alias of [getRight](#getright)\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromEither = getRight;\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var FromEither = {\n  URI: URI,\n  fromEither: fromEither\n};\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the option is an instance of `Some`, `false` otherwise.\n *\n * @example\n * import { some, none, isSome } from 'fp-ts/Option'\n *\n * assert.strictEqual(isSome(some(1)), true)\n * assert.strictEqual(isSome(none), false)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isSome = _.isSome;\n/**\n * Returns `true` if the option is `None`, `false` otherwise.\n *\n * @example\n * import { some, none, isNone } from 'fp-ts/Option'\n *\n * assert.strictEqual(isNone(some(1)), false)\n * assert.strictEqual(isNone(none), true)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isNone = function (fa) {\n  return fa._tag === 'None';\n};\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = function (onNone, onSome) {\n  return function (ma) {\n    return isNone(ma) ? onNone() : onSome(ma.value);\n  };\n};\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchW;\n/**\n * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is\n * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.\n *\n * @example\n * import { some, none, match } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a some containing 1'\n * )\n *\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a none'\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = matchW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var fold = match;\n/**\n * Less strict version of [`getOrElse`](#getorelse).\n *\n * The `W` suffix (short for **W**idening) means that the handler return type will be merged.\n *\n * @category error handling\n * @since 2.6.0\n */\nexport var getOrElseW = function (onNone) {\n  return function (ma) {\n    return isNone(ma) ? onNone() : ma.value;\n  };\n};\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns the given default value\n *\n * @example\n * import { some, none, getOrElse } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.0.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * @category sequencing\n * @since 2.0.0\n */\nexport var flatten = compact;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category combinators\n * @since 2.15.0\n */\nexport var tap = /*#__PURE__*/dual(2, chainable.tap(Chain));\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n * import * as E from 'fp-ts/Either'\n *\n * const compute = (value: number) => pipe(\n *   O.of(value),\n *   O.tapEither((value) => value > 0 ? E.right('ok') : E.left('error')),\n * )\n *\n * assert.deepStrictEqual(compute(1), O.of(1))\n * assert.deepStrictEqual(compute(-42), O.none)\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapEither = /*#__PURE__*/dual(2, tapEither_(FromEither, Chain));\n/**\n * @since 2.0.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = /*#__PURE__*/fromEitherK_(FromEither);\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainEitherK = /*#__PURE__*/chainEitherK_(FromEither, Chain);\n/**\n * Alias of `tapEither`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherK = tapEither;\n/**\n * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise\n * returns the value wrapped in a `Some`.\n *\n * @example\n * import { none, some, fromNullable } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(fromNullable(undefined), none)\n * assert.deepStrictEqual(fromNullable(null), none)\n * assert.deepStrictEqual(fromNullable(1), some(1))\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromNullable = function (a) {\n  return a == null ? none : some(a);\n};\n/**\n * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a\n * `Some`.\n *\n * See also [`tryCatchK`](#trycatchk).\n *\n * @example\n * import { none, some, tryCatch } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   tryCatch(() => {\n *     throw new Error()\n *   }),\n *   none\n * )\n * assert.deepStrictEqual(tryCatch(() => 1), some(1))\n *\n * @category interop\n * @since 2.0.0\n */\nexport var tryCatch = function (f) {\n  try {\n    return some(f());\n  } catch (e) {\n    return none;\n  }\n};\n/**\n * Converts a function that may throw to one returning a `Option`.\n *\n * @category interop\n * @since 2.10.0\n */\nexport var tryCatchK = function (f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return tryCatch(function () {\n      return f.apply(void 0, a);\n    });\n  };\n};\n/**\n * Returns a *smart constructor* from a function that returns a nullable value.\n *\n * @example\n * import { fromNullableK, none, some } from 'fp-ts/Option'\n *\n * const f = (s: string): number | undefined => {\n *   const n = parseFloat(s)\n *   return isNaN(n) ? undefined : n\n * }\n *\n * const g = fromNullableK(f)\n *\n * assert.deepStrictEqual(g('1'), some(1))\n * assert.deepStrictEqual(g('a'), none)\n *\n * @category lifting\n * @since 2.9.0\n */\nexport var fromNullableK = function (f) {\n  return flow(f, fromNullable);\n};\n/**\n * This is `chain` + `fromNullable`, useful when working with optional values.\n *\n * @example\n * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Employee {\n *   readonly company?: {\n *     readonly address?: {\n *       readonly street?: {\n *         readonly name?: string\n *       }\n *     }\n *   }\n * }\n *\n * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee1.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   some('high street')\n * )\n *\n * const employee2: Employee = { company: { address: { street: {} } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee2.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   none\n * )\n *\n * @category sequencing\n * @since 2.9.0\n */\nexport var chainNullableK = function (f) {\n  return function (ma) {\n    return isNone(ma) ? none : fromNullable(f(ma.value));\n  };\n};\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `null`.\n *\n * @example\n * import { some, none, toNullable } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toNullable\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toNullable\n *   ),\n *   null\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var toNullable = /*#__PURE__*/match(constNull, identity);\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.\n *\n * @example\n * import { some, none, toUndefined } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toUndefined\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toUndefined\n *   ),\n *   undefined\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var toUndefined = /*#__PURE__*/match(constUndefined, identity);\nexport function elem(E) {\n  return function (a, ma) {\n    if (ma === undefined) {\n      var elemE_1 = elem(E);\n      return function (ma) {\n        return elemE_1(a, ma);\n      };\n    }\n    return isNone(ma) ? false : E.equals(a, ma.value);\n  };\n}\n/**\n * Returns `true` if the predicate is satisfied by the wrapped value\n *\n * @example\n * import { some, none, exists } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 0)\n *   ),\n *   true\n * )\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 1)\n *   ),\n *   false\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     exists(n => n > 0)\n *   ),\n *   false\n * )\n *\n * @since 2.0.0\n */\nexport var exists = function (predicate) {\n  return function (ma) {\n    return isNone(ma) ? false : predicate(ma.value);\n  };\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/chainable.bind(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n/**\n * @since 2.11.0\n */\nexport var ApT = /*#__PURE__*/of(_.emptyReadonlyArray);\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n  return function (as) {\n    var o = f(0, _.head(as));\n    if (isNone(o)) {\n      return none;\n    }\n    var out = [o.value];\n    for (var i = 1; i < as.length; i++) {\n      var o_1 = f(i, as[i]);\n      if (isNone(o_1)) {\n        return none;\n      }\n      out.push(o_1.value);\n    }\n    return some(out);\n  };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyArrayWithIndex = function (f) {\n  var g = traverseReadonlyNonEmptyArrayWithIndex(f);\n  return function (as) {\n    return _.isNonEmpty(as) ? g(as) : ApT;\n  };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverse(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArray = function (f) {\n  return traverseReadonlyArrayWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * Equivalent to `ReadonlyArray#sequence(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceArray = /*#__PURE__*/traverseArray(identity);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chainFirst = tap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `Refinement` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getRefinement(getOption) {\n  return function (a) {\n    return isSome(getOption(a));\n  };\n}\n/**\n * Use [`chainNullableK`](#chainnullablek) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var mapNullable = chainNullableK;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `O.Functor` instead of `O.option`\n * (where `O` is from `import O from 'fp-ts/Option'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var option = {\n  URI: URI,\n  map: _map,\n  of: of,\n  ap: _ap,\n  chain: flatMap,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  zero: zero,\n  alt: _alt,\n  extend: _extend,\n  compact: compact,\n  separate: separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  wither: _wither,\n  wilt: _wilt,\n  throwError: throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplySemigroup = /*#__PURE__*/getApplySemigroup_(Apply);\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplyMonoid = /*#__PURE__*/getApplicativeMonoid(Applicative);\n/**\n * Use\n *\n * ```ts\n * import { first } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(first())\n * ```\n *\n * instead.\n *\n * Monoid returning the left-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(a)      |\n *\n * @example\n * import { getFirstMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getFirstMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFirstMonoid = function () {\n  return getMonoid(first());\n};\n/**\n * Use\n *\n * ```ts\n * import { last } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(last())\n * ```\n *\n * instead.\n *\n * Monoid returning the right-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(b)      |\n *\n * @example\n * import { getLastMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getLastMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getLastMonoid = function () {\n  return getMonoid(last());\n};","import { constFalse, constTrue, flow, pipe } from './function';\nvar contramap_ = function (predicate, f) {\n  return pipe(predicate, contramap(f));\n};\n/**\n * @since 2.11.0\n */\nexport var contramap = function (f) {\n  return function (predicate) {\n    return flow(f, predicate);\n  };\n};\n/**\n * @category type lambdas\n * @since 2.11.0\n */\nexport var URI = 'Predicate';\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getSemigroupAny = function () {\n  return {\n    concat: function (first, second) {\n      return pipe(first, or(second));\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getMonoidAny = function () {\n  return {\n    concat: getSemigroupAny().concat,\n    empty: constFalse\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getSemigroupAll = function () {\n  return {\n    concat: function (first, second) {\n      return pipe(first, and(second));\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getMonoidAll = function () {\n  return {\n    concat: getSemigroupAll().concat,\n    empty: constTrue\n  };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Contravariant = {\n  URI: URI,\n  contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var not = function (predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n};\n/**\n * @since 2.11.0\n */\nexport var or = function (second) {\n  return function (first) {\n    return function (a) {\n      return first(a) || second(a);\n    };\n  };\n};\n/**\n * @since 2.11.0\n */\nexport var and = function (second) {\n  return function (first) {\n    return function (a) {\n      return first(a) && second(a);\n    };\n  };\n};","import { eqStrict } from './Eq';\nimport { constant, constTrue, pipe } from './function';\n// -------------------------------------------------------------------------------------\n// defaults\n// -------------------------------------------------------------------------------------\n/**\n * @category defaults\n * @since 2.10.0\n */\nexport var equalsDefault = function (compare) {\n  return function (first, second) {\n    return first === second || compare(first, second) === 0;\n  };\n};\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromCompare = function (compare) {\n  return {\n    equals: equalsDefault(compare),\n    compare: function (first, second) {\n      return first === second ? 0 : compare(first, second);\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Given a tuple of `Ord`s returns an `Ord` for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Ord'\n * import * as B from 'fp-ts/boolean'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n *\n * const O = tuple(S.Ord, N.Ord, B.Ord)\n * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n  var ords = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    ords[_i] = arguments[_i];\n  }\n  return fromCompare(function (first, second) {\n    var i = 0;\n    for (; i < ords.length - 1; i++) {\n      var r = ords[i].compare(first[i], second[i]);\n      if (r !== 0) {\n        return r;\n      }\n    }\n    return ords[i].compare(first[i], second[i]);\n  });\n};\n/**\n * @since 2.10.0\n */\nexport var reverse = function (O) {\n  return fromCompare(function (first, second) {\n    return O.compare(second, first);\n  });\n};\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) {\n  return pipe(fa, contramap(f));\n};\n/**\n * A typical use case for `contramap` would be like, given some `User` type, to construct an `Ord<User>`.\n *\n * We can do so with a function from `User -> X` where `X` is some value that we know how to compare\n * for ordering (meaning we have an `Ord<X>`)\n *\n * For example, given the following `User` type, there are lots of possible choices for `X`,\n * but let's say we want to sort a list of users by `lastName`.\n *\n * If we have a way of comparing `lastName`s for ordering (`ordLastName: Ord<string>`) and we know how to go from `User -> string`,\n * using `contramap` we can do this\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import { contramap, Ord } from 'fp-ts/Ord'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as S from 'fp-ts/string'\n *\n * interface User {\n *   readonly firstName: string\n *   readonly lastName: string\n * }\n *\n * const ordLastName: Ord<string> = S.Ord\n *\n * const ordByLastName: Ord<User> = pipe(\n *   ordLastName,\n *   contramap((user) => user.lastName)\n * )\n *\n * assert.deepStrictEqual(\n *   RA.sort(ordByLastName)([\n *     { firstName: 'a', lastName: 'd' },\n *     { firstName: 'c', lastName: 'b' }\n *   ]),\n *   [\n *     { firstName: 'c', lastName: 'b' },\n *     { firstName: 'a', lastName: 'd' }\n *   ]\n * )\n *\n * @since 2.0.0\n */\nexport var contramap = function (f) {\n  return function (fa) {\n    return fromCompare(function (first, second) {\n      return fa.compare(f(first), f(second));\n    });\n  };\n};\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Ord';\n/**\n * A typical use case for the `Semigroup` instance of `Ord` is merging two or more orderings.\n *\n * For example the following snippet builds an `Ord` for a type `User` which\n * sorts by `created` date descending, and **then** `lastName`\n *\n * @example\n * import * as D from 'fp-ts/Date'\n * import { pipe } from 'fp-ts/function'\n * import { contramap, getSemigroup, Ord, reverse } from 'fp-ts/Ord'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as S from 'fp-ts/string'\n *\n * interface User {\n *   readonly id: string\n *   readonly lastName: string\n *   readonly created: Date\n * }\n *\n * const ordByLastName: Ord<User> = pipe(\n *   S.Ord,\n *   contramap((user) => user.lastName)\n * )\n *\n * const ordByCreated: Ord<User> = pipe(\n *   D.Ord,\n *   contramap((user) => user.created)\n * )\n *\n * const ordUserByCreatedDescThenLastName = getSemigroup<User>().concat(\n *   reverse(ordByCreated),\n *   ordByLastName\n * )\n *\n * assert.deepStrictEqual(\n *   RA.sort(ordUserByCreatedDescThenLastName)([\n *     { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) },\n *     { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },\n *     { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) }\n *   ]),\n *   [\n *     { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) },\n *     { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },\n *     { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) }\n *   ]\n * )\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return fromCompare(function (a, b) {\n        var ox = first.compare(a, b);\n        return ox !== 0 ? ox : second.compare(a, b);\n      });\n    }\n  };\n};\n/**\n * Returns a `Monoid` such that:\n *\n * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`\n * - its `empty` value is an `Ord` that always considers compared elements equal\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import { contramap, reverse, getMonoid } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as B from 'fp-ts/boolean'\n * import { pipe } from 'fp-ts/function'\n * import { concatAll } from 'fp-ts/Monoid'\n * import * as N from 'fp-ts/number'\n *\n * interface User {\n *   readonly id: number\n *   readonly name: string\n *   readonly age: number\n *   readonly rememberMe: boolean\n * }\n *\n * const byName = pipe(\n *   S.Ord,\n *   contramap((p: User) => p.name)\n * )\n *\n * const byAge = pipe(\n *   N.Ord,\n *   contramap((p: User) => p.age)\n * )\n *\n * const byRememberMe = pipe(\n *   B.Ord,\n *   contramap((p: User) => p.rememberMe)\n * )\n *\n * const M = getMonoid<User>()\n *\n * const users: Array<User> = [\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }\n * ]\n *\n * // sort by name, then by age, then by `rememberMe`\n * const O1 = concatAll(M)([byName, byAge, byRememberMe])\n * assert.deepStrictEqual(sort(O1)(users), [\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * // now `rememberMe = true` first, then by name, then by age\n * const O2 = concatAll(M)([reverse(byRememberMe), byName, byAge])\n * assert.deepStrictEqual(sort(O2)(users), [\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * @category instances\n * @since 2.4.0\n */\nexport var getMonoid = function () {\n  return {\n    concat: getSemigroup().concat,\n    empty: fromCompare(function () {\n      return 0;\n    })\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Contravariant = {\n  URI: URI,\n  contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var trivial = {\n  equals: constTrue,\n  compare: /*#__PURE__*/constant(0)\n};\n/**\n * @since 2.11.0\n */\nexport var equals = function (O) {\n  return function (second) {\n    return function (first) {\n      return first === second || O.compare(first, second) === 0;\n    };\n  };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly less than_ another\n *\n * @since 2.0.0\n */\nexport var lt = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) === -1;\n  };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport var gt = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) === 1;\n  };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly less than_ another\n *\n * @since 2.0.0\n */\nexport var leq = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) !== 1;\n  };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport var geq = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) !== -1;\n  };\n};\n// TODO: curry in v3\n/**\n * Take the minimum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport var min = function (O) {\n  return function (first, second) {\n    return first === second || O.compare(first, second) < 1 ? first : second;\n  };\n};\n// TODO: curry in v3\n/**\n * Take the maximum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport var max = function (O) {\n  return function (first, second) {\n    return first === second || O.compare(first, second) > -1 ? first : second;\n  };\n};\n/**\n * Clamp a value between a minimum and a maximum\n *\n * @since 2.0.0\n */\nexport var clamp = function (O) {\n  var minO = min(O);\n  var maxO = max(O);\n  return function (low, hi) {\n    return function (a) {\n      return maxO(minO(a, hi), low);\n    };\n  };\n};\n/**\n * Test whether a value is between a minimum and a maximum (inclusive)\n *\n * @since 2.0.0\n */\nexport var between = function (O) {\n  var ltO = lt(O);\n  var gtO = gt(O);\n  return function (low, hi) {\n    return function (a) {\n      return ltO(a, low) || gtO(a, hi) ? false : true;\n    };\n  };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleOrd = tuple;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualOrd = reverse;\n/**\n * Use [`Contravariant`](#contravariant) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ord = Contravariant;\n// default compare for primitive types\nfunction compare(first, second) {\n  return first < second ? -1 : first > second ? 1 : 0;\n}\nvar strictOrd = {\n  equals: eqStrict.equals,\n  compare: compare\n};\n/**\n * Use [`Ord`](./boolean.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordBoolean = strictOrd;\n/**\n * Use [`Ord`](./string.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordString = strictOrd;\n/**\n * Use [`Ord`](./number.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordNumber = strictOrd;\n/**\n * Use [`Ord`](./Date.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordDate = /*#__PURE__*/pipe(ordNumber, /*#__PURE__*/\ncontramap(function (date) {\n  return date.valueOf();\n}));","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEquals } from './Eq';\nimport { dual, flow, identity, pipe, SK } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { getMonoid } from './Ord';\nimport * as Se from './Semigroup';\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nexport var empty = _.emptyReadonlyArray;\n/**\n * @internal\n */\nexport var isNonEmpty = _.isNonEmpty;\n/**\n * @internal\n */\nexport var isOutOfBound = function (i, as) {\n  return i < 0 || i >= as.length;\n};\n/**\n * @internal\n */\nexport var prependW = function (head) {\n  return function (tail) {\n    return __spreadArray([head], tail, true);\n  };\n};\n/**\n * @internal\n */\nexport var prepend = prependW;\n/**\n * @internal\n */\nexport var appendW = function (end) {\n  return function (init) {\n    return __spreadArray(__spreadArray([], init, true), [end], false);\n  };\n};\n/**\n * @internal\n */\nexport var append = appendW;\n/**\n * @internal\n */\nexport var unsafeInsertAt = function (i, a, as) {\n  if (isNonEmpty(as)) {\n    var xs = _.fromReadonlyNonEmptyArray(as);\n    xs.splice(i, 0, a);\n    return xs;\n  }\n  return [a];\n};\n/**\n * @internal\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n  if (as[i] === a) {\n    return as;\n  } else {\n    var xs = _.fromReadonlyNonEmptyArray(as);\n    xs[i] = a;\n    return xs;\n  }\n};\n/**\n * Remove duplicates from a `ReadonlyNonEmptyArray`, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyNonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.11.0\n */\nexport var uniq = function (E) {\n  return function (as) {\n    if (as.length === 1) {\n      return as;\n    }\n    var out = [head(as)];\n    var rest = tail(as);\n    var _loop_1 = function (a) {\n      if (out.every(function (o) {\n        return !E.equals(o, a);\n      })) {\n        out.push(a);\n      }\n    };\n    for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {\n      var a = rest_1[_i];\n      _loop_1(a);\n    }\n    return out;\n  };\n};\n/**\n * Sort the elements of a `ReadonlyNonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { contramap } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n *\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n *\n * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))\n *\n * const sortByNameByAge = RNEA.sortBy([byName, byAge])\n *\n * const persons: RNEA.ReadonlyNonEmptyArray<Person> = [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 },\n *   { name: 'b', age: 2 }\n * ]\n *\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @since 2.11.0\n */\nexport var sortBy = function (ords) {\n  if (isNonEmpty(ords)) {\n    var M = getMonoid();\n    return sort(ords.reduce(M.concat, M.empty));\n  }\n  return identity;\n};\n/**\n * @since 2.11.0\n */\nexport var union = function (E) {\n  var uniqE = uniq(E);\n  return function (second) {\n    return function (first) {\n      return uniqE(pipe(first, concat(second)));\n    };\n  };\n};\n/**\n * Rotate a `ReadonlyNonEmptyArray` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n * assert.deepStrictEqual(rotate(-2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])\n *\n * @since 2.11.0\n */\nexport var rotate = function (n) {\n  return function (as) {\n    var len = as.length;\n    var m = Math.round(n) % len;\n    if (isOutOfBound(Math.abs(m), as) || m === 0) {\n      return as;\n    }\n    if (m < 0) {\n      var _a = splitAt(-m)(as),\n        f = _a[0],\n        s = _a[1];\n      return pipe(s, concat(f));\n    } else {\n      return rotate(m - len)(as);\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Return a `ReadonlyNonEmptyArray` from a `ReadonlyArray` returning `none` if the input is empty.\n *\n * @category conversions\n * @since 2.5.0\n */\nexport var fromReadonlyArray = function (as) {\n  return isNonEmpty(as) ? _.some(as) : _.none;\n};\n/**\n * Return a `ReadonlyNonEmptyArray` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { makeBy } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(pipe(5, makeBy(double)), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var makeBy = function (f) {\n  return function (n) {\n    var j = Math.max(0, Math.floor(n));\n    var out = [f(0)];\n    for (var i = 1; i < j; i++) {\n      out.push(f(i));\n    }\n    return out;\n  };\n};\n/**\n * Create a `ReadonlyNonEmptyArray` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { replicate } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(3, replicate('a')), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var replicate = function (a) {\n  return makeBy(function () {\n    return a;\n  });\n};\n/**\n * Create a `ReadonlyNonEmptyArray` containing a range of integers, including both endpoints.\n *\n * @example\n * import { range } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var range = function (start, end) {\n  return start <= end ? makeBy(function (i) {\n    return start + i;\n  })(end - start + 1) : [start];\n};\n/**\n * Return the tuple of the `head` and the `tail`.\n *\n * @example\n * import { unprepend } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])\n *\n * @since 2.9.0\n */\nexport var unprepend = function (as) {\n  return [head(as), tail(as)];\n};\n/**\n * Return the tuple of the `init` and the `last`.\n *\n * @example\n * import { unappend } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unappend([1, 2, 3, 4]), [[1, 2, 3], 4])\n *\n * @since 2.9.0\n */\nexport var unappend = function (as) {\n  return [init(as), last(as)];\n};\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var fromArray = function (as) {\n  return fromReadonlyArray(as.slice());\n};\nexport function concatW(second) {\n  return function (first) {\n    return first.concat(second);\n  };\n}\nexport function concat(x, y) {\n  return y ? x.concat(y) : function (y) {\n    return y.concat(x);\n  };\n}\n/**\n * @since 2.5.0\n */\nexport var reverse = function (as) {\n  return as.length === 1 ? as : __spreadArray([last(as)], as.slice(0, -1).reverse(), true);\n};\nexport function group(E) {\n  return function (as) {\n    var len = as.length;\n    if (len === 0) {\n      return empty;\n    }\n    var out = [];\n    var head = as[0];\n    var nea = [head];\n    for (var i = 1; i < len; i++) {\n      var a = as[i];\n      if (E.equals(a, head)) {\n        nea.push(a);\n      } else {\n        out.push(nea);\n        head = a;\n        nea = [head];\n      }\n    }\n    out.push(nea);\n    return out;\n  };\n}\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { groupBy } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['a', 'b', 'ab']), {\n *   '1': ['a', 'b'],\n *   '2': ['ab']\n * })\n *\n * @since 2.5.0\n */\nexport var groupBy = function (f) {\n  return function (as) {\n    var out = {};\n    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n      var a = as_1[_i];\n      var k = f(a);\n      if (_.has.call(out, k)) {\n        out[k].push(a);\n      } else {\n        out[k] = [a];\n      }\n    }\n    return out;\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var sort = function (O) {\n  return function (as) {\n    return as.length === 1 ? as : as.slice().sort(O.compare);\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var updateAt = function (i, a) {\n  return modifyAt(i, function () {\n    return a;\n  });\n};\n/**\n * @since 2.5.0\n */\nexport var modifyAt = function (i, f) {\n  return function (as) {\n    return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n  };\n};\n/**\n * @since 2.5.1\n */\nexport var zipWith = function (as, bs, f) {\n  var cs = [f(as[0], bs[0])];\n  var len = Math.min(as.length, bs.length);\n  for (var i = 1; i < len; i++) {\n    cs[i] = f(as[i], bs[i]);\n  }\n  return cs;\n};\nexport function zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return zipWith(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\n/**\n * @since 2.5.1\n */\nexport var unzip = function (abs) {\n  var fa = [abs[0][0]];\n  var fb = [abs[0][1]];\n  for (var i = 1; i < abs.length; i++) {\n    fa[i] = abs[i][0];\n    fb[i] = abs[i][1];\n  }\n  return [fa, fb];\n};\n/**\n * Prepend an element to every member of a `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { prependAll } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.10.0\n */\nexport var prependAll = function (middle) {\n  return function (as) {\n    var out = [middle, as[0]];\n    for (var i = 1; i < as.length; i++) {\n      out.push(middle, as[i]);\n    }\n    return out;\n  };\n};\n/**\n * Places an element in between members of a `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { intersperse } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.9.0\n */\nexport var intersperse = function (middle) {\n  return function (as) {\n    var rest = tail(as);\n    return isNonEmpty(rest) ? pipe(rest, prependAll(middle), prepend(head(as))) : as;\n  };\n};\n/**\n * @category sequencing\n * @since 2.10.0\n */\nexport var chainWithIndex = function (f) {\n  return function (as) {\n    var out = _.fromReadonlyNonEmptyArray(f(0, head(as)));\n    for (var i = 1; i < as.length; i++) {\n      out.push.apply(out, f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * A useful recursion pattern for processing a `ReadonlyNonEmptyArray` to produce a new `ReadonlyNonEmptyArray`, often used for \"chopping\" up the input\n * `ReadonlyNonEmptyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `ReadonlyNonEmptyArray` and produce a\n * value and the tail of the `ReadonlyNonEmptyArray`.\n *\n * @since 2.10.0\n */\nexport var chop = function (f) {\n  return function (as) {\n    var _a = f(as),\n      b = _a[0],\n      rest = _a[1];\n    var out = [b];\n    var next = rest;\n    while (isNonEmpty(next)) {\n      var _b = f(next),\n        b_1 = _b[0],\n        rest_2 = _b[1];\n      out.push(b_1);\n      next = rest_2;\n    }\n    return out;\n  };\n};\n/**\n * Splits a `ReadonlyNonEmptyArray` into two pieces, the first piece has max `n` elements.\n *\n * @since 2.10.0\n */\nexport var splitAt = function (n) {\n  return function (as) {\n    var m = Math.max(1, n);\n    return m >= as.length ? [as, empty] : [pipe(as.slice(1, m), prepend(head(as))), as.slice(m)];\n  };\n};\n/**\n * Splits a `ReadonlyNonEmptyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the `ReadonlyNonEmptyArray`.\n *\n * @since 2.10.0\n */\nexport var chunksOf = function (n) {\n  return chop(splitAt(n));\n};\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return pipe(fa, mapWithIndex(f));\n};\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return pipe(wa, extend(f));\n};\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = foldMap(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = foldMapWithIndex(M);\n  return function (fa, f) {\n    return pipe(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return pipe(fa, reduceRightWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (ta, f) {\n    return pipe(ta, traverseWithIndexF(f));\n  };\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var of = _.singleton;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3] as RNEA.ReadonlyNonEmptyArray<number>,\n *     RNEA.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n  return function (as) {\n    return pipe(as, concatW(that()));\n  };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `ReadonlyNonEmptyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RNEA.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.6.2\n */\nexport var alt = altW;\n/**\n * @since 2.5.0\n */\nexport var ap = function (as) {\n  return flatMap(function (f) {\n    return pipe(as, map(f));\n  });\n};\n/**\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RNEA.flatMap((n) => [`a${n}`, `b${n}`])\n *   ),\n *   ['a1', 'b1', 'a2', 'b2', 'a3', 'b3']\n * )\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return pipe(ma, chainWithIndex(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @since 2.5.0\n */\nexport var extend = function (f) {\n  return function (as) {\n    var next = tail(as);\n    var out = [f(as)];\n    while (isNonEmpty(next)) {\n      out.push(f(next));\n      next = tail(next);\n    }\n    return out;\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.5.0\n */\nexport var map = function (f) {\n  return mapWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * @category mapping\n * @since 2.5.0\n */\nexport var mapWithIndex = function (f) {\n  return function (as) {\n    var out = [f(0, head(as))];\n    for (var i = 1; i < as.length; i++) {\n      out.push(f(i, as[i]));\n    }\n    return out;\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n  return reduceWithIndex(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nexport var foldMap = function (S) {\n  return function (f) {\n    return function (as) {\n      return as.slice(1).reduce(function (s, a) {\n        return S.concat(s, f(a));\n      }, f(as[0]));\n    };\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n  return reduceRightWithIndex(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceWithIndex = function (b, f) {\n  return function (as) {\n    return as.reduce(function (b, a, i) {\n      return f(i, b, a);\n    }, b);\n  };\n};\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (S) {\n  return function (f) {\n    return function (as) {\n      return as.slice(1).reduce(function (s, a, i) {\n        return S.concat(s, f(i + 1, a));\n      }, f(0, as[0]));\n    };\n  };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = function (b, f) {\n  return function (as) {\n    return as.reduceRight(function (b, a, i) {\n      return f(i, a, b);\n    }, b);\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  var traverseWithIndexF = traverseWithIndex(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return traverseWithIndex(F)(SK);\n};\n/**\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n  return function (f) {\n    return function (as) {\n      var out = F.map(f(0, head(as)), of);\n      for (var i = 1; i < as.length; i++) {\n        out = F.ap(F.map(out, function (bs) {\n          return function (b) {\n            return pipe(bs, append(b));\n          };\n        }), f(i, as[i]));\n      }\n      return out;\n    };\n  };\n};\n/**\n * @category Comonad\n * @since 2.6.3\n */\nexport var extract = _.head;\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyNonEmptyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getShow = function (S) {\n  return {\n    show: function (as) {\n      return \"[\".concat(as.map(S.show).join(', '), \"]\");\n    }\n  };\n};\n/**\n * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getSemigroup = function () {\n  return {\n    concat: concat\n  };\n};\n/**\n * @example\n * import { getEq } from 'fp-ts/ReadonlyNonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals([1, 2], [1, 2]), true)\n * assert.strictEqual(E.equals([1, 2], [1, 3]), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getEq = function (E) {\n  return fromEquals(function (xs, ys) {\n    return xs.length === ys.length && xs.every(function (x, i) {\n      return E.equals(x, ys[i]);\n    });\n  });\n};\n/**\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = /*#__PURE__*/chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n  URI: URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n  URI: URI,\n  map: _map,\n  extend: _extend,\n  extract: extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.5.0\n */\nexport var head = extract;\n/**\n * @since 2.5.0\n */\nexport var tail = _.tail;\n/**\n * @since 2.5.0\n */\nexport var last = function (as) {\n  return as[as.length - 1];\n};\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.5.0\n */\nexport var init = function (as) {\n  return as.slice(0, -1);\n};\n/**\n * @since 2.5.0\n */\nexport var min = function (O) {\n  var S = Se.min(O);\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\n/**\n * @since 2.5.0\n */\nexport var max = function (O) {\n  var S = Se.max(O);\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\n/**\n * @since 2.10.0\n */\nexport var concatAll = function (S) {\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\n/**\n * Break a `ReadonlyArray` into its first element and remaining elements.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeft = function (f) {\n  return function (as) {\n    return f(head(as), tail(as));\n  };\n};\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRight = function (f) {\n  return function (as) {\n    return f(init(as), last(as));\n  };\n};\n/**\n * Apply a function to the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyHead = function (f) {\n  return function (as) {\n    return __spreadArray([f(head(as))], tail(as), true);\n  };\n};\n/**\n * Change the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateHead = function (a) {\n  return modifyHead(function () {\n    return a;\n  });\n};\n/**\n * Apply a function to the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyLast = function (f) {\n  return function (as) {\n    return pipe(init(as), append(f(last(as))));\n  };\n};\n/**\n * Change the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateLast = function (a) {\n  return modifyLast(function () {\n    return a;\n  });\n};\n/**\n * Places an element in between members of a `ReadonlyNonEmptyArray`, then folds the results using the provided `Semigroup`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = function (S) {\n  var concatAllS = concatAll(S);\n  return function (middle) {\n    return flow(intersperse(middle), concatAllS);\n  };\n};\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexport var chain = flatMap;\nexport function groupSort(O) {\n  var sortO = sort(O);\n  var groupO = group(O);\n  return function (as) {\n    return isNonEmpty(as) ? groupO(sortO(as)) : empty;\n  };\n}\nexport function filter(predicate) {\n  return filterWithIndex(function (_, a) {\n    return predicate(a);\n  });\n}\n/**\n * Use [`filterWithIndex`](./ReadonlyArray.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var filterWithIndex = function (predicate) {\n  return function (as) {\n    return fromReadonlyArray(as.filter(function (a, i) {\n      return predicate(i, a);\n    }));\n  };\n};\n/**\n * Use [`unprepend`](#unprepend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var uncons = unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var unsnoc = unappend;\nexport function cons(head, tail) {\n  return tail === undefined ? prepend(head) : pipe(tail, prepend(head));\n}\n/**\n * Use [`append`](./ReadonlyArray.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var snoc = function (init, end) {\n  return pipe(init, concat([end]));\n};\n/**\n * Use [`insertAt`](./ReadonlyArray.ts.html#insertat) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some(unsafeInsertAt(i, a, as));\n  };\n};\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * Use [`concatAll`](#concatall) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var fold = concatAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `RNEA.Functor` instead of `RNEA.readonlyNonEmptyArray`\n * (where `RNEA` is from `import RNEA from 'fp-ts/ReadonlyNonEmptyArray'`)\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var readonlyNonEmptyArray = {\n  URI: URI,\n  of: of,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  ap: _ap,\n  chain: flatMap,\n  extend: _extend,\n  extract: extract,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  alt: _alt\n};","/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nimport { getSemigroup, identity } from './function';\nimport * as _ from './internal';\nimport * as M from './Magma';\nimport * as Or from './Ord';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.min(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var min = function (O) {\n  return {\n    concat: Or.min(O)\n  };\n};\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.max(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var max = function (O) {\n  return {\n    concat: Or.max(O)\n  };\n};\n/**\n * @category constructors\n * @since 2.10.0\n */\nexport var constant = function (a) {\n  return {\n    concat: function () {\n      return a;\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n *\n * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')\n *\n * @since 2.10.0\n */\nexport var reverse = M.reverse;\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import { struct } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const S = struct<Point>({\n *   x: N.SemigroupSum,\n *   y: N.SemigroupSum\n * })\n *\n * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @since 2.10.0\n */\nexport var struct = function (semigroups) {\n  return {\n    concat: function (first, second) {\n      var r = {};\n      for (var k in semigroups) {\n        if (_.has.call(semigroups, k)) {\n          r[k] = semigroups[k].concat(first[k], second[k]);\n        }\n      }\n      return r;\n    }\n  };\n};\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Semigroup'\n * import * as B from 'fp-ts/boolean'\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/string'\n *\n * const S1 = tuple(S.Semigroup, N.SemigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n  var semigroups = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    semigroups[_i] = arguments[_i];\n  }\n  return {\n    concat: function (first, second) {\n      return semigroups.map(function (s, i) {\n        return s.concat(first[i], second[i]);\n      });\n    }\n  };\n};\n/**\n * Between each pair of elements insert `middle`.\n *\n * @example\n * import { intercalate } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n * import { pipe } from 'fp-ts/function'\n *\n * const S1 = pipe(S.Semigroup, intercalate(' + '))\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a + b')\n *\n * @since 2.10.0\n */\nexport var intercalate = function (middle) {\n  return function (S) {\n    return {\n      concat: function (x, y) {\n        return S.concat(x, S.concat(middle, y));\n      }\n    };\n  };\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var first = function () {\n  return {\n    concat: identity\n  };\n};\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var last = function () {\n  return {\n    concat: function (_, y) {\n      return y;\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Given a sequence of `as`, concat them and return the total.\n *\n * If `as` is empty, return the provided `startWith` value.\n *\n * @example\n * import { concatAll } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * const sum = concatAll(N.SemigroupSum)(0)\n *\n * assert.deepStrictEqual(sum([1, 2, 3]), 6)\n * assert.deepStrictEqual(sum([]), 0)\n *\n * @since 2.10.0\n */\nexport var concatAll = M.concatAll;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `void` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupVoid = constant(undefined);\n/**\n * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getObjectSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return Object.assign({}, first, second);\n    }\n  };\n};\n/**\n * Use [`last`](#last) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getLastSemigroup = last;\n/**\n * Use [`first`](#first) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFirstSemigroup = first;\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleSemigroup = tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getStructSemigroup = struct;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualSemigroup = reverse;\n/**\n * Use [`max`](#max) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getJoinSemigroup = max;\n/**\n * Use [`min`](#min) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getMeetSemigroup = min;\n/**\n * Use [`intercalate`](#intercalate) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var getIntercalateSemigroup = intercalate;\nexport function fold(S) {\n  var concatAllS = concatAll(S);\n  return function (startWith, as) {\n    return as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as);\n  };\n}\n/**\n * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAll = {\n  concat: function (x, y) {\n    return x && y;\n  }\n};\n/**\n * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAny = {\n  concat: function (x, y) {\n    return x || y;\n  }\n};\n/**\n * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionSemigroup = getSemigroup;\n/**\n * Use [`Semigroup`](./string.ts.html#Semigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupString = {\n  concat: function (x, y) {\n    return x + y;\n  }\n};\n/**\n * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupSum = {\n  concat: function (x, y) {\n    return x + y;\n  }\n};\n/**\n * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupProduct = {\n  concat: function (x, y) {\n    return x * y;\n  }\n};","/**\n * ```ts\n * interface Separated<E, A> {\n *    readonly left: E\n *    readonly right: A\n * }\n * ```\n *\n * Represents a result of separating a whole into two parts.\n *\n * @since 2.10.0\n */\nimport { pipe } from './function';\nimport { flap as flap_ } from './Functor';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.10.0\n */\nexport var separated = function (left, right) {\n  return {\n    left: left,\n    right: right\n  };\n};\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\nvar _mapLeft = function (fa, f) {\n  return pipe(fa, mapLeft(f));\n};\nvar _bimap = function (fa, g, f) {\n  return pipe(fa, bimap(g, f));\n};\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.10.0\n */\nexport var map = function (f) {\n  return function (fa) {\n    return separated(left(fa), f(right(fa)));\n  };\n};\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category error handling\n * @since 2.10.0\n */\nexport var mapLeft = function (f) {\n  return function (fa) {\n    return separated(f(left(fa)), right(fa));\n  };\n};\n/**\n * Map a pair of functions over the two type arguments of the bifunctor.\n *\n * @category mapping\n * @since 2.10.0\n */\nexport var bimap = function (f, g) {\n  return function (fa) {\n    return separated(f(left(fa)), g(right(fa)));\n  };\n};\n/**\n * @category type lambdas\n * @since 2.10.0\n */\nexport var URI = 'Separated';\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Bifunctor = {\n  URI: URI,\n  mapLeft: _mapLeft,\n  bimap: _bimap\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.10.0\n */\nexport var left = function (s) {\n  return s.left;\n};\n/**\n * @since 2.10.0\n */\nexport var right = function (s) {\n  return s.right;\n};","import * as _ from './internal';\nexport function wiltDefault(T, C) {\n  return function (F) {\n    var traverseF = T.traverse(F);\n    return function (wa, f) {\n      return F.map(traverseF(wa, f), C.separate);\n    };\n  };\n}\nexport function witherDefault(T, C) {\n  return function (F) {\n    var traverseF = T.traverse(F);\n    return function (wa, f) {\n      return F.map(traverseF(wa, f), C.compact);\n    };\n  };\n}\nexport function filterE(W) {\n  return function (F) {\n    var witherF = W.wither(F);\n    return function (predicate) {\n      return function (ga) {\n        return witherF(ga, function (a) {\n          return F.map(predicate(a), function (b) {\n            return b ? _.some(a) : _.none;\n          });\n        });\n      };\n    };\n  };\n}","export function guard(F, P) {\n  return function (b) {\n    return b ? P.of(undefined) : F.zero();\n  };\n}","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getBooleanAlgebra = function (B) {\n  return function () {\n    return {\n      meet: function (x, y) {\n        return function (a) {\n          return B.meet(x(a), y(a));\n        };\n      },\n      join: function (x, y) {\n        return function (a) {\n          return B.join(x(a), y(a));\n        };\n      },\n      zero: function () {\n        return B.zero;\n      },\n      one: function () {\n        return B.one;\n      },\n      implies: function (x, y) {\n        return function (a) {\n          return B.implies(x(a), y(a));\n        };\n      },\n      not: function (x) {\n        return function (a) {\n          return B.not(x(a));\n        };\n      }\n    };\n  };\n};\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getSemigroup = function (S) {\n  return function () {\n    return {\n      concat: function (f, g) {\n        return function (a) {\n          return S.concat(f(a), g(a));\n        };\n      }\n    };\n  };\n};\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getMonoid = function (M) {\n  var getSemigroupM = getSemigroup(M);\n  return function () {\n    return {\n      concat: getSemigroupM().concat,\n      empty: function () {\n        return M.empty;\n      }\n    };\n  };\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getSemiring = function (S) {\n  return {\n    add: function (f, g) {\n      return function (x) {\n        return S.add(f(x), g(x));\n      };\n    },\n    zero: function () {\n      return S.zero;\n    },\n    mul: function (f, g) {\n      return function (x) {\n        return S.mul(f(x), g(x));\n      };\n    },\n    one: function () {\n      return S.one;\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getRing = function (R) {\n  var S = getSemiring(R);\n  return {\n    add: S.add,\n    mul: S.mul,\n    one: S.one,\n    zero: S.zero,\n    sub: function (f, g) {\n      return function (x) {\n        return R.sub(f(x), g(x));\n      };\n    }\n  };\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var apply = function (a) {\n  return function (f) {\n    return f(a);\n  };\n};\n/**\n * @since 2.0.0\n */\nexport function identity(a) {\n  return a;\n}\n/**\n * @since 2.0.0\n */\nexport var unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nexport function constant(a) {\n  return function () {\n    return a;\n  };\n}\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexport var constTrue = /*#__PURE__*/constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexport var constFalse = /*#__PURE__*/constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexport var constNull = /*#__PURE__*/constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexport var constUndefined = /*#__PURE__*/constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexport var constVoid = constUndefined;\nexport function flip(f) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    if (args.length > 1) {\n      return f(args[1], args[0]);\n    }\n    return function (a) {\n      return f(a)(args[0]);\n    };\n  };\n}\nexport function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n  switch (arguments.length) {\n    case 1:\n      return ab;\n    case 2:\n      return function () {\n        return bc(ab.apply(this, arguments));\n      };\n    case 3:\n      return function () {\n        return cd(bc(ab.apply(this, arguments)));\n      };\n    case 4:\n      return function () {\n        return de(cd(bc(ab.apply(this, arguments))));\n      };\n    case 5:\n      return function () {\n        return ef(de(cd(bc(ab.apply(this, arguments)))));\n      };\n    case 6:\n      return function () {\n        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n      };\n    case 7:\n      return function () {\n        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n      };\n    case 8:\n      return function () {\n        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n      };\n    case 9:\n      return function () {\n        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n      };\n  }\n  return;\n}\n/**\n * @since 2.0.0\n */\nexport function tuple() {\n  var t = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    t[_i] = arguments[_i];\n  }\n  return t;\n}\n/**\n * @since 2.0.0\n */\nexport function increment(n) {\n  return n + 1;\n}\n/**\n * @since 2.0.0\n */\nexport function decrement(n) {\n  return n - 1;\n}\n/**\n * @since 2.0.0\n */\nexport function absurd(_) {\n  throw new Error('Called `absurd` function which should be uncallable');\n}\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nexport function tupled(f) {\n  return function (a) {\n    return f.apply(void 0, a);\n  };\n}\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nexport function untupled(f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return f(a);\n  };\n}\nexport function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n  switch (arguments.length) {\n    case 1:\n      return a;\n    case 2:\n      return ab(a);\n    case 3:\n      return bc(ab(a));\n    case 4:\n      return cd(bc(ab(a)));\n    case 5:\n      return de(cd(bc(ab(a))));\n    case 6:\n      return ef(de(cd(bc(ab(a)))));\n    case 7:\n      return fg(ef(de(cd(bc(ab(a))))));\n    case 8:\n      return gh(fg(ef(de(cd(bc(ab(a)))))));\n    case 9:\n      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n    default:\n      {\n        var ret = arguments[0];\n        for (var i = 1; i < arguments.length; i++) {\n          ret = arguments[i](ret);\n        }\n        return ret;\n      }\n  }\n}\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexport var hole = absurd;\n/**\n * @since 2.11.0\n */\nexport var SK = function (_, b) {\n  return b;\n};\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function not(predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n}\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var getEndomorphismMonoid = function () {\n  return {\n    concat: function (first, second) {\n      return flow(first, second);\n    },\n    empty: identity\n  };\n};\n/** @internal */\nexport var dual = function (arity, body) {\n  var isDataFirst = typeof arity === 'number' ? function (args) {\n    return args.length >= arity;\n  } : arity;\n  return function () {\n    var args = Array.from(arguments);\n    if (isDataFirst(arguments)) {\n      return body.apply(this, args);\n    }\n    return function (self) {\n      return body.apply(void 0, __spreadArray([self], args, false));\n    };\n  };\n};","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { dual } from './function';\n// -------------------------------------------------------------------------------------\n// Option\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var isNone = function (fa) {\n  return fa._tag === 'None';\n};\n/** @internal */\nexport var isSome = function (fa) {\n  return fa._tag === 'Some';\n};\n/** @internal */\nexport var none = {\n  _tag: 'None'\n};\n/** @internal */\nexport var some = function (a) {\n  return {\n    _tag: 'Some',\n    value: a\n  };\n};\n// -------------------------------------------------------------------------------------\n// Either\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var isLeft = function (ma) {\n  return ma._tag === 'Left';\n};\n/** @internal */\nexport var isRight = function (ma) {\n  return ma._tag === 'Right';\n};\n/** @internal */\nexport var left = function (e) {\n  return {\n    _tag: 'Left',\n    left: e\n  };\n};\n/** @internal */\nexport var right = function (a) {\n  return {\n    _tag: 'Right',\n    right: a\n  };\n};\n// -------------------------------------------------------------------------------------\n// ReadonlyNonEmptyArray\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var singleton = function (a) {\n  return [a];\n};\n/** @internal */\nexport var isNonEmpty = function (as) {\n  return as.length > 0;\n};\n/** @internal */\nexport var head = function (as) {\n  return as[0];\n};\n/** @internal */\nexport var tail = function (as) {\n  return as.slice(1);\n};\n// -------------------------------------------------------------------------------------\n// empty\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var emptyReadonlyArray = [];\n/** @internal */\nexport var emptyRecord = {};\n// -------------------------------------------------------------------------------------\n// Record\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var has = Object.prototype.hasOwnProperty;\n// -------------------------------------------------------------------------------------\n// NonEmptyArray\n// -------------------------------------------------------------------------------------\n/** @internal */\nexport var fromReadonlyNonEmptyArray = function (as) {\n  return __spreadArray([as[0]], as.slice(1), true);\n};\n/** @internal */\nexport var liftNullable = function (F) {\n  return function (f, onNullable) {\n    return function () {\n      var a = [];\n      for (var _i = 0; _i < arguments.length; _i++) {\n        a[_i] = arguments[_i];\n      }\n      var o = f.apply(void 0, a);\n      return F.fromEither(o == null ? left(onNullable.apply(void 0, a)) : right(o));\n    };\n  };\n};\n/** @internal */\nexport var liftOption = function (F) {\n  return function (f, onNone) {\n    return function () {\n      var a = [];\n      for (var _i = 0; _i < arguments.length; _i++) {\n        a[_i] = arguments[_i];\n      }\n      var o = f.apply(void 0, a);\n      return F.fromEither(isNone(o) ? left(onNone.apply(void 0, a)) : right(o.value));\n    };\n  };\n};\n/** @internal */\nexport var flatMapNullable = function (F, M) {\n  /*#__PURE__*/return dual(3, function (self, f, onNullable) {\n    return M.flatMap(self, liftNullable(F)(f, onNullable));\n  });\n};\n/** @internal */\nexport var flatMapOption = function (F, M) {\n  /*#__PURE__*/return dual(3, function (self, f, onNone) {\n    return M.flatMap(self, liftOption(F)(f, onNone));\n  });\n};\n/** @internal */\nexport var flatMapEither = function (F, M) {\n  /*#__PURE__*/return dual(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromEither(f(a));\n    });\n  });\n};\n/** @internal */\nexport var flatMapIO = function (F, M) {\n  /*#__PURE__*/return dual(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromIO(f(a));\n    });\n  });\n};\n/** @internal */\nexport var flatMapTask = function (F, M) {\n  /*#__PURE__*/return dual(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromTask(f(a));\n    });\n  });\n};\n/** @internal */\nexport var flatMapReader = function (F, M) {\n  /*#__PURE__*/return dual(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromReader(f(a));\n    });\n  });\n};","\"use strict\";\n\nvar __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.dual = 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;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getBooleanAlgebra = function (B) {\n  return function () {\n    return {\n      meet: function (x, y) {\n        return function (a) {\n          return B.meet(x(a), y(a));\n        };\n      },\n      join: function (x, y) {\n        return function (a) {\n          return B.join(x(a), y(a));\n        };\n      },\n      zero: function () {\n        return B.zero;\n      },\n      one: function () {\n        return B.one;\n      },\n      implies: function (x, y) {\n        return function (a) {\n          return B.implies(x(a), y(a));\n        };\n      },\n      not: function (x) {\n        return function (a) {\n          return B.not(x(a));\n        };\n      }\n    };\n  };\n};\nexports.getBooleanAlgebra = getBooleanAlgebra;\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getSemigroup = function (S) {\n  return function () {\n    return {\n      concat: function (f, g) {\n        return function (a) {\n          return S.concat(f(a), g(a));\n        };\n      }\n    };\n  };\n};\nexports.getSemigroup = getSemigroup;\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getMonoid = function (M) {\n  var getSemigroupM = (0, exports.getSemigroup)(M);\n  return function () {\n    return {\n      concat: getSemigroupM().concat,\n      empty: function () {\n        return M.empty;\n      }\n    };\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getSemiring = function (S) {\n  return {\n    add: function (f, g) {\n      return function (x) {\n        return S.add(f(x), g(x));\n      };\n    },\n    zero: function () {\n      return S.zero;\n    },\n    mul: function (f, g) {\n      return function (x) {\n        return S.mul(f(x), g(x));\n      };\n    },\n    one: function () {\n      return S.one;\n    }\n  };\n};\nexports.getSemiring = getSemiring;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getRing = function (R) {\n  var S = (0, exports.getSemiring)(R);\n  return {\n    add: S.add,\n    mul: S.mul,\n    one: S.one,\n    zero: S.zero,\n    sub: function (f, g) {\n      return function (x) {\n        return R.sub(f(x), g(x));\n      };\n    }\n  };\n};\nexports.getRing = getRing;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nvar apply = function (a) {\n  return function (f) {\n    return f(a);\n  };\n};\nexports.apply = apply;\n/**\n * @since 2.0.0\n */\nfunction identity(a) {\n  return a;\n}\nexports.identity = identity;\n/**\n * @since 2.0.0\n */\nexports.unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nfunction constant(a) {\n  return function () {\n    return a;\n  };\n}\nexports.constant = constant;\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexports.constTrue = constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexports.constFalse = constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexports.constNull = constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexports.constUndefined = constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexports.constVoid = exports.constUndefined;\nfunction flip(f) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    if (args.length > 1) {\n      return f(args[1], args[0]);\n    }\n    return function (a) {\n      return f(a)(args[0]);\n    };\n  };\n}\nexports.flip = flip;\nfunction flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n  switch (arguments.length) {\n    case 1:\n      return ab;\n    case 2:\n      return function () {\n        return bc(ab.apply(this, arguments));\n      };\n    case 3:\n      return function () {\n        return cd(bc(ab.apply(this, arguments)));\n      };\n    case 4:\n      return function () {\n        return de(cd(bc(ab.apply(this, arguments))));\n      };\n    case 5:\n      return function () {\n        return ef(de(cd(bc(ab.apply(this, arguments)))));\n      };\n    case 6:\n      return function () {\n        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n      };\n    case 7:\n      return function () {\n        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n      };\n    case 8:\n      return function () {\n        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n      };\n    case 9:\n      return function () {\n        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n      };\n  }\n  return;\n}\nexports.flow = flow;\n/**\n * @since 2.0.0\n */\nfunction tuple() {\n  var t = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    t[_i] = arguments[_i];\n  }\n  return t;\n}\nexports.tuple = tuple;\n/**\n * @since 2.0.0\n */\nfunction increment(n) {\n  return n + 1;\n}\nexports.increment = increment;\n/**\n * @since 2.0.0\n */\nfunction decrement(n) {\n  return n - 1;\n}\nexports.decrement = decrement;\n/**\n * @since 2.0.0\n */\nfunction absurd(_) {\n  throw new Error('Called `absurd` function which should be uncallable');\n}\nexports.absurd = absurd;\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nfunction tupled(f) {\n  return function (a) {\n    return f.apply(void 0, a);\n  };\n}\nexports.tupled = tupled;\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nfunction untupled(f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return f(a);\n  };\n}\nexports.untupled = untupled;\nfunction pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n  switch (arguments.length) {\n    case 1:\n      return a;\n    case 2:\n      return ab(a);\n    case 3:\n      return bc(ab(a));\n    case 4:\n      return cd(bc(ab(a)));\n    case 5:\n      return de(cd(bc(ab(a))));\n    case 6:\n      return ef(de(cd(bc(ab(a)))));\n    case 7:\n      return fg(ef(de(cd(bc(ab(a))))));\n    case 8:\n      return gh(fg(ef(de(cd(bc(ab(a)))))));\n    case 9:\n      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n    default:\n      {\n        var ret = arguments[0];\n        for (var i = 1; i < arguments.length; i++) {\n          ret = arguments[i](ret);\n        }\n        return ret;\n      }\n  }\n}\nexports.pipe = pipe;\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexports.hole = absurd;\n/**\n * @since 2.11.0\n */\nvar SK = function (_, b) {\n  return b;\n};\nexports.SK = SK;\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nfunction not(predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n}\nexports.not = not;\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nvar getEndomorphismMonoid = function () {\n  return {\n    concat: function (first, second) {\n      return flow(first, second);\n    },\n    empty: identity\n  };\n};\nexports.getEndomorphismMonoid = getEndomorphismMonoid;\n/** @internal */\nvar dual = function (arity, body) {\n  var isDataFirst = typeof arity === 'number' ? function (args) {\n    return args.length >= arity;\n  } : arity;\n  return function () {\n    var args = Array.from(arguments);\n    if (isDataFirst(arguments)) {\n      return body.apply(this, args);\n    }\n    return function (self) {\n      return body.apply(void 0, __spreadArray([self], args, false));\n    };\n  };\n};\nexports.dual = dual;"],"names":["hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","toString","Object","prototype","includes","key","call","join","module","exports","default","getApplicativeMonoid","F","f","M","concat","empty","of","apFirst","A","second","first","ap","map","a","apSecond","b","apS","name","fb","fa","_a","assign","getApplySemigroup","S","x","y","equals","Ord","compare","__spreadArray","to","from","pack","ar","l","slice","isNonEmpty","match","onEmpty","onNonEmpty","as","isOutOfBound","elem","E","undefined","elemE_1","element","_chainRecDepthFirst","chainRecDepthFirst","_chainRecBreadthFirst","chainRecBreadthFirst","filterMapWithIndex","out","optionB","value","filterMap","_","foldMapWithIndex","reduce","reduceWithIndex","foldMap","foldMapWithIndexM","len","reduceRight","reduceRightWithIndex","todo","e","shift","unshift","left","right","initial","go","forEach","v","_i","initial_1","n","predicate","ma","lookup","copy","as_1","init","rest","reverse","r","_tag","O","sort","fc","Math","min","bs","middle","ords","g","input","scope","unionE","unionE_1","elemE","xs","ys","intersectionE_1","filter","differenceE_1","fab","predicateWithIndex","that","foldMapM","traverseF","ta","traverseWithIndexF","fa_1","wa","fas","fbs","_witherF","_wiltF","bb","mt","b_1","show","every","aLen","bLen","ordering","intersectionE","differenceE","URI","mapWithIndex","chain","unfold","alt","zero","extend","compact","separate","partition","partitionMap","partitionMapWithIndex","partitionWithIndex","filterWithIndex","traverse","sequence","traverseWithIndex","wither","wilt","chainRec","fromEither","splice","some","intercalateM","array","chainFirst","tapM","tap","bind","fromEquals","eqStrict","fromOption","onNone","fromPredicate","onFalse","fromOptionK","fromOptionF","chainOptionK","fromOptionKF","fromEitherK","chainEitherK","fromEitherKF","filterOrElse","tapEither","self","flap","bindTo","let_","asUnit","asM","prependW","head","tail","prepend","appendW","end","append","unsafeInsertAt","fromReadonlyNonEmptyArray","unsafeUpdateAt","uniq","_loop_1","o","rest_1","sortBy","union","uniqE","rotate","m","round","abs","splitAt","s","fromArray","makeBy","j","max","floor","replicate","range","start","unprepend","unappend","last","concatW","group","nea","groupBy","k","insertAt","updateAt","modifyAt","zipWith","cs","zip","unzip","prependAll","intersperse","chainWithIndex","chop","next","_b","rest_2","chunksOf","_map","_mapWithIndex","_ap","_extend","_reduce","_foldMap","_reduceRight","_traverse","_alt","_reduceWithIndex","_foldMapWithIndex","_reduceRightWithIndex","_traverseWithIndex","altW","flatMap","duplicate","flatten","extract","getShow","getSemigroup","getEq","getUnionSemigroup","Functor","Pointed","FunctorWithIndex","Apply","Applicative","Chain","Monad","Foldable","FoldableWithIndex","Traversable","TraversableWithIndex","Alt","Comonad","Do","concatAll","matchLeft","matchRight","modifyHead","updateHead","modifyLast","updateLast","intercalate","groupSort","sortO","groupO","uncons","unsnoc","cons","snoc","prependToAll","fold","nonEmptyArray","none","getLeft","getRight","_filter","_filterMap","_partition","_partitionMap","isNone","getOrd","isSome","getMonoid","orElse","guard","Alternative","Extend","defaultSeparated","Compactable","not","Filterable","_wither","_wilt","throwError","MonadThrow","matchW","onSome","foldW","getOrElseW","getOrElse","chainFirstEitherK","fromNullable","tryCatch","tryCatchK","fromNullableK","chainNullableK","toNullable","toUndefined","exists","ApT","traverseReadonlyNonEmptyArrayWithIndex","o_1","traverseReadonlyArrayWithIndex","traverseArrayWithIndex","traverseArray","sequenceArray","getRefinement","getOption","mapNullable","getApplyMonoid","getFirstMonoid","getLastMonoid","equalsDefault","fromCompare","contramap","ox","concatAllS","separated","wiltDefault","T","C","witherDefault","filterE","W","witherF","ga","P","identity","constant","constTrue","constNull","constUndefined","flow","ab","bc","cd","de","ef","fg","gh","hi","ij","this","pipe","ret","SK","dual","arity","body","isDataFirst","args","isLeft","isRight","singleton","emptyReadonlyArray","emptyRecord","has","liftNullable","onNullable","liftOption","flatMapNullable","flatMapOption","defineProperty","getEndomorphismMonoid","hole","untupled","tupled","absurd","decrement","increment","tuple","flip","constVoid","constFalse","unsafeCoerce","getRing","getSemiring","getBooleanAlgebra","B","meet","one","implies","getSemigroupM","add","mul","R","sub","Error","t"],"sourceRoot":""}