{"version":3,"sources":["node_modules/fp-ts/lib/function.js","node_modules/fp-ts/lib/internal.js","node_modules/fp-ts/lib/Apply.js","node_modules/fp-ts/lib/Functor.js","node_modules/fp-ts/lib/Applicative.js","node_modules/fp-ts/lib/Chain.js","node_modules/fp-ts/lib/FromEither.js","node_modules/fp-ts/lib/Predicate.js","node_modules/fp-ts/lib/Magma.js","node_modules/fp-ts/lib/Eq.js","node_modules/fp-ts/lib/Ord.js","node_modules/fp-ts/lib/Semigroup.js","node_modules/fp-ts/lib/Separated.js","node_modules/fp-ts/lib/Witherable.js","node_modules/fp-ts/lib/Zero.js","node_modules/fp-ts/lib/Option.js","node_modules/fp-ts/lib/pipeable.js","src/app/shared/directives/option/option.directive.ts","src/app/shared/directives/option/none.directive.ts","src/app/shared/directives/option/some.directive.ts","src/app/shared/directives/option/option.module.ts"],"sourcesContent":["\"use strict\";\n\nvar __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.dual = exports.getEndomorphismMonoid = exports.SK = exports.hole = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.unsafeCoerce = exports.apply = exports.getRing = exports.getSemiring = exports.getMonoid = exports.getSemigroup = exports.getBooleanAlgebra = void 0;\nexports.identity = identity;\nexports.constant = constant;\nexports.flip = flip;\nexports.flow = flow;\nexports.tuple = tuple;\nexports.increment = increment;\nexports.decrement = decrement;\nexports.absurd = absurd;\nexports.tupled = tupled;\nexports.untupled = untupled;\nexports.pipe = pipe;\nexports.not = not;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getBooleanAlgebra = function (B) {\n  return function () {\n    return {\n      meet: function (x, y) {\n        return function (a) {\n          return B.meet(x(a), y(a));\n        };\n      },\n      join: function (x, y) {\n        return function (a) {\n          return B.join(x(a), y(a));\n        };\n      },\n      zero: function () {\n        return B.zero;\n      },\n      one: function () {\n        return B.one;\n      },\n      implies: function (x, y) {\n        return function (a) {\n          return B.implies(x(a), y(a));\n        };\n      },\n      not: function (x) {\n        return function (a) {\n          return B.not(x(a));\n        };\n      }\n    };\n  };\n};\nexports.getBooleanAlgebra = getBooleanAlgebra;\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getSemigroup = function (S) {\n  return function () {\n    return {\n      concat: function (f, g) {\n        return function (a) {\n          return S.concat(f(a), g(a));\n        };\n      }\n    };\n  };\n};\nexports.getSemigroup = getSemigroup;\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getMonoid = function (M) {\n  var getSemigroupM = (0, exports.getSemigroup)(M);\n  return function () {\n    return {\n      concat: getSemigroupM().concat,\n      empty: function () {\n        return M.empty;\n      }\n    };\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getSemiring = function (S) {\n  return {\n    add: function (f, g) {\n      return function (x) {\n        return S.add(f(x), g(x));\n      };\n    },\n    zero: function () {\n      return S.zero;\n    },\n    mul: function (f, g) {\n      return function (x) {\n        return S.mul(f(x), g(x));\n      };\n    },\n    one: function () {\n      return S.one;\n    }\n  };\n};\nexports.getSemiring = getSemiring;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getRing = function (R) {\n  var S = (0, exports.getSemiring)(R);\n  return {\n    add: S.add,\n    mul: S.mul,\n    one: S.one,\n    zero: S.zero,\n    sub: function (f, g) {\n      return function (x) {\n        return R.sub(f(x), g(x));\n      };\n    }\n  };\n};\nexports.getRing = getRing;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nvar apply = function (a) {\n  return function (f) {\n    return f(a);\n  };\n};\nexports.apply = apply;\n/**\n * @since 2.0.0\n */\nfunction identity(a) {\n  return a;\n}\n/**\n * @since 2.0.0\n */\nexports.unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nfunction constant(a) {\n  return function () {\n    return a;\n  };\n}\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexports.constTrue = constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexports.constFalse = constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexports.constNull = constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexports.constUndefined = constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexports.constVoid = exports.constUndefined;\nfunction flip(f) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    if (args.length > 1) {\n      return f(args[1], args[0]);\n    }\n    return function (a) {\n      return f(a)(args[0]);\n    };\n  };\n}\nfunction flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n  switch (arguments.length) {\n    case 1:\n      return ab;\n    case 2:\n      return function () {\n        return bc(ab.apply(this, arguments));\n      };\n    case 3:\n      return function () {\n        return cd(bc(ab.apply(this, arguments)));\n      };\n    case 4:\n      return function () {\n        return de(cd(bc(ab.apply(this, arguments))));\n      };\n    case 5:\n      return function () {\n        return ef(de(cd(bc(ab.apply(this, arguments)))));\n      };\n    case 6:\n      return function () {\n        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n      };\n    case 7:\n      return function () {\n        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n      };\n    case 8:\n      return function () {\n        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n      };\n    case 9:\n      return function () {\n        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n      };\n  }\n  return;\n}\n/**\n * @since 2.0.0\n */\nfunction tuple() {\n  var t = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    t[_i] = arguments[_i];\n  }\n  return t;\n}\n/**\n * @since 2.0.0\n */\nfunction increment(n) {\n  return n + 1;\n}\n/**\n * @since 2.0.0\n */\nfunction decrement(n) {\n  return n - 1;\n}\n/**\n * @since 2.0.0\n */\nfunction absurd(_) {\n  throw new Error('Called `absurd` function which should be uncallable');\n}\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nfunction tupled(f) {\n  return function (a) {\n    return f.apply(void 0, a);\n  };\n}\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nfunction untupled(f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return f(a);\n  };\n}\nfunction pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n  switch (arguments.length) {\n    case 1:\n      return a;\n    case 2:\n      return ab(a);\n    case 3:\n      return bc(ab(a));\n    case 4:\n      return cd(bc(ab(a)));\n    case 5:\n      return de(cd(bc(ab(a))));\n    case 6:\n      return ef(de(cd(bc(ab(a)))));\n    case 7:\n      return fg(ef(de(cd(bc(ab(a))))));\n    case 8:\n      return gh(fg(ef(de(cd(bc(ab(a)))))));\n    case 9:\n      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n    default:\n      {\n        var ret = arguments[0];\n        for (var i = 1; i < arguments.length; i++) {\n          ret = arguments[i](ret);\n        }\n        return ret;\n      }\n  }\n}\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexports.hole = absurd;\n/**\n * @since 2.11.0\n */\nvar SK = function (_, b) {\n  return b;\n};\nexports.SK = SK;\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nfunction not(predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n}\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nvar getEndomorphismMonoid = function () {\n  return {\n    concat: function (first, second) {\n      return flow(first, second);\n    },\n    empty: identity\n  };\n};\nexports.getEndomorphismMonoid = getEndomorphismMonoid;\n/** @internal */\nvar dual = function (arity, body) {\n  var isDataFirst = typeof arity === 'number' ? function (args) {\n    return args.length >= arity;\n  } : arity;\n  return function () {\n    var args = Array.from(arguments);\n    if (isDataFirst(arguments)) {\n      return body.apply(this, args);\n    }\n    return function (self) {\n      return body.apply(void 0, __spreadArray([self], args, false));\n    };\n  };\n};\nexports.dual = dual;","\"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  return /*#__PURE__*/(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  return /*#__PURE__*/(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  return /*#__PURE__*/(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  return /*#__PURE__*/(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  return /*#__PURE__*/(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  return /*#__PURE__*/(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\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.ap = ap;\nexports.apFirst = apFirst;\nexports.apSecond = apSecond;\nexports.apS = apS;\nexports.getApplySemigroup = getApplySemigroup;\nexports.sequenceT = sequenceT;\nexports.sequenceS = sequenceS;\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}\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}\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}\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}\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}\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}\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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.map = map;\nexports.flap = flap;\nexports.bindTo = bindTo;\nexports.let = let_;\nexports.getFunctorComposition = getFunctorComposition;\nexports.as = as;\nexports.asUnit = asUnit;\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}\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}\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}\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}\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}\n/** @internal */\nfunction as(F) {\n  return function (self, b) {\n    return F.map(self, function () {\n      return b;\n    });\n  };\n}\n/** @internal */\nfunction asUnit(F) {\n  var asM = as(F);\n  return function (self) {\n    return asM(self, undefined);\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getApplicativeMonoid = getApplicativeMonoid;\nexports.getApplicativeComposition = getApplicativeComposition;\n/**\n * The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values\n * of type `f a` from values of type `a`.\n *\n * Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are\n * wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the\n * function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for\n * any number of function arguments.\n *\n * Instances must satisfy the following laws in addition to the `Apply` laws:\n *\n * 1. Identity: `A.ap(A.of(a => a), fa) <-> fa`\n * 2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`\n * 3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`\n *\n * Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`\n *\n * @since 2.0.0\n */\nvar Apply_1 = require(\"./Apply\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nfunction getApplicativeMonoid(F) {\n  var f = (0, Apply_1.getApplySemigroup)(F);\n  return function (M) {\n    return {\n      concat: f(M).concat,\n      empty: F.of(M.empty)\n    };\n  };\n}\n/** @deprecated */\nfunction getApplicativeComposition(F, G) {\n  var map = (0, Functor_1.getFunctorComposition)(F, G).map;\n  var _ap = (0, Apply_1.ap)(F, G);\n  return {\n    map: map,\n    of: function (a) {\n      return F.of(G.of(a));\n    },\n    ap: function (fgab, fga) {\n      return (0, function_1.pipe)(fgab, _ap(fga));\n    }\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.chainFirst = chainFirst;\nexports.tap = tap;\nexports.bind = bind;\nfunction chainFirst(M) {\n  var tapM = tap(M);\n  return function (f) {\n    return function (first) {\n      return tapM(first, f);\n    };\n  };\n}\n/** @internal */\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}\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}","\"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.fromOption = fromOption;\nexports.fromPredicate = fromPredicate;\nexports.fromOptionK = fromOptionK;\nexports.chainOptionK = chainOptionK;\nexports.fromEitherK = fromEitherK;\nexports.chainEitherK = chainEitherK;\nexports.chainFirstEitherK = chainFirstEitherK;\nexports.filterOrElse = filterOrElse;\nexports.tapEither = tapEither;\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}\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}\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}\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}\nfunction fromEitherK(F) {\n  return function (f) {\n    return (0, function_1.flow)(f, F.fromEither);\n  };\n}\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}\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}\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}\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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.and = exports.or = exports.not = exports.Contravariant = exports.getMonoidAll = exports.getSemigroupAll = exports.getMonoidAny = exports.getSemigroupAny = exports.URI = exports.contramap = void 0;\nvar function_1 = require(\"./function\");\nvar contramap_ = function (predicate, f) {\n  return (0, function_1.pipe)(predicate, (0, exports.contramap)(f));\n};\n/**\n * @since 2.11.0\n */\nvar contramap = function (f) {\n  return function (predicate) {\n    return (0, function_1.flow)(f, predicate);\n  };\n};\nexports.contramap = contramap;\n/**\n * @category type lambdas\n * @since 2.11.0\n */\nexports.URI = 'Predicate';\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getSemigroupAny = function () {\n  return {\n    concat: function (first, second) {\n      return (0, function_1.pipe)(first, (0, exports.or)(second));\n    }\n  };\n};\nexports.getSemigroupAny = getSemigroupAny;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getMonoidAny = function () {\n  return {\n    concat: (0, exports.getSemigroupAny)().concat,\n    empty: function_1.constFalse\n  };\n};\nexports.getMonoidAny = getMonoidAny;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getSemigroupAll = function () {\n  return {\n    concat: function (first, second) {\n      return (0, function_1.pipe)(first, (0, exports.and)(second));\n    }\n  };\n};\nexports.getSemigroupAll = getSemigroupAll;\n/**\n * @category instances\n * @since 2.11.0\n */\nvar getMonoidAll = function () {\n  return {\n    concat: (0, exports.getSemigroupAll)().concat,\n    empty: function_1.constTrue\n  };\n};\nexports.getMonoidAll = getMonoidAll;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.Contravariant = {\n  URI: exports.URI,\n  contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nvar not = function (predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n};\nexports.not = not;\n/**\n * @since 2.11.0\n */\nvar or = function (second) {\n  return function (first) {\n    return function (a) {\n      return first(a) || second(a);\n    };\n  };\n};\nexports.or = or;\n/**\n * @since 2.11.0\n */\nvar and = function (second) {\n  return function (first) {\n    return function (a) {\n      return first(a) && second(a);\n    };\n  };\n};\nexports.and = and;","\"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\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\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};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.semigroupProduct = exports.semigroupSum = exports.semigroupString = exports.getFunctionSemigroup = exports.semigroupAny = exports.semigroupAll = 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;\nexports.fold = fold;\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}\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.wiltDefault = wiltDefault;\nexports.witherDefault = witherDefault;\nexports.filterE = filterE;\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}\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}\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}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.guard = guard;\nfunction guard(F, P) {\n  return function (b) {\n    return b ? P.of(undefined) : F.zero();\n  };\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.throwError = exports.Witherable = exports.wilt = exports.wither = exports.Traversable = exports.sequence = exports.traverse = exports.Filterable = exports.partitionMap = exports.partition = exports.filterMap = exports.filter = exports.Compactable = exports.separate = exports.compact = exports.Extend = exports.extend = exports.Alternative = exports.guard = exports.Zero = exports.zero = exports.Alt = exports.alt = exports.altW = exports.orElse = exports.Foldable = exports.reduceRight = exports.foldMap = exports.reduce = exports.Monad = exports.Chain = exports.flatMap = exports.Applicative = exports.Apply = exports.ap = exports.Pointed = exports.of = exports.asUnit = exports.as = exports.Functor = exports.map = exports.getMonoid = exports.getOrd = exports.getEq = exports.getShow = exports.URI = exports.getRight = exports.getLeft = exports.some = exports.none = void 0;\nexports.getLastMonoid = exports.getFirstMonoid = exports.getApplyMonoid = exports.getApplySemigroup = exports.option = exports.mapNullable = exports.chainFirst = exports.chain = exports.sequenceArray = exports.traverseArray = exports.traverseArrayWithIndex = exports.traverseReadonlyArrayWithIndex = exports.traverseReadonlyNonEmptyArrayWithIndex = exports.ApT = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.exists = exports.toUndefined = exports.toNullable = exports.chainNullableK = exports.fromNullableK = exports.tryCatchK = exports.tryCatch = exports.fromNullable = exports.chainFirstEitherK = exports.chainEitherK = exports.fromEitherK = exports.duplicate = exports.tapEither = exports.tap = exports.flatten = exports.apSecond = exports.apFirst = exports.flap = exports.getOrElse = exports.getOrElseW = exports.fold = exports.match = exports.foldW = exports.matchW = exports.isNone = exports.isSome = exports.FromEither = exports.fromEither = exports.MonadThrow = void 0;\nexports.fromPredicate = fromPredicate;\nexports.elem = elem;\nexports.getRefinement = getRefinement;\nvar Applicative_1 = require(\"./Applicative\");\nvar Apply_1 = require(\"./Apply\");\nvar chainable = __importStar(require(\"./Chain\"));\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar Predicate_1 = require(\"./Predicate\");\nvar Semigroup_1 = require(\"./Semigroup\");\nvar Separated_1 = require(\"./Separated\");\nvar Witherable_1 = require(\"./Witherable\");\nvar Zero_1 = require(\"./Zero\");\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.none = _.none;\n/**\n * Constructs a `Some`. Represents an optional value that exists.\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.some = _.some;\nfunction fromPredicate(predicate) {\n  return function (a) {\n    return predicate(a) ? (0, exports.some)(a) : exports.none;\n  };\n}\n/**\n * Returns the `Left` value of an `Either` if possible.\n *\n * @example\n * import { getLeft, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getLeft(right(1)), none)\n * assert.deepStrictEqual(getLeft(left('a')), some('a'))\n *\n * @category constructors\n * @since 2.0.0\n */\nvar getLeft = function (ma) {\n  return ma._tag === 'Right' ? exports.none : (0, exports.some)(ma.left);\n};\nexports.getLeft = getLeft;\n/**\n * Returns the `Right` value of an `Either` if possible.\n *\n * @example\n * import { getRight, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getRight(right(1)), some(1))\n * assert.deepStrictEqual(getRight(left('a')), none)\n *\n * @category constructors\n * @since 2.0.0\n */\nvar getRight = function (ma) {\n  return ma._tag === 'Left' ? exports.none : (0, exports.some)(ma.right);\n};\nexports.getRight = getRight;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\nvar _ap = function (fab, fa) {\n  return (0, function_1.pipe)(fab, (0, exports.ap)(fa));\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 _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};\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 _extend = function (wa, f) {\n  return (0, function_1.pipe)(wa, (0, exports.extend)(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/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.URI = 'Option';\n/**\n * @category instances\n * @since 2.0.0\n */\nvar getShow = function (S) {\n  return {\n    show: function (ma) {\n      return (0, exports.isNone)(ma) ? 'none' : \"some(\".concat(S.show(ma.value), \")\");\n    }\n  };\n};\nexports.getShow = getShow;\n/**\n * @example\n * import { none, some, getEq } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals(none, none), true)\n * assert.strictEqual(E.equals(none, some(1)), false)\n * assert.strictEqual(E.equals(some(1), none), false)\n * assert.strictEqual(E.equals(some(1), some(2)), false)\n * assert.strictEqual(E.equals(some(1), some(1)), true)\n *\n * @category instances\n * @since 2.0.0\n */\nvar getEq = function (E) {\n  return {\n    equals: function (x, y) {\n      return x === y || ((0, exports.isNone)(x) ? (0, exports.isNone)(y) : (0, exports.isNone)(y) ? false : E.equals(x.value, y.value));\n    }\n  };\n};\nexports.getEq = getEq;\n/**\n * The `Ord` instance allows `Option` values to be compared with\n * `compare`, whenever there is an `Ord` instance for\n * the type the `Option` contains.\n *\n * `None` is considered to be less than any `Some` value.\n *\n *\n * @example\n * import { none, some, getOrd } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const O = getOrd(N.Ord)\n * assert.strictEqual(O.compare(none, none), 0)\n * assert.strictEqual(O.compare(none, some(1)), -1)\n * assert.strictEqual(O.compare(some(1), none), 1)\n * assert.strictEqual(O.compare(some(1), some(2)), -1)\n * assert.strictEqual(O.compare(some(1), some(1)), 0)\n *\n * @category instances\n * @since 2.0.0\n */\nvar getOrd = function (O) {\n  return {\n    equals: (0, exports.getEq)(O).equals,\n    compare: function (x, y) {\n      return x === y ? 0 : (0, exports.isSome)(x) ? (0, exports.isSome)(y) ? O.compare(x.value, y.value) : 1 : -1;\n    }\n  };\n};\nexports.getOrd = getOrd;\n/**\n * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | some(a)            |\n * | none    | some(b) | some(b)            |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getMonoid, some, none } from 'fp-ts/Option'\n * import { SemigroupSum } from 'fp-ts/number'\n *\n * const M = getMonoid(SemigroupSum)\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nvar getMonoid = function (S) {\n  return {\n    concat: function (x, y) {\n      return (0, exports.isNone)(x) ? y : (0, exports.isNone)(y) ? x : (0, exports.some)(S.concat(x.value, y.value));\n    },\n    empty: exports.none\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category mapping\n * @since 2.0.0\n */\nvar map = function (f) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? exports.none : (0, exports.some)(f(fa.value));\n  };\n};\nexports.map = map;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * Maps the `Some` value of this `Option` to the specified constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexports.as = (0, function_1.dual)(2, (0, Functor_1.as)(exports.Functor));\n/**\n * Maps the `Some` value of this `Option` to the void constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexports.asUnit = (0, Functor_1.asUnit)(exports.Functor);\n/**\n * @category constructors\n * @since 2.7.0\n */\nexports.of = exports.some;\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n  URI: exports.URI,\n  of: exports.of\n};\n/**\n * @since 2.0.0\n */\nvar ap = function (fa) {\n  return function (fab) {\n    return (0, exports.isNone)(fab) ? exports.none : (0, exports.isNone)(fa) ? exports.none : (0, exports.some)(fab.value(fa.value));\n  };\n};\nexports.ap = ap;\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 * @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 sequencing\n * @since 2.14.0\n */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n  return (0, exports.isNone)(ma) ? exports.none : f(ma.value);\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 * @category folding\n * @since 2.0.0\n */\nvar reduce = function (b, f) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? b : f(b, fa.value);\n  };\n};\nexports.reduce = reduce;\n/**\n * @category folding\n * @since 2.0.0\n */\nvar foldMap = function (M) {\n  return function (f) {\n    return function (fa) {\n      return (0, exports.isNone)(fa) ? M.empty : f(fa.value);\n    };\n  };\n};\nexports.foldMap = foldMap;\n/**\n * @category folding\n * @since 2.0.0\n */\nvar reduceRight = function (b, f) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? b : f(fa.value, b);\n  };\n};\nexports.reduceRight = reduceRight;\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 * Returns the provided `Option` `that` if `self` is `None`, otherwise returns `self`.\n *\n * @param self - The first `Option` to be checked.\n * @param that - The `Option` to return if `self` is `None`.\n *\n * @example\n * import * as O from \"fp-ts/Option\"\n *\n * assert.deepStrictEqual(O.orElse(O.none, () => O.none), O.none)\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.none), O.some(1))\n * assert.deepStrictEqual(O.orElse(O.none, () => O.some('b')), O.some('b'))\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.some('b')), O.some(1))\n *\n * @category error handling\n * @since 2.16.0\n */\nexports.orElse = (0, function_1.dual)(2, function (self, that) {\n  return (0, exports.isNone)(self) ? that() : self;\n});\n/**\n * Alias of `orElse`.\n *\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @category legacy\n * @since 2.9.0\n */\nexports.altW = exports.orElse;\n/**\n * Alias of `orElse`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexports.alt = exports.orElse;\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 * @since 2.7.0\n */\nvar zero = function () {\n  return exports.none;\n};\nexports.zero = zero;\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 * @since 2.0.0\n */\nvar extend = function (f) {\n  return function (wa) {\n    return (0, exports.isNone)(wa) ? exports.none : (0, exports.some)(f(wa));\n  };\n};\nexports.extend = extend;\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 filtering\n * @since 2.0.0\n */\nexports.compact = (0, exports.flatMap)(function_1.identity);\nvar defaultSeparated = /*#__PURE__*/(0, Separated_1.separated)(exports.none, exports.none);\n/**\n * @category filtering\n * @since 2.0.0\n */\nvar separate = function (ma) {\n  return (0, exports.isNone)(ma) ? defaultSeparated : (0, Separated_1.separated)((0, exports.getLeft)(ma.value), (0, exports.getRight)(ma.value));\n};\nexports.separate = separate;\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 filtering\n * @since 2.0.0\n */\nvar filter = function (predicate) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? exports.none : predicate(fa.value) ? fa : exports.none;\n  };\n};\nexports.filter = filter;\n/**\n * @category filtering\n * @since 2.0.0\n */\nvar filterMap = function (f) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? exports.none : f(fa.value);\n  };\n};\nexports.filterMap = filterMap;\n/**\n * @category filtering\n * @since 2.0.0\n */\nvar partition = function (predicate) {\n  return function (fa) {\n    return (0, Separated_1.separated)(_filter(fa, (0, Predicate_1.not)(predicate)), _filter(fa, predicate));\n  };\n};\nexports.partition = partition;\n/**\n * @category filtering\n * @since 2.0.0\n */\nvar partitionMap = function (f) {\n  return (0, function_1.flow)((0, exports.map)(f), exports.separate);\n};\nexports.partitionMap = partitionMap;\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 traversing\n * @since 2.6.3\n */\nvar traverse = function (F) {\n  return function (f) {\n    return function (ta) {\n      return (0, exports.isNone)(ta) ? F.of(exports.none) : F.map(f(ta.value), exports.some);\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 (0, exports.isNone)(ta) ? F.of(exports.none) : F.map(ta.value, exports.some);\n  };\n};\nexports.sequence = sequence;\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};\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 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 * @category instances\n * @since 2.7.0\n */\nexports.Witherable = {\n  URI: exports.URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  compact: exports.compact,\n  separate: exports.separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  wither: _wither,\n  wilt: _wilt\n};\n/**\n * @since 2.7.0\n */\nvar throwError = function () {\n  return exports.none;\n};\nexports.throwError = throwError;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.MonadThrow = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  of: exports.of,\n  chain: exports.flatMap,\n  throwError: exports.throwError\n};\n/**\n * Transforms an `Either` to an `Option` discarding the error.\n *\n * Alias of [getRight](#getright)\n *\n * @category conversions\n * @since 2.0.0\n */\nexports.fromEither = exports.getRight;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.FromEither = {\n  URI: exports.URI,\n  fromEither: exports.fromEither\n};\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the option is an instance of `Some`, `false` otherwise.\n *\n * @example\n * import { some, none, isSome } from 'fp-ts/Option'\n *\n * assert.strictEqual(isSome(some(1)), true)\n * assert.strictEqual(isSome(none), false)\n *\n * @category refinements\n * @since 2.0.0\n */\nexports.isSome = _.isSome;\n/**\n * Returns `true` if the option is `None`, `false` otherwise.\n *\n * @example\n * import { some, none, isNone } from 'fp-ts/Option'\n *\n * assert.strictEqual(isNone(some(1)), false)\n * assert.strictEqual(isNone(none), true)\n *\n * @category refinements\n * @since 2.0.0\n */\nvar isNone = function (fa) {\n  return fa._tag === 'None';\n};\nexports.isNone = isNone;\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nvar matchW = function (onNone, onSome) {\n  return function (ma) {\n    return (0, exports.isNone)(ma) ? onNone() : onSome(ma.value);\n  };\n};\nexports.matchW = matchW;\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexports.foldW = exports.matchW;\n/**\n * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is\n * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.\n *\n * @example\n * import { some, none, match } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a some containing 1'\n * )\n *\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a none'\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexports.match = exports.matchW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexports.fold = exports.match;\n/**\n * Less strict version of [`getOrElse`](#getorelse).\n *\n * The `W` suffix (short for **W**idening) means that the handler return type will be merged.\n *\n * @category error handling\n * @since 2.6.0\n */\nvar getOrElseW = function (onNone) {\n  return function (ma) {\n    return (0, exports.isNone)(ma) ? onNone() : ma.value;\n  };\n};\nexports.getOrElseW = getOrElseW;\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns the given default value\n *\n * @example\n * import { some, none, getOrElse } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexports.getOrElse = exports.getOrElseW;\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.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.0.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\n/**\n * @category sequencing\n * @since 2.0.0\n */\nexports.flatten = exports.compact;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category combinators\n * @since 2.15.0\n */\nexports.tap = (0, function_1.dual)(2, chainable.tap(exports.Chain));\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n * import * as E from 'fp-ts/Either'\n *\n * const compute = (value: number) => pipe(\n *   O.of(value),\n *   O.tapEither((value) => value > 0 ? E.right('ok') : E.left('error')),\n * )\n *\n * assert.deepStrictEqual(compute(1), O.of(1))\n * assert.deepStrictEqual(compute(-42), O.none)\n *\n * @category combinators\n * @since 2.16.0\n */\nexports.tapEither = (0, function_1.dual)(2, (0, FromEither_1.tapEither)(exports.FromEither, exports.Chain));\n/**\n * @since 2.0.0\n */\nexports.duplicate = (0, exports.extend)(function_1.identity);\n/**\n * @category lifting\n * @since 2.11.0\n */\nexports.fromEitherK = (0, FromEither_1.fromEitherK)(exports.FromEither);\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexports.chainEitherK = /*#__PURE__*/(0, FromEither_1.chainEitherK)(exports.FromEither, exports.Chain);\n/**\n * Alias of `tapEither`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexports.chainFirstEitherK = exports.tapEither;\n/**\n * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise\n * returns the value wrapped in a `Some`.\n *\n * @example\n * import { none, some, fromNullable } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(fromNullable(undefined), none)\n * assert.deepStrictEqual(fromNullable(null), none)\n * assert.deepStrictEqual(fromNullable(1), some(1))\n *\n * @category conversions\n * @since 2.0.0\n */\nvar fromNullable = function (a) {\n  return a == null ? exports.none : (0, exports.some)(a);\n};\nexports.fromNullable = fromNullable;\n/**\n * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a\n * `Some`.\n *\n * See also [`tryCatchK`](#trycatchk).\n *\n * @example\n * import { none, some, tryCatch } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   tryCatch(() => {\n *     throw new Error()\n *   }),\n *   none\n * )\n * assert.deepStrictEqual(tryCatch(() => 1), some(1))\n *\n * @category interop\n * @since 2.0.0\n */\nvar tryCatch = function (f) {\n  try {\n    return (0, exports.some)(f());\n  } catch (e) {\n    return exports.none;\n  }\n};\nexports.tryCatch = tryCatch;\n/**\n * Converts a function that may throw to one returning a `Option`.\n *\n * @category interop\n * @since 2.10.0\n */\nvar tryCatchK = function (f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return (0, exports.tryCatch)(function () {\n      return f.apply(void 0, a);\n    });\n  };\n};\nexports.tryCatchK = tryCatchK;\n/**\n * Returns a *smart constructor* from a function that returns a nullable value.\n *\n * @example\n * import { fromNullableK, none, some } from 'fp-ts/Option'\n *\n * const f = (s: string): number | undefined => {\n *   const n = parseFloat(s)\n *   return isNaN(n) ? undefined : n\n * }\n *\n * const g = fromNullableK(f)\n *\n * assert.deepStrictEqual(g('1'), some(1))\n * assert.deepStrictEqual(g('a'), none)\n *\n * @category lifting\n * @since 2.9.0\n */\nvar fromNullableK = function (f) {\n  return (0, function_1.flow)(f, exports.fromNullable);\n};\nexports.fromNullableK = fromNullableK;\n/**\n * This is `chain` + `fromNullable`, useful when working with optional values.\n *\n * @example\n * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Employee {\n *   readonly company?: {\n *     readonly address?: {\n *       readonly street?: {\n *         readonly name?: string\n *       }\n *     }\n *   }\n * }\n *\n * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee1.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   some('high street')\n * )\n *\n * const employee2: Employee = { company: { address: { street: {} } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee2.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   none\n * )\n *\n * @category sequencing\n * @since 2.9.0\n */\nvar chainNullableK = function (f) {\n  return function (ma) {\n    return (0, exports.isNone)(ma) ? exports.none : (0, exports.fromNullable)(f(ma.value));\n  };\n};\nexports.chainNullableK = chainNullableK;\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `null`.\n *\n * @example\n * import { some, none, toNullable } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toNullable\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toNullable\n *   ),\n *   null\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexports.toNullable = (0, exports.match)(function_1.constNull, function_1.identity);\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.\n *\n * @example\n * import { some, none, toUndefined } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toUndefined\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toUndefined\n *   ),\n *   undefined\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexports.toUndefined = (0, exports.match)(function_1.constUndefined, function_1.identity);\nfunction elem(E) {\n  return function (a, ma) {\n    if (ma === undefined) {\n      var elemE_1 = elem(E);\n      return function (ma) {\n        return elemE_1(a, ma);\n      };\n    }\n    return (0, exports.isNone)(ma) ? false : E.equals(a, ma.value);\n  };\n}\n/**\n * Returns `true` if the predicate is satisfied by the wrapped value\n *\n * @example\n * import { some, none, exists } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 0)\n *   ),\n *   true\n * )\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 1)\n *   ),\n *   false\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     exists(n => n > 0)\n *   ),\n *   false\n * )\n *\n * @since 2.0.0\n */\nvar exists = function (predicate) {\n  return function (ma) {\n    return (0, exports.isNone)(ma) ? false : predicate(ma.value);\n  };\n};\nexports.exists = exists;\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 = chainable.bind(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n/**\n * @since 2.11.0\n */\nexports.ApT = (0, exports.of)(_.emptyReadonlyArray);\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nvar traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n  return function (as) {\n    var o = f(0, _.head(as));\n    if ((0, exports.isNone)(o)) {\n      return exports.none;\n    }\n    var out = [o.value];\n    for (var i = 1; i < as.length; i++) {\n      var o_1 = f(i, as[i]);\n      if ((0, exports.isNone)(o_1)) {\n        return exports.none;\n      }\n      out.push(o_1.value);\n    }\n    return (0, exports.some)(out);\n  };\n};\nexports.traverseReadonlyNonEmptyArrayWithIndex = traverseReadonlyNonEmptyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nvar traverseReadonlyArrayWithIndex = function (f) {\n  var g = (0, exports.traverseReadonlyNonEmptyArrayWithIndex)(f);\n  return function (as) {\n    return _.isNonEmpty(as) ? g(as) : exports.ApT;\n  };\n};\nexports.traverseReadonlyArrayWithIndex = traverseReadonlyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexports.traverseArrayWithIndex = exports.traverseReadonlyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverse(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nvar traverseArray = function (f) {\n  return (0, exports.traverseReadonlyArrayWithIndex)(function (_, a) {\n    return f(a);\n  });\n};\nexports.traverseArray = traverseArray;\n/**\n * Equivalent to `ReadonlyArray#sequence(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexports.sequenceArray = /*#__PURE__*/(0, exports.traverseArray)(function_1.identity);\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 * Alias of `tap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexports.chainFirst = exports.tap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `Refinement` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nfunction getRefinement(getOption) {\n  return function (a) {\n    return (0, exports.isSome)(getOption(a));\n  };\n}\n/**\n * Use [`chainNullableK`](#chainnullablek) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.mapNullable = exports.chainNullableK;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `O.Functor` instead of `O.option`\n * (where `O` is from `import O from 'fp-ts/Option'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.option = {\n  URI: exports.URI,\n  map: _map,\n  of: exports.of,\n  ap: _ap,\n  chain: exports.flatMap,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: exports.sequence,\n  zero: exports.zero,\n  alt: _alt,\n  extend: _extend,\n  compact: exports.compact,\n  separate: exports.separate,\n  filter: _filter,\n  filterMap: _filterMap,\n  partition: _partition,\n  partitionMap: _partitionMap,\n  wither: _wither,\n  wilt: _wilt,\n  throwError: exports.throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getApplySemigroup = (0, Apply_1.getApplySemigroup)(exports.Apply);\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getApplyMonoid = (0, Applicative_1.getApplicativeMonoid)(exports.Applicative);\n/**\n * Use\n *\n * ```ts\n * import { first } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(first())\n * ```\n *\n * instead.\n *\n * Monoid returning the left-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(a)      |\n *\n * @example\n * import { getFirstMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getFirstMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nvar getFirstMonoid = function () {\n  return (0, exports.getMonoid)((0, Semigroup_1.first)());\n};\nexports.getFirstMonoid = getFirstMonoid;\n/**\n * Use\n *\n * ```ts\n * import { last } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(last())\n * ```\n *\n * instead.\n *\n * Monoid returning the right-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(b)      |\n *\n * @example\n * import { getLastMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getLastMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nvar getLastMonoid = function () {\n  return (0, exports.getMonoid)((0, Semigroup_1.last)());\n};\nexports.getLastMonoid = getLastMonoid;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.pipe = void 0;\nexports.map = map;\nexports.contramap = contramap;\nexports.mapWithIndex = mapWithIndex;\nexports.ap = ap;\nexports.chain = chain;\nexports.bimap = bimap;\nexports.mapLeft = mapLeft;\nexports.extend = extend;\nexports.reduce = reduce;\nexports.foldMap = foldMap;\nexports.reduceRight = reduceRight;\nexports.reduceWithIndex = reduceWithIndex;\nexports.foldMapWithIndex = foldMapWithIndex;\nexports.reduceRightWithIndex = reduceRightWithIndex;\nexports.alt = alt;\nexports.filter = filter;\nexports.filterMap = filterMap;\nexports.partition = partition;\nexports.partitionMap = partitionMap;\nexports.filterWithIndex = filterWithIndex;\nexports.filterMapWithIndex = filterMapWithIndex;\nexports.partitionWithIndex = partitionWithIndex;\nexports.partitionMapWithIndex = partitionMapWithIndex;\nexports.promap = promap;\nexports.compose = compose;\nexports.pipeable = pipeable;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar function_1 = require(\"./function\");\nfunction map(F) {\n  return function (f) {\n    return function (fa) {\n      return F.map(fa, f);\n    };\n  };\n}\nfunction contramap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.contramap(fa, f);\n    };\n  };\n}\nfunction mapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.mapWithIndex(fa, f);\n    };\n  };\n}\nfunction ap(F) {\n  return function (fa) {\n    return function (fab) {\n      return F.ap(fab, fa);\n    };\n  };\n}\nfunction chain(F) {\n  return function (f) {\n    return function (fa) {\n      return F.chain(fa, f);\n    };\n  };\n}\nfunction bimap(F) {\n  return function (f, g) {\n    return function (fea) {\n      return F.bimap(fea, f, g);\n    };\n  };\n}\nfunction mapLeft(F) {\n  return function (f) {\n    return function (fea) {\n      return F.mapLeft(fea, f);\n    };\n  };\n}\nfunction extend(F) {\n  return function (f) {\n    return function (wa) {\n      return F.extend(wa, f);\n    };\n  };\n}\nfunction reduce(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduce(fa, b, f);\n    };\n  };\n}\nfunction foldMap(F) {\n  return function (M) {\n    var foldMapM = F.foldMap(M);\n    return function (f) {\n      return function (fa) {\n        return foldMapM(fa, f);\n      };\n    };\n  };\n}\nfunction reduceRight(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceRight(fa, b, f);\n    };\n  };\n}\nfunction reduceWithIndex(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceWithIndex(fa, b, f);\n    };\n  };\n}\nfunction foldMapWithIndex(F) {\n  return function (M) {\n    var foldMapWithIndexM = F.foldMapWithIndex(M);\n    return function (f) {\n      return function (fa) {\n        return foldMapWithIndexM(fa, f);\n      };\n    };\n  };\n}\nfunction reduceRightWithIndex(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceRightWithIndex(fa, b, f);\n    };\n  };\n}\nfunction alt(F) {\n  return function (that) {\n    return function (fa) {\n      return F.alt(fa, that);\n    };\n  };\n}\nfunction filter(F) {\n  return function (predicate) {\n    return function (fa) {\n      return F.filter(fa, predicate);\n    };\n  };\n}\nfunction filterMap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.filterMap(fa, f);\n    };\n  };\n}\nfunction partition(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partition(fa, f);\n    };\n  };\n}\nfunction partitionMap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionMap(fa, f);\n    };\n  };\n}\nfunction filterWithIndex(F) {\n  return function (predicate) {\n    return function (fa) {\n      return F.filterWithIndex(fa, predicate);\n    };\n  };\n}\nfunction filterMapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.filterMapWithIndex(fa, f);\n    };\n  };\n}\nfunction partitionWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionWithIndex(fa, f);\n    };\n  };\n}\nfunction partitionMapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionMapWithIndex(fa, f);\n    };\n  };\n}\nfunction promap(F) {\n  return function (f, g) {\n    return function (fbc) {\n      return F.promap(fbc, f, g);\n    };\n  };\n}\nfunction compose(F) {\n  return function (ea) {\n    return function (ab) {\n      return F.compose(ab, ea);\n    };\n  };\n}\nvar isFunctor = function (I) {\n  return typeof I.map === 'function';\n};\nvar isContravariant = function (I) {\n  return typeof I.contramap === 'function';\n};\nvar isFunctorWithIndex = function (I) {\n  return typeof I.mapWithIndex === 'function';\n};\nvar isApply = function (I) {\n  return typeof I.ap === 'function';\n};\nvar isChain = function (I) {\n  return typeof I.chain === 'function';\n};\nvar isBifunctor = function (I) {\n  return typeof I.bimap === 'function';\n};\nvar isExtend = function (I) {\n  return typeof I.extend === 'function';\n};\nvar isFoldable = function (I) {\n  return typeof I.reduce === 'function';\n};\nvar isFoldableWithIndex = function (I) {\n  return typeof I.reduceWithIndex === 'function';\n};\nvar isAlt = function (I) {\n  return typeof I.alt === 'function';\n};\nvar isCompactable = function (I) {\n  return typeof I.compact === 'function';\n};\nvar isFilterable = function (I) {\n  return typeof I.filter === 'function';\n};\nvar isFilterableWithIndex = function (I) {\n  return typeof I.filterWithIndex === 'function';\n};\nvar isProfunctor = function (I) {\n  return typeof I.promap === 'function';\n};\nvar isSemigroupoid = function (I) {\n  return typeof I.compose === 'function';\n};\nvar isMonadThrow = function (I) {\n  return typeof I.throwError === 'function';\n};\n/** @deprecated */\nfunction pipeable(I) {\n  var r = {};\n  if (isFunctor(I)) {\n    r.map = map(I);\n  }\n  if (isContravariant(I)) {\n    r.contramap = contramap(I);\n  }\n  if (isFunctorWithIndex(I)) {\n    r.mapWithIndex = mapWithIndex(I);\n  }\n  if (isApply(I)) {\n    r.ap = ap(I);\n    r.apFirst = (0, Apply_1.apFirst)(I);\n    r.apSecond = (0, Apply_1.apSecond)(I);\n  }\n  if (isChain(I)) {\n    r.chain = chain(I);\n    r.chainFirst = (0, Chain_1.chainFirst)(I);\n    r.flatten = r.chain(function_1.identity);\n  }\n  if (isBifunctor(I)) {\n    r.bimap = bimap(I);\n    r.mapLeft = mapLeft(I);\n  }\n  if (isExtend(I)) {\n    r.extend = extend(I);\n    r.duplicate = r.extend(function_1.identity);\n  }\n  if (isFoldable(I)) {\n    r.reduce = reduce(I);\n    r.foldMap = foldMap(I);\n    r.reduceRight = reduceRight(I);\n  }\n  if (isFoldableWithIndex(I)) {\n    r.reduceWithIndex = reduceWithIndex(I);\n    r.foldMapWithIndex = foldMapWithIndex(I);\n    r.reduceRightWithIndex = reduceRightWithIndex(I);\n  }\n  if (isAlt(I)) {\n    r.alt = alt(I);\n  }\n  if (isCompactable(I)) {\n    r.compact = I.compact;\n    r.separate = I.separate;\n  }\n  if (isFilterable(I)) {\n    r.filter = filter(I);\n    r.filterMap = filterMap(I);\n    r.partition = partition(I);\n    r.partitionMap = partitionMap(I);\n  }\n  if (isFilterableWithIndex(I)) {\n    r.filterWithIndex = filterWithIndex(I);\n    r.filterMapWithIndex = filterMapWithIndex(I);\n    r.partitionWithIndex = partitionWithIndex(I);\n    r.partitionMapWithIndex = partitionMapWithIndex(I);\n  }\n  if (isProfunctor(I)) {\n    r.promap = promap(I);\n  }\n  if (isSemigroupoid(I)) {\n    r.compose = compose(I);\n  }\n  if (isMonadThrow(I)) {\n    var fromOption = function (onNone) {\n      return function (ma) {\n        return ma._tag === 'None' ? I.throwError(onNone()) : I.of(ma.value);\n      };\n    };\n    var fromEither = function (ma) {\n      return ma._tag === 'Left' ? I.throwError(ma.left) : I.of(ma.right);\n    };\n    var fromPredicate = function (predicate, onFalse) {\n      return function (a) {\n        return predicate(a) ? I.of(a) : I.throwError(onFalse(a));\n      };\n    };\n    var filterOrElse = function (predicate, onFalse) {\n      return function (ma) {\n        return I.chain(ma, function (a) {\n          return predicate(a) ? I.of(a) : I.throwError(onFalse(a));\n        });\n      };\n    };\n    r.fromOption = fromOption;\n    r.fromEither = fromEither;\n    r.fromPredicate = fromPredicate;\n    r.filterOrElse = filterOrElse;\n  }\n  return r;\n}\n/**\n * Use [`pipe`](https://gcanti.github.io/fp-ts/modules/function.ts.html#pipe) from `function` module instead.\n *\n * @since 2.0.0\n * @deprecated\n */\nexports.pipe = function_1.pipe;","import {\n  Directive,\n  EmbeddedViewRef,\n  Input,\n  TemplateRef,\n  ViewContainerRef,\n} from \"@angular/core\";\nimport {\n  fold,\n  fromNullable,\n  isNone,\n  isSome,\n  none,\n  Option,\n} from \"fp-ts/lib/Option\";\nimport { pipe } from \"fp-ts/lib/pipeable\";\n\ninterface OptionCaseView {\n  viewContainerRef: ViewContainerRef;\n  templateRef: TemplateRef<Object>;\n}\n\n@Directive({\n  selector: \"[useOption]\",\n})\nexport class OptionDirective {\n  option: Option<any> = none;\n\n  noneCases: OptionCaseView[] = [];\n  someCases: OptionCaseView[] = [];\n\n  mountedCases: OptionCaseView[] = [];\n\n  @Input()\n  set useOption(option: Option<any>) {\n    if (this.option._tag !== option._tag) {\n      this.mountedCases.forEach(this.removeCaseView);\n    }\n\n    this.option = option;\n\n    if (isNone(option)) {\n      this.noneCases.forEach(this.ensureCaseView);\n      this.mountedCases = this.noneCases;\n    }\n\n    if (isSome(option)) {\n      const context = {\n        $implicit: option.value,\n      };\n      this.someCases.forEach((cv) => this.ensureCaseView(cv, context));\n      this.mountedCases = this.someCases;\n    }\n  }\n\n  registerNone = (\n    viewContainerRef: ViewContainerRef,\n    templateRef: TemplateRef<Object>\n  ) => this.noneCases.push({ viewContainerRef, templateRef });\n  registerSome = (\n    viewContainerRef: ViewContainerRef,\n    templateRef: TemplateRef<Object>\n  ) => this.someCases.push({ viewContainerRef, templateRef });\n\n  ensureCaseView = (caseView: OptionCaseView, context?: any) => {\n    pipe(\n      fromNullable(<EmbeddedViewRef<any>>caseView.viewContainerRef.get(0)),\n      fold(\n        () => this.createCaseView(caseView, context),\n        (vr) => this.updateViewRef(vr, context)\n      )\n    );\n  };\n\n  createCaseView = (caseView: OptionCaseView, context?: any) => {\n    caseView.viewContainerRef.createEmbeddedView(caseView.templateRef, context);\n  };\n\n  removeCaseView = (caseView: OptionCaseView) =>\n    caseView.viewContainerRef.clear();\n\n  updateViewRef = (viewRef: EmbeddedViewRef<any>, context?: any) => {\n    if (context) {\n      Object.keys(context).forEach((key) => {\n        viewRef.context[key] = context[key];\n      });\n      viewRef.detectChanges();\n    }\n  };\n}\n","import {\n  Directive,\n  Host,\n  Optional,\n  TemplateRef,\n  ViewContainerRef,\n} from \"@angular/core\";\n\nimport { OptionDirective } from \"./option.directive\";\n\n@Directive({\n  selector: \"[onNone]\",\n})\nexport class NoneDirective {\n  constructor(\n    readonly viewContainer: ViewContainerRef,\n    readonly templateRef: TemplateRef<Object>,\n    @Optional() @Host() readonly optionDirective?: OptionDirective\n  ) {\n    if (!!optionDirective) {\n      optionDirective.registerNone(viewContainer, templateRef);\n    }\n  }\n}\n","import {\n  Directive,\n  Host,\n  Optional,\n  TemplateRef,\n  ViewContainerRef,\n} from \"@angular/core\";\n\nimport { OptionDirective } from \"./option.directive\";\n\n@Directive({\n  selector: \"[onSome]\",\n})\nexport class SomeDirective {\n  constructor(\n    readonly viewContainer: ViewContainerRef,\n    readonly templateRef: TemplateRef<Object>,\n    @Optional() @Host() readonly optionDirective?: OptionDirective\n  ) {\n    if (!!optionDirective) {\n      optionDirective.registerSome(viewContainer, templateRef);\n    }\n  }\n}\n","import { NgModule } from \"@angular/core\";\n\nimport { NoneDirective } from \"./none.directive\";\nimport { OptionDirective } from \"./option.directive\";\nimport { SomeDirective } from \"./some.directive\";\n\nconst DIRECTIVES = [OptionDirective, NoneDirective, SomeDirective];\n\n@NgModule({\n  declarations: DIRECTIVES,\n  imports: [],\n  exports: DIRECTIVES,\n})\nexport class OptionModule {}\n"],"mappings":"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","names":["require_function","__commonJSMin","exports","__spreadArray","to","from","pack","i","l","ar","identity","constant","flip","flow","tuple","increment","decrement","absurd","tupled","untupled","pipe","not","getBooleanAlgebra","B","x","y","a","getSemigroup","S","f","g","getMonoid","M","getSemigroupM","getSemiring","getRing","R","apply","args","_i","ab","bc","cd","de","ef","fg","gh","hi","ij","n","_","ret","SK","b","predicate","getEndomorphismMonoid","first","second","dual","arity","body","isDataFirst","self","require_internal","__commonJSMin","exports","__spreadArray","to","from","pack","i","l","ar","function_1","isNone","fa","isSome","some","a","isLeft","ma","isRight","left","e","right","singleton","isNonEmpty","as","head","tail","fromReadonlyNonEmptyArray","liftNullable","F","f","onNullable","_i","liftOption","onNone","flatMapNullable","M","self","flatMapOption","flatMapEither","flatMapIO","flatMapTask","flatMapReader","require_Apply","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","ap","apFirst","apSecond","apS","getApplySemigroup","sequenceT","sequenceS","function_1","_","F","G","fa","fab","gab","ga","A","second","first","a","b","name","fb","_a","S","x","y","curried","f","n","acc","combined","i","tupleConstructors","c","d","e","getTupleConstructor","len","args","_i","fas","getRecordConstructor","keys","r","fr","require_Functor","__commonJSMin","exports","map","flap","bindTo","let_","getFunctorComposition","as","asUnit","function_1","F","G","f","fa","ga","a","fab","name","_a","_map","fga","self","b","asM","require_Applicative","__commonJSMin","exports","getApplicativeMonoid","getApplicativeComposition","Apply_1","function_1","Functor_1","F","f","M","G","map","_ap","a","fgab","fga","require_Chain","__commonJSMin","exports","chainFirst","tap","bind","M","tapM","f","first","a","name","ma","b","_a","require_FromEither","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","fromOption","fromPredicate","fromOptionK","chainOptionK","fromEitherK","chainEitherK","chainFirstEitherK","filterOrElse","tapEither","Chain_1","function_1","_","F","onNone","ma","predicate","onFalse","a","fromOptionF","from","f","M","fromOptionKF","fromEitherKF","tapEitherM","fromEither","tapM","self","require_Predicate","__commonJSMin","exports","function_1","contramap_","predicate","f","contramap","getSemigroupAny","first","second","getMonoidAny","getSemigroupAll","getMonoidAll","not","a","or","and","require_Magma","__commonJSMin","exports","reverse","M","first","second","filterFirst","predicate","filterSecond","endo","f","concatAll","startWith","as","a","acc","require_Eq","__commonJSMin","exports","function_1","fromEquals","equals","x","y","struct","eqs","first","second","key","tuple","_i","E","i","contramap_","fa","f","contramap","a","b","empty","getSemigroup","getMonoid","require_Ord","__commonJSMin","exports","Eq_1","function_1","equalsDefault","compare","first","second","fromCompare","tuple","ords","_i","r","reverse","O","contramap_","fa","f","contramap","getSemigroup","a","b","ox","getMonoid","equals","lt","gt","leq","geq","min","max","clamp","minO","maxO","low","hi","between","ltO","gtO","strictOrd","date","require_Semigroup","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","fold","function_1","_","M","Or","min","O","max","constant","a","struct","semigroups","first","second","r","tuple","_i","s","i","intercalate","middle","S","x","y","last","getObjectSemigroup","concatAllS","startWith","as","require_Separated","__commonJSMin","exports","function_1","Functor_1","separated","left","right","_map","fa","f","_mapLeft","_bimap","g","map","mapLeft","bimap","s","require_Witherable","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","wiltDefault","witherDefault","filterE","_","T","C","F","traverseF","wa","f","W","witherF","predicate","ga","a","b","require_Zero","__commonJSMin","exports","guard","F","P","b","require_Option","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","fromPredicate","elem","getRefinement","Applicative_1","Apply_1","chainable","FromEither_1","function_1","Functor_1","_","Predicate_1","Semigroup_1","Separated_1","Witherable_1","Zero_1","predicate","a","getLeft","ma","getRight","_map","fa","f","_ap","fab","_reduce","b","_foldMap","M","foldMapM","_reduceRight","_traverse","F","traverseF","ta","_alt","that","_filter","_filterMap","_extend","wa","_partition","_partitionMap","getShow","S","getEq","E","x","y","getOrd","O","getMonoid","map","ap","reduce","foldMap","reduceRight","self","zero","extend","defaultSeparated","separate","filter","filterMap","partition","partitionMap","traverse","sequence","_wither","_wilt","wither","_witherF","wilt","_wiltF","throwError","isNone","matchW","onNone","onSome","getOrElseW","fromNullable","tryCatch","tryCatchK","_i","fromNullableK","chainNullableK","elemE_1","exists","let_","traverseReadonlyNonEmptyArrayWithIndex","as","out","o_1","traverseReadonlyArrayWithIndex","g","traverseArray","getOption","getFirstMonoid","getLastMonoid","require_pipeable","__commonJSMin","exports","map","contramap","mapWithIndex","ap","chain","bimap","mapLeft","extend","reduce","foldMap","reduceRight","reduceWithIndex","foldMapWithIndex","reduceRightWithIndex","alt","filter","filterMap","partition","partitionMap","filterWithIndex","filterMapWithIndex","partitionWithIndex","partitionMapWithIndex","promap","compose","pipeable","Apply_1","Chain_1","function_1","F","f","fa","fab","g","fea","wa","b","M","foldMapM","foldMapWithIndexM","that","predicate","fbc","ea","ab","isFunctor","I","isContravariant","isFunctorWithIndex","isApply","isChain","isBifunctor","isExtend","isFoldable","isFoldableWithIndex","isAlt","isCompactable","isFilterable","isFilterableWithIndex","isProfunctor","isSemigroupoid","isMonadThrow","fromOption","onNone","ma","fromEither","fromPredicate","onFalse","a","filterOrElse","import_Option","import_pipeable","OptionDirective","constructor","option","none","noneCases","someCases","mountedCases","registerNone","viewContainerRef","templateRef","push","registerSome","ensureCaseView","caseView","context","pipe","fromNullable","get","fold","createCaseView","vr","updateViewRef","createEmbeddedView","removeCaseView","clear","viewRef","Object","keys","forEach","key","detectChanges","useOption","_tag","isNone","isSome","$implicit","value","cv","selectors","inputs","_OptionDirective","NoneDirective","constructor","viewContainer","templateRef","optionDirective","registerNone","ɵɵdirectiveInject","ViewContainerRef","TemplateRef","OptionDirective","selectors","_NoneDirective","SomeDirective","constructor","viewContainer","templateRef","optionDirective","registerSome","ɵɵdirectiveInject","ViewContainerRef","TemplateRef","OptionDirective","selectors","_SomeDirective","OptionModule","_OptionModule"],"x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]}