{"version":3,"file":"js/9982-7d2743120c6d3c9ad122.js","mappings":"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","sources":["webpack://uk-b2c/./node_modules/@tabler/icons-react/dist/esm/icons/IconSearch.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Apply.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Array.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Chain.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Eq.js","webpack://uk-b2c/./node_modules/fp-ts/lib/FromEither.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Functor.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Magma.js","webpack://uk-b2c/./node_modules/fp-ts/lib/NonEmptyArray.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Ord.js","webpack://uk-b2c/./node_modules/fp-ts/lib/ReadonlyArray.js","webpack://uk-b2c/./node_modules/fp-ts/lib/ReadonlyNonEmptyArray.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Semigroup.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Separated.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Witherable.js","webpack://uk-b2c/./node_modules/fp-ts/lib/Zero.js","webpack://uk-b2c/./node_modules/fp-ts/lib/internal.js","webpack://uk-b2c/./node_modules/fp-ts/lib/number.js"],"sourcesContent":["/**\n * @tabler/icons-react v2.42.0 - MIT\n */\n\nimport createReactComponent from '../createReactComponent.js';\nvar IconSearch = createReactComponent(\"search\", \"IconSearch\", [[\"path\", {\n  d: \"M10 10m-7 0a7 7 0 1 0 14 0a7 7 0 1 0 -14 0\",\n  key: \"svg-0\"\n}], [\"path\", {\n  d: \"M21 21l-6 -6\",\n  key: \"svg-1\"\n}]]);\nexport { IconSearch as default };","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.sequenceS = exports.sequenceT = exports.getApplySemigroup = exports.apS = exports.apSecond = exports.apFirst = exports.ap = void 0;\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 */\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nfunction 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}\nexports.ap = ap;\nfunction 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}\nexports.apFirst = apFirst;\nfunction 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}\nexports.apSecond = apSecond;\nfunction 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}\nexports.apS = apS;\nfunction 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}\nexports.getApplySemigroup = getApplySemigroup;\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(function_1.tuple, len - 1, []);\n  }\n  return tupleConstructors[len];\n}\nfunction 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}\nexports.sequenceT = sequenceT;\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}\nfunction 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}\nexports.sequenceS = sequenceS;","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.lefts = exports.rights = exports.reverse = exports.modifyAt = exports.deleteAt = exports.updateAt = exports.insertAt = exports.copy = exports.findLastIndex = exports.findLastMap = exports.findLast = exports.findFirstMap = exports.findFirst = exports.findIndex = exports.dropLeftWhile = exports.dropRight = exports.dropLeft = exports.spanLeft = exports.takeLeftWhile = exports.takeRight = exports.takeLeft = exports.init = exports.tail = exports.last = exports.head = exports.lookup = exports.isOutOfBound = exports.size = exports.scanRight = exports.scanLeft = exports.chainWithIndex = exports.foldRight = exports.matchRight = exports.matchRightW = exports.foldLeft = exports.matchLeft = exports.matchLeftW = exports.match = exports.matchW = exports.fromEither = exports.fromOption = exports.fromPredicate = exports.replicate = exports.makeBy = exports.appendW = exports.append = exports.prependW = exports.prepend = exports.isNonEmpty = exports.isEmpty = void 0;\nexports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.reduce = exports.foldMapWithIndex = exports.foldMap = exports.duplicate = exports.extend = exports.filterWithIndex = exports.alt = exports.altW = exports.partitionMapWithIndex = exports.partitionMap = exports.partitionWithIndex = exports.partition = exports.filter = exports.separate = exports.compact = exports.filterMap = exports.filterMapWithIndex = exports.mapWithIndex = exports.flatten = exports.flatMap = exports.ap = exports.map = exports.zero = exports.of = exports.difference = exports.intersection = exports.union = exports.concat = exports.concatW = exports.comprehension = exports.fromOptionK = exports.chunksOf = exports.splitAt = exports.chop = exports.sortBy = exports.uniq = exports.elem = exports.rotate = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.sort = void 0;\nexports.some = exports.every = exports.unsafeDeleteAt = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.fromEitherK = exports.FromEither = exports.filterE = exports.ChainRecBreadthFirst = exports.chainRecBreadthFirst = exports.ChainRecDepthFirst = exports.chainRecDepthFirst = exports.Witherable = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.FilterableWithIndex = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.guard = exports.Zero = exports.Alt = exports.Unfoldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getDifferenceMagma = exports.getIntersectionSemigroup = exports.getUnionMonoid = exports.getUnionSemigroup = exports.getOrd = exports.getEq = exports.getMonoid = exports.getSemigroup = exports.getShow = exports.URI = exports.unfold = exports.wilt = exports.wither = void 0;\nexports.array = exports.prependToAll = exports.snoc = exports.cons = exports.empty = exports.range = exports.chain = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.intercalate = exports.exists = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar NEA = __importStar(require(\"./NonEmptyArray\"));\nvar RA = __importStar(require(\"./ReadonlyArray\"));\nvar Separated_1 = require(\"./Separated\");\nvar Witherable_1 = require(\"./Witherable\");\nvar Zero_1 = require(\"./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 */\nvar isEmpty = function (as) {\n  return as.length === 0;\n};\nexports.isEmpty = isEmpty;\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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nvar makeBy = function (n, f) {\n  return n <= 0 ? [] : NEA.makeBy(f)(n);\n};\nexports.makeBy = makeBy;\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 */\nvar replicate = function (n, a) {\n  return (0, exports.makeBy)(n, function () {\n    return a;\n  });\n};\nexports.replicate = replicate;\nfunction fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? [a] : [];\n  };\n}\nexports.fromPredicate = fromPredicate;\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 */\nvar fromOption = function (ma) {\n  return _.isNone(ma) ? [] : [ma.value];\n};\nexports.fromOption = fromOption;\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 */\nvar fromEither = function (e) {\n  return _.isLeft(e) ? [] : [e.right];\n};\nexports.fromEither = fromEither;\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 */\nvar matchW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(as) : onEmpty();\n  };\n};\nexports.matchW = matchW;\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 */\nexports.match = exports.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 */\nvar matchLeftW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(NEA.head(as), NEA.tail(as)) : onEmpty();\n  };\n};\nexports.matchLeftW = matchLeftW;\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 */\nexports.matchLeft = exports.matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexports.foldLeft = exports.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 */\nvar matchRightW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(NEA.init(as), NEA.last(as)) : onEmpty();\n  };\n};\nexports.matchRightW = matchRightW;\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 */\nexports.matchRight = exports.matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexports.foldRight = exports.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 */\nvar 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};\nexports.chainWithIndex = chainWithIndex;\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 */\nvar 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};\nexports.scanLeft = scanLeft;\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 */\nvar 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};\nexports.scanRight = scanRight;\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 */\nvar size = function (as) {\n  return as.length;\n};\nexports.size = size;\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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nvar tail = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(NEA.tail(as)) : _.none;\n};\nexports.tail = tail;\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 */\nvar init = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(NEA.init(as)) : _.none;\n};\nexports.init = init;\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 */\nvar takeLeft = function (n) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(n, as) ? (0, exports.copy)(as) : as.slice(0, n);\n  };\n};\nexports.takeLeft = takeLeft;\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 */\nvar takeRight = function (n) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(n, as) ? (0, exports.copy)(as) : n === 0 ? [] : as.slice(-n);\n  };\n};\nexports.takeRight = takeRight;\nfunction 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}\nexports.takeLeftWhile = takeLeftWhile;\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};\nfunction spanLeft(predicate) {\n  return function (as) {\n    var _a = (0, exports.splitAt)(spanLeftIndex(as, predicate))(as),\n      init = _a[0],\n      rest = _a[1];\n    return {\n      init: init,\n      rest: rest\n    };\n  };\n}\nexports.spanLeft = spanLeft;\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 */\nvar dropLeft = function (n) {\n  return function (as) {\n    return n <= 0 || (0, exports.isEmpty)(as) ? (0, exports.copy)(as) : n >= as.length ? [] : as.slice(n, as.length);\n  };\n};\nexports.dropLeft = dropLeft;\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 */\nvar dropRight = function (n) {\n  return function (as) {\n    return n <= 0 || (0, exports.isEmpty)(as) ? (0, exports.copy)(as) : n >= as.length ? [] : as.slice(0, as.length - n);\n  };\n};\nexports.dropRight = dropRight;\nfunction dropLeftWhile(predicate) {\n  return function (as) {\n    return as.slice(spanLeftIndex(as, predicate));\n  };\n}\nexports.dropLeftWhile = dropLeftWhile;\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 */\nexports.findIndex = RA.findIndex;\nfunction findFirst(predicate) {\n  return RA.findFirst(predicate);\n}\nexports.findFirst = findFirst;\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 */\nexports.findFirstMap = RA.findFirstMap;\nfunction findLast(predicate) {\n  return RA.findLast(predicate);\n}\nexports.findLast = findLast;\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 */\nexports.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 */\nexports.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 */\nvar copy = function (as) {\n  return as.slice();\n};\nexports.copy = copy;\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 */\nvar insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some((0, exports.unsafeInsertAt)(i, a, as));\n  };\n};\nexports.insertAt = insertAt;\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 */\nvar updateAt = function (i, a) {\n  return (0, exports.modifyAt)(i, function () {\n    return a;\n  });\n};\nexports.updateAt = updateAt;\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 */\nvar deleteAt = function (i) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeDeleteAt)(i, as));\n  };\n};\nexports.deleteAt = deleteAt;\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 */\nvar modifyAt = function (i, f) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));\n  };\n};\nexports.modifyAt = modifyAt;\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 */\nvar reverse = function (as) {\n  return (0, exports.isEmpty)(as) ? [] : as.slice().reverse();\n};\nexports.reverse = reverse;\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 */\nvar 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};\nexports.rights = rights;\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 */\nvar 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};\nexports.lefts = lefts;\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 */\nvar sort = function (O) {\n  return function (as) {\n    return as.length <= 1 ? (0, exports.copy)(as) : as.slice().sort(O.compare);\n  };\n};\nexports.sort = sort;\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 */\nvar 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};\nexports.zipWith = zipWith;\nfunction zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return (0, exports.zipWith)(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\nexports.zip = zip;\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 */\nvar 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};\nexports.unzip = unzip;\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 */\nvar prependAll = function (middle) {\n  var f = NEA.prependAll(middle);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : [];\n  };\n};\nexports.prependAll = prependAll;\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 */\nvar intersperse = function (middle) {\n  var f = NEA.intersperse(middle);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as);\n  };\n};\nexports.intersperse = intersperse;\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 */\nvar rotate = function (n) {\n  var f = NEA.rotate(n);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as);\n  };\n};\nexports.rotate = rotate;\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 */\nexports.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 */\nvar uniq = function (E) {\n  var f = NEA.uniq(E);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as);\n  };\n};\nexports.uniq = uniq;\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 */\nvar sortBy = function (ords) {\n  var f = NEA.sortBy(ords);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as);\n  };\n};\nexports.sortBy = sortBy;\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 */\nvar chop = function (f) {\n  var g = NEA.chop(f);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? g(as) : [];\n  };\n};\nexports.chop = chop;\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 */\nvar splitAt = function (n) {\n  return function (as) {\n    return n >= 1 && (0, exports.isNonEmpty)(as) ? NEA.splitAt(n)(as) : (0, exports.isEmpty)(as) ? [(0, exports.copy)(as), []] : [[], (0, exports.copy)(as)];\n  };\n};\nexports.splitAt = splitAt;\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 */\nvar chunksOf = function (n) {\n  var f = NEA.chunksOf(n);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : [];\n  };\n};\nexports.chunksOf = chunksOf;\n/**\n * @category lifting\n * @since 2.11.0\n */\nvar 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 (0, exports.fromOption)(f.apply(void 0, a));\n  };\n};\nexports.fromOptionK = fromOptionK;\nfunction 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 (0, exports.isNonEmpty)(input) ? (0, exports.flatMap)(NEA.head(input), function (a) {\n      return go((0, function_1.pipe)(scope, (0, exports.append)(a)), NEA.tail(input));\n    }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : [];\n  };\n  return go([], input);\n}\nexports.comprehension = comprehension;\n/**\n * @since 2.11.0\n */\nvar concatW = function (second) {\n  return function (first) {\n    return (0, exports.isEmpty)(first) ? (0, exports.copy)(second) : (0, exports.isEmpty)(second) ? (0, exports.copy)(first) : first.concat(second);\n  };\n};\nexports.concatW = concatW;\n/**\n * @since 2.11.0\n */\nexports.concat = exports.concatW;\nfunction 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 (0, exports.isNonEmpty)(first) && (0, exports.isNonEmpty)(second) ? unionE(second)(first) : (0, exports.isNonEmpty)(first) ? (0, exports.copy)(first) : (0, exports.copy)(second);\n  };\n}\nexports.union = union;\nfunction intersection(E) {\n  var elemE = (0, exports.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}\nexports.intersection = intersection;\nfunction difference(E) {\n  var elemE = (0, exports.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}\nexports.difference = difference;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f));\n};\nvar _ap = function (fab, fa) {\n  return (0, function_1.pipe)(fab, (0, exports.ap)(fa));\n};\n/* istanbul ignore next */\nvar _filter = function (fa, predicate) {\n  return (0, function_1.pipe)(fa, (0, exports.filter)(predicate));\n};\n/* istanbul ignore next */\nvar _filterMap = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.filterMap)(f));\n};\n/* istanbul ignore next */\nvar _partition = function (fa, predicate) {\n  return (0, function_1.pipe)(fa, (0, exports.partition)(predicate));\n};\n/* istanbul ignore next */\nvar _partitionMap = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionMap)(f));\n};\n/* istanbul ignore next */\nvar _partitionWithIndex = function (fa, predicateWithIndex) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionWithIndex)(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar _partitionMapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionMapWithIndex)(f));\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return (0, function_1.pipe)(fa, (0, exports.alt)(that));\n};\nvar _reduce = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = (0, exports.foldMap)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _filterMapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.filterMapWithIndex)(f));\n};\n/* istanbul ignore next */\nvar _filterWithIndex = function (fa, predicateWithIndex) {\n  return (0, function_1.pipe)(fa, (0, exports.filterWithIndex)(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar _extend = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.extend)(f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = (0, exports.traverse)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (ta, f) {\n    return (0, function_1.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 */\nexports.of = NEA.of;\n/**\n * Makes an empty `Array`, useful for building a [`Monoid`](#Monoid)\n *\n * @since 2.7.0\n */\nvar zero = function () {\n  return [];\n};\nexports.zero = zero;\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 */\nvar map = function (f) {\n  return function (fa) {\n    return fa.map(function (a) {\n      return f(a);\n    });\n  };\n};\nexports.map = map;\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 */\nvar ap = function (fa) {\n  return (0, exports.flatMap)(function (f) {\n    return (0, function_1.pipe)(fa, (0, exports.map)(f));\n  });\n};\nexports.ap = ap;\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 */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n  return (0, function_1.pipe)(ma, (0, exports.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 */\nexports.flatten = (0, exports.flatMap)(function_1.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 */\nvar mapWithIndex = function (f) {\n  return function (fa) {\n    return fa.map(function (a, i) {\n      return f(i, a);\n    });\n  };\n};\nexports.mapWithIndex = mapWithIndex;\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 */\nvar 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};\nexports.filterMapWithIndex = filterMapWithIndex;\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 */\nvar filterMap = function (f) {\n  return (0, exports.filterMapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.filterMap = filterMap;\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 */\nexports.compact = (0, exports.filterMap)(function_1.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 */\nvar 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 (0, Separated_1.separated)(left, right);\n};\nexports.separate = separate;\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 */\nvar filter = function (predicate) {\n  return function (as) {\n    return as.filter(predicate);\n  };\n};\nexports.filter = filter;\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 */\nvar partition = function (predicate) {\n  return (0, exports.partitionWithIndex)(function (_, a) {\n    return predicate(a);\n  });\n};\nexports.partition = partition;\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 */\nvar 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 (0, Separated_1.separated)(left, right);\n  };\n};\nexports.partitionWithIndex = partitionWithIndex;\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 */\nvar partitionMap = function (f) {\n  return (0, exports.partitionMapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.partitionMap = partitionMap;\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 */\nvar 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 (0, Separated_1.separated)(left, right);\n  };\n};\nexports.partitionMapWithIndex = partitionMapWithIndex;\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 */\nvar altW = function (that) {\n  return function (fa) {\n    return fa.concat(that());\n  };\n};\nexports.altW = altW;\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 */\nexports.alt = exports.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 */\nvar filterWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    return as.filter(function (b, i) {\n      return predicateWithIndex(i, b);\n    });\n  };\n};\nexports.filterWithIndex = filterWithIndex;\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 */\nvar extend = function (f) {\n  return function (wa) {\n    return wa.map(function (_, i) {\n      return f(wa.slice(i));\n    });\n  };\n};\nexports.extend = extend;\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 */\nexports.duplicate = (0, exports.extend)(function_1.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nvar traverse = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\nexports.traverse = traverse;\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 */\nvar sequence = function (F) {\n  return function (ta) {\n    return _reduce(ta, F.of((0, exports.zero)()), function (fas, fa) {\n      return F.ap(F.map(fas, function (as) {\n        return function (a) {\n          return (0, function_1.pipe)(as, (0, exports.append)(a));\n        };\n      }), fa);\n    });\n  };\n};\nexports.sequence = sequence;\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 */\nvar traverseWithIndex = function (F) {\n  return function (f) {\n    return (0, exports.reduceWithIndex)(F.of((0, exports.zero)()), function (i, fbs, a) {\n      return F.ap(F.map(fbs, function (bs) {\n        return function (b) {\n          return (0, function_1.pipe)(bs, (0, exports.append)(b));\n        };\n      }), f(i, a));\n    });\n  };\n};\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wither = function (F) {\n  var _witherF = _wither(F);\n  return function (f) {\n    return function (fa) {\n      return _witherF(fa, f);\n    };\n  };\n};\nexports.wither = wither;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wilt = function (F) {\n  var _wiltF = _wilt(F);\n  return function (f) {\n    return function (fa) {\n      return _wiltF(fa, f);\n    };\n  };\n};\nexports.wilt = wilt;\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 */\nvar 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};\nexports.unfold = unfold;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.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 */\nexports.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 */\nvar getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return first.concat(second);\n    }\n  };\n};\nexports.getSemigroup = getSemigroup;\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 */\nvar getMonoid = function () {\n  return {\n    concat: (0, exports.getSemigroup)().concat,\n    empty: []\n  };\n};\nexports.getMonoid = getMonoid;\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 */\nexports.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 */\nexports.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 */\nvar getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\nexports.getUnionSemigroup = getUnionSemigroup;\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 */\nvar getUnionMonoid = function (E) {\n  return {\n    concat: (0, exports.getUnionSemigroup)(E).concat,\n    empty: []\n  };\n};\nexports.getUnionMonoid = getUnionMonoid;\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 */\nvar getIntersectionSemigroup = function (E) {\n  var intersectionE = intersection(E);\n  return {\n    concat: function (first, second) {\n      return intersectionE(second)(first);\n    }\n  };\n};\nexports.getIntersectionSemigroup = getIntersectionSemigroup;\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 */\nvar getDifferenceMagma = function (E) {\n  var differenceE = difference(E);\n  return {\n    concat: function (first, second) {\n      return differenceE(second)(first);\n    }\n  };\n};\nexports.getDifferenceMagma = getDifferenceMagma;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n  URI: exports.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 */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n  URI: exports.URI,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Apply = {\n  URI: exports.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 */\nexports.apFirst = (0, Apply_1.apFirst)(exports.Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Chain = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.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 */\nexports.chainFirst = /*#__PURE__*/(0, Chain_1.chainFirst)(exports.Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Unfoldable = {\n  URI: exports.URI,\n  unfold: exports.unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n  URI: exports.URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.Zero = {\n  URI: exports.URI,\n  zero: exports.zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexports.guard = (0, Zero_1.guard)(exports.Zero, exports.Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alternative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  alt: _alt,\n  zero: exports.zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Extend = {\n  URI: exports.URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Compactable = {\n  URI: exports.URI,\n  compact: exports.compact,\n  separate: exports.separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Filterable = {\n  URI: exports.URI,\n  map: _map,\n  compact: exports.compact,\n  separate: exports.separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FilterableWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  compact: exports.compact,\n  separate: exports.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 */\nexports.Foldable = {\n  URI: exports.URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n  URI: exports.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 */\nexports.Traversable = {\n  URI: exports.URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n  URI: exports.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: exports.sequence,\n  traverseWithIndex: _traverseWithIndex\n};\nvar _wither = /*#__PURE__*/(0, Witherable_1.witherDefault)(exports.Traversable, exports.Compactable);\nvar _wilt = /*#__PURE__*/(0, Witherable_1.wiltDefault)(exports.Traversable, exports.Compactable);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Witherable = {\n  URI: exports.URI,\n  map: _map,\n  compact: exports.compact,\n  separate: exports.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: exports.sequence,\n  wither: _wither,\n  wilt: _wilt\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexports.chainRecDepthFirst = RA.chainRecDepthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecDepthFirst = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.flatMap,\n  chainRec: _chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexports.chainRecBreadthFirst = RA.chainRecBreadthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecBreadthFirst = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.flatMap,\n  chainRec: _chainRecBreadthFirst\n};\n/**\n * Filter values inside a context.\n *\n * @since 2.11.0\n */\nexports.filterE = (0, Witherable_1.filterE)(exports.Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.FromEither = {\n  URI: exports.URI,\n  fromEither: exports.fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexports.fromEitherK = (0, FromEither_1.fromEitherK)(exports.FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexports.unsafeInsertAt = NEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nvar unsafeUpdateAt = function (i, a, as) {\n  return (0, exports.isNonEmpty)(as) ? NEA.unsafeUpdateAt(i, a, as) : [];\n};\nexports.unsafeUpdateAt = unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nvar unsafeDeleteAt = function (i, as) {\n  var xs = as.slice();\n  xs.splice(i, 1);\n  return xs;\n};\nexports.unsafeDeleteAt = unsafeDeleteAt;\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 */\nexports.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 */\nvar some = function (predicate) {\n  return function (as) {\n    return as.some(predicate);\n  };\n};\nexports.some = some;\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexports.exists = exports.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 */\nexports.intercalate = RA.intercalate;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexports.Do = (0, exports.of)(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bindTo = (0, Functor_1.bindTo)(exports.Functor);\nvar let_ = /*#__PURE__*/(0, Functor_1.let)(exports.Functor);\nexports.let = let_;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bind = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexports.chain = exports.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 */\nexports.range = NEA.range;\n/**\n * Use a new `[]` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.empty = [];\n/**\n * Use `prepend` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.cons = NEA.cons;\n/**\n * Use `append` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.snoc = NEA.snoc;\n/**\n * Use `prependAll` instead\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.prependToAll = exports.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 */\nexports.array = {\n  URI: exports.URI,\n  compact: exports.compact,\n  separate: exports.separate,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.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: exports.zero,\n  unfold: exports.unfold,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  extend: _extend,\n  wither: _wither,\n  wilt: _wilt\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bind = exports.tap = exports.chainFirst = void 0;\nfunction chainFirst(M) {\n  var tapM = tap(M);\n  return function (f) {\n    return function (first) {\n      return tapM(first, f);\n    };\n  };\n}\nexports.chainFirst = chainFirst;\n/** @internal */\nfunction 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}\nexports.tap = tap;\nfunction 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}\nexports.bind = bind;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.eqDate = exports.eqNumber = exports.eqString = exports.eqBoolean = exports.eq = exports.strictEqual = exports.getStructEq = exports.getTupleEq = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.eqStrict = exports.URI = exports.contramap = exports.tuple = exports.struct = exports.fromEquals = void 0;\nvar function_1 = require(\"./function\");\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nvar fromEquals = function (equals) {\n  return {\n    equals: function (x, y) {\n      return x === y || equals(x, y);\n    }\n  };\n};\nexports.fromEquals = fromEquals;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.10.0\n */\nvar struct = function (eqs) {\n  return (0, exports.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};\nexports.struct = struct;\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 */\nvar tuple = function () {\n  var eqs = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    eqs[_i] = arguments[_i];\n  }\n  return (0, exports.fromEquals)(function (first, second) {\n    return eqs.every(function (E, i) {\n      return E.equals(first[i], second[i]);\n    });\n  });\n};\nexports.tuple = tuple;\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.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 */\nvar contramap = function (f) {\n  return function (fa) {\n    return (0, exports.fromEquals)(function (x, y) {\n      return fa.equals(f(x), f(y));\n    });\n  };\n};\nexports.contramap = contramap;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.URI = 'Eq';\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.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 */\nvar getSemigroup = function () {\n  return {\n    concat: function (x, y) {\n      return (0, exports.fromEquals)(function (a, b) {\n        return x.equals(a, b) && y.equals(a, b);\n      });\n    }\n  };\n};\nexports.getSemigroup = getSemigroup;\n/**\n * @category instances\n * @since 2.6.0\n */\nvar getMonoid = function () {\n  return {\n    concat: (0, exports.getSemigroup)().concat,\n    empty: empty\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Contravariant = {\n  URI: exports.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 */\nexports.getTupleEq = exports.tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getStructEq = exports.struct;\n/**\n * Use [`eqStrict`](#eqstrict) instead\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.strictEqual = exports.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 */\nexports.eq = exports.Contravariant;\n/**\n * Use [`Eq`](./boolean.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.eqBoolean = exports.eqStrict;\n/**\n * Use [`Eq`](./string.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.eqString = exports.eqStrict;\n/**\n * Use [`Eq`](./number.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.eqNumber = exports.eqStrict;\n/**\n * Use [`Eq`](./Date.ts.html#eq) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.eqDate = {\n  equals: function (first, second) {\n    return first.valueOf() === second.valueOf();\n  }\n};","\"use strict\";\n\n/**\n * The `FromEither` type class represents those data types which support errors.\n *\n * @since 2.10.0\n */\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.tapEither = exports.filterOrElse = exports.chainFirstEitherK = exports.chainEitherK = exports.fromEitherK = exports.chainOptionK = exports.fromOptionK = exports.fromPredicate = exports.fromOption = void 0;\nvar Chain_1 = require(\"./Chain\");\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nfunction fromOption(F) {\n  return function (onNone) {\n    return function (ma) {\n      return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value));\n    };\n  };\n}\nexports.fromOption = fromOption;\nfunction 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}\nexports.fromPredicate = fromPredicate;\nfunction fromOptionK(F) {\n  var fromOptionF = fromOption(F);\n  return function (onNone) {\n    var from = fromOptionF(onNone);\n    return function (f) {\n      return (0, function_1.flow)(f, from);\n    };\n  };\n}\nexports.fromOptionK = fromOptionK;\nfunction 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}\nexports.chainOptionK = chainOptionK;\nfunction fromEitherK(F) {\n  return function (f) {\n    return (0, function_1.flow)(f, F.fromEither);\n  };\n}\nexports.fromEitherK = fromEitherK;\nfunction 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}\nexports.chainEitherK = chainEitherK;\nfunction 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}\nexports.chainFirstEitherK = chainFirstEitherK;\nfunction 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}\nexports.filterOrElse = filterOrElse;\n/** @internal */\nfunction tapEither(F, M) {\n  var fromEither = fromEitherK(F);\n  var tapM = (0, Chain_1.tap)(M);\n  return function (self, f) {\n    return tapM(self, fromEither(f));\n  };\n}\nexports.tapEither = tapEither;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.asUnit = exports.as = exports.getFunctorComposition = exports.let = exports.bindTo = exports.flap = exports.map = void 0;\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 */\nvar function_1 = require(\"./function\");\nfunction 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}\nexports.map = map;\nfunction 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}\nexports.flap = flap;\nfunction 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}\nexports.bindTo = bindTo;\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}\nexports.let = let_;\n/** @deprecated */\nfunction getFunctorComposition(F, G) {\n  var _map = map(F, G);\n  return {\n    map: function (fga, f) {\n      return (0, function_1.pipe)(fga, _map(f));\n    }\n  };\n}\nexports.getFunctorComposition = getFunctorComposition;\n/** @internal */\nfunction as(F) {\n  return function (self, b) {\n    return F.map(self, function () {\n      return b;\n    });\n  };\n}\nexports.as = as;\n/** @internal */\nfunction asUnit(F) {\n  var asM = as(F);\n  return function (self) {\n    return asM(self, undefined);\n  };\n}\nexports.asUnit = asUnit;","\"use strict\";\n\n/**\n * A `Magma` is a pair `(A, concat)` in which `A` is a non-empty set and `concat` is a binary operation on `A`\n *\n * See [Semigroup](https://gcanti.github.io/fp-ts/modules/Semigroup.ts.html) for some instances.\n *\n * @since 2.0.0\n */\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.concatAll = exports.endo = exports.filterSecond = exports.filterFirst = exports.reverse = void 0;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Magma`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse, concatAll } from 'fp-ts/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(reverse(N.MagmaSub))(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), 2)\n *\n * @since 2.11.0\n */\nvar reverse = function (M) {\n  return {\n    concat: function (first, second) {\n      return M.concat(second, first);\n    }\n  };\n};\nexports.reverse = reverse;\n/**\n * @since 2.11.0\n */\nvar filterFirst = function (predicate) {\n  return function (M) {\n    return {\n      concat: function (first, second) {\n        return predicate(first) ? M.concat(first, second) : second;\n      }\n    };\n  };\n};\nexports.filterFirst = filterFirst;\n/**\n * @since 2.11.0\n */\nvar filterSecond = function (predicate) {\n  return function (M) {\n    return {\n      concat: function (first, second) {\n        return predicate(second) ? M.concat(first, second) : first;\n      }\n    };\n  };\n};\nexports.filterSecond = filterSecond;\n/**\n * @since 2.11.0\n */\nvar endo = function (f) {\n  return function (M) {\n    return {\n      concat: function (first, second) {\n        return M.concat(f(first), f(second));\n      }\n    };\n  };\n};\nexports.endo = endo;\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/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(N.MagmaSub)(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), -6)\n *\n * @since 2.11.0\n */\nvar concatAll = function (M) {\n  return function (startWith) {\n    return function (as) {\n      return as.reduce(function (a, acc) {\n        return M.concat(a, acc);\n      }, startWith);\n    };\n  };\n};\nexports.concatAll = concatAll;","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\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.mapWithIndex = exports.map = exports.flatten = exports.duplicate = exports.extend = exports.flatMap = exports.ap = exports.alt = exports.altW = exports.chunksOf = exports.splitAt = exports.chop = exports.chainWithIndex = exports.foldMap = exports.foldMapWithIndex = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.of = exports.copy = exports.modifyAt = exports.updateAt = exports.insertAt = exports.sort = exports.groupBy = exports.group = exports.reverse = exports.concat = exports.concatW = exports.unappend = exports.unprepend = exports.range = exports.replicate = exports.makeBy = exports.fromArray = exports.fromReadonlyNonEmptyArray = exports.rotate = exports.union = exports.sortBy = exports.uniq = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.append = exports.appendW = exports.prepend = exports.prependW = exports.isOutOfBound = exports.isNonEmpty = void 0;\nexports.chain = exports.intercalate = exports.updateLast = exports.modifyLast = exports.updateHead = exports.modifyHead = exports.matchRight = exports.matchLeft = exports.concatAll = exports.max = exports.min = exports.init = exports.last = exports.tail = exports.head = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getUnionSemigroup = exports.getEq = exports.getSemigroup = exports.getShow = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.reduce = void 0;\nexports.nonEmptyArray = exports.fold = exports.prependToAll = exports.snoc = exports.cons = exports.unsnoc = exports.uncons = exports.filterWithIndex = exports.filter = exports.groupSort = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar Ord_1 = require(\"./Ord\");\nvar RNEA = __importStar(require(\"./ReadonlyNonEmptyArray\"));\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nvar isNonEmpty = function (as) {\n  return as.length > 0;\n};\nexports.isNonEmpty = isNonEmpty;\n/**\n * @internal\n */\nvar isOutOfBound = function (i, as) {\n  return i < 0 || i >= as.length;\n};\nexports.isOutOfBound = isOutOfBound;\n/**\n * @internal\n */\nvar prependW = function (head) {\n  return function (tail) {\n    return __spreadArray([head], tail, true);\n  };\n};\nexports.prependW = prependW;\n/**\n * @internal\n */\nexports.prepend = exports.prependW;\n/**\n * @internal\n */\nvar appendW = function (end) {\n  return function (init) {\n    return __spreadArray(__spreadArray([], init, true), [end], false);\n  };\n};\nexports.appendW = appendW;\n/**\n * @internal\n */\nexports.append = exports.appendW;\n/**\n * @internal\n */\nvar unsafeInsertAt = function (i, a, as) {\n  if ((0, exports.isNonEmpty)(as)) {\n    var xs = (0, exports.fromReadonlyNonEmptyArray)(as);\n    xs.splice(i, 0, a);\n    return xs;\n  }\n  return [a];\n};\nexports.unsafeInsertAt = unsafeInsertAt;\n/**\n * @internal\n */\nvar unsafeUpdateAt = function (i, a, as) {\n  var xs = (0, exports.fromReadonlyNonEmptyArray)(as);\n  xs[i] = a;\n  return xs;\n};\nexports.unsafeUpdateAt = unsafeUpdateAt;\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 */\nvar uniq = function (E) {\n  return function (as) {\n    if (as.length === 1) {\n      return (0, exports.copy)(as);\n    }\n    var out = [(0, exports.head)(as)];\n    var rest = (0, exports.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};\nexports.uniq = uniq;\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 */\nvar sortBy = function (ords) {\n  if ((0, exports.isNonEmpty)(ords)) {\n    var M = (0, Ord_1.getMonoid)();\n    return (0, exports.sort)(ords.reduce(M.concat, M.empty));\n  }\n  return exports.copy;\n};\nexports.sortBy = sortBy;\n/**\n * @since 2.11.0\n */\nvar union = function (E) {\n  var uniqE = (0, exports.uniq)(E);\n  return function (second) {\n    return function (first) {\n      return uniqE((0, function_1.pipe)(first, concat(second)));\n    };\n  };\n};\nexports.union = union;\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 */\nvar rotate = function (n) {\n  return function (as) {\n    var len = as.length;\n    var m = Math.round(n) % len;\n    if ((0, exports.isOutOfBound)(Math.abs(m), as) || m === 0) {\n      return (0, exports.copy)(as);\n    }\n    if (m < 0) {\n      var _a = (0, exports.splitAt)(-m)(as),\n        f = _a[0],\n        s = _a[1];\n      return (0, function_1.pipe)(s, concat(f));\n    } else {\n      return (0, exports.rotate)(m - len)(as);\n    }\n  };\n};\nexports.rotate = rotate;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.10.0\n */\nexports.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 */\nvar fromArray = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(as) : _.none;\n};\nexports.fromArray = fromArray;\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 */\nvar 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};\nexports.makeBy = makeBy;\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 */\nvar replicate = function (a) {\n  return (0, exports.makeBy)(function () {\n    return a;\n  });\n};\nexports.replicate = replicate;\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 */\nvar range = function (start, end) {\n  return start <= end ? (0, exports.makeBy)(function (i) {\n    return start + i;\n  })(end - start + 1) : [start];\n};\nexports.range = range;\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 */\nvar unprepend = function (as) {\n  return [(0, exports.head)(as), (0, exports.tail)(as)];\n};\nexports.unprepend = unprepend;\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 */\nvar unappend = function (as) {\n  return [(0, exports.init)(as), (0, exports.last)(as)];\n};\nexports.unappend = unappend;\nfunction concatW(second) {\n  return function (first) {\n    return first.concat(second);\n  };\n}\nexports.concatW = concatW;\nfunction concat(x, y) {\n  return y ? x.concat(y) : function (y) {\n    return y.concat(x);\n  };\n}\nexports.concat = concat;\n/**\n * @since 2.0.0\n */\nvar reverse = function (as) {\n  return __spreadArray([(0, exports.last)(as)], as.slice(0, -1).reverse(), true);\n};\nexports.reverse = reverse;\nfunction 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}\nexports.group = group;\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 */\nvar 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};\nexports.groupBy = groupBy;\n/**\n * @since 2.0.0\n */\nvar sort = function (O) {\n  return function (as) {\n    return as.slice().sort(O.compare);\n  };\n};\nexports.sort = sort;\n/**\n * @since 2.0.0\n */\nvar insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some((0, exports.unsafeInsertAt)(i, a, as));\n  };\n};\nexports.insertAt = insertAt;\n/**\n * @since 2.0.0\n */\nvar updateAt = function (i, a) {\n  return (0, exports.modifyAt)(i, function () {\n    return a;\n  });\n};\nexports.updateAt = updateAt;\n/**\n * @since 2.0.0\n */\nvar modifyAt = function (i, f) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));\n  };\n};\nexports.modifyAt = modifyAt;\n/**\n * @since 2.0.0\n */\nexports.copy = exports.fromReadonlyNonEmptyArray;\n/**\n * @category constructors\n * @since 2.0.0\n */\nvar of = function (a) {\n  return [a];\n};\nexports.of = of;\n/**\n * @since 2.5.1\n */\nvar 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};\nexports.zipWith = zipWith;\nfunction zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return (0, exports.zipWith)(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\nexports.zip = zip;\n/**\n * @since 2.5.1\n */\nvar 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};\nexports.unzip = unzip;\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 */\nvar 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};\nexports.prependAll = prependAll;\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 */\nvar intersperse = function (middle) {\n  return function (as) {\n    var rest = (0, exports.tail)(as);\n    return (0, exports.isNonEmpty)(rest) ? (0, function_1.pipe)(rest, (0, exports.prependAll)(middle), (0, exports.prepend)((0, exports.head)(as))) : (0, exports.copy)(as);\n  };\n};\nexports.intersperse = intersperse;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.foldMapWithIndex = RNEA.foldMapWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.foldMap = RNEA.foldMap;\n/**\n * @category sequencing\n * @since 2.10.0\n */\nvar chainWithIndex = function (f) {\n  return function (as) {\n    var out = (0, exports.fromReadonlyNonEmptyArray)(f(0, (0, exports.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};\nexports.chainWithIndex = chainWithIndex;\n/**\n * @since 2.10.0\n */\nvar 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 ((0, exports.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};\nexports.chop = chop;\n/**\n * Splits a `NonEmptyArray` into two pieces, the first piece has max `n` elements.\n *\n * @since 2.10.0\n */\nvar splitAt = function (n) {\n  return function (as) {\n    var m = Math.max(1, n);\n    return m >= as.length ? [(0, exports.copy)(as), []] : [(0, function_1.pipe)(as.slice(1, m), (0, exports.prepend)((0, exports.head)(as))), as.slice(m)];\n  };\n};\nexports.splitAt = splitAt;\n/**\n * @since 2.10.0\n */\nvar chunksOf = function (n) {\n  return (0, exports.chop)((0, exports.splitAt)(n));\n};\nexports.chunksOf = chunksOf;\n/* istanbul ignore next */\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f));\n};\n/* istanbul ignore next */\nvar _ap = function (fab, fa) {\n  return (0, function_1.pipe)(fab, (0, exports.ap)(fa));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return (0, function_1.pipe)(wa, (0, exports.extend)(f));\n};\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = (0, exports.foldMap)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = (0, exports.traverse)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return (0, function_1.pipe)(fa, (0, exports.alt)(that));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (ta, f) {\n    return (0, function_1.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 */\nvar altW = function (that) {\n  return function (as) {\n    return (0, function_1.pipe)(as, concatW(that()));\n  };\n};\nexports.altW = altW;\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 */\nexports.alt = exports.altW;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @since 2.0.0\n */\nvar ap = function (as) {\n  return (0, exports.flatMap)(function (f) {\n    return (0, function_1.pipe)(as, (0, exports.map)(f));\n  });\n};\nexports.ap = ap;\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 */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n  return (0, function_1.pipe)(ma, (0, exports.chainWithIndex)(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @since 2.0.0\n */\nvar extend = function (f) {\n  return function (as) {\n    var next = (0, exports.tail)(as);\n    var out = [f(as)];\n    while ((0, exports.isNonEmpty)(next)) {\n      out.push(f(next));\n      next = (0, exports.tail)(next);\n    }\n    return out;\n  };\n};\nexports.extend = extend;\n/**\n * @since 2.5.0\n */\nexports.duplicate = (0, exports.extend)(function_1.identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexports.flatten = (0, exports.flatMap)(function_1.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 */\nvar map = function (f) {\n  return (0, exports.mapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.map = map;\n/**\n * @category mapping\n * @since 2.0.0\n */\nvar mapWithIndex = function (f) {\n  return function (as) {\n    var out = [f(0, (0, exports.head)(as))];\n    for (var i = 1; i < as.length; i++) {\n      out.push(f(i, as[i]));\n    }\n    return out;\n  };\n};\nexports.mapWithIndex = mapWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.reduce = RNEA.reduce;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.reduceWithIndex = RNEA.reduceWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.reduceRight = RNEA.reduceRight;\n/**\n * @category folding\n * @since 2.0.0\n */\nexports.reduceRightWithIndex = RNEA.reduceRightWithIndex;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar traverse = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\nexports.traverse = traverse;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar sequence = function (F) {\n  return (0, exports.traverseWithIndex)(F)(function (_, a) {\n    return a;\n  });\n};\nexports.sequence = sequence;\n/**\n * @category sequencing\n * @since 2.6.3\n */\nvar traverseWithIndex = function (F) {\n  return function (f) {\n    return function (as) {\n      var out = F.map(f(0, (0, exports.head)(as)), exports.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 (0, function_1.pipe)(bs, (0, exports.append)(b));\n          };\n        }), f(i, as[i]));\n      }\n      return out;\n    };\n  };\n};\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @since 2.7.0\n */\nexports.extract = RNEA.head;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.URI = 'NonEmptyArray';\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getShow = RNEA.getShow;\n/**\n * Builds a `Semigroup` instance for `NonEmptyArray`\n *\n * @category instances\n * @since 2.0.0\n */\nvar getSemigroup = function () {\n  return {\n    concat: concat\n  };\n};\nexports.getSemigroup = getSemigroup;\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 */\nexports.getEq = RNEA.getEq;\n/**\n * @since 2.11.0\n */\nvar getUnionSemigroup = function (E) {\n  var unionE = (0, exports.union)(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\nexports.getUnionSemigroup = getUnionSemigroup;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n  URI: exports.URI,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Apply = {\n  URI: exports.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 */\nexports.apFirst = (0, Apply_1.apFirst)(exports.Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Chain = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.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 */\nexports.chainFirst = /*#__PURE__*/(0, Chain_1.chainFirst)(exports.Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Foldable = {\n  URI: exports.URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n  URI: exports.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 */\nexports.Traversable = {\n  URI: exports.URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n  URI: exports.URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Comonad = {\n  URI: exports.URI,\n  map: _map,\n  extend: _extend,\n  extract: exports.extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexports.Do = (0, exports.of)(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bindTo = (0, Functor_1.bindTo)(exports.Functor);\nvar let_ = /*#__PURE__*/(0, Functor_1.let)(exports.Functor);\nexports.let = let_;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bind = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.0.0\n */\nexports.head = RNEA.head;\n/**\n * @since 2.0.0\n */\nvar tail = function (as) {\n  return as.slice(1);\n};\nexports.tail = tail;\n/**\n * @since 2.0.0\n */\nexports.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 */\nvar init = function (as) {\n  return as.slice(0, -1);\n};\nexports.init = init;\n/**\n * @since 2.0.0\n */\nexports.min = RNEA.min;\n/**\n * @since 2.0.0\n */\nexports.max = RNEA.max;\n/**\n * @since 2.10.0\n */\nvar concatAll = function (S) {\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\nexports.concatAll = concatAll;\n/**\n * Break an `Array` into its first element and remaining elements.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchLeft = function (f) {\n  return function (as) {\n    return f((0, exports.head)(as), (0, exports.tail)(as));\n  };\n};\nexports.matchLeft = matchLeft;\n/**\n * Break an `Array` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchRight = function (f) {\n  return function (as) {\n    return f((0, exports.init)(as), (0, exports.last)(as));\n  };\n};\nexports.matchRight = matchRight;\n/**\n * Apply a function to the head, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar modifyHead = function (f) {\n  return function (as) {\n    return __spreadArray([f((0, exports.head)(as))], (0, exports.tail)(as), true);\n  };\n};\nexports.modifyHead = modifyHead;\n/**\n * Change the head, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar updateHead = function (a) {\n  return (0, exports.modifyHead)(function () {\n    return a;\n  });\n};\nexports.updateHead = updateHead;\n/**\n * Apply a function to the last element, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar modifyLast = function (f) {\n  return function (as) {\n    return (0, function_1.pipe)((0, exports.init)(as), (0, exports.append)(f((0, exports.last)(as))));\n  };\n};\nexports.modifyLast = modifyLast;\n/**\n * Change the last element, creating a new `NonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar updateLast = function (a) {\n  return (0, exports.modifyLast)(function () {\n    return a;\n  });\n};\nexports.updateLast = updateLast;\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 */\nexports.intercalate = RNEA.intercalate;\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexports.chain = exports.flatMap;\nfunction groupSort(O) {\n  var sortO = (0, exports.sort)(O);\n  var groupO = group(O);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? groupO(sortO(as)) : [];\n  };\n}\nexports.groupSort = groupSort;\nfunction filter(predicate) {\n  return (0, exports.filterWithIndex)(function (_, a) {\n    return predicate(a);\n  });\n}\nexports.filter = filter;\n/**\n * Use [`filterWithIndex`](./Array.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nvar filterWithIndex = function (predicate) {\n  return function (as) {\n    return (0, exports.fromArray)(as.filter(function (a, i) {\n      return predicate(i, a);\n    }));\n  };\n};\nexports.filterWithIndex = filterWithIndex;\n/**\n * Use [`unprepend`](#unprepend) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.uncons = exports.unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.unsnoc = exports.unappend;\nfunction cons(head, tail) {\n  return tail === undefined ? (0, exports.prepend)(head) : (0, function_1.pipe)(tail, (0, exports.prepend)(head));\n}\nexports.cons = cons;\n/**\n * Use [`append`](./Array.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nvar snoc = function (init, end) {\n  return (0, function_1.pipe)(init, (0, exports.append)(end));\n};\nexports.snoc = snoc;\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.prependToAll = exports.prependAll;\n/**\n * Use [`concatAll`](#concatall) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.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 */\nexports.nonEmptyArray = {\n  URI: exports.URI,\n  of: exports.of,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  ap: _ap,\n  chain: exports.flatMap,\n  extend: _extend,\n  extract: exports.extract,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  alt: _alt\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ordDate = exports.ordNumber = exports.ordString = exports.ordBoolean = exports.ord = exports.getDualOrd = exports.getTupleOrd = exports.between = exports.clamp = exports.max = exports.min = exports.geq = exports.leq = exports.gt = exports.lt = exports.equals = exports.trivial = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.URI = exports.contramap = exports.reverse = exports.tuple = exports.fromCompare = exports.equalsDefault = void 0;\nvar Eq_1 = require(\"./Eq\");\nvar function_1 = require(\"./function\");\n// -------------------------------------------------------------------------------------\n// defaults\n// -------------------------------------------------------------------------------------\n/**\n * @category defaults\n * @since 2.10.0\n */\nvar equalsDefault = function (compare) {\n  return function (first, second) {\n    return first === second || compare(first, second) === 0;\n  };\n};\nexports.equalsDefault = equalsDefault;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nvar fromCompare = function (compare) {\n  return {\n    equals: (0, exports.equalsDefault)(compare),\n    compare: function (first, second) {\n      return first === second ? 0 : compare(first, second);\n    }\n  };\n};\nexports.fromCompare = fromCompare;\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 */\nvar tuple = function () {\n  var ords = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    ords[_i] = arguments[_i];\n  }\n  return (0, exports.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};\nexports.tuple = tuple;\n/**\n * @since 2.10.0\n */\nvar reverse = function (O) {\n  return (0, exports.fromCompare)(function (first, second) {\n    return O.compare(second, first);\n  });\n};\nexports.reverse = reverse;\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.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 */\nvar contramap = function (f) {\n  return function (fa) {\n    return (0, exports.fromCompare)(function (first, second) {\n      return fa.compare(f(first), f(second));\n    });\n  };\n};\nexports.contramap = contramap;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.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 */\nvar getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return (0, exports.fromCompare)(function (a, b) {\n        var ox = first.compare(a, b);\n        return ox !== 0 ? ox : second.compare(a, b);\n      });\n    }\n  };\n};\nexports.getSemigroup = getSemigroup;\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 */\nvar getMonoid = function () {\n  return {\n    concat: (0, exports.getSemigroup)().concat,\n    empty: (0, exports.fromCompare)(function () {\n      return 0;\n    })\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Contravariant = {\n  URI: exports.URI,\n  contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexports.trivial = {\n  equals: function_1.constTrue,\n  compare: /*#__PURE__*/(0, function_1.constant)(0)\n};\n/**\n * @since 2.11.0\n */\nvar equals = function (O) {\n  return function (second) {\n    return function (first) {\n      return first === second || O.compare(first, second) === 0;\n    };\n  };\n};\nexports.equals = equals;\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly less than_ another\n *\n * @since 2.0.0\n */\nvar lt = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) === -1;\n  };\n};\nexports.lt = lt;\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly greater than_ another\n *\n * @since 2.0.0\n */\nvar gt = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) === 1;\n  };\n};\nexports.gt = gt;\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly less than_ another\n *\n * @since 2.0.0\n */\nvar leq = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) !== 1;\n  };\n};\nexports.leq = leq;\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly greater than_ another\n *\n * @since 2.0.0\n */\nvar geq = function (O) {\n  return function (first, second) {\n    return O.compare(first, second) !== -1;\n  };\n};\nexports.geq = geq;\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 */\nvar min = function (O) {\n  return function (first, second) {\n    return first === second || O.compare(first, second) < 1 ? first : second;\n  };\n};\nexports.min = min;\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 */\nvar max = function (O) {\n  return function (first, second) {\n    return first === second || O.compare(first, second) > -1 ? first : second;\n  };\n};\nexports.max = max;\n/**\n * Clamp a value between a minimum and a maximum\n *\n * @since 2.0.0\n */\nvar clamp = function (O) {\n  var minO = (0, exports.min)(O);\n  var maxO = (0, exports.max)(O);\n  return function (low, hi) {\n    return function (a) {\n      return maxO(minO(a, hi), low);\n    };\n  };\n};\nexports.clamp = clamp;\n/**\n * Test whether a value is between a minimum and a maximum (inclusive)\n *\n * @since 2.0.0\n */\nvar between = function (O) {\n  var ltO = (0, exports.lt)(O);\n  var gtO = (0, exports.gt)(O);\n  return function (low, hi) {\n    return function (a) {\n      return ltO(a, low) || gtO(a, hi) ? false : true;\n    };\n  };\n};\nexports.between = between;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getTupleOrd = exports.tuple;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getDualOrd = exports.reverse;\n/**\n * Use [`Contravariant`](#contravariant) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.ord = exports.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: Eq_1.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 */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.ordDate = (0, function_1.pipe)(exports.ordNumber, /*#__PURE__*/\n(0, exports.contramap)(function (date) {\n  return date.valueOf();\n}));","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\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.sort = exports.lefts = exports.rights = exports.reverse = exports.modifyAt = exports.deleteAt = exports.updateAt = exports.insertAt = exports.findLastIndex = exports.findLastMap = exports.findLast = exports.findFirstMap = exports.findFirst = exports.findIndex = exports.dropLeftWhile = exports.dropRight = exports.dropLeft = exports.spanLeft = exports.takeLeftWhile = exports.takeRight = exports.takeLeft = exports.init = exports.tail = exports.last = exports.head = exports.lookup = exports.isOutOfBound = exports.size = exports.scanRight = exports.scanLeft = exports.chainWithIndex = exports.foldRight = exports.matchRight = exports.matchRightW = exports.foldLeft = exports.matchLeft = exports.matchLeftW = exports.match = exports.matchW = exports.fromEither = exports.fromOption = exports.fromPredicate = exports.replicate = exports.makeBy = exports.appendW = exports.append = exports.prependW = exports.prepend = exports.isNonEmpty = exports.isEmpty = void 0;\nexports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.foldMap = exports.reduce = exports.foldMapWithIndex = exports.duplicate = exports.extend = exports.filterWithIndex = exports.partitionMapWithIndex = exports.partitionMap = exports.partitionWithIndex = exports.partition = exports.compact = exports.filterMap = exports.filterMapWithIndex = exports.filter = exports.separate = exports.mapWithIndex = exports.map = exports.flatten = exports.flatMap = exports.ap = exports.alt = exports.altW = exports.zero = exports.of = exports._chainRecBreadthFirst = exports._chainRecDepthFirst = exports.difference = exports.intersection = exports.union = exports.concat = exports.concatW = exports.comprehension = exports.fromOptionK = exports.chunksOf = exports.splitAt = exports.chop = exports.sortBy = exports.uniq = exports.elem = exports.rotate = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = void 0;\nexports.toArray = exports.unsafeDeleteAt = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.fromEitherK = exports.FromEither = exports.filterE = exports.Witherable = exports.ChainRecBreadthFirst = exports.chainRecBreadthFirst = exports.ChainRecDepthFirst = exports.chainRecDepthFirst = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.FilterableWithIndex = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.guard = exports.Zero = exports.Alt = exports.Unfoldable = exports.chainFirst = exports.Monad = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getDifferenceMagma = exports.getIntersectionSemigroup = exports.getUnionMonoid = exports.getUnionSemigroup = exports.getOrd = exports.getEq = exports.getMonoid = exports.getSemigroup = exports.getShow = exports.URI = exports.unfold = exports.wilt = exports.wither = exports.traverseWithIndex = void 0;\nexports.readonlyArray = exports.prependToAll = exports.snoc = exports.cons = exports.range = exports.chain = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.intercalate = exports.exists = exports.some = exports.every = exports.empty = exports.fromArray = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar Eq_1 = require(\"./Eq\");\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar N = __importStar(require(\"./number\"));\nvar Ord_1 = require(\"./Ord\");\nvar RNEA = __importStar(require(\"./ReadonlyNonEmptyArray\"));\nvar Separated_1 = require(\"./Separated\");\nvar Witherable_1 = require(\"./Witherable\");\nvar Zero_1 = require(\"./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 */\nvar isEmpty = function (as) {\n  return as.length === 0;\n};\nexports.isEmpty = isEmpty;\n/**\n * Test whether a `ReadonlyArray` is non empty.\n *\n * @category refinements\n * @since 2.5.0\n */\nexports.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 */\nexports.prepend = RNEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @since 2.11.0\n */\nexports.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 */\nexports.append = RNEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @since 2.11.0\n */\nexports.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 */\nvar makeBy = function (n, f) {\n  return n <= 0 ? exports.empty : RNEA.makeBy(f)(n);\n};\nexports.makeBy = makeBy;\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 */\nvar replicate = function (n, a) {\n  return (0, exports.makeBy)(n, function () {\n    return a;\n  });\n};\nexports.replicate = replicate;\nfunction fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? [a] : exports.empty;\n  };\n}\nexports.fromPredicate = fromPredicate;\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.11.0\n */\nvar fromOption = function (ma) {\n  return _.isNone(ma) ? exports.empty : [ma.value];\n};\nexports.fromOption = fromOption;\n/**\n * Transforms an `Either` to a `ReadonlyArray`.\n *\n * @category conversions\n * @since 2.11.0\n */\nvar fromEither = function (e) {\n  return _.isLeft(e) ? exports.empty : [e.right];\n};\nexports.fromEither = fromEither;\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 */\nvar matchW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(as) : onEmpty();\n  };\n};\nexports.matchW = matchW;\n/**\n * @category pattern matching\n * @since 2.11.0\n */\nexports.match = exports.matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchLeftW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(RNEA.head(as), RNEA.tail(as)) : onEmpty();\n  };\n};\nexports.matchLeftW = matchLeftW;\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 */\nexports.matchLeft = exports.matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexports.foldLeft = exports.matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchRightW = function (onEmpty, onNonEmpty) {\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? onNonEmpty(RNEA.init(as), RNEA.last(as)) : onEmpty();\n  };\n};\nexports.matchRightW = matchRightW;\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexports.matchRight = exports.matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexports.foldRight = exports.matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category sequencing\n * @since 2.7.0\n */\nvar chainWithIndex = function (f) {\n  return function (as) {\n    if ((0, exports.isEmpty)(as)) {\n      return exports.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};\nexports.chainWithIndex = chainWithIndex;\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 */\nvar 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};\nexports.scanLeft = scanLeft;\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 */\nvar 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};\nexports.scanRight = scanRight;\n/**\n * Calculate the number of elements in a `ReadonlyArray`.\n *\n * @since 2.10.0\n */\nvar size = function (as) {\n  return as.length;\n};\nexports.size = size;\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.5.0\n */\nexports.isOutOfBound = RNEA.isOutOfBound;\nfunction lookup(i, as) {\n  return as === undefined ? function (as) {\n    return lookup(i, as);\n  } : (0, exports.isOutOfBound)(i, as) ? _.none : _.some(as[i]);\n}\nexports.lookup = 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/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 */\nvar head = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(RNEA.head(as)) : _.none;\n};\nexports.head = 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/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 */\nvar last = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(RNEA.last(as)) : _.none;\n};\nexports.last = 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/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 */\nvar tail = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(RNEA.tail(as)) : _.none;\n};\nexports.tail = tail;\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 */\nvar init = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(RNEA.init(as)) : _.none;\n};\nexports.init = init;\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 */\nvar takeLeft = function (n) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(n, as) ? as : n === 0 ? exports.empty : as.slice(0, n);\n  };\n};\nexports.takeLeft = takeLeft;\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 */\nvar takeRight = function (n) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(n, as) ? as : n === 0 ? exports.empty : as.slice(-n);\n  };\n};\nexports.takeRight = takeRight;\nfunction 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 ? exports.empty : out;\n  };\n}\nexports.takeLeftWhile = takeLeftWhile;\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};\nfunction spanLeft(predicate) {\n  return function (as) {\n    var _a = (0, exports.splitAt)(spanLeftIndex(as, predicate))(as),\n      init = _a[0],\n      rest = _a[1];\n    return {\n      init: init,\n      rest: rest\n    };\n  };\n}\nexports.spanLeft = spanLeft;\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 */\nvar dropLeft = function (n) {\n  return function (as) {\n    return n <= 0 || (0, exports.isEmpty)(as) ? as : n >= as.length ? exports.empty : as.slice(n, as.length);\n  };\n};\nexports.dropLeft = dropLeft;\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 */\nvar dropRight = function (n) {\n  return function (as) {\n    return n <= 0 || (0, exports.isEmpty)(as) ? as : n >= as.length ? exports.empty : as.slice(0, as.length - n);\n  };\n};\nexports.dropRight = dropRight;\nfunction dropLeftWhile(predicate) {\n  return function (as) {\n    var i = spanLeftIndex(as, predicate);\n    return i === 0 ? as : i === as.length ? exports.empty : as.slice(i);\n  };\n}\nexports.dropLeftWhile = dropLeftWhile;\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 */\nvar 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};\nexports.findIndex = findIndex;\nfunction 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}\nexports.findFirst = findFirst;\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 */\nvar 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};\nexports.findFirstMap = findFirstMap;\nfunction 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}\nexports.findLast = findLast;\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 */\nvar 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};\nexports.findLastMap = findLastMap;\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 */\nvar 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};\nexports.findLastIndex = findLastIndex;\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 */\nvar insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as));\n  };\n};\nexports.insertAt = insertAt;\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 */\nvar updateAt = function (i, a) {\n  return (0, exports.modifyAt)(i, function () {\n    return a;\n  });\n};\nexports.updateAt = updateAt;\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 */\nvar deleteAt = function (i) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeDeleteAt)(i, as));\n  };\n};\nexports.deleteAt = deleteAt;\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 */\nvar modifyAt = function (i, f) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));\n  };\n};\nexports.modifyAt = modifyAt;\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 */\nvar reverse = function (as) {\n  return as.length <= 1 ? as : as.slice().reverse();\n};\nexports.reverse = reverse;\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 */\nvar 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};\nexports.rights = rights;\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 */\nvar 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};\nexports.lefts = lefts;\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 */\nvar sort = function (O) {\n  return function (as) {\n    return as.length <= 1 ? as : as.slice().sort(O.compare);\n  };\n};\nexports.sort = sort;\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 */\nvar 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};\nexports.zipWith = zipWith;\nfunction zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return (0, exports.zipWith)(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\nexports.zip = zip;\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 */\nvar 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};\nexports.unzip = unzip;\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 */\nvar prependAll = function (middle) {\n  var f = RNEA.prependAll(middle);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : as;\n  };\n};\nexports.prependAll = prependAll;\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 */\nvar intersperse = function (middle) {\n  var f = RNEA.intersperse(middle);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : as;\n  };\n};\nexports.intersperse = intersperse;\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 */\nvar rotate = function (n) {\n  var f = RNEA.rotate(n);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : as;\n  };\n};\nexports.rotate = rotate;\nfunction 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}\nexports.elem = elem;\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 */\nvar uniq = function (E) {\n  var f = RNEA.uniq(E);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : as;\n  };\n};\nexports.uniq = uniq;\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 */\nvar sortBy = function (ords) {\n  var f = RNEA.sortBy(ords);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : as;\n  };\n};\nexports.sortBy = sortBy;\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 */\nvar chop = function (f) {\n  var g = RNEA.chop(f);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? g(as) : exports.empty;\n  };\n};\nexports.chop = chop;\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 */\nvar splitAt = function (n) {\n  return function (as) {\n    return n >= 1 && (0, exports.isNonEmpty)(as) ? RNEA.splitAt(n)(as) : (0, exports.isEmpty)(as) ? [as, exports.empty] : [exports.empty, as];\n  };\n};\nexports.splitAt = splitAt;\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 */\nvar chunksOf = function (n) {\n  var f = RNEA.chunksOf(n);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? f(as) : exports.empty;\n  };\n};\nexports.chunksOf = chunksOf;\n/**\n * @category lifting\n * @since 2.11.0\n */\nvar 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 (0, exports.fromOption)(f.apply(void 0, a));\n  };\n};\nexports.fromOptionK = fromOptionK;\nfunction 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 (0, exports.isNonEmpty)(input) ? (0, exports.flatMap)(RNEA.head(input), function (a) {\n      return go((0, function_1.pipe)(scope, (0, exports.append)(a)), RNEA.tail(input));\n    }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : exports.empty;\n  };\n  return go(exports.empty, input);\n}\nexports.comprehension = comprehension;\n/**\n * @since 2.11.0\n */\nvar concatW = function (second) {\n  return function (first) {\n    return (0, exports.isEmpty)(first) ? second : (0, exports.isEmpty)(second) ? first : first.concat(second);\n  };\n};\nexports.concatW = concatW;\n/**\n * @since 2.11.0\n */\nexports.concat = exports.concatW;\nfunction 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 (0, exports.isNonEmpty)(first) && (0, exports.isNonEmpty)(second) ? unionE(second)(first) : (0, exports.isNonEmpty)(first) ? first : second;\n  };\n}\nexports.union = union;\nfunction 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}\nexports.intersection = intersection;\nfunction 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}\nexports.difference = difference;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\nvar _mapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f));\n};\nvar _ap = function (fab, fa) {\n  return (0, function_1.pipe)(fab, (0, exports.ap)(fa));\n};\nvar _filter = function (fa, predicate) {\n  return (0, function_1.pipe)(fa, (0, exports.filter)(predicate));\n};\nvar _filterMap = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.filterMap)(f));\n};\nvar _partition = function (fa, predicate) {\n  return (0, function_1.pipe)(fa, (0, exports.partition)(predicate));\n};\nvar _partitionMap = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionMap)(f));\n};\nvar _partitionWithIndex = function (fa, predicateWithIndex) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionWithIndex)(predicateWithIndex));\n};\nvar _partitionMapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.partitionMapWithIndex)(f));\n};\nvar _alt = function (fa, that) {\n  return (0, function_1.pipe)(fa, (0, exports.alt)(that));\n};\nvar _reduce = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f));\n};\nvar _foldMap = function (M) {\n  var foldMapM = (0, exports.foldMap)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapM(f));\n  };\n};\nvar _reduceRight = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f));\n};\nvar _reduceWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapWithIndexM(f));\n  };\n};\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\nvar _filterMapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.filterMapWithIndex)(f));\n};\nvar _filterWithIndex = function (fa, predicateWithIndex) {\n  return (0, function_1.pipe)(fa, (0, exports.filterWithIndex)(predicateWithIndex));\n};\nvar _extend = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.extend)(f));\n};\nvar _traverse = function (F) {\n  var traverseF = (0, exports.traverse)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseWithIndexF(f));\n  };\n};\n/** @internal */\nvar _chainRecDepthFirst = function (a, f) {\n  return (0, function_1.pipe)(a, (0, exports.chainRecDepthFirst)(f));\n};\nexports._chainRecDepthFirst = _chainRecDepthFirst;\n/** @internal */\nvar _chainRecBreadthFirst = function (a, f) {\n  return (0, function_1.pipe)(a, (0, exports.chainRecBreadthFirst)(f));\n};\nexports._chainRecBreadthFirst = _chainRecBreadthFirst;\n/**\n * @category constructors\n * @since 2.5.0\n */\nexports.of = RNEA.of;\n/**\n * @since 2.7.0\n */\nvar zero = function () {\n  return exports.empty;\n};\nexports.zero = zero;\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 */\nvar altW = function (that) {\n  return function (fa) {\n    return fa.concat(that());\n  };\n};\nexports.altW = altW;\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 */\nexports.alt = exports.altW;\n/**\n * @since 2.5.0\n */\nvar ap = function (fa) {\n  return (0, exports.flatMap)(function (f) {\n    return (0, function_1.pipe)(fa, (0, exports.map)(f));\n  });\n};\nexports.ap = ap;\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 */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n  return (0, function_1.pipe)(ma, (0, exports.chainWithIndex)(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexports.flatten = (0, exports.flatMap)(function_1.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 */\nvar map = function (f) {\n  return function (fa) {\n    return fa.map(function (a) {\n      return f(a);\n    });\n  };\n};\nexports.map = map;\n/**\n * @category mapping\n * @since 2.5.0\n */\nvar mapWithIndex = function (f) {\n  return function (fa) {\n    return fa.map(function (a, i) {\n      return f(i, a);\n    });\n  };\n};\nexports.mapWithIndex = mapWithIndex;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar 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 (0, Separated_1.separated)(left, right);\n};\nexports.separate = separate;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar filter = function (predicate) {\n  return function (as) {\n    return as.filter(predicate);\n  };\n};\nexports.filter = filter;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar 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};\nexports.filterMapWithIndex = filterMapWithIndex;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar filterMap = function (f) {\n  return (0, exports.filterMapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.filterMap = filterMap;\n/**\n * @category filtering\n * @since 2.5.0\n */\nexports.compact = (0, exports.filterMap)(function_1.identity);\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar partition = function (predicate) {\n  return (0, exports.partitionWithIndex)(function (_, a) {\n    return predicate(a);\n  });\n};\nexports.partition = partition;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar 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 (0, Separated_1.separated)(left, right);\n  };\n};\nexports.partitionWithIndex = partitionWithIndex;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar partitionMap = function (f) {\n  return (0, exports.partitionMapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.partitionMap = partitionMap;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar 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 (0, Separated_1.separated)(left, right);\n  };\n};\nexports.partitionMapWithIndex = partitionMapWithIndex;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar filterWithIndex = function (predicateWithIndex) {\n  return function (as) {\n    return as.filter(function (a, i) {\n      return predicateWithIndex(i, a);\n    });\n  };\n};\nexports.filterWithIndex = filterWithIndex;\n/**\n * @since 2.5.0\n */\nvar extend = function (f) {\n  return function (wa) {\n    return wa.map(function (_, i) {\n      return f(wa.slice(i));\n    });\n  };\n};\nexports.extend = extend;\n/**\n * @since 2.5.0\n */\nexports.duplicate = (0, exports.extend)(function_1.identity);\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.foldMapWithIndex = foldMapWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduce = function (b, f) {\n  return (0, exports.reduceWithIndex)(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\nexports.reduce = reduce;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar foldMap = function (M) {\n  var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n  return function (f) {\n    return foldMapWithIndexM(function (_, a) {\n      return f(a);\n    });\n  };\n};\nexports.foldMap = foldMap;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.reduceWithIndex = reduceWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduceRight = function (b, f) {\n  return (0, exports.reduceRightWithIndex)(b, function (_, a, b) {\n    return f(a, b);\n  });\n};\nexports.reduceRight = reduceRight;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.reduceRightWithIndex = reduceRightWithIndex;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar traverse = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\nexports.traverse = traverse;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar sequence = function (F) {\n  return function (ta) {\n    return _reduce(ta, F.of((0, exports.zero)()), function (fas, fa) {\n      return F.ap(F.map(fas, function (as) {\n        return function (a) {\n          return (0, function_1.pipe)(as, (0, exports.append)(a));\n        };\n      }), fa);\n    });\n  };\n};\nexports.sequence = sequence;\n/**\n * @category sequencing\n * @since 2.6.3\n */\nvar traverseWithIndex = function (F) {\n  return function (f) {\n    return (0, exports.reduceWithIndex)(F.of((0, exports.zero)()), function (i, fbs, a) {\n      return F.ap(F.map(fbs, function (bs) {\n        return function (b) {\n          return (0, function_1.pipe)(bs, (0, exports.append)(b));\n        };\n      }), f(i, a));\n    });\n  };\n};\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wither = function (F) {\n  var _witherF = _wither(F);\n  return function (f) {\n    return function (fa) {\n      return _witherF(fa, f);\n    };\n  };\n};\nexports.wither = wither;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wilt = function (F) {\n  var _wiltF = _wilt(F);\n  return function (f) {\n    return function (fa) {\n      return _wiltF(fa, f);\n    };\n  };\n};\nexports.wilt = wilt;\n/**\n * @since 2.6.6\n */\nvar 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};\nexports.unfold = unfold;\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexports.URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nvar getShow = function (S) {\n  return {\n    show: function (as) {\n      return \"[\".concat(as.map(S.show).join(', '), \"]\");\n    }\n  };\n};\nexports.getShow = getShow;\n/**\n * @category instances\n * @since 2.5.0\n */\nvar getSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return (0, exports.isEmpty)(first) ? second : (0, exports.isEmpty)(second) ? first : first.concat(second);\n    }\n  };\n};\nexports.getSemigroup = getSemigroup;\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 */\nvar getMonoid = function () {\n  return {\n    concat: (0, exports.getSemigroup)().concat,\n    empty: exports.empty\n  };\n};\nexports.getMonoid = getMonoid;\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 */\nvar getEq = function (E) {\n  return (0, Eq_1.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};\nexports.getEq = getEq;\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 */\nvar getOrd = function (O) {\n  return (0, Ord_1.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};\nexports.getOrd = getOrd;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getUnionSemigroup = function (E) {\n  var unionE = union(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\nexports.getUnionSemigroup = getUnionSemigroup;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getUnionMonoid = function (E) {\n  return {\n    concat: (0, exports.getUnionSemigroup)(E).concat,\n    empty: exports.empty\n  };\n};\nexports.getUnionMonoid = getUnionMonoid;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getIntersectionSemigroup = function (E) {\n  var intersectionE = intersection(E);\n  return {\n    concat: function (first, second) {\n      return intersectionE(second)(first);\n    }\n  };\n};\nexports.getIntersectionSemigroup = getIntersectionSemigroup;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getDifferenceMagma = function (E) {\n  var differenceE = difference(E);\n  return {\n    concat: function (first, second) {\n      return differenceE(second)(first);\n    }\n  };\n};\nexports.getDifferenceMagma = getDifferenceMagma;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n  URI: exports.URI,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Apply = {\n  URI: exports.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 */\nexports.apFirst = (0, Apply_1.apFirst)(exports.Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Chain = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.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 */\nexports.chainFirst = /*#__PURE__*/(0, Chain_1.chainFirst)(exports.Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Unfoldable = {\n  URI: exports.URI,\n  unfold: exports.unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n  URI: exports.URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.Zero = {\n  URI: exports.URI,\n  zero: exports.zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexports.guard = (0, Zero_1.guard)(exports.Zero, exports.Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alternative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  alt: _alt,\n  zero: exports.zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Extend = {\n  URI: exports.URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Compactable = {\n  URI: exports.URI,\n  compact: exports.compact,\n  separate: exports.separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Filterable = {\n  URI: exports.URI,\n  map: _map,\n  compact: exports.compact,\n  separate: exports.separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FilterableWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  compact: exports.compact,\n  separate: exports.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 */\nexports.Foldable = {\n  URI: exports.URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n  URI: exports.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 */\nexports.Traversable = {\n  URI: exports.URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n  URI: exports.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: exports.sequence,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nvar 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};\nexports.chainRecDepthFirst = chainRecDepthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecDepthFirst = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.flatMap,\n  chainRec: exports._chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nvar 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};\nexports.chainRecBreadthFirst = chainRecBreadthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecBreadthFirst = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.flatMap,\n  chainRec: exports._chainRecBreadthFirst\n};\nvar _wither = /*#__PURE__*/(0, Witherable_1.witherDefault)(exports.Traversable, exports.Compactable);\nvar _wilt = /*#__PURE__*/(0, Witherable_1.wiltDefault)(exports.Traversable, exports.Compactable);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Witherable = {\n  URI: exports.URI,\n  map: _map,\n  compact: exports.compact,\n  separate: exports.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: exports.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 */\nexports.filterE = (0, Witherable_1.filterE)(exports.Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.FromEither = {\n  URI: exports.URI,\n  fromEither: exports.fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexports.fromEitherK = (0, FromEither_1.fromEitherK)(exports.FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexports.unsafeInsertAt = RNEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nvar unsafeUpdateAt = function (i, a, as) {\n  return (0, exports.isNonEmpty)(as) ? RNEA.unsafeUpdateAt(i, a, as) : as;\n};\nexports.unsafeUpdateAt = unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nvar unsafeDeleteAt = function (i, as) {\n  var xs = as.slice();\n  xs.splice(i, 1);\n  return xs;\n};\nexports.unsafeDeleteAt = unsafeDeleteAt;\n/**\n * @category conversions\n * @since 2.5.0\n */\nvar toArray = function (as) {\n  return as.slice();\n};\nexports.toArray = toArray;\n/**\n * @category conversions\n * @since 2.5.0\n */\nvar fromArray = function (as) {\n  return (0, exports.isEmpty)(as) ? exports.empty : as.slice();\n};\nexports.fromArray = fromArray;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexports.empty = RNEA.empty;\nfunction every(predicate) {\n  return function (as) {\n    return as.every(predicate);\n  };\n}\nexports.every = every;\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 */\nvar some = function (predicate) {\n  return function (as) {\n    return as.some(predicate);\n  };\n};\nexports.some = some;\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexports.exists = exports.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 */\nvar intercalate = function (M) {\n  var intercalateM = RNEA.intercalate(M);\n  return function (middle) {\n    return (0, exports.match)(function () {\n      return M.empty;\n    }, intercalateM(middle));\n  };\n};\nexports.intercalate = intercalate;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexports.Do = (0, exports.of)(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bindTo = (0, Functor_1.bindTo)(exports.Functor);\nvar let_ = /*#__PURE__*/(0, Functor_1.let)(exports.Functor);\nexports.let = let_;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bind = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexports.chain = exports.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 */\nexports.range = RNEA.range;\n/**\n * Use [`prepend`](#prepend) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.cons = RNEA.cons;\n/**\n * Use [`append`](#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.snoc = RNEA.snoc;\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.prependToAll = exports.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 */\nexports.readonlyArray = {\n  URI: exports.URI,\n  compact: exports.compact,\n  separate: exports.separate,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.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: exports.zero,\n  unfold: exports.unfold,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  extend: _extend,\n  wither: _wither,\n  wilt: _wilt\n};","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\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.reduceRight = exports.foldMap = exports.reduce = exports.mapWithIndex = exports.map = exports.flatten = exports.duplicate = exports.extend = exports.flatMap = exports.ap = exports.alt = exports.altW = exports.of = exports.chunksOf = exports.splitAt = exports.chop = exports.chainWithIndex = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.modifyAt = exports.updateAt = exports.sort = exports.groupBy = exports.group = exports.reverse = exports.concat = exports.concatW = exports.fromArray = exports.unappend = exports.unprepend = exports.range = exports.replicate = exports.makeBy = exports.fromReadonlyArray = exports.rotate = exports.union = exports.sortBy = exports.uniq = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.append = exports.appendW = exports.prepend = exports.prependW = exports.isOutOfBound = exports.isNonEmpty = exports.empty = void 0;\nexports.groupSort = exports.chain = exports.intercalate = exports.updateLast = exports.modifyLast = exports.updateHead = exports.modifyHead = exports.matchRight = exports.matchLeft = exports.concatAll = exports.max = exports.min = exports.init = exports.last = exports.tail = exports.head = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getUnionSemigroup = exports.getEq = exports.getSemigroup = exports.getShow = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.foldMapWithIndex = exports.reduceWithIndex = void 0;\nexports.readonlyNonEmptyArray = exports.fold = exports.prependToAll = exports.insertAt = exports.snoc = exports.cons = exports.unsnoc = exports.uncons = exports.filterWithIndex = exports.filter = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar Eq_1 = require(\"./Eq\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar Ord_1 = require(\"./Ord\");\nvar Se = __importStar(require(\"./Semigroup\"));\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nexports.empty = _.emptyReadonlyArray;\n/**\n * @internal\n */\nexports.isNonEmpty = _.isNonEmpty;\n/**\n * @internal\n */\nvar isOutOfBound = function (i, as) {\n  return i < 0 || i >= as.length;\n};\nexports.isOutOfBound = isOutOfBound;\n/**\n * @internal\n */\nvar prependW = function (head) {\n  return function (tail) {\n    return __spreadArray([head], tail, true);\n  };\n};\nexports.prependW = prependW;\n/**\n * @internal\n */\nexports.prepend = exports.prependW;\n/**\n * @internal\n */\nvar appendW = function (end) {\n  return function (init) {\n    return __spreadArray(__spreadArray([], init, true), [end], false);\n  };\n};\nexports.appendW = appendW;\n/**\n * @internal\n */\nexports.append = exports.appendW;\n/**\n * @internal\n */\nvar unsafeInsertAt = function (i, a, as) {\n  if ((0, exports.isNonEmpty)(as)) {\n    var xs = _.fromReadonlyNonEmptyArray(as);\n    xs.splice(i, 0, a);\n    return xs;\n  }\n  return [a];\n};\nexports.unsafeInsertAt = unsafeInsertAt;\n/**\n * @internal\n */\nvar 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};\nexports.unsafeUpdateAt = unsafeUpdateAt;\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 */\nvar uniq = function (E) {\n  return function (as) {\n    if (as.length === 1) {\n      return as;\n    }\n    var out = [(0, exports.head)(as)];\n    var rest = (0, exports.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};\nexports.uniq = uniq;\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 */\nvar sortBy = function (ords) {\n  if ((0, exports.isNonEmpty)(ords)) {\n    var M = (0, Ord_1.getMonoid)();\n    return (0, exports.sort)(ords.reduce(M.concat, M.empty));\n  }\n  return function_1.identity;\n};\nexports.sortBy = sortBy;\n/**\n * @since 2.11.0\n */\nvar union = function (E) {\n  var uniqE = (0, exports.uniq)(E);\n  return function (second) {\n    return function (first) {\n      return uniqE((0, function_1.pipe)(first, concat(second)));\n    };\n  };\n};\nexports.union = union;\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 */\nvar rotate = function (n) {\n  return function (as) {\n    var len = as.length;\n    var m = Math.round(n) % len;\n    if ((0, exports.isOutOfBound)(Math.abs(m), as) || m === 0) {\n      return as;\n    }\n    if (m < 0) {\n      var _a = (0, exports.splitAt)(-m)(as),\n        f = _a[0],\n        s = _a[1];\n      return (0, function_1.pipe)(s, concat(f));\n    } else {\n      return (0, exports.rotate)(m - len)(as);\n    }\n  };\n};\nexports.rotate = rotate;\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 */\nvar fromReadonlyArray = function (as) {\n  return (0, exports.isNonEmpty)(as) ? _.some(as) : _.none;\n};\nexports.fromReadonlyArray = fromReadonlyArray;\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 */\nvar 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};\nexports.makeBy = makeBy;\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 */\nvar replicate = function (a) {\n  return (0, exports.makeBy)(function () {\n    return a;\n  });\n};\nexports.replicate = replicate;\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 */\nvar range = function (start, end) {\n  return start <= end ? (0, exports.makeBy)(function (i) {\n    return start + i;\n  })(end - start + 1) : [start];\n};\nexports.range = range;\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 */\nvar unprepend = function (as) {\n  return [(0, exports.head)(as), (0, exports.tail)(as)];\n};\nexports.unprepend = unprepend;\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 */\nvar unappend = function (as) {\n  return [(0, exports.init)(as), (0, exports.last)(as)];\n};\nexports.unappend = unappend;\n/**\n * @category conversions\n * @since 2.5.0\n */\nvar fromArray = function (as) {\n  return (0, exports.fromReadonlyArray)(as.slice());\n};\nexports.fromArray = fromArray;\nfunction concatW(second) {\n  return function (first) {\n    return first.concat(second);\n  };\n}\nexports.concatW = concatW;\nfunction concat(x, y) {\n  return y ? x.concat(y) : function (y) {\n    return y.concat(x);\n  };\n}\nexports.concat = concat;\n/**\n * @since 2.5.0\n */\nvar reverse = function (as) {\n  return as.length === 1 ? as : __spreadArray([(0, exports.last)(as)], as.slice(0, -1).reverse(), true);\n};\nexports.reverse = reverse;\nfunction group(E) {\n  return function (as) {\n    var len = as.length;\n    if (len === 0) {\n      return exports.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}\nexports.group = group;\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 */\nvar 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};\nexports.groupBy = groupBy;\n/**\n * @since 2.5.0\n */\nvar sort = function (O) {\n  return function (as) {\n    return as.length === 1 ? as : as.slice().sort(O.compare);\n  };\n};\nexports.sort = sort;\n/**\n * @since 2.5.0\n */\nvar updateAt = function (i, a) {\n  return (0, exports.modifyAt)(i, function () {\n    return a;\n  });\n};\nexports.updateAt = updateAt;\n/**\n * @since 2.5.0\n */\nvar modifyAt = function (i, f) {\n  return function (as) {\n    return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));\n  };\n};\nexports.modifyAt = modifyAt;\n/**\n * @since 2.5.1\n */\nvar 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};\nexports.zipWith = zipWith;\nfunction zip(as, bs) {\n  if (bs === undefined) {\n    return function (bs) {\n      return zip(bs, as);\n    };\n  }\n  return (0, exports.zipWith)(as, bs, function (a, b) {\n    return [a, b];\n  });\n}\nexports.zip = zip;\n/**\n * @since 2.5.1\n */\nvar 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};\nexports.unzip = unzip;\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 */\nvar 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};\nexports.prependAll = prependAll;\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 */\nvar intersperse = function (middle) {\n  return function (as) {\n    var rest = (0, exports.tail)(as);\n    return (0, exports.isNonEmpty)(rest) ? (0, function_1.pipe)(rest, (0, exports.prependAll)(middle), (0, exports.prepend)((0, exports.head)(as))) : as;\n  };\n};\nexports.intersperse = intersperse;\n/**\n * @category sequencing\n * @since 2.10.0\n */\nvar chainWithIndex = function (f) {\n  return function (as) {\n    var out = _.fromReadonlyNonEmptyArray(f(0, (0, exports.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};\nexports.chainWithIndex = chainWithIndex;\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 */\nvar 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 ((0, exports.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};\nexports.chop = chop;\n/**\n * Splits a `ReadonlyNonEmptyArray` into two pieces, the first piece has max `n` elements.\n *\n * @since 2.10.0\n */\nvar splitAt = function (n) {\n  return function (as) {\n    var m = Math.max(1, n);\n    return m >= as.length ? [as, exports.empty] : [(0, function_1.pipe)(as.slice(1, m), (0, exports.prepend)((0, exports.head)(as))), as.slice(m)];\n  };\n};\nexports.splitAt = splitAt;\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 */\nvar chunksOf = function (n) {\n  return (0, exports.chop)((0, exports.splitAt)(n));\n};\nexports.chunksOf = chunksOf;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f));\n};\nvar _ap = function (fab, fa) {\n  return (0, function_1.pipe)(fab, (0, exports.ap)(fa));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return (0, function_1.pipe)(wa, (0, exports.extend)(f));\n};\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  var foldMapM = (0, exports.foldMap)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f));\n};\n/* istanbul ignore next */\nvar _traverse = function (F) {\n  var traverseF = (0, exports.traverse)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseF(f));\n  };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return (0, function_1.pipe)(fa, (0, exports.alt)(that));\n};\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n  var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n  return function (fa, f) {\n    return (0, function_1.pipe)(fa, foldMapWithIndexM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n  return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (ta, f) {\n    return (0, function_1.pipe)(ta, traverseWithIndexF(f));\n  };\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexports.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 */\nvar altW = function (that) {\n  return function (as) {\n    return (0, function_1.pipe)(as, concatW(that()));\n  };\n};\nexports.altW = altW;\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 */\nexports.alt = exports.altW;\n/**\n * @since 2.5.0\n */\nvar ap = function (as) {\n  return (0, exports.flatMap)(function (f) {\n    return (0, function_1.pipe)(as, (0, exports.map)(f));\n  });\n};\nexports.ap = ap;\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 */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n  return (0, function_1.pipe)(ma, (0, exports.chainWithIndex)(function (i, a) {\n    return f(a, i);\n  }));\n});\n/**\n * @since 2.5.0\n */\nvar extend = function (f) {\n  return function (as) {\n    var next = (0, exports.tail)(as);\n    var out = [f(as)];\n    while ((0, exports.isNonEmpty)(next)) {\n      out.push(f(next));\n      next = (0, exports.tail)(next);\n    }\n    return out;\n  };\n};\nexports.extend = extend;\n/**\n * @since 2.5.0\n */\nexports.duplicate = /*#__PURE__*/(0, exports.extend)(function_1.identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexports.flatten = /*#__PURE__*/(0, exports.flatMap)(function_1.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 */\nvar map = function (f) {\n  return (0, exports.mapWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.map = map;\n/**\n * @category mapping\n * @since 2.5.0\n */\nvar mapWithIndex = function (f) {\n  return function (as) {\n    var out = [f(0, (0, exports.head)(as))];\n    for (var i = 1; i < as.length; i++) {\n      out.push(f(i, as[i]));\n    }\n    return out;\n  };\n};\nexports.mapWithIndex = mapWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduce = function (b, f) {\n  return (0, exports.reduceWithIndex)(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\nexports.reduce = reduce;\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.foldMap = foldMap;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduceRight = function (b, f) {\n  return (0, exports.reduceRightWithIndex)(b, function (_, b, a) {\n    return f(b, a);\n  });\n};\nexports.reduceRight = reduceRight;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.reduceWithIndex = reduceWithIndex;\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.foldMapWithIndex = foldMapWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.reduceRightWithIndex = reduceRightWithIndex;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar traverse = function (F) {\n  var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n  return function (f) {\n    return traverseWithIndexF(function (_, a) {\n      return f(a);\n    });\n  };\n};\nexports.traverse = traverse;\n/**\n * @category traversing\n * @since 2.6.3\n */\nvar sequence = function (F) {\n  return (0, exports.traverseWithIndex)(F)(function_1.SK);\n};\nexports.sequence = sequence;\n/**\n * @category sequencing\n * @since 2.6.3\n */\nvar traverseWithIndex = function (F) {\n  return function (f) {\n    return function (as) {\n      var out = F.map(f(0, (0, exports.head)(as)), exports.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 (0, function_1.pipe)(bs, (0, exports.append)(b));\n          };\n        }), f(i, as[i]));\n      }\n      return out;\n    };\n  };\n};\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @category Comonad\n * @since 2.6.3\n */\nexports.extract = _.head;\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexports.URI = 'ReadonlyNonEmptyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nvar getShow = function (S) {\n  return {\n    show: function (as) {\n      return \"[\".concat(as.map(S.show).join(', '), \"]\");\n    }\n  };\n};\nexports.getShow = getShow;\n/**\n * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`\n *\n * @category instances\n * @since 2.5.0\n */\nvar getSemigroup = function () {\n  return {\n    concat: concat\n  };\n};\nexports.getSemigroup = getSemigroup;\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 */\nvar getEq = function (E) {\n  return (0, Eq_1.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};\nexports.getEq = getEq;\n/**\n * @since 2.11.0\n */\nvar getUnionSemigroup = function (E) {\n  var unionE = (0, exports.union)(E);\n  return {\n    concat: function (first, second) {\n      return unionE(second)(first);\n    }\n  };\n};\nexports.getUnionSemigroup = getUnionSemigroup;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n  URI: exports.URI,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Apply = {\n  URI: exports.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 */\nexports.apFirst = (0, Apply_1.apFirst)(exports.Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Chain = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: exports.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 */\nexports.chainFirst = (0, Chain_1.chainFirst)(exports.Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Foldable = {\n  URI: exports.URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n  URI: exports.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 */\nexports.Traversable = {\n  URI: exports.URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n  URI: exports.URI,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n  URI: exports.URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Comonad = {\n  URI: exports.URI,\n  map: _map,\n  extend: _extend,\n  extract: exports.extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexports.Do = (0, exports.of)(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bindTo = (0, Functor_1.bindTo)(exports.Functor);\nvar let_ = /*#__PURE__*/(0, Functor_1.let)(exports.Functor);\nexports.let = let_;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bind = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.5.0\n */\nexports.head = exports.extract;\n/**\n * @since 2.5.0\n */\nexports.tail = _.tail;\n/**\n * @since 2.5.0\n */\nvar last = function (as) {\n  return as[as.length - 1];\n};\nexports.last = 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/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.5.0\n */\nvar init = function (as) {\n  return as.slice(0, -1);\n};\nexports.init = init;\n/**\n * @since 2.5.0\n */\nvar min = function (O) {\n  var S = Se.min(O);\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\nexports.min = min;\n/**\n * @since 2.5.0\n */\nvar max = function (O) {\n  var S = Se.max(O);\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\nexports.max = max;\n/**\n * @since 2.10.0\n */\nvar concatAll = function (S) {\n  return function (as) {\n    return as.reduce(S.concat);\n  };\n};\nexports.concatAll = concatAll;\n/**\n * Break a `ReadonlyArray` into its first element and remaining elements.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchLeft = function (f) {\n  return function (as) {\n    return f((0, exports.head)(as), (0, exports.tail)(as));\n  };\n};\nexports.matchLeft = matchLeft;\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchRight = function (f) {\n  return function (as) {\n    return f((0, exports.init)(as), (0, exports.last)(as));\n  };\n};\nexports.matchRight = matchRight;\n/**\n * Apply a function to the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar modifyHead = function (f) {\n  return function (as) {\n    return __spreadArray([f((0, exports.head)(as))], (0, exports.tail)(as), true);\n  };\n};\nexports.modifyHead = modifyHead;\n/**\n * Change the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar updateHead = function (a) {\n  return (0, exports.modifyHead)(function () {\n    return a;\n  });\n};\nexports.updateHead = updateHead;\n/**\n * Apply a function to the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar modifyLast = function (f) {\n  return function (as) {\n    return (0, function_1.pipe)((0, exports.init)(as), (0, exports.append)(f((0, exports.last)(as))));\n  };\n};\nexports.modifyLast = modifyLast;\n/**\n * Change the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nvar updateLast = function (a) {\n  return (0, exports.modifyLast)(function () {\n    return a;\n  });\n};\nexports.updateLast = updateLast;\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 */\nvar intercalate = function (S) {\n  var concatAllS = (0, exports.concatAll)(S);\n  return function (middle) {\n    return (0, function_1.flow)((0, exports.intersperse)(middle), concatAllS);\n  };\n};\nexports.intercalate = intercalate;\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexports.chain = exports.flatMap;\nfunction groupSort(O) {\n  var sortO = (0, exports.sort)(O);\n  var groupO = group(O);\n  return function (as) {\n    return (0, exports.isNonEmpty)(as) ? groupO(sortO(as)) : exports.empty;\n  };\n}\nexports.groupSort = groupSort;\nfunction filter(predicate) {\n  return (0, exports.filterWithIndex)(function (_, a) {\n    return predicate(a);\n  });\n}\nexports.filter = filter;\n/**\n * Use [`filterWithIndex`](./ReadonlyArray.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nvar filterWithIndex = function (predicate) {\n  return function (as) {\n    return (0, exports.fromReadonlyArray)(as.filter(function (a, i) {\n      return predicate(i, a);\n    }));\n  };\n};\nexports.filterWithIndex = filterWithIndex;\n/**\n * Use [`unprepend`](#unprepend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexports.uncons = exports.unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexports.unsnoc = exports.unappend;\nfunction cons(head, tail) {\n  return tail === undefined ? (0, exports.prepend)(head) : (0, function_1.pipe)(tail, (0, exports.prepend)(head));\n}\nexports.cons = cons;\n/**\n * Use [`append`](./ReadonlyArray.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nvar snoc = function (init, end) {\n  return (0, function_1.pipe)(init, concat([end]));\n};\nexports.snoc = snoc;\n/**\n * Use [`insertAt`](./ReadonlyArray.ts.html#insertat) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nvar insertAt = function (i, a) {\n  return function (as) {\n    return i < 0 || i > as.length ? _.none : _.some((0, exports.unsafeInsertAt)(i, a, as));\n  };\n};\nexports.insertAt = insertAt;\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.prependToAll = exports.prependAll;\n/**\n * Use [`concatAll`](#concatall) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.fold = exports.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 */\nexports.readonlyNonEmptyArray = {\n  URI: exports.URI,\n  of: exports.of,\n  map: _map,\n  mapWithIndex: _mapWithIndex,\n  ap: _ap,\n  chain: exports.flatMap,\n  extend: _extend,\n  extract: exports.extract,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  reduceWithIndex: _reduceWithIndex,\n  foldMapWithIndex: _foldMapWithIndex,\n  reduceRightWithIndex: _reduceRightWithIndex,\n  traverseWithIndex: _traverseWithIndex,\n  alt: _alt\n};","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.semigroupProduct = exports.semigroupSum = exports.semigroupString = exports.getFunctionSemigroup = exports.semigroupAny = exports.semigroupAll = exports.fold = exports.getIntercalateSemigroup = exports.getMeetSemigroup = exports.getJoinSemigroup = exports.getDualSemigroup = exports.getStructSemigroup = exports.getTupleSemigroup = exports.getFirstSemigroup = exports.getLastSemigroup = exports.getObjectSemigroup = exports.semigroupVoid = exports.concatAll = exports.last = exports.first = exports.intercalate = exports.tuple = exports.struct = exports.reverse = exports.constant = exports.max = exports.min = void 0;\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 */\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nvar M = __importStar(require(\"./Magma\"));\nvar Or = __importStar(require(\"./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 */\nvar min = function (O) {\n  return {\n    concat: Or.min(O)\n  };\n};\nexports.min = min;\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 */\nvar max = function (O) {\n  return {\n    concat: Or.max(O)\n  };\n};\nexports.max = max;\n/**\n * @category constructors\n * @since 2.10.0\n */\nvar constant = function (a) {\n  return {\n    concat: function () {\n      return a;\n    }\n  };\n};\nexports.constant = constant;\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 */\nexports.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 */\nvar 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};\nexports.struct = struct;\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 */\nvar 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};\nexports.tuple = tuple;\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 */\nvar 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};\nexports.intercalate = intercalate;\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 */\nvar first = function () {\n  return {\n    concat: function_1.identity\n  };\n};\nexports.first = first;\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 */\nvar last = function () {\n  return {\n    concat: function (_, y) {\n      return y;\n    }\n  };\n};\nexports.last = last;\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 */\nexports.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 */\nexports.semigroupVoid = (0, exports.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 */\nvar getObjectSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return Object.assign({}, first, second);\n    }\n  };\n};\nexports.getObjectSemigroup = getObjectSemigroup;\n/**\n * Use [`last`](#last) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getLastSemigroup = exports.last;\n/**\n * Use [`first`](#first) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getFirstSemigroup = exports.first;\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getTupleSemigroup = exports.tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getStructSemigroup = exports.struct;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getDualSemigroup = exports.reverse;\n/**\n * Use [`max`](#max) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getJoinSemigroup = exports.max;\n/**\n * Use [`min`](#min) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getMeetSemigroup = exports.min;\n/**\n * Use [`intercalate`](#intercalate) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.getIntercalateSemigroup = exports.intercalate;\nfunction fold(S) {\n  var concatAllS = (0, exports.concatAll)(S);\n  return function (startWith, as) {\n    return as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as);\n  };\n}\nexports.fold = fold;\n/**\n * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.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 */\nexports.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 */\nexports.getFunctionSemigroup = function_1.getSemigroup;\n/**\n * Use [`Semigroup`](./string.ts.html#Semigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.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 */\nexports.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 */\nexports.semigroupProduct = {\n  concat: function (x, y) {\n    return x * y;\n  }\n};","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.right = exports.left = exports.flap = exports.Functor = exports.Bifunctor = exports.URI = exports.bimap = exports.mapLeft = exports.map = exports.separated = void 0;\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.10.0\n */\nvar separated = function (left, right) {\n  return {\n    left: left,\n    right: right\n  };\n};\nexports.separated = separated;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\nvar _mapLeft = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapLeft)(f));\n};\nvar _bimap = function (fa, g, f) {\n  return (0, function_1.pipe)(fa, (0, exports.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 */\nvar map = function (f) {\n  return function (fa) {\n    return (0, exports.separated)((0, exports.left)(fa), f((0, exports.right)(fa)));\n  };\n};\nexports.map = map;\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category error handling\n * @since 2.10.0\n */\nvar mapLeft = function (f) {\n  return function (fa) {\n    return (0, exports.separated)(f((0, exports.left)(fa)), (0, exports.right)(fa));\n  };\n};\nexports.mapLeft = mapLeft;\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 */\nvar bimap = function (f, g) {\n  return function (fa) {\n    return (0, exports.separated)(f((0, exports.left)(fa)), g((0, exports.right)(fa)));\n  };\n};\nexports.bimap = bimap;\n/**\n * @category type lambdas\n * @since 2.10.0\n */\nexports.URI = 'Separated';\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Bifunctor = {\n  URI: exports.URI,\n  mapLeft: _mapLeft,\n  bimap: _bimap\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.10.0\n */\nvar left = function (s) {\n  return s.left;\n};\nexports.left = left;\n/**\n * @since 2.10.0\n */\nvar right = function (s) {\n  return s.right;\n};\nexports.right = right;","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.filterE = exports.witherDefault = exports.wiltDefault = void 0;\nvar _ = __importStar(require(\"./internal\"));\nfunction 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}\nexports.wiltDefault = wiltDefault;\nfunction 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}\nexports.witherDefault = witherDefault;\nfunction 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}\nexports.filterE = filterE;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.guard = void 0;\nfunction guard(F, P) {\n  return function (b) {\n    return b ? P.of(undefined) : F.zero();\n  };\n}\nexports.guard = guard;","\"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.flatMapReader = exports.flatMapTask = exports.flatMapIO = exports.flatMapEither = exports.flatMapOption = exports.flatMapNullable = exports.liftOption = exports.liftNullable = exports.fromReadonlyNonEmptyArray = exports.has = exports.emptyRecord = exports.emptyReadonlyArray = exports.tail = exports.head = exports.isNonEmpty = exports.singleton = exports.right = exports.left = exports.isRight = exports.isLeft = exports.some = exports.none = exports.isSome = exports.isNone = void 0;\nvar function_1 = require(\"./function\");\n// -------------------------------------------------------------------------------------\n// Option\n// -------------------------------------------------------------------------------------\n/** @internal */\nvar isNone = function (fa) {\n  return fa._tag === 'None';\n};\nexports.isNone = isNone;\n/** @internal */\nvar isSome = function (fa) {\n  return fa._tag === 'Some';\n};\nexports.isSome = isSome;\n/** @internal */\nexports.none = {\n  _tag: 'None'\n};\n/** @internal */\nvar some = function (a) {\n  return {\n    _tag: 'Some',\n    value: a\n  };\n};\nexports.some = some;\n// -------------------------------------------------------------------------------------\n// Either\n// -------------------------------------------------------------------------------------\n/** @internal */\nvar isLeft = function (ma) {\n  return ma._tag === 'Left';\n};\nexports.isLeft = isLeft;\n/** @internal */\nvar isRight = function (ma) {\n  return ma._tag === 'Right';\n};\nexports.isRight = isRight;\n/** @internal */\nvar left = function (e) {\n  return {\n    _tag: 'Left',\n    left: e\n  };\n};\nexports.left = left;\n/** @internal */\nvar right = function (a) {\n  return {\n    _tag: 'Right',\n    right: a\n  };\n};\nexports.right = right;\n// -------------------------------------------------------------------------------------\n// ReadonlyNonEmptyArray\n// -------------------------------------------------------------------------------------\n/** @internal */\nvar singleton = function (a) {\n  return [a];\n};\nexports.singleton = singleton;\n/** @internal */\nvar isNonEmpty = function (as) {\n  return as.length > 0;\n};\nexports.isNonEmpty = isNonEmpty;\n/** @internal */\nvar head = function (as) {\n  return as[0];\n};\nexports.head = head;\n/** @internal */\nvar tail = function (as) {\n  return as.slice(1);\n};\nexports.tail = tail;\n// -------------------------------------------------------------------------------------\n// empty\n// -------------------------------------------------------------------------------------\n/** @internal */\nexports.emptyReadonlyArray = [];\n/** @internal */\nexports.emptyRecord = {};\n// -------------------------------------------------------------------------------------\n// Record\n// -------------------------------------------------------------------------------------\n/** @internal */\nexports.has = Object.prototype.hasOwnProperty;\n// -------------------------------------------------------------------------------------\n// NonEmptyArray\n// -------------------------------------------------------------------------------------\n/** @internal */\nvar fromReadonlyNonEmptyArray = function (as) {\n  return __spreadArray([as[0]], as.slice(1), true);\n};\nexports.fromReadonlyNonEmptyArray = fromReadonlyNonEmptyArray;\n/** @internal */\nvar 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 ? (0, exports.left)(onNullable.apply(void 0, a)) : (0, exports.right)(o));\n    };\n  };\n};\nexports.liftNullable = liftNullable;\n/** @internal */\nvar 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((0, exports.isNone)(o) ? (0, exports.left)(onNone.apply(void 0, a)) : (0, exports.right)(o.value));\n    };\n  };\n};\nexports.liftOption = liftOption;\n/** @internal */\nvar flatMapNullable = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(3, function (self, f, onNullable) {\n    return M.flatMap(self, (0, exports.liftNullable)(F)(f, onNullable));\n  });\n};\nexports.flatMapNullable = flatMapNullable;\n/** @internal */\nvar flatMapOption = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(3, function (self, f, onNone) {\n    return M.flatMap(self, (0, exports.liftOption)(F)(f, onNone));\n  });\n};\nexports.flatMapOption = flatMapOption;\n/** @internal */\nvar flatMapEither = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromEither(f(a));\n    });\n  });\n};\nexports.flatMapEither = flatMapEither;\n/** @internal */\nvar flatMapIO = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromIO(f(a));\n    });\n  });\n};\nexports.flatMapIO = flatMapIO;\n/** @internal */\nvar flatMapTask = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromTask(f(a));\n    });\n  });\n};\nexports.flatMapTask = flatMapTask;\n/** @internal */\nvar flatMapReader = function (F, M) {\n  /*#__PURE__*/return (0, function_1.dual)(2, function (self, f) {\n    return M.flatMap(self, function (a) {\n      return F.fromReader(f(a));\n    });\n  });\n};\nexports.flatMapReader = flatMapReader;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Field = exports.MonoidProduct = exports.MonoidSum = exports.SemigroupProduct = exports.SemigroupSum = exports.MagmaSub = exports.Show = exports.Bounded = exports.Ord = exports.Eq = exports.isNumber = void 0;\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * @category refinements\n * @since 2.11.0\n */\nvar isNumber = function (u) {\n  return typeof u === 'number';\n};\nexports.isNumber = isNumber;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Eq = {\n  equals: function (first, second) {\n    return first === second;\n  }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Ord = {\n  equals: exports.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 */\nexports.Bounded = {\n  equals: exports.Eq.equals,\n  compare: exports.Ord.compare,\n  top: Infinity,\n  bottom: -Infinity\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Show = {\n  show: function (n) {\n    return JSON.stringify(n);\n  }\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.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 */\nexports.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 */\nexports.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 */\nexports.MonoidSum = {\n  concat: exports.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 */\nexports.MonoidProduct = {\n  concat: exports.SemigroupProduct.concat,\n  empty: 1\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Field = {\n  add: exports.SemigroupSum.concat,\n  zero: 0,\n  mul: exports.SemigroupProduct.concat,\n  one: 1,\n  sub: exports.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};"],"names":["IconSearch","d","key","__createBinding","this","Object","create","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","defineProperty","__setModuleDefault","v","value","__importStar","mod","result","prototype","hasOwnProperty","call","exports","sequenceS","sequenceT","getApplySemigroup","apS","apSecond","apFirst","ap","function_1","_","curried","f","n","acc","x","combined","Array","length","i","apply","F","G","fa","fab","map","gab","ga","A","second","first","a","b","name","fb","_a","assign","S","concat","y","tupleConstructors","c","e","args","_i","arguments","len","has","tuple","getTupleConstructor","fas","r","keys","getRecordConstructor","fr","lefts","rights","reverse","modifyAt","deleteAt","updateAt","insertAt","copy","findLastIndex","findLastMap","findLast","findFirstMap","findFirst","findIndex","dropLeftWhile","dropRight","dropLeft","spanLeft","takeLeftWhile","takeRight","takeLeft","init","tail","last","head","lookup","isOutOfBound","size","scanRight","scanLeft","chainWithIndex","foldRight","matchRight","matchRightW","foldLeft","matchLeft","matchLeftW","match","matchW","fromEither","fromOption","fromPredicate","replicate","makeBy","appendW","append","prependW","prepend","isNonEmpty","isEmpty","traverseWithIndex","sequence","traverse","reduceRightWithIndex","reduceRight","reduceWithIndex","reduce","foldMapWithIndex","foldMap","duplicate","extend","filterWithIndex","alt","altW","partitionMapWithIndex","partitionMap","partitionWithIndex","partition","filter","separate","compact","filterMap","filterMapWithIndex","mapWithIndex","flatten","flatMap","zero","of","difference","intersection","union","concatW","comprehension","fromOptionK","chunksOf","splitAt","chop","sortBy","uniq","elem","rotate","intersperse","prependAll","unzip","zip","zipWith","sort","some","every","unsafeDeleteAt","unsafeUpdateAt","unsafeInsertAt","fromEitherK","FromEither","filterE","ChainRecBreadthFirst","chainRecBreadthFirst","ChainRecDepthFirst","chainRecDepthFirst","Witherable","TraversableWithIndex","Traversable","FoldableWithIndex","Foldable","FilterableWithIndex","Filterable","Compactable","Extend","Alternative","guard","Zero","Alt","Unfoldable","Monad","chainFirst","Chain","Applicative","Apply","FunctorWithIndex","Pointed","flap","Functor","getDifferenceMagma","getIntersectionSemigroup","getUnionMonoid","getUnionSemigroup","getOrd","getEq","getMonoid","getSemigroup","getShow","URI","unfold","wilt","wither","array","prependToAll","snoc","cons","empty","range","chain","bind","bindTo","Do","intercalate","exists","Apply_1","Chain_1","FromEither_1","Functor_1","NEA","RA","Separated_1","Witherable_1","Zero_1","as","predicate","ma","isNone","isLeft","right","onEmpty","onNonEmpty","out","push","none","slice","as_1","spanLeftIndex","l","rest","_tag","left","O","compare","fc","Math","min","bs","middle","E","ords","g","input","go","scope","pipe","unionE","unionE_1","elemE","xs","ys","intersectionE_1","differenceE_1","_map","_mapWithIndex","_ap","_filter","_filterMap","_partition","_partitionMap","_partitionWithIndex","predicateWithIndex","_partitionMapWithIndex","_alt","that","_reduce","_foldMap","M","foldMapM","_reduceRight","_reduceWithIndex","_foldMapWithIndex","foldMapWithIndexM","_reduceRightWithIndex","_filterMapWithIndex","_filterWithIndex","_extend","_traverse","traverseF","ta","_traverseWithIndex","traverseWithIndexF","_chainRecDepthFirst","_chainRecBreadthFirst","dual","identity","optionB","isSome","fa_1","separated","wa","fbs","_witherF","_wither","_wiltF","_wilt","bb","mt","b_1","intersectionE","differenceE","witherDefault","wiltDefault","chainRec","splice","emptyRecord","let_","let","tap","tapM","eqDate","eqNumber","eqString","eqBoolean","eq","strictEqual","getStructEq","getTupleEq","Contravariant","eqStrict","contramap","struct","fromEquals","equals","eqs","valueOf","tapEither","filterOrElse","chainFirstEitherK","chainEitherK","chainOptionK","onNone","fromOptionF","from","flow","self","onFalse","fromOptionKF","fromEitherKF","tapEitherM","asUnit","getFunctorComposition","fga","asM","concatAll","endo","filterSecond","filterFirst","startWith","__spreadArray","to","pack","ar","groupBy","group","unappend","unprepend","fromArray","fromReadonlyNonEmptyArray","updateLast","modifyLast","updateHead","modifyHead","max","Comonad","extract","nonEmptyArray","fold","unsnoc","uncons","groupSort","Ord_1","RNEA","end","_loop_1","rest_1","uniqE","round","abs","s","j","floor","start","nea","cs","next","_b","rest_2","sortO","groupO","ordDate","ordNumber","ordString","ordBoolean","ord","getDualOrd","getTupleOrd","between","clamp","geq","leq","gt","lt","trivial","fromCompare","equalsDefault","Eq_1","ox","constTrue","constant","minO","maxO","low","hi","ltO","gtO","strictOrd","date","toArray","readonlyArray","N","elemE_1","element","show","join","aLen","bLen","ordering","Ord","todo","shift","unshift","initial","forEach","initial_1","intercalateM","fromReadonlyArray","readonlyNonEmptyArray","Se","emptyReadonlyArray","singleton","SK","concatAllS","semigroupProduct","semigroupSum","semigroupString","getFunctionSemigroup","semigroupAny","semigroupAll","getIntercalateSemigroup","getMeetSemigroup","getJoinSemigroup","getDualSemigroup","getStructSemigroup","getTupleSemigroup","getFirstSemigroup","getLastSemigroup","getObjectSemigroup","semigroupVoid","Or","semigroups","Bifunctor","bimap","mapLeft","T","C","W","witherF","P","flatMapReader","flatMapTask","flatMapIO","flatMapEither","flatMapOption","flatMapNullable","liftOption","liftNullable","isRight","onNullable","fromIO","fromTask","fromReader","Field","MonoidProduct","MonoidSum","SemigroupProduct","SemigroupSum","MagmaSub","Show","Bounded","Eq","isNumber","u","top","Infinity","bottom","JSON","stringify","add","mul","one","sub","degree","div"],"sourceRoot":""}