{"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\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getEndomorphismMonoid = exports.not = exports.SK = exports.hole = exports.pipe = exports.untupled = exports.tupled = exports.absurd = exports.decrement = exports.increment = exports.tuple = exports.flow = exports.flip = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.constant = exports.unsafeCoerce = exports.identity = exports.apply = exports.getRing = exports.getSemiring = exports.getMonoid = exports.getSemigroup = exports.getBooleanAlgebra = void 0;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getBooleanAlgebra = function (B) {\n  return function () {\n    return {\n      meet: function (x, y) {\n        return function (a) {\n          return B.meet(x(a), y(a));\n        };\n      },\n      join: function (x, y) {\n        return function (a) {\n          return B.join(x(a), y(a));\n        };\n      },\n      zero: function () {\n        return B.zero;\n      },\n      one: function () {\n        return B.one;\n      },\n      implies: function (x, y) {\n        return function (a) {\n          return B.implies(x(a), y(a));\n        };\n      },\n      not: function (x) {\n        return function (a) {\n          return B.not(x(a));\n        };\n      }\n    };\n  };\n};\nexports.getBooleanAlgebra = getBooleanAlgebra;\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getSemigroup = function (S) {\n  return function () {\n    return {\n      concat: function (f, g) {\n        return function (a) {\n          return S.concat(f(a), g(a));\n        };\n      }\n    };\n  };\n};\nexports.getSemigroup = getSemigroup;\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nvar getMonoid = function (M) {\n  var getSemigroupM = (0, exports.getSemigroup)(M);\n  return function () {\n    return {\n      concat: getSemigroupM().concat,\n      empty: function () {\n        return M.empty;\n      }\n    };\n  };\n};\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getSemiring = function (S) {\n  return {\n    add: function (f, g) {\n      return function (x) {\n        return S.add(f(x), g(x));\n      };\n    },\n    zero: function () {\n      return S.zero;\n    },\n    mul: function (f, g) {\n      return function (x) {\n        return S.mul(f(x), g(x));\n      };\n    },\n    one: function () {\n      return S.one;\n    }\n  };\n};\nexports.getSemiring = getSemiring;\n/**\n * @category instances\n * @since 2.10.0\n */\nvar getRing = function (R) {\n  var S = (0, exports.getSemiring)(R);\n  return {\n    add: S.add,\n    mul: S.mul,\n    one: S.one,\n    zero: S.zero,\n    sub: function (f, g) {\n      return function (x) {\n        return R.sub(f(x), g(x));\n      };\n    }\n  };\n};\nexports.getRing = getRing;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nvar apply = function (a) {\n  return function (f) {\n    return f(a);\n  };\n};\nexports.apply = apply;\n/**\n * @since 2.0.0\n */\nfunction identity(a) {\n  return a;\n}\nexports.identity = identity;\n/**\n * @since 2.0.0\n */\nexports.unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nfunction constant(a) {\n  return function () {\n    return a;\n  };\n}\nexports.constant = constant;\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexports.constTrue = constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexports.constFalse = constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexports.constNull = constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexports.constUndefined = constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexports.constVoid = exports.constUndefined;\nfunction flip(f) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    if (args.length > 1) {\n      return f(args[1], args[0]);\n    }\n    return function (a) {\n      return f(a)(args[0]);\n    };\n  };\n}\nexports.flip = flip;\nfunction flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n  switch (arguments.length) {\n    case 1:\n      return ab;\n    case 2:\n      return function () {\n        return bc(ab.apply(this, arguments));\n      };\n    case 3:\n      return function () {\n        return cd(bc(ab.apply(this, arguments)));\n      };\n    case 4:\n      return function () {\n        return de(cd(bc(ab.apply(this, arguments))));\n      };\n    case 5:\n      return function () {\n        return ef(de(cd(bc(ab.apply(this, arguments)))));\n      };\n    case 6:\n      return function () {\n        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n      };\n    case 7:\n      return function () {\n        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n      };\n    case 8:\n      return function () {\n        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n      };\n    case 9:\n      return function () {\n        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n      };\n  }\n  return;\n}\nexports.flow = flow;\n/**\n * @since 2.0.0\n */\nfunction tuple() {\n  var t = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    t[_i] = arguments[_i];\n  }\n  return t;\n}\nexports.tuple = tuple;\n/**\n * @since 2.0.0\n */\nfunction increment(n) {\n  return n + 1;\n}\nexports.increment = increment;\n/**\n * @since 2.0.0\n */\nfunction decrement(n) {\n  return n - 1;\n}\nexports.decrement = decrement;\n/**\n * @since 2.0.0\n */\nfunction absurd(_) {\n  throw new Error('Called `absurd` function which should be uncallable');\n}\nexports.absurd = absurd;\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nfunction tupled(f) {\n  return function (a) {\n    return f.apply(void 0, a);\n  };\n}\nexports.tupled = tupled;\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nfunction untupled(f) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return f(a);\n  };\n}\nexports.untupled = untupled;\nfunction pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n  switch (arguments.length) {\n    case 1:\n      return a;\n    case 2:\n      return ab(a);\n    case 3:\n      return bc(ab(a));\n    case 4:\n      return cd(bc(ab(a)));\n    case 5:\n      return de(cd(bc(ab(a))));\n    case 6:\n      return ef(de(cd(bc(ab(a)))));\n    case 7:\n      return fg(ef(de(cd(bc(ab(a))))));\n    case 8:\n      return gh(fg(ef(de(cd(bc(ab(a)))))));\n    case 9:\n      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n    default:\n      {\n        var ret = arguments[0];\n        for (var i = 1; i < arguments.length; i++) {\n          ret = arguments[i](ret);\n        }\n        return ret;\n      }\n  }\n}\nexports.pipe = pipe;\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexports.hole = absurd;\n/**\n * @since 2.11.0\n */\nvar SK = function (_, b) {\n  return b;\n};\nexports.SK = SK;\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nfunction not(predicate) {\n  return function (a) {\n    return !predicate(a);\n  };\n}\nexports.not = not;\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nvar getEndomorphismMonoid = function () {\n  return {\n    concat: function (first, second) {\n      return flow(first, second);\n    },\n    empty: identity\n  };\n};\nexports.getEndomorphismMonoid = getEndomorphismMonoid;","\"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.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;\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;","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.sequenceS = exports.sequenceT = exports.getApplySemigroup = exports.apS = exports.apSecond = exports.apFirst = exports.ap = void 0;\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nfunction ap(F, G) {\n  return function (fa) {\n    return function (fab) {\n      return F.ap(F.map(fab, function (gab) {\n        return function (ga) {\n          return G.ap(gab, ga);\n        };\n      }), fa);\n    };\n  };\n}\nexports.ap = ap;\nfunction apFirst(A) {\n  return function (second) {\n    return function (first) {\n      return A.ap(A.map(first, function (a) {\n        return function () {\n          return a;\n        };\n      }), second);\n    };\n  };\n}\nexports.apFirst = apFirst;\nfunction apSecond(A) {\n  return function (second) {\n    return function (first) {\n      return A.ap(A.map(first, function () {\n        return function (b) {\n          return b;\n        };\n      }), second);\n    };\n  };\n}\nexports.apSecond = apSecond;\nfunction apS(F) {\n  return function (name, fb) {\n    return function (fa) {\n      return F.ap(F.map(fa, function (a) {\n        return function (b) {\n          var _a;\n          return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n        };\n      }), fb);\n    };\n  };\n}\nexports.apS = apS;\nfunction getApplySemigroup(F) {\n  return function (S) {\n    return {\n      concat: function (first, second) {\n        return F.ap(F.map(first, function (x) {\n          return function (y) {\n            return S.concat(x, y);\n          };\n        }), second);\n      }\n    };\n  };\n}\nexports.getApplySemigroup = getApplySemigroup;\nfunction curried(f, n, acc) {\n  return function (x) {\n    var combined = Array(acc.length + 1);\n    for (var i = 0; i < acc.length; i++) {\n      combined[i] = acc[i];\n    }\n    combined[acc.length] = x;\n    return n === 0 ? f.apply(null, combined) : curried(f, n - 1, combined);\n  };\n}\nvar tupleConstructors = {\n  1: function (a) {\n    return [a];\n  },\n  2: function (a) {\n    return function (b) {\n      return [a, b];\n    };\n  },\n  3: function (a) {\n    return function (b) {\n      return function (c) {\n        return [a, b, c];\n      };\n    };\n  },\n  4: function (a) {\n    return function (b) {\n      return function (c) {\n        return function (d) {\n          return [a, b, c, d];\n        };\n      };\n    };\n  },\n  5: function (a) {\n    return function (b) {\n      return function (c) {\n        return function (d) {\n          return function (e) {\n            return [a, b, c, d, e];\n          };\n        };\n      };\n    };\n  }\n};\nfunction getTupleConstructor(len) {\n  if (!_.has.call(tupleConstructors, len)) {\n    tupleConstructors[len] = curried(function_1.tuple, len - 1, []);\n  }\n  return tupleConstructors[len];\n}\nfunction sequenceT(F) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    var len = args.length;\n    var f = getTupleConstructor(len);\n    var fas = F.map(args[0], f);\n    for (var i = 1; i < len; i++) {\n      fas = F.ap(fas, args[i]);\n    }\n    return fas;\n  };\n}\nexports.sequenceT = sequenceT;\nfunction getRecordConstructor(keys) {\n  var len = keys.length;\n  switch (len) {\n    case 1:\n      return function (a) {\n        var _a;\n        return _a = {}, _a[keys[0]] = a, _a;\n      };\n    case 2:\n      return function (a) {\n        return function (b) {\n          var _a;\n          return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a;\n        };\n      };\n    case 3:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            var _a;\n            return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a;\n          };\n        };\n      };\n    case 4:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            return function (d) {\n              var _a;\n              return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a[keys[3]] = d, _a;\n            };\n          };\n        };\n      };\n    case 5:\n      return function (a) {\n        return function (b) {\n          return function (c) {\n            return function (d) {\n              return function (e) {\n                var _a;\n                return _a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a[keys[3]] = d, _a[keys[4]] = e, _a;\n              };\n            };\n          };\n        };\n      };\n    default:\n      return curried(function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\n        var r = {};\n        for (var i = 0; i < len; i++) {\n          r[keys[i]] = args[i];\n        }\n        return r;\n      }, len - 1, []);\n  }\n}\nfunction sequenceS(F) {\n  return function (r) {\n    var keys = Object.keys(r);\n    var len = keys.length;\n    var f = getRecordConstructor(keys);\n    var fr = F.map(r[keys[0]], f);\n    for (var i = 1; i < len; i++) {\n      fr = F.ap(fr, r[keys[i]]);\n    }\n    return fr;\n  };\n}\nexports.sequenceS = sequenceS;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getFunctorComposition = exports.let = exports.bindTo = exports.flap = exports.map = void 0;\n/**\n * A `Functor` is a type constructor which supports a mapping operation `map`.\n *\n * `map` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return types use the type\n * constructor `f` to represent some computational context.\n *\n * Instances must satisfy the following laws:\n *\n * 1. Identity: `F.map(fa, a => a) <-> fa`\n * 2. Composition: `F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)`\n *\n * @since 2.0.0\n */\nvar function_1 = require(\"./function\");\nfunction map(F, G) {\n  return function (f) {\n    return function (fa) {\n      return F.map(fa, function (ga) {\n        return G.map(ga, f);\n      });\n    };\n  };\n}\nexports.map = map;\nfunction flap(F) {\n  return function (a) {\n    return function (fab) {\n      return F.map(fab, function (f) {\n        return f(a);\n      });\n    };\n  };\n}\nexports.flap = flap;\nfunction bindTo(F) {\n  return function (name) {\n    return function (fa) {\n      return F.map(fa, function (a) {\n        var _a;\n        return _a = {}, _a[name] = a, _a;\n      });\n    };\n  };\n}\nexports.bindTo = bindTo;\nfunction let_(F) {\n  return function (name, f) {\n    return function (fa) {\n      return F.map(fa, function (a) {\n        var _a;\n        return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));\n      });\n    };\n  };\n}\nexports.let = let_;\n/** @deprecated */\nfunction getFunctorComposition(F, G) {\n  var _map = map(F, G);\n  return {\n    map: function (fga, f) {\n      return (0, function_1.pipe)(fga, _map(f));\n    }\n  };\n}\nexports.getFunctorComposition = getFunctorComposition;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getApplicativeComposition = exports.getApplicativeMonoid = void 0;\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}\nexports.getApplicativeMonoid = getApplicativeMonoid;\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}\nexports.getApplicativeComposition = getApplicativeComposition;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bind = exports.chainFirst = void 0;\nfunction chainFirst(M) {\n  return function (f) {\n    return function (first) {\n      return M.chain(first, function (a) {\n        return M.map(f(a), function () {\n          return a;\n        });\n      });\n    };\n  };\n}\nexports.chainFirst = chainFirst;\nfunction bind(M) {\n  return function (name, f) {\n    return function (ma) {\n      return M.chain(ma, function (a) {\n        return M.map(f(a), function (b) {\n          var _a;\n          return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n        });\n      });\n    };\n  };\n}\nexports.bind = bind;","\"use strict\";\n\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.filterOrElse = exports.chainFirstEitherK = exports.chainEitherK = exports.fromEitherK = exports.chainOptionK = exports.fromOptionK = exports.fromPredicate = exports.fromOption = void 0;\nvar Chain_1 = require(\"./Chain\");\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nfunction fromOption(F) {\n  return function (onNone) {\n    return function (ma) {\n      return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value));\n    };\n  };\n}\nexports.fromOption = fromOption;\nfunction fromPredicate(F) {\n  return function (predicate, onFalse) {\n    return function (a) {\n      return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));\n    };\n  };\n}\nexports.fromPredicate = fromPredicate;\nfunction fromOptionK(F) {\n  var fromOptionF = fromOption(F);\n  return function (onNone) {\n    var from = fromOptionF(onNone);\n    return function (f) {\n      return (0, function_1.flow)(f, from);\n    };\n  };\n}\nexports.fromOptionK = fromOptionK;\nfunction chainOptionK(F, M) {\n  var fromOptionKF = fromOptionK(F);\n  return function (onNone) {\n    var from = fromOptionKF(onNone);\n    return function (f) {\n      return function (ma) {\n        return M.chain(ma, from(f));\n      };\n    };\n  };\n}\nexports.chainOptionK = chainOptionK;\nfunction fromEitherK(F) {\n  return function (f) {\n    return (0, function_1.flow)(f, F.fromEither);\n  };\n}\nexports.fromEitherK = fromEitherK;\nfunction chainEitherK(F, M) {\n  var fromEitherKF = fromEitherK(F);\n  return function (f) {\n    return function (ma) {\n      return M.chain(ma, fromEitherKF(f));\n    };\n  };\n}\nexports.chainEitherK = chainEitherK;\nfunction chainFirstEitherK(F, M) {\n  return (0, function_1.flow)(fromEitherK(F), (0, Chain_1.chainFirst)(M));\n}\nexports.chainFirstEitherK = chainFirstEitherK;\nfunction filterOrElse(F, M) {\n  return function (predicate, onFalse) {\n    return function (ma) {\n      return M.chain(ma, function (a) {\n        return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));\n      });\n    };\n  };\n}\nexports.filterOrElse = filterOrElse;","\"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.fold = exports.getIntercalateSemigroup = exports.getMeetSemigroup = exports.getJoinSemigroup = exports.getDualSemigroup = exports.getStructSemigroup = exports.getTupleSemigroup = exports.getFirstSemigroup = exports.getLastSemigroup = exports.getObjectSemigroup = exports.semigroupVoid = exports.concatAll = exports.last = exports.first = exports.intercalate = exports.tuple = exports.struct = exports.reverse = exports.constant = exports.max = exports.min = void 0;\n/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nvar M = __importStar(require(\"./Magma\"));\nvar Or = __importStar(require(\"./Ord\"));\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.min(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category constructors\n * @since 2.10.0\n */\nvar min = function (O) {\n  return {\n    concat: Or.min(O)\n  };\n};\nexports.min = min;\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.max(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category constructors\n * @since 2.10.0\n */\nvar max = function (O) {\n  return {\n    concat: Or.max(O)\n  };\n};\nexports.max = max;\n/**\n * @category constructors\n * @since 2.10.0\n */\nvar constant = function (a) {\n  return {\n    concat: function () {\n      return a;\n    }\n  };\n};\nexports.constant = constant;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n *\n * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')\n *\n * @since 2.10.0\n */\nexports.reverse = M.reverse;\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import { struct } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const S = struct<Point>({\n *   x: N.SemigroupSum,\n *   y: N.SemigroupSum\n * })\n *\n * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @since 2.10.0\n */\nvar struct = function (semigroups) {\n  return {\n    concat: function (first, second) {\n      var r = {};\n      for (var k in semigroups) {\n        if (_.has.call(semigroups, k)) {\n          r[k] = semigroups[k].concat(first[k], second[k]);\n        }\n      }\n      return r;\n    }\n  };\n};\nexports.struct = struct;\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Semigroup'\n * import * as B from 'fp-ts/boolean'\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/string'\n *\n * const S1 = tuple(S.Semigroup, N.SemigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @since 2.10.0\n */\nvar tuple = function () {\n  var semigroups = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    semigroups[_i] = arguments[_i];\n  }\n  return {\n    concat: function (first, second) {\n      return semigroups.map(function (s, i) {\n        return s.concat(first[i], second[i]);\n      });\n    }\n  };\n};\nexports.tuple = tuple;\n/**\n * Between each pair of elements insert `middle`.\n *\n * @example\n * import { intercalate } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n * import { pipe } from 'fp-ts/function'\n *\n * const S1 = pipe(S.Semigroup, intercalate(' + '))\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a + b')\n *\n * @since 2.10.0\n */\nvar intercalate = function (middle) {\n  return function (S) {\n    return {\n      concat: function (x, y) {\n        return S.concat(x, S.concat(middle, y));\n      }\n    };\n  };\n};\nexports.intercalate = intercalate;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.10.0\n */\nvar first = function () {\n  return {\n    concat: function_1.identity\n  };\n};\nexports.first = first;\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nvar last = function () {\n  return {\n    concat: function (_, y) {\n      return y;\n    }\n  };\n};\nexports.last = last;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Given a sequence of `as`, concat them and return the total.\n *\n * If `as` is empty, return the provided `startWith` value.\n *\n * @example\n * import { concatAll } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * const sum = concatAll(N.SemigroupSum)(0)\n *\n * assert.deepStrictEqual(sum([1, 2, 3]), 6)\n * assert.deepStrictEqual(sum([]), 0)\n *\n * @since 2.10.0\n */\nexports.concatAll = M.concatAll;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `void` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupVoid = (0, exports.constant)(undefined);\n/**\n * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nvar getObjectSemigroup = function () {\n  return {\n    concat: function (first, second) {\n      return Object.assign({}, first, second);\n    }\n  };\n};\nexports.getObjectSemigroup = getObjectSemigroup;\n/**\n * Use [`last`](#last) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getLastSemigroup = exports.last;\n/**\n * Use [`first`](#first) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getFirstSemigroup = exports.first;\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getTupleSemigroup = exports.tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getStructSemigroup = exports.struct;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getDualSemigroup = exports.reverse;\n/**\n * Use [`max`](#max) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getJoinSemigroup = exports.max;\n/**\n * Use [`min`](#min) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getMeetSemigroup = exports.min;\n/**\n * Use [`intercalate`](#intercalate) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.getIntercalateSemigroup = exports.intercalate;\nfunction fold(S) {\n  var concatAllS = (0, exports.concatAll)(S);\n  return function (startWith, as) {\n    return as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as);\n  };\n}\nexports.fold = fold;\n/**\n * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupAll = {\n  concat: function (x, y) {\n    return x && y;\n  }\n};\n/**\n * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupAny = {\n  concat: function (x, y) {\n    return x || y;\n  }\n};\n/**\n * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.getFunctionSemigroup = function_1.getSemigroup;\n/**\n * Use [`Semigroup`](./string.ts.html#Semigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupString = {\n  concat: function (x, y) {\n    return x + y;\n  }\n};\n/**\n * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupSum = {\n  concat: function (x, y) {\n    return x + y;\n  }\n};\n/**\n * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupProduct = {\n  concat: function (x, y) {\n    return x * y;\n  }\n};","\"use strict\";\n\n/**\n * ```ts\n * interface Separated<E, A> {\n *    readonly left: E\n *    readonly right: A\n * }\n * ```\n *\n * Represents a result of separating a whole into two parts.\n *\n * @since 2.10.0\n */\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.right = exports.left = exports.flap = exports.Functor = exports.Bifunctor = exports.URI = exports.bimap = exports.mapLeft = exports.map = exports.separated = void 0;\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.10.0\n */\nvar separated = function (left, right) {\n  return {\n    left: left,\n    right: right\n  };\n};\nexports.separated = separated;\nvar _map = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.map)(f));\n};\nvar _mapLeft = function (fa, f) {\n  return (0, function_1.pipe)(fa, (0, exports.mapLeft)(f));\n};\nvar _bimap = function (fa, g, f) {\n  return (0, function_1.pipe)(fa, (0, exports.bimap)(g, f));\n};\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.10.0\n */\nvar map = function (f) {\n  return function (fa) {\n    return (0, exports.separated)((0, exports.left)(fa), f((0, exports.right)(fa)));\n  };\n};\nexports.map = map;\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category error handling\n * @since 2.10.0\n */\nvar mapLeft = function (f) {\n  return function (fa) {\n    return (0, exports.separated)(f((0, exports.left)(fa)), (0, exports.right)(fa));\n  };\n};\nexports.mapLeft = mapLeft;\n/**\n * Map a pair of functions over the two type arguments of the bifunctor.\n *\n * @category mapping\n * @since 2.10.0\n */\nvar bimap = function (f, g) {\n  return function (fa) {\n    return (0, exports.separated)(f((0, exports.left)(fa)), g((0, exports.right)(fa)));\n  };\n};\nexports.bimap = bimap;\n/**\n * @category type lambdas\n * @since 2.10.0\n */\nexports.URI = 'Separated';\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Bifunctor = {\n  URI: exports.URI,\n  mapLeft: _mapLeft,\n  bimap: _bimap\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Functor = {\n  URI: exports.URI,\n  map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.10.0\n */\nvar left = function (s) {\n  return s.left;\n};\nexports.left = left;\n/**\n * @since 2.10.0\n */\nvar right = function (s) {\n  return s.right;\n};\nexports.right = right;","\"use strict\";\n\nvar __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\nvar __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n});\nvar __importStar = this && this.__importStar || function (mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n};\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.filterE = exports.witherDefault = exports.wiltDefault = void 0;\nvar _ = __importStar(require(\"./internal\"));\nfunction wiltDefault(T, C) {\n  return function (F) {\n    var traverseF = T.traverse(F);\n    return function (wa, f) {\n      return F.map(traverseF(wa, f), C.separate);\n    };\n  };\n}\nexports.wiltDefault = wiltDefault;\nfunction witherDefault(T, C) {\n  return function (F) {\n    var traverseF = T.traverse(F);\n    return function (wa, f) {\n      return F.map(traverseF(wa, f), C.compact);\n    };\n  };\n}\nexports.witherDefault = witherDefault;\nfunction filterE(W) {\n  return function (F) {\n    var witherF = W.wither(F);\n    return function (predicate) {\n      return function (ga) {\n        return witherF(ga, function (a) {\n          return F.map(predicate(a), function (b) {\n            return b ? _.some(a) : _.none;\n          });\n        });\n      };\n    };\n  };\n}\nexports.filterE = filterE;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.guard = void 0;\nfunction guard(F, P) {\n  return function (b) {\n    return b ? P.of(undefined) : F.zero();\n  };\n}\nexports.guard = guard;","\"use strict\";\n\nvar __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.fromEither = exports.MonadThrow = exports.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.Foldable = exports.reduceRight = exports.foldMap = exports.reduce = exports.Monad = exports.Chain = exports.chain = exports.Applicative = exports.Apply = exports.ap = exports.Pointed = exports.of = exports.Functor = exports.map = exports.getMonoid = exports.getOrd = exports.getEq = exports.getShow = exports.URI = exports.getRight = exports.getLeft = exports.fromPredicate = exports.some = exports.none = void 0;\nexports.getLastMonoid = exports.getFirstMonoid = exports.getApplyMonoid = exports.getApplySemigroup = exports.option = exports.mapNullable = exports.getRefinement = 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.elem = exports.toUndefined = exports.toNullable = exports.chainNullableK = exports.fromNullableK = exports.tryCatchK = exports.tryCatch = exports.fromNullable = exports.chainFirstEitherK = exports.chainEitherK = exports.fromEitherK = exports.duplicate = exports.chainFirst = 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 = void 0;\nvar Applicative_1 = require(\"./Applicative\");\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar 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}\nexports.fromPredicate = fromPredicate;\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 _chain = function (ma, f) {\n  return (0, function_1.pipe)(ma, (0, exports.chain)(f));\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 * @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 * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category sequencing\n * @since 2.0.0\n */\nvar chain = function (f) {\n  return function (ma) {\n    return (0, exports.isNone)(ma) ? exports.none : f(ma.value);\n  };\n};\nexports.chain = chain;\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Chain = {\n  URI: exports.URI,\n  map: _map,\n  ap: _ap,\n  chain: _chain\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: _chain\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 * 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 error handling\n * @since 2.9.0\n */\nvar altW = function (that) {\n  return function (fa) {\n    return (0, exports.isNone)(fa) ? that() : fa;\n  };\n};\nexports.altW = altW;\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `Option` returns the left-most non-`None` value.\n *\n * | x       | y       | pipe(x, alt(() => 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 * as O from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     O.none,\n *     O.alt(() => O.none)\n *   ),\n *   O.none\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.some('a'),\n *     O.alt<string>(() => O.none)\n *   ),\n *   O.some('a')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.none,\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('b')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.some('a'),\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('a')\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexports.alt = exports.altW;\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.chain)(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: _chain,\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 sequencing\n * @since 2.0.0\n */\nexports.chainFirst = /*#__PURE__*/(0, Chain_1.chainFirst)(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 * @category sequencing\n * @since 2.12.0\n */\nexports.chainFirstEitherK = /*#__PURE__*/(0, FromEither_1.chainFirstEitherK)(exports.FromEither, exports.Chain);\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}\nexports.elem = elem;\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 = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n/**\n * @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// 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}\nexports.getRefinement = getRefinement;\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: _chain,\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 = exports.pipeable = exports.compose = exports.promap = exports.partitionMapWithIndex = exports.partitionWithIndex = exports.filterMapWithIndex = exports.filterWithIndex = exports.partitionMap = exports.partition = exports.filterMap = exports.filter = exports.alt = exports.reduceRightWithIndex = exports.foldMapWithIndex = exports.reduceWithIndex = exports.reduceRight = exports.foldMap = exports.reduce = exports.extend = exports.mapLeft = exports.bimap = exports.chain = exports.ap = exports.mapWithIndex = exports.contramap = exports.map = void 0;\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}\nexports.map = map;\nfunction contramap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.contramap(fa, f);\n    };\n  };\n}\nexports.contramap = contramap;\nfunction mapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.mapWithIndex(fa, f);\n    };\n  };\n}\nexports.mapWithIndex = mapWithIndex;\nfunction ap(F) {\n  return function (fa) {\n    return function (fab) {\n      return F.ap(fab, fa);\n    };\n  };\n}\nexports.ap = ap;\nfunction chain(F) {\n  return function (f) {\n    return function (fa) {\n      return F.chain(fa, f);\n    };\n  };\n}\nexports.chain = chain;\nfunction bimap(F) {\n  return function (f, g) {\n    return function (fea) {\n      return F.bimap(fea, f, g);\n    };\n  };\n}\nexports.bimap = bimap;\nfunction mapLeft(F) {\n  return function (f) {\n    return function (fea) {\n      return F.mapLeft(fea, f);\n    };\n  };\n}\nexports.mapLeft = mapLeft;\nfunction extend(F) {\n  return function (f) {\n    return function (wa) {\n      return F.extend(wa, f);\n    };\n  };\n}\nexports.extend = extend;\nfunction reduce(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduce(fa, b, f);\n    };\n  };\n}\nexports.reduce = reduce;\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}\nexports.foldMap = foldMap;\nfunction reduceRight(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceRight(fa, b, f);\n    };\n  };\n}\nexports.reduceRight = reduceRight;\nfunction reduceWithIndex(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceWithIndex(fa, b, f);\n    };\n  };\n}\nexports.reduceWithIndex = reduceWithIndex;\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}\nexports.foldMapWithIndex = foldMapWithIndex;\nfunction reduceRightWithIndex(F) {\n  return function (b, f) {\n    return function (fa) {\n      return F.reduceRightWithIndex(fa, b, f);\n    };\n  };\n}\nexports.reduceRightWithIndex = reduceRightWithIndex;\nfunction alt(F) {\n  return function (that) {\n    return function (fa) {\n      return F.alt(fa, that);\n    };\n  };\n}\nexports.alt = alt;\nfunction filter(F) {\n  return function (predicate) {\n    return function (fa) {\n      return F.filter(fa, predicate);\n    };\n  };\n}\nexports.filter = filter;\nfunction filterMap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.filterMap(fa, f);\n    };\n  };\n}\nexports.filterMap = filterMap;\nfunction partition(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partition(fa, f);\n    };\n  };\n}\nexports.partition = partition;\nfunction partitionMap(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionMap(fa, f);\n    };\n  };\n}\nexports.partitionMap = partitionMap;\nfunction filterWithIndex(F) {\n  return function (predicate) {\n    return function (fa) {\n      return F.filterWithIndex(fa, predicate);\n    };\n  };\n}\nexports.filterWithIndex = filterWithIndex;\nfunction filterMapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.filterMapWithIndex(fa, f);\n    };\n  };\n}\nexports.filterMapWithIndex = filterMapWithIndex;\nfunction partitionWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionWithIndex(fa, f);\n    };\n  };\n}\nexports.partitionWithIndex = partitionWithIndex;\nfunction partitionMapWithIndex(F) {\n  return function (f) {\n    return function (fa) {\n      return F.partitionMapWithIndex(fa, f);\n    };\n  };\n}\nexports.partitionMapWithIndex = partitionMapWithIndex;\nfunction promap(F) {\n  return function (f, g) {\n    return function (fbc) {\n      return F.promap(fbc, f, g);\n    };\n  };\n}\nexports.promap = promap;\nfunction compose(F) {\n  return function (ea) {\n    return function (ab) {\n      return F.compose(ab, ea);\n    };\n  };\n}\nexports.compose = compose;\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}\nexports.pipeable = pipeable;\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","getBooleanAlgebra","B","x","y","a","getSemigroup","S","f","g","getMonoid","M","getSemigroupM","getSemiring","getRing","R","apply","identity","constant","flip","args","_i","flow","ab","bc","cd","de","ef","fg","gh","hi","ij","tuple","increment","n","decrement","absurd","_","tupled","untupled","pipe","ret","i","SK","b","not","predicate","getEndomorphismMonoid","first","second","require_internal","__commonJSMin","exports","__spreadArray","to","from","pack","l","ar","isNone","fa","isSome","some","a","isLeft","ma","isRight","left","e","right","singleton","isNonEmpty","as","head","tail","fromReadonlyNonEmptyArray","require_Apply","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","function_1","_","ap","F","G","fa","fab","gab","ga","apFirst","A","second","first","a","apSecond","b","apS","name","fb","_a","getApplySemigroup","S","x","y","curried","f","n","acc","combined","i","tupleConstructors","c","d","e","getTupleConstructor","len","sequenceT","args","_i","fas","getRecordConstructor","keys","r","sequenceS","fr","require_Functor","__commonJSMin","exports","function_1","map","F","G","f","fa","ga","flap","a","fab","bindTo","name","_a","let_","getFunctorComposition","_map","fga","require_Applicative","__commonJSMin","exports","Apply_1","function_1","Functor_1","getApplicativeMonoid","F","f","M","getApplicativeComposition","G","map","_ap","a","fgab","fga","require_Chain","__commonJSMin","exports","chainFirst","M","f","first","a","bind","name","ma","b","_a","require_FromEither","__commonJSMin","exports","__createBinding","o","m","k","k2","desc","__setModuleDefault","v","__importStar","mod","result","Chain_1","function_1","_","fromOption","F","onNone","ma","fromPredicate","predicate","onFalse","a","fromOptionK","fromOptionF","from","f","chainOptionK","M","fromOptionKF","fromEitherK","chainEitherK","fromEitherKF","chainFirstEitherK","filterOrElse","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","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","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","fold","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","T","C","F","traverseF","wa","f","witherDefault","filterE","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","Applicative_1","Apply_1","Chain_1","FromEither_1","function_1","Functor_1","_","Predicate_1","Semigroup_1","Separated_1","Witherable_1","Zero_1","fromPredicate","predicate","a","getLeft","ma","getRight","_map","fa","f","_ap","fab","_chain","_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","chain","reduce","foldMap","reduceRight","altW","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","elem","elemE_1","exists","let_","traverseReadonlyNonEmptyArrayWithIndex","as","out","i","o_1","traverseReadonlyArrayWithIndex","g","traverseArray","getRefinement","getOption","getFirstMonoid","getLastMonoid","require_pipeable","__commonJSMin","exports","Apply_1","Chain_1","function_1","map","F","f","fa","contramap","mapWithIndex","ap","fab","chain","bimap","g","fea","mapLeft","extend","wa","reduce","b","foldMap","M","foldMapM","reduceRight","reduceWithIndex","foldMapWithIndex","foldMapWithIndexM","reduceRightWithIndex","alt","that","filter","predicate","filterMap","partition","partitionMap","filterWithIndex","filterMapWithIndex","partitionWithIndex","partitionMapWithIndex","promap","fbc","compose","ea","ab","isFunctor","I","isContravariant","isFunctorWithIndex","isApply","isChain","isBifunctor","isExtend","isFoldable","isFoldableWithIndex","isAlt","isCompactable","isFilterable","isFilterableWithIndex","isProfunctor","isSemigroupoid","isMonadThrow","pipeable","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]}