{"version":3,"file":"js/7386-9517bc2538de3a17dcde.js","mappings":"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","sources":["webpack://uk-b2c/./node_modules/fp-ts/es6/Either.js","webpack://uk-b2c/./node_modules/fp-ts/es6/ChainRec.js","webpack://uk-b2c/./node_modules/io-ts/es6/index.js"],"sourcesContent":["import { getApplicativeMonoid } from './Applicative';\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_, getApplySemigroup as getApplySemigroup_ } from './Apply';\nimport * as chainable from './Chain';\nimport { tailRec } from './ChainRec';\nimport { chainOptionK as chainOptionK_, filterOrElse as filterOrElse_, fromOption as fromOption_, fromOptionK as fromOptionK_, fromPredicate as fromPredicate_ } from './FromEither';\nimport { dual, flow, identity, pipe } from './function';\nimport { as as as_, asUnit as asUnit_, bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { separated } from './Separated';\nimport { wiltDefault, witherDefault } from './Witherable';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this\n * structure.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var left = _.left;\n/**\n * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias\n * of this structure.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var right = _.right;\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/dual(2, function (ma, f) {\n  return isLeft(ma) ? ma : f(ma.right);\n});\nvar _map = function (fa, f) {\n  return pipe(fa, map(f));\n};\nvar _ap = function (fab, fa) {\n  return pipe(fab, ap(fa));\n};\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) {\n  return pipe(fa, reduce(b, f));\n};\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n  return function (fa, f) {\n    var foldMapM = foldMap(M);\n    return pipe(fa, foldMapM(f));\n  };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) {\n  return pipe(fa, reduceRight(b, f));\n};\nvar _traverse = function (F) {\n  var traverseF = traverse(F);\n  return function (ta, f) {\n    return pipe(ta, traverseF(f));\n  };\n};\nvar _bimap = function (fa, f, g) {\n  return pipe(fa, bimap(f, g));\n};\nvar _mapLeft = function (fa, f) {\n  return pipe(fa, mapLeft(f));\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) {\n  return pipe(fa, alt(that));\n};\n/* istanbul ignore next */\nvar _extend = function (wa, f) {\n  return pipe(wa, extend(f));\n};\nvar _chainRec = function (a, f) {\n  return tailRec(f(a), function (e) {\n    return isLeft(e) ? right(left(e.left)) : isLeft(e.right) ? left(f(e.right.left)) : right(right(e.right.right));\n  });\n};\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Either';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = function (SE, SA) {\n  return {\n    show: function (ma) {\n      return isLeft(ma) ? \"left(\".concat(SE.show(ma.left), \")\") : \"right(\".concat(SA.show(ma.right), \")\");\n    }\n  };\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = function (EL, EA) {\n  return {\n    equals: function (x, y) {\n      return x === y || (isLeft(x) ? isLeft(y) && EL.equals(x.left, y.left) : isRight(y) && EA.equals(x.right, y.right));\n    }\n  };\n};\n/**\n * Semigroup returning the left-most non-`Left` value. If both operands are `Right`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * @example\n * import { getSemigroup, left, right } from 'fp-ts/Either'\n * import { SemigroupSum } from 'fp-ts/number'\n *\n * const S = getSemigroup<string, number>(SemigroupSum)\n * assert.deepStrictEqual(S.concat(left('a'), left('b')), left('a'))\n * assert.deepStrictEqual(S.concat(left('a'), right(2)), right(2))\n * assert.deepStrictEqual(S.concat(right(1), left('b')), right(1))\n * assert.deepStrictEqual(S.concat(right(1), right(2)), right(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = function (S) {\n  return {\n    concat: function (x, y) {\n      return isLeft(y) ? x : isLeft(x) ? y : right(S.concat(x.right, y.right));\n    }\n  };\n};\n/**\n * Builds a `Compactable` instance for `Either` given `Monoid` for the left side.\n *\n * @category filtering\n * @since 2.10.0\n */\nexport var getCompactable = function (M) {\n  var empty = left(M.empty);\n  return {\n    URI: URI,\n    _E: undefined,\n    compact: function (ma) {\n      return isLeft(ma) ? ma : ma.right._tag === 'None' ? empty : right(ma.right.value);\n    },\n    separate: function (ma) {\n      return isLeft(ma) ? separated(ma, ma) : isLeft(ma.right) ? separated(right(ma.right.left), empty) : separated(empty, right(ma.right.right));\n    }\n  };\n};\n/**\n * Builds a `Filterable` instance for `Either` given `Monoid` for the left side\n *\n * @category filtering\n * @since 2.10.0\n */\nexport var getFilterable = function (M) {\n  var empty = left(M.empty);\n  var _a = getCompactable(M),\n    compact = _a.compact,\n    separate = _a.separate;\n  var filter = function (ma, predicate) {\n    return isLeft(ma) ? ma : predicate(ma.right) ? ma : empty;\n  };\n  var partition = function (ma, p) {\n    return isLeft(ma) ? separated(ma, ma) : p(ma.right) ? separated(empty, right(ma.right)) : separated(right(ma.right), empty);\n  };\n  return {\n    URI: URI,\n    _E: undefined,\n    map: _map,\n    compact: compact,\n    separate: separate,\n    filter: filter,\n    filterMap: function (ma, f) {\n      if (isLeft(ma)) {\n        return ma;\n      }\n      var ob = f(ma.right);\n      return ob._tag === 'None' ? empty : right(ob.value);\n    },\n    partition: partition,\n    partitionMap: function (ma, f) {\n      if (isLeft(ma)) {\n        return separated(ma, ma);\n      }\n      var e = f(ma.right);\n      return isLeft(e) ? separated(right(e.left), empty) : separated(empty, right(e.right));\n    }\n  };\n};\n/**\n * Builds `Witherable` instance for `Either` given `Monoid` for the left side\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var getWitherable = function (M) {\n  var F_ = getFilterable(M);\n  var C = getCompactable(M);\n  return {\n    URI: URI,\n    _E: undefined,\n    map: _map,\n    compact: F_.compact,\n    separate: F_.separate,\n    filter: F_.filter,\n    filterMap: F_.filterMap,\n    partition: F_.partition,\n    partitionMap: F_.partitionMap,\n    traverse: _traverse,\n    sequence: sequence,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    wither: witherDefault(Traversable, C),\n    wilt: wiltDefault(Traversable, C)\n  };\n};\n/**\n * The default [`Applicative`](#applicative) instance returns the first error, if you want to\n * get all errors you need to provide a way to concatenate them via a `Semigroup`.\n *\n * @example\n * import * as A from 'fp-ts/Apply'\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n *\n * const parseString = (u: unknown): E.Either<string, string> =>\n *   typeof u === 'string' ? E.right(u) : E.left('not a string')\n *\n * const parseNumber = (u: unknown): E.Either<string, number> =>\n *   typeof u === 'number' ? E.right(u) : E.left('not a number')\n *\n * interface Person {\n *   readonly name: string\n *   readonly age: number\n * }\n *\n * const parsePerson = (\n *   input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n *   pipe(\n *     E.Do,\n *     E.apS('name', parseString(input.name)),\n *     E.apS('age', parseNumber(input.age))\n *   )\n *\n * assert.deepStrictEqual(parsePerson({}), E.left('not a string')) // <= first error\n *\n * const Applicative = E.getApplicativeValidation(\n *   pipe(string.Semigroup, S.intercalate(', '))\n * )\n *\n * const apS = A.apS(Applicative)\n *\n * const parsePersonAll = (\n *   input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n *   pipe(\n *     E.Do,\n *     apS('name', parseString(input.name)),\n *     apS('age', parseNumber(input.age))\n *   )\n *\n * assert.deepStrictEqual(parsePersonAll({}), E.left('not a string, not a number')) // <= all errors\n *\n * @category error handling\n * @since 2.7.0\n */\nexport var getApplicativeValidation = function (SE) {\n  return {\n    URI: URI,\n    _E: undefined,\n    map: _map,\n    ap: function (fab, fa) {\n      return isLeft(fab) ? isLeft(fa) ? left(SE.concat(fab.left, fa.left)) : fab : isLeft(fa) ? fa : right(fab.right(fa.right));\n    },\n    of: of\n  };\n};\n/**\n * The default [`Alt`](#alt) instance returns the last error, if you want to\n * get all errors you need to provide a way to concatenate them via a `Semigroup`.\n *\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n *\n * const parseString = (u: unknown): E.Either<string, string> =>\n *   typeof u === 'string' ? E.right(u) : E.left('not a string')\n *\n * const parseNumber = (u: unknown): E.Either<string, number> =>\n *   typeof u === 'number' ? E.right(u) : E.left('not a number')\n *\n * const parse = (u: unknown): E.Either<string, string | number> =>\n *   pipe(\n *     parseString(u),\n *     E.alt<string, string | number>(() => parseNumber(u))\n *   )\n *\n * assert.deepStrictEqual(parse(true), E.left('not a number')) // <= last error\n *\n * const Alt = E.getAltValidation(pipe(string.Semigroup, S.intercalate(', ')))\n *\n * const parseAll = (u: unknown): E.Either<string, string | number> =>\n *   Alt.alt<string | number>(parseString(u), () => parseNumber(u))\n *\n * assert.deepStrictEqual(parseAll(true), E.left('not a string, not a number')) // <= all errors\n *\n * @category error handling\n * @since 2.7.0\n */\nexport var getAltValidation = function (SE) {\n  return {\n    URI: URI,\n    _E: undefined,\n    map: _map,\n    alt: function (me, that) {\n      if (isRight(me)) {\n        return me;\n      }\n      var ea = that();\n      return isLeft(ea) ? left(SE.concat(me.left, ea.left)) : ea;\n    }\n  };\n};\n/**\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) {\n  return function (fa) {\n    return isLeft(fa) ? fa : right(f(fa.right));\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n  URI: URI,\n  map: _map\n};\n/**\n * Maps the `Right` value of this `Either` to the specified constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var as = dual(2, as_(Functor));\n/**\n * Maps the `Right` value of this `Either` to the void constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var asUnit = asUnit_(Functor);\n/**\n * @category constructors\n * @since 2.7.0\n */\nexport var of = right;\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n  URI: URI,\n  of: of\n};\n/**\n * Less strict version of [`ap`](#ap).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.8.0\n */\nexport var apW = function (fa) {\n  return function (fab) {\n    return isLeft(fab) ? fab : isLeft(fa) ? fa : right(fab.right(fa.right));\n  };\n};\n/**\n * @since 2.0.0\n */\nexport var ap = apW;\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n  URI: URI,\n  map: _map,\n  ap: _ap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap\n};\n/**\n * Left-associative fold of a structure.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n *\n * const startWith = 'prefix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.reduce(startWith, concat)),\n *   'prefix:a'\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.reduce(startWith, concat)),\n *   'prefix'\n * )\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = function (b, f) {\n  return function (fa) {\n    return isLeft(fa) ? b : f(b, fa.right);\n  };\n};\n/**\n * Map each element of the structure to a monoid, and combine the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as S from 'fp-ts/string'\n *\n * const yell = (a: string) => `${a}!`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.foldMap(S.Monoid)(yell)),\n *   'a!'\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.foldMap(S.Monoid)(yell)),\n *   S.Monoid.empty\n * )\n *\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = function (M) {\n  return function (f) {\n    return function (fa) {\n      return isLeft(fa) ? M.empty : f(fa.right);\n    };\n  };\n};\n/**\n * Right-associative fold of a structure.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n *\n * const startWith = 'postfix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.reduceRight(startWith, concat)),\n *   'a:postfix'\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.reduceRight(startWith, concat)),\n *   'postfix'\n * )\n *\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) {\n  return function (fa) {\n    return isLeft(fa) ? b : f(fa.right, b);\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n  URI: URI,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight\n};\n/**\n * Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(['a']), E.traverse(O.Applicative)(RA.head)),\n *   O.some(E.right('a'))\n *  )\n *\n * assert.deepStrictEqual(\n *   pipe(E.right([]), E.traverse(O.Applicative)(RA.head)),\n *   O.none\n * )\n *\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n  return function (f) {\n    return function (ta) {\n      return isLeft(ta) ? F.of(left(ta.left)) : F.map(f(ta.right), right);\n    };\n  };\n};\n/**\n * Evaluate each monadic action in the structure from left to right, and collect the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(O.some('a')), E.sequence(O.Applicative)),\n *   O.some(E.right('a'))\n *  )\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(O.none), E.sequence(O.Applicative)),\n *   O.none\n * )\n *\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n  return function (ma) {\n    return isLeft(ma) ? F.of(left(ma.left)) : F.map(ma.right, right);\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n  URI: URI,\n  map: _map,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence\n};\n/**\n * Map a pair of functions over the two type arguments of the bifunctor.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var bimap = function (f, g) {\n  return function (fa) {\n    return isLeft(fa) ? left(f(fa.left)) : right(g(fa.right));\n  };\n};\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var mapLeft = function (f) {\n  return function (fa) {\n    return isLeft(fa) ? left(f(fa.left)) : fa;\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Bifunctor = {\n  URI: URI,\n  bimap: _bimap,\n  mapLeft: _mapLeft\n};\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the error and the return types will be merged.\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n  return function (fa) {\n    return isLeft(fa) ? that() : fa;\n  };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `Either` returns the left-most non-`Left` value (or the right-most `Left` value if both values are `Left`).\n *\n * | x        | y        | pipe(x, alt(() => y) |\n * | -------- | -------- | -------------------- |\n * | left(a)  | left(b)  | left(b)              |\n * | left(a)  | right(2) | right(2)             |\n * | right(1) | left(b)  | right(1)             |\n * | right(1) | right(2) | right(1)             |\n *\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     E.left('a'),\n *     E.alt(() => E.left('b'))\n *   ),\n *   E.left('b')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     E.left('a'),\n *     E.alt(() => E.right(2))\n *   ),\n *   E.right(2)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     E.right(1),\n *     E.alt(() => E.left('b'))\n *   ),\n *   E.right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     E.right(1),\n *     E.alt(() => E.right(2))\n *   ),\n *   E.right(1)\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var alt = altW;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n  URI: URI,\n  map: _map,\n  alt: _alt\n};\n/**\n * @since 2.0.0\n */\nexport var extend = function (f) {\n  return function (wa) {\n    return isLeft(wa) ? wa : right(f(wa));\n  };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n  URI: URI,\n  map: _map,\n  extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ChainRec = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  chain: flatMap,\n  chainRec: _chainRec\n};\n/**\n * @since 2.6.3\n */\nexport var throwError = left;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadThrow = {\n  URI: URI,\n  map: _map,\n  ap: _ap,\n  of: of,\n  chain: flatMap,\n  throwError: throwError\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var FromEither = {\n  URI: URI,\n  fromEither: identity\n};\n/**\n * @example\n * import { fromPredicate, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     1,\n *     fromPredicate(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     -1,\n *     fromPredicate(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   left('error')\n * )\n *\n * @category lifting\n * @since 2.0.0\n */\nexport var fromPredicate = /*#__PURE__*/fromPredicate_(FromEither);\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     O.some(1),\n *     E.fromOption(() => 'error')\n *   ),\n *   E.right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.none,\n *     E.fromOption(() => 'error')\n *   ),\n *   E.left('error')\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromOption = /*#__PURE__*/fromOption_(FromEither);\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the either is an instance of `Left`, `false` otherwise.\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isLeft = _.isLeft;\n/**\n * Returns `true` if the either is an instance of `Right`, `false` otherwise.\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isRight = _.isRight;\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = function (onLeft, onRight) {\n  return function (ma) {\n    return isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);\n  };\n};\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchW;\n/**\n * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the first function,\n * if the value is a `Right` the inner value is applied to the second function.\n *\n * @example\n * import { match, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * function onLeft(errors: Array<string>): string {\n *   return `Errors: ${errors.join(', ')}`\n * }\n *\n * function onRight(value: number): string {\n *   return `Ok: ${value}`\n * }\n *\n * assert.strictEqual(\n *   pipe(\n *     right(1),\n *     match(onLeft, onRight)\n *   ),\n *   'Ok: 1'\n * )\n * assert.strictEqual(\n *   pipe(\n *     left(['error 1', 'error 2']),\n *     match(onLeft, onRight)\n *   ),\n *   'Errors: error 1, error 2'\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = matchW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var fold = match;\n/**\n * Less strict version of [`getOrElse`](#getorelse).\n *\n * The `W` suffix (short for **W**idening) means that the handler return type will be merged.\n *\n * @category error handling\n * @since 2.6.0\n */\nexport var getOrElseW = function (onLeft) {\n  return function (ma) {\n    return isLeft(ma) ? onLeft(ma.left) : ma.right;\n  };\n};\n/**\n * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.\n *\n * @example\n * import { getOrElse, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     right(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     left('error'),\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/flap_(Functor);\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var apFirst = /*#__PURE__*/apFirst_(Apply);\n/**\n * Less strict version of [`apFirst`](#apfirst)\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var apFirstW = apFirst;\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.0.0\n */\nexport var apSecond = /*#__PURE__*/apSecond_(Apply);\n/**\n * Less strict version of [`apSecond`](#apsecond)\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var apSecondW = apSecond;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category combinators\n * @since 2.15.0\n */\nexport var tap = /*#__PURE__*/dual(2, chainable.tap(Chain));\n/**\n * Less strict version of [`flatten`](#flatten).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category sequencing\n * @since 2.11.0\n */\nexport var flattenW = /*#__PURE__*/flatMap(identity);\n/**\n * The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.\n *\n * @example\n * import * as E from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))\n * assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))\n * assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport var flatten = flattenW;\n/**\n * @since 2.0.0\n */\nexport var duplicate = /*#__PURE__*/extend(identity);\n/**\n * Use `liftOption`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var fromOptionK = /*#__PURE__*/fromOptionK_(FromEither);\n/**\n * Use `flatMapOption`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainOptionK = /*#__PURE__*/chainOptionK_(FromEither, Chain);\n/**\n * Use `flatMapOption`.\n *\n * @category legacy\n * @since 2.13.2\n */\nexport var chainOptionKW = /*#__PURE__*/chainOptionK;\n/** @internal */\nvar _FromEither = {\n  fromEither: FromEither.fromEither\n};\n/**\n * @category lifting\n * @since 2.15.0\n */\nexport var liftNullable = /*#__PURE__*/_.liftNullable(_FromEither);\n/**\n * @category lifting\n * @since 2.15.0\n */\nexport var liftOption = /*#__PURE__*/_.liftOption(_FromEither);\n/** @internal */\nvar _FlatMap = {\n  flatMap: flatMap\n};\n/**\n * @category sequencing\n * @since 2.15.0\n */\nexport var flatMapNullable = /*#__PURE__*/_.flatMapNullable(_FromEither, _FlatMap);\n/**\n * @category sequencing\n * @since 2.15.0\n */\nexport var flatMapOption = /*#__PURE__*/_.flatMapOption(_FromEither, _FlatMap);\n/**\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     E.right(1),\n *     E.filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   E.right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     E.right(-1),\n *     E.filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   E.left('error')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     E.left('a'),\n *     E.filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   E.left('a')\n * )\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filterOrElse = /*#__PURE__*/filterOrElse_(FromEither, Chain);\n/**\n * Less strict version of [`filterOrElse`](#filterorelse).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category filtering\n * @since 2.9.0\n */\nexport var filterOrElseW = filterOrElse;\n/**\n * Returns a `Right` if is a `Left` (and vice versa).\n *\n * @since 2.0.0\n */\nexport var swap = function (ma) {\n  return isLeft(ma) ? right(ma.left) : left(ma.right);\n};\n/**\n * Less strict version of [`orElse`](#orelse).\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.10.0\n */\nexport var orElseW = function (onLeft) {\n  return function (ma) {\n    return isLeft(ma) ? onLeft(ma.left) : ma;\n  };\n};\n/**\n * Useful for recovering from errors.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var orElse = orElseW;\n/**\n * Takes a default and a nullable value, if the value is not nully, turn it into a `Right`, if the value is nully use\n * the provided default as a `Left`.\n *\n * @example\n * import { fromNullable, left, right } from 'fp-ts/Either'\n *\n * const parse = fromNullable('nully')\n *\n * assert.deepStrictEqual(parse(1), right(1))\n * assert.deepStrictEqual(parse(null), left('nully'))\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromNullable = function (e) {\n  return function (a) {\n    return a == null ? left(e) : right(a);\n  };\n};\n/**\n * Constructs a new `Either` from a function that might throw.\n *\n * See also [`tryCatchK`](#trycatchk).\n *\n * @example\n * import * as E from 'fp-ts/Either'\n *\n * const unsafeHead = <A>(as: ReadonlyArray<A>): A => {\n *   if (as.length > 0) {\n *     return as[0]\n *   } else {\n *     throw new Error('empty array')\n *   }\n * }\n *\n * const head = <A>(as: ReadonlyArray<A>): E.Either<Error, A> =>\n *   E.tryCatch(() => unsafeHead(as), e => (e instanceof Error ? e : new Error('unknown error')))\n *\n * assert.deepStrictEqual(head([]), E.left(new Error('empty array')))\n * assert.deepStrictEqual(head([1, 2, 3]), E.right(1))\n *\n * @category interop\n * @since 2.0.0\n */\nexport var tryCatch = function (f, onThrow) {\n  try {\n    return right(f());\n  } catch (e) {\n    return left(onThrow(e));\n  }\n};\n/**\n * Converts a function that may throw to one returning a `Either`.\n *\n * @category interop\n * @since 2.10.0\n */\nexport var tryCatchK = function (f, onThrow) {\n  return function () {\n    var a = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      a[_i] = arguments[_i];\n    }\n    return tryCatch(function () {\n      return f.apply(void 0, a);\n    }, onThrow);\n  };\n};\n/**\n * Use `liftNullable`.\n *\n * @category legacy\n * @since 2.9.0\n */\nexport var fromNullableK = function (e) {\n  var from = fromNullable(e);\n  return function (f) {\n    return flow(f, from);\n  };\n};\n/**\n * Use `flatMapNullable`.\n *\n * @category legacy\n * @since 2.9.0\n */\nexport var chainNullableK = function (e) {\n  var from = fromNullableK(e);\n  return function (f) {\n    return flatMap(from(f));\n  };\n};\n/**\n * @category conversions\n * @since 2.10.0\n */\nexport var toUnion = /*#__PURE__*/foldW(identity, identity);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Default value for the `onError` argument of `tryCatch`\n *\n * @since 2.0.0\n */\nexport function toError(e) {\n  return e instanceof Error ? e : new Error(String(e));\n}\nexport function elem(E) {\n  return function (a, ma) {\n    if (ma === undefined) {\n      var elemE_1 = elem(E);\n      return function (ma) {\n        return elemE_1(a, ma);\n      };\n    }\n    return isLeft(ma) ? false : E.equals(a, ma.right);\n  };\n}\n/**\n * Returns `false` if `Left` or returns the result of the application of the given predicate to the `Right` value.\n *\n * @example\n * import { exists, left, right } from 'fp-ts/Either'\n *\n * const gt2 = exists((n: number) => n > 2)\n *\n * assert.strictEqual(gt2(left('a')), false)\n * assert.strictEqual(gt2(right(1)), false)\n * assert.strictEqual(gt2(right(3)), true)\n *\n * @since 2.0.0\n */\nexport var exists = function (predicate) {\n  return function (ma) {\n    return isLeft(ma) ? false : predicate(ma.right);\n  };\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/bindTo_(Functor);\nvar let_ = /*#__PURE__*/let__(Functor);\nexport {\n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/chainable.bind(Chain);\n/**\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category do notation\n * @since 2.8.0\n */\nexport var bindW = bind;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/apS_(Apply);\n/**\n * Less strict version of [`apS`](#aps).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category do notation\n * @since 2.8.0\n */\nexport var apSW = apS;\n/**\n * @since 2.11.0\n */\nexport var ApT = /*#__PURE__*/of(_.emptyReadonlyArray);\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n  return function (as) {\n    var e = f(0, _.head(as));\n    if (isLeft(e)) {\n      return e;\n    }\n    var out = [e.right];\n    for (var i = 1; i < as.length; i++) {\n      var e_1 = f(i, as[i]);\n      if (isLeft(e_1)) {\n        return e_1;\n      }\n      out.push(e_1.right);\n    }\n    return right(out);\n  };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyArrayWithIndex = function (f) {\n  var g = traverseReadonlyNonEmptyArrayWithIndex(f);\n  return function (as) {\n    return _.isNonEmpty(as) ? g(as) : ApT;\n  };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverse(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArray = function (f) {\n  return traverseReadonlyArrayWithIndex(function (_, a) {\n    return f(a);\n  });\n};\n/**\n * Equivalent to `ReadonlyArray#sequence(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceArray = /*#__PURE__*/traverseArray(identity);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.6.0\n */\nexport var chainW = flatMap;\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chainFirst = tap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.8.0\n */\nexport var chainFirstW = tap;\n/**\n * Use [`parse`](./Json.ts.html#parse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function parseJSON(s, onError) {\n  return tryCatch(function () {\n    return JSON.parse(s);\n  }, onError);\n}\n/**\n * Use [`stringify`](./Json.ts.html#stringify) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var stringifyJSON = function (u, onError) {\n  return tryCatch(function () {\n    var s = JSON.stringify(u);\n    if (typeof s !== 'string') {\n      throw new Error('Converting unsupported structure to JSON');\n    }\n    return s;\n  }, onError);\n};\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `E.Functor` instead of `E.either`\n * (where `E` is from `import E from 'fp-ts/Either'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var either = {\n  URI: URI,\n  map: _map,\n  of: of,\n  ap: _ap,\n  chain: flatMap,\n  reduce: _reduce,\n  foldMap: _foldMap,\n  reduceRight: _reduceRight,\n  traverse: _traverse,\n  sequence: sequence,\n  bimap: _bimap,\n  mapLeft: _mapLeft,\n  alt: _alt,\n  extend: _extend,\n  chainRec: _chainRec,\n  throwError: throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * Semigroup returning the left-most `Left` value. If both operands are `Right`s then the inner values\n * are concatenated using the provided `Semigroup`\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplySemigroup = /*#__PURE__*/getApplySemigroup_(Apply);\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplyMonoid = /*#__PURE__*/getApplicativeMonoid(Applicative);\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getValidationSemigroup = function (SE, SA) {\n  return getApplySemigroup_(getApplicativeValidation(SE))(SA);\n};\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getValidationMonoid = function (SE, MA) {\n  return getApplicativeMonoid(getApplicativeValidation(SE))(MA);\n};\n/**\n * Use [`getApplicativeValidation`](#getapplicativevalidation) and [`getAltValidation`](#getaltvalidation) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getValidation(SE) {\n  var ap = getApplicativeValidation(SE).ap;\n  var alt = getAltValidation(SE).alt;\n  return {\n    URI: URI,\n    _E: undefined,\n    map: _map,\n    of: of,\n    chain: flatMap,\n    bimap: _bimap,\n    mapLeft: _mapLeft,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    extend: _extend,\n    traverse: _traverse,\n    sequence: sequence,\n    chainRec: _chainRec,\n    throwError: throwError,\n    ap: ap,\n    alt: alt\n  };\n}","/**\n * @since 2.0.0\n */\nexport var tailRec = function (startWith, f) {\n  var ab = f(startWith);\n  while (ab._tag === 'Left') {\n    ab = f(ab.left);\n  }\n  return ab.right;\n};","var __extends = this && this.__extends || function () {\n  var extendStatics = function (d, b) {\n    extendStatics = Object.setPrototypeOf || {\n      __proto__: []\n    } instanceof Array && function (d, b) {\n      d.__proto__ = b;\n    } || function (d, b) {\n      for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n    };\n    return extendStatics(d, b);\n  };\n  return function (d, b) {\n    if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n    extendStatics(d, b);\n    function __() {\n      this.constructor = d;\n    }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n  };\n}();\nvar __assign = this && this.__assign || function () {\n  __assign = Object.assign || function (t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n    }\n    return t;\n  };\n  return __assign.apply(this, arguments);\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};\n/**\n * @since 1.0.0\n */\nimport { isLeft, left, right } from 'fp-ts/es6/Either';\n/**\n * @category Decode error\n * @since 1.0.0\n */\nexport var failures = left;\n/**\n * @category Decode error\n * @since 1.0.0\n */\nexport var failure = function (value, context, message) {\n  return failures([{\n    value: value,\n    context: context,\n    message: message\n  }]);\n};\n/**\n * @category Decode error\n * @since 1.0.0\n */\nexport var success = right;\n/**\n * @category Codec\n * @since 1.0.0\n */\nvar Type = /** @class */function () {\n  function Type( /** a unique name for this codec */\n  name, /** a custom type guard */\n  is, /** succeeds if a value of type I can be decoded to a value of type A */\n  validate, /** converts a value of type A to a value of type O */\n  encode) {\n    this.name = name;\n    this.is = is;\n    this.validate = validate;\n    this.encode = encode;\n    this.decode = this.decode.bind(this);\n  }\n  /**\n   * @since 1.0.0\n   */\n  Type.prototype.pipe = function (ab, name) {\n    var _this = this;\n    if (name === void 0) {\n      name = \"pipe(\".concat(this.name, \", \").concat(ab.name, \")\");\n    }\n    return new Type(name, ab.is, function (i, c) {\n      var e = _this.validate(i, c);\n      if (isLeft(e)) {\n        return e;\n      }\n      return ab.validate(e.right, c);\n    }, this.encode === identity && ab.encode === identity ? identity : function (b) {\n      return _this.encode(ab.encode(b));\n    });\n  };\n  /**\n   * @since 1.0.0\n   */\n  Type.prototype.asDecoder = function () {\n    return this;\n  };\n  /**\n   * @since 1.0.0\n   */\n  Type.prototype.asEncoder = function () {\n    return this;\n  };\n  /**\n   * a version of `validate` with a default context\n   * @since 1.0.0\n   */\n  Type.prototype.decode = function (i) {\n    return this.validate(i, [{\n      key: '',\n      type: this,\n      actual: i\n    }]);\n  };\n  return Type;\n}();\nexport { Type };\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 1.0.0\n */\nexport var identity = function (a) {\n  return a;\n};\n/**\n * @since 1.0.0\n */\nexport function getFunctionName(f) {\n  return f.displayName || f.name || \"<function\".concat(f.length, \">\");\n}\n/**\n * @since 1.0.0\n */\nexport function getContextEntry(key, decoder) {\n  return {\n    key: key,\n    type: decoder\n  };\n}\n/**\n * @since 1.0.0\n */\nexport function appendContext(c, key, decoder, actual) {\n  var len = c.length;\n  var r = Array(len + 1);\n  for (var i = 0; i < len; i++) {\n    r[i] = c[i];\n  }\n  r[len] = {\n    key: key,\n    type: decoder,\n    actual: actual\n  };\n  return r;\n}\nfunction pushAll(xs, ys) {\n  var l = ys.length;\n  for (var i = 0; i < l; i++) {\n    xs.push(ys[i]);\n  }\n}\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction getNameFromProps(props) {\n  return Object.keys(props).map(function (k) {\n    return \"\".concat(k, \": \").concat(props[k].name);\n  }).join(', ');\n}\nfunction useIdentity(codecs) {\n  for (var i = 0; i < codecs.length; i++) {\n    if (codecs[i].encode !== identity) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction getInterfaceTypeName(props) {\n  return \"{ \".concat(getNameFromProps(props), \" }\");\n}\nfunction getPartialTypeName(inner) {\n  return \"Partial<\".concat(inner, \">\");\n}\nfunction enumerableRecord(keys, domain, codomain, name) {\n  if (name === void 0) {\n    name = \"{ [K in \".concat(domain.name, \"]: \").concat(codomain.name, \" }\");\n  }\n  var len = keys.length;\n  return new DictionaryType(name, function (u) {\n    return UnknownRecord.is(u) && keys.every(function (k) {\n      return codomain.is(u[k]);\n    });\n  }, function (u, c) {\n    var e = UnknownRecord.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var o = e.right;\n    var a = {};\n    var errors = [];\n    var changed = false;\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      var ok = o[k];\n      var codomainResult = codomain.validate(ok, appendContext(c, k, codomain, ok));\n      if (isLeft(codomainResult)) {\n        pushAll(errors, codomainResult.left);\n      } else {\n        var vok = codomainResult.right;\n        changed = changed || vok !== ok;\n        a[k] = vok;\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(changed || Object.keys(o).length !== len ? a : o);\n  }, codomain.encode === identity ? identity : function (a) {\n    var s = {};\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      s[k] = codomain.encode(a[k]);\n    }\n    return s;\n  }, domain, codomain);\n}\n/**\n * @internal\n */\nexport function getDomainKeys(domain) {\n  var _a;\n  if (isLiteralC(domain)) {\n    var literal_1 = domain.value;\n    if (string.is(literal_1)) {\n      return _a = {}, _a[literal_1] = null, _a;\n    }\n  } else if (isKeyofC(domain)) {\n    return domain.keys;\n  } else if (isUnionC(domain)) {\n    var keys = domain.types.map(function (type) {\n      return getDomainKeys(type);\n    });\n    return keys.some(undefinedType.is) ? undefined : Object.assign.apply(Object, __spreadArray([{}], keys, false));\n  }\n  return undefined;\n}\nfunction nonEnumerableRecord(domain, codomain, name) {\n  if (name === void 0) {\n    name = \"{ [K in \".concat(domain.name, \"]: \").concat(codomain.name, \" }\");\n  }\n  return new DictionaryType(name, function (u) {\n    if (UnknownRecord.is(u)) {\n      return Object.keys(u).every(function (k) {\n        return domain.is(k) && codomain.is(u[k]);\n      });\n    }\n    return isAnyC(codomain) && Array.isArray(u);\n  }, function (u, c) {\n    if (UnknownRecord.is(u)) {\n      var a = {};\n      var errors = [];\n      var keys = Object.keys(u);\n      var len = keys.length;\n      var changed = false;\n      for (var i = 0; i < len; i++) {\n        var k = keys[i];\n        var ok = u[k];\n        var domainResult = domain.validate(k, appendContext(c, k, domain, k));\n        if (isLeft(domainResult)) {\n          pushAll(errors, domainResult.left);\n        } else {\n          var vk = domainResult.right;\n          changed = changed || vk !== k;\n          k = vk;\n          var codomainResult = codomain.validate(ok, appendContext(c, k, codomain, ok));\n          if (isLeft(codomainResult)) {\n            pushAll(errors, codomainResult.left);\n          } else {\n            var vok = codomainResult.right;\n            changed = changed || vok !== ok;\n            a[k] = vok;\n          }\n        }\n      }\n      return errors.length > 0 ? failures(errors) : success(changed ? a : u);\n    }\n    if (isAnyC(codomain) && Array.isArray(u)) {\n      return success(u);\n    }\n    return failure(u, c);\n  }, domain.encode === identity && codomain.encode === identity ? identity : function (a) {\n    var s = {};\n    var keys = Object.keys(a);\n    var len = keys.length;\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      s[String(domain.encode(k))] = codomain.encode(a[k]);\n    }\n    return s;\n  }, domain, codomain);\n}\nfunction getUnionName(codecs) {\n  return '(' + codecs.map(function (type) {\n    return type.name;\n  }).join(' | ') + ')';\n}\n/**\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function mergeAll(base, us) {\n  var equal = true;\n  var primitive = true;\n  var baseIsNotADictionary = !UnknownRecord.is(base);\n  for (var _i = 0, us_1 = us; _i < us_1.length; _i++) {\n    var u = us_1[_i];\n    if (u !== base) {\n      equal = false;\n    }\n    if (UnknownRecord.is(u)) {\n      primitive = false;\n    }\n  }\n  if (equal) {\n    return base;\n  } else if (primitive) {\n    return us[us.length - 1];\n  }\n  var r = {};\n  for (var _a = 0, us_2 = us; _a < us_2.length; _a++) {\n    var u = us_2[_a];\n    for (var k in u) {\n      if (!hasOwnProperty.call(r, k) || baseIsNotADictionary || u[k] !== base[k]) {\n        r[k] = u[k];\n      }\n    }\n  }\n  return r;\n}\nfunction getProps(codec) {\n  switch (codec._tag) {\n    case 'RefinementType':\n    case 'ReadonlyType':\n      return getProps(codec.type);\n    case 'InterfaceType':\n    case 'StrictType':\n    case 'PartialType':\n      return codec.props;\n    case 'IntersectionType':\n      return codec.types.reduce(function (props, type) {\n        return Object.assign(props, getProps(type));\n      }, {});\n  }\n}\nfunction stripKeys(o, props) {\n  var keys = Object.getOwnPropertyNames(o);\n  var shouldStrip = false;\n  var r = {};\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!hasOwnProperty.call(props, key)) {\n      shouldStrip = true;\n    } else {\n      r[key] = o[key];\n    }\n  }\n  return shouldStrip ? r : o;\n}\nfunction getExactTypeName(codec) {\n  if (isTypeC(codec)) {\n    return \"{| \".concat(getNameFromProps(codec.props), \" |}\");\n  } else if (isPartialC(codec)) {\n    return getPartialTypeName(\"{| \".concat(getNameFromProps(codec.props), \" |}\"));\n  }\n  return \"Exact<\".concat(codec.name, \">\");\n}\nfunction isNonEmpty(as) {\n  return as.length > 0;\n}\n/**\n * @internal\n */\nexport var emptyTags = {};\nfunction intersect(a, b) {\n  var r = [];\n  for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {\n    var v = a_1[_i];\n    if (b.indexOf(v) !== -1) {\n      r.push(v);\n    }\n  }\n  return r;\n}\nfunction mergeTags(a, b) {\n  if (a === emptyTags) {\n    return b;\n  }\n  if (b === emptyTags) {\n    return a;\n  }\n  var r = Object.assign({}, a);\n  for (var k in b) {\n    if (hasOwnProperty.call(a, k)) {\n      var intersection_1 = intersect(a[k], b[k]);\n      if (isNonEmpty(intersection_1)) {\n        r[k] = intersection_1;\n      } else {\n        r = emptyTags;\n        break;\n      }\n    } else {\n      r[k] = b[k];\n    }\n  }\n  return r;\n}\nfunction intersectTags(a, b) {\n  if (a === emptyTags || b === emptyTags) {\n    return emptyTags;\n  }\n  var r = emptyTags;\n  for (var k in a) {\n    if (hasOwnProperty.call(b, k)) {\n      var intersection_2 = intersect(a[k], b[k]);\n      if (intersection_2.length === 0) {\n        if (r === emptyTags) {\n          r = {};\n        }\n        r[k] = a[k].concat(b[k]);\n      }\n    }\n  }\n  return r;\n}\n// tslint:disable-next-line: deprecation\nfunction isAnyC(codec) {\n  return codec._tag === 'AnyType';\n}\nfunction isLiteralC(codec) {\n  return codec._tag === 'LiteralType';\n}\nfunction isKeyofC(codec) {\n  return codec._tag === 'KeyofType';\n}\nfunction isTypeC(codec) {\n  return codec._tag === 'InterfaceType';\n}\nfunction isPartialC(codec) {\n  return codec._tag === 'PartialType';\n}\n// tslint:disable-next-line: deprecation\nfunction isStrictC(codec) {\n  return codec._tag === 'StrictType';\n}\nfunction isExactC(codec) {\n  return codec._tag === 'ExactType';\n}\n// tslint:disable-next-line: deprecation\nfunction isRefinementC(codec) {\n  return codec._tag === 'RefinementType';\n}\nfunction isIntersectionC(codec) {\n  return codec._tag === 'IntersectionType';\n}\nfunction isUnionC(codec) {\n  return codec._tag === 'UnionType';\n}\nfunction isRecursiveC(codec) {\n  return codec._tag === 'RecursiveType';\n}\nvar lazyCodecs = [];\n/**\n * @internal\n */\nexport function getTags(codec) {\n  if (lazyCodecs.indexOf(codec) !== -1) {\n    return emptyTags;\n  }\n  if (isTypeC(codec) || isStrictC(codec)) {\n    var index = emptyTags;\n    // tslint:disable-next-line: forin\n    for (var k in codec.props) {\n      var prop = codec.props[k];\n      if (isLiteralC(prop)) {\n        if (index === emptyTags) {\n          index = {};\n        }\n        index[k] = [prop.value];\n      }\n    }\n    return index;\n  } else if (isExactC(codec) || isRefinementC(codec)) {\n    return getTags(codec.type);\n  } else if (isIntersectionC(codec)) {\n    return codec.types.reduce(function (tags, codec) {\n      return mergeTags(tags, getTags(codec));\n    }, emptyTags);\n  } else if (isUnionC(codec)) {\n    return codec.types.slice(1).reduce(function (tags, codec) {\n      return intersectTags(tags, getTags(codec));\n    }, getTags(codec.types[0]));\n  } else if (isRecursiveC(codec)) {\n    lazyCodecs.push(codec);\n    var tags = getTags(codec.type);\n    lazyCodecs.pop();\n    return tags;\n  }\n  return emptyTags;\n}\n/**\n * @internal\n */\nexport function getIndex(codecs) {\n  var tags = getTags(codecs[0]);\n  var keys = Object.keys(tags);\n  var len = codecs.length;\n  var _loop_1 = function (k) {\n    var all = tags[k].slice();\n    var index = [tags[k]];\n    for (var i = 1; i < len; i++) {\n      var codec = codecs[i];\n      var ctags = getTags(codec);\n      var values = ctags[k];\n      // tslint:disable-next-line: strict-type-predicates\n      if (values === undefined) {\n        return \"continue-keys\";\n      } else {\n        if (values.some(function (v) {\n          return all.indexOf(v) !== -1;\n        })) {\n          return \"continue-keys\";\n        } else {\n          all.push.apply(all, values);\n          index.push(values);\n        }\n      }\n    }\n    return {\n      value: [k, index]\n    };\n  };\n  keys: for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n    var k = keys_1[_i];\n    var state_1 = _loop_1(k);\n    if (typeof state_1 === \"object\") return state_1.value;\n    switch (state_1) {\n      case \"continue-keys\":\n        continue keys;\n    }\n  }\n  return undefined;\n}\n// -------------------------------------------------------------------------------------\n// primitives\n// -------------------------------------------------------------------------------------\n/**\n * @since 1.0.0\n */\nvar NullType = /** @class */function (_super) {\n  __extends(NullType, _super);\n  function NullType() {\n    var _this = _super.call(this, 'null', function (u) {\n      return u === null;\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'NullType';\n    return _this;\n  }\n  return NullType;\n}(Type);\nexport { NullType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var nullType = new NullType();\n/**\n * @since 1.0.0\n */\nvar UndefinedType = /** @class */function (_super) {\n  __extends(UndefinedType, _super);\n  function UndefinedType() {\n    var _this = _super.call(this, 'undefined', function (u) {\n      return u === void 0;\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'UndefinedType';\n    return _this;\n  }\n  return UndefinedType;\n}(Type);\nexport { UndefinedType };\nvar undefinedType = new UndefinedType();\n/**\n * @since 1.2.0\n */\nvar VoidType = /** @class */function (_super) {\n  __extends(VoidType, _super);\n  function VoidType() {\n    var _this = _super.call(this, 'void', undefinedType.is, undefinedType.validate, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'VoidType';\n    return _this;\n  }\n  return VoidType;\n}(Type);\nexport { VoidType };\n/**\n * @category primitives\n * @since 1.2.0\n */\nexport var voidType = new VoidType();\n/**\n * @since 1.5.0\n */\nvar UnknownType = /** @class */function (_super) {\n  __extends(UnknownType, _super);\n  function UnknownType() {\n    var _this = _super.call(this, 'unknown', function (_) {\n      return true;\n    }, success, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'UnknownType';\n    return _this;\n  }\n  return UnknownType;\n}(Type);\nexport { UnknownType };\n/**\n * @category primitives\n * @since 1.5.0\n */\nexport var unknown = new UnknownType();\n/**\n * @since 1.0.0\n */\nvar StringType = /** @class */function (_super) {\n  __extends(StringType, _super);\n  function StringType() {\n    var _this = _super.call(this, 'string', function (u) {\n      return typeof u === 'string';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'StringType';\n    return _this;\n  }\n  return StringType;\n}(Type);\nexport { StringType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var string = new StringType();\n/**\n * @since 1.0.0\n */\nvar NumberType = /** @class */function (_super) {\n  __extends(NumberType, _super);\n  function NumberType() {\n    var _this = _super.call(this, 'number', function (u) {\n      return typeof u === 'number';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'NumberType';\n    return _this;\n  }\n  return NumberType;\n}(Type);\nexport { NumberType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var number = new NumberType();\n/**\n * @since 2.1.0\n */\nvar BigIntType = /** @class */function (_super) {\n  __extends(BigIntType, _super);\n  function BigIntType() {\n    var _this = _super.call(this, 'bigint',\n    // tslint:disable-next-line: valid-typeof\n    function (u) {\n      return typeof u === 'bigint';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'BigIntType';\n    return _this;\n  }\n  return BigIntType;\n}(Type);\nexport { BigIntType };\n/**\n * @category primitives\n * @since 2.1.0\n */\nexport var bigint = new BigIntType();\n/**\n * @since 1.0.0\n */\nvar BooleanType = /** @class */function (_super) {\n  __extends(BooleanType, _super);\n  function BooleanType() {\n    var _this = _super.call(this, 'boolean', function (u) {\n      return typeof u === 'boolean';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'BooleanType';\n    return _this;\n  }\n  return BooleanType;\n}(Type);\nexport { BooleanType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var boolean = new BooleanType();\n/**\n * @since 1.0.0\n */\nvar AnyArrayType = /** @class */function (_super) {\n  __extends(AnyArrayType, _super);\n  function AnyArrayType() {\n    var _this = _super.call(this, 'UnknownArray', Array.isArray, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'AnyArrayType';\n    return _this;\n  }\n  return AnyArrayType;\n}(Type);\nexport { AnyArrayType };\n/**\n * @category primitives\n * @since 1.7.1\n */\nexport var UnknownArray = new AnyArrayType();\n/**\n * @since 1.0.0\n */\nvar AnyDictionaryType = /** @class */function (_super) {\n  __extends(AnyDictionaryType, _super);\n  function AnyDictionaryType() {\n    var _this = _super.call(this, 'UnknownRecord', function (u) {\n      return u !== null && typeof u === 'object' && !Array.isArray(u);\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'AnyDictionaryType';\n    return _this;\n  }\n  return AnyDictionaryType;\n}(Type);\nexport { AnyDictionaryType };\n/**\n * @category primitives\n * @since 1.7.1\n */\nexport var UnknownRecord = new AnyDictionaryType();\nexport {\n/**\n * @category primitives\n * @since 1.0.0\n */\nnullType as null,\n/**\n * @category primitives\n * @since 1.0.0\n */\nundefinedType as undefined,\n/**\n * @category primitives\n * @since 1.0.0\n */\nvoidType as void };\n/**\n * @since 1.0.0\n */\nvar LiteralType = /** @class */function (_super) {\n  __extends(LiteralType, _super);\n  function LiteralType(name, is, validate, encode, value) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.value = value;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'LiteralType';\n    return _this;\n  }\n  return LiteralType;\n}(Type);\nexport { LiteralType };\n/**\n * @category constructors\n * @since 1.0.0\n */\nexport function literal(value, name) {\n  if (name === void 0) {\n    name = JSON.stringify(value);\n  }\n  var is = function (u) {\n    return u === value;\n  };\n  return new LiteralType(name, is, function (u, c) {\n    return is(u) ? success(value) : failure(u, c);\n  }, identity, value);\n}\n/**\n * @since 1.0.0\n */\nvar KeyofType = /** @class */function (_super) {\n  __extends(KeyofType, _super);\n  function KeyofType(name, is, validate, encode, keys) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.keys = keys;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'KeyofType';\n    return _this;\n  }\n  return KeyofType;\n}(Type);\nexport { KeyofType };\n/**\n * @category constructors\n * @since 1.0.0\n */\nexport function keyof(keys, name) {\n  if (name === void 0) {\n    name = Object.keys(keys).map(function (k) {\n      return JSON.stringify(k);\n    }).join(' | ');\n  }\n  var is = function (u) {\n    return string.is(u) && hasOwnProperty.call(keys, u);\n  };\n  return new KeyofType(name, is, function (u, c) {\n    return is(u) ? success(u) : failure(u, c);\n  }, identity, keys);\n}\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @since 1.0.0\n */\nvar RefinementType = /** @class */function (_super) {\n  __extends(RefinementType, _super);\n  function RefinementType(name, is, validate, encode, type, predicate) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.type = type;\n    _this.predicate = predicate;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'RefinementType';\n    return _this;\n  }\n  return RefinementType;\n}(Type);\nexport { RefinementType };\n/**\n * @category combinators\n * @since 1.8.1\n */\nexport function brand(codec, predicate, name) {\n  return refinement(codec, predicate, name);\n}\n/**\n * A branded codec representing an integer\n *\n * @category primitives\n * @since 1.8.1\n */\nexport var Int = brand(number, function (n) {\n  return Number.isInteger(n);\n}, 'Int');\n/**\n * @since 1.0.0\n */\nvar RecursiveType = /** @class */function (_super) {\n  __extends(RecursiveType, _super);\n  function RecursiveType(name, is, validate, encode, runDefinition) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.runDefinition = runDefinition;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'RecursiveType';\n    return _this;\n  }\n  return RecursiveType;\n}(Type);\nexport { RecursiveType };\nObject.defineProperty(RecursiveType.prototype, 'type', {\n  get: function () {\n    return this.runDefinition();\n  },\n  enumerable: true,\n  configurable: true\n});\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function recursion(name, definition) {\n  var cache;\n  var runDefinition = function () {\n    if (!cache) {\n      cache = definition(Self);\n      cache.name = name;\n    }\n    return cache;\n  };\n  var Self = new RecursiveType(name, function (u) {\n    return runDefinition().is(u);\n  }, function (u, c) {\n    return runDefinition().validate(u, c);\n  }, function (a) {\n    return runDefinition().encode(a);\n  }, runDefinition);\n  return Self;\n}\n/**\n * @since 1.0.0\n */\nvar ArrayType = /** @class */function (_super) {\n  __extends(ArrayType, _super);\n  function ArrayType(name, is, validate, encode, type) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.type = type;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'ArrayType';\n    return _this;\n  }\n  return ArrayType;\n}(Type);\nexport { ArrayType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function array(item, name) {\n  if (name === void 0) {\n    name = \"Array<\".concat(item.name, \">\");\n  }\n  return new ArrayType(name, function (u) {\n    return UnknownArray.is(u) && u.every(item.is);\n  }, function (u, c) {\n    var e = UnknownArray.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var us = e.right;\n    var len = us.length;\n    var as = us;\n    var errors = [];\n    for (var i = 0; i < len; i++) {\n      var ui = us[i];\n      var result = item.validate(ui, appendContext(c, String(i), item, ui));\n      if (isLeft(result)) {\n        pushAll(errors, result.left);\n      } else {\n        var ai = result.right;\n        if (ai !== ui) {\n          if (as === us) {\n            as = us.slice();\n          }\n          as[i] = ai;\n        }\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(as);\n  }, item.encode === identity ? identity : function (a) {\n    return a.map(item.encode);\n  }, item);\n}\n/**\n * @since 1.0.0\n */\nvar InterfaceType = /** @class */function (_super) {\n  __extends(InterfaceType, _super);\n  function InterfaceType(name, is, validate, encode, props) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.props = props;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'InterfaceType';\n    return _this;\n  }\n  return InterfaceType;\n}(Type);\nexport { InterfaceType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function type(props, name) {\n  if (name === void 0) {\n    name = getInterfaceTypeName(props);\n  }\n  var keys = Object.keys(props);\n  var types = keys.map(function (key) {\n    return props[key];\n  });\n  var len = keys.length;\n  return new InterfaceType(name, function (u) {\n    if (UnknownRecord.is(u)) {\n      for (var i = 0; i < len; i++) {\n        var k = keys[i];\n        var uk = u[k];\n        if (uk === undefined && !hasOwnProperty.call(u, k) || !types[i].is(uk)) {\n          return false;\n        }\n      }\n      return true;\n    }\n    return false;\n  }, function (u, c) {\n    var e = UnknownRecord.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var o = e.right;\n    var a = o;\n    var errors = [];\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      var ak = a[k];\n      var type_1 = types[i];\n      var result = type_1.validate(ak, appendContext(c, k, type_1, ak));\n      if (isLeft(result)) {\n        pushAll(errors, result.left);\n      } else {\n        var vak = result.right;\n        if (vak !== ak || vak === undefined && !hasOwnProperty.call(a, k)) {\n          /* istanbul ignore next */\n          if (a === o) {\n            a = __assign({}, o);\n          }\n          a[k] = vak;\n        }\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(a);\n  }, useIdentity(types) ? identity : function (a) {\n    var s = __assign({}, a);\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      var encode = types[i].encode;\n      if (encode !== identity) {\n        s[k] = encode(a[k]);\n      }\n    }\n    return s;\n  }, props);\n}\n/**\n * @since 1.0.0\n */\nvar PartialType = /** @class */function (_super) {\n  __extends(PartialType, _super);\n  function PartialType(name, is, validate, encode, props) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.props = props;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'PartialType';\n    return _this;\n  }\n  return PartialType;\n}(Type);\nexport { PartialType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function partial(props, name) {\n  if (name === void 0) {\n    name = getPartialTypeName(getInterfaceTypeName(props));\n  }\n  var keys = Object.keys(props);\n  var types = keys.map(function (key) {\n    return props[key];\n  });\n  var len = keys.length;\n  return new PartialType(name, function (u) {\n    if (UnknownRecord.is(u)) {\n      for (var i = 0; i < len; i++) {\n        var k = keys[i];\n        var uk = u[k];\n        if (uk !== undefined && !props[k].is(uk)) {\n          return false;\n        }\n      }\n      return true;\n    }\n    return false;\n  }, function (u, c) {\n    var e = UnknownRecord.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var o = e.right;\n    var a = o;\n    var errors = [];\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      var ak = a[k];\n      var type_2 = props[k];\n      var result = type_2.validate(ak, appendContext(c, k, type_2, ak));\n      if (isLeft(result)) {\n        if (ak !== undefined) {\n          pushAll(errors, result.left);\n        }\n      } else {\n        var vak = result.right;\n        if (vak !== ak) {\n          /* istanbul ignore next */\n          if (a === o) {\n            a = __assign({}, o);\n          }\n          a[k] = vak;\n        }\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(a);\n  }, useIdentity(types) ? identity : function (a) {\n    var s = __assign({}, a);\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      var ak = a[k];\n      if (ak !== undefined) {\n        s[k] = types[i].encode(ak);\n      }\n    }\n    return s;\n  }, props);\n}\n/**\n * @since 1.0.0\n */\nvar DictionaryType = /** @class */function (_super) {\n  __extends(DictionaryType, _super);\n  function DictionaryType(name, is, validate, encode, domain, codomain) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.domain = domain;\n    _this.codomain = codomain;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'DictionaryType';\n    return _this;\n  }\n  return DictionaryType;\n}(Type);\nexport { DictionaryType };\n/**\n * @category combinators\n * @since 1.7.1\n */\nexport function record(domain, codomain, name) {\n  var keys = getDomainKeys(domain);\n  return keys ? enumerableRecord(Object.keys(keys), domain, codomain, name) : nonEnumerableRecord(domain, codomain, name);\n}\n/**\n * @since 1.0.0\n */\nvar UnionType = /** @class */function (_super) {\n  __extends(UnionType, _super);\n  function UnionType(name, is, validate, encode, types) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.types = types;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'UnionType';\n    return _this;\n  }\n  return UnionType;\n}(Type);\nexport { UnionType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function union(codecs, name) {\n  if (name === void 0) {\n    name = getUnionName(codecs);\n  }\n  var index = getIndex(codecs);\n  if (index !== undefined && codecs.length > 0) {\n    var tag_1 = index[0],\n      groups_1 = index[1];\n    var len_1 = groups_1.length;\n    var find_1 = function (value) {\n      for (var i = 0; i < len_1; i++) {\n        if (groups_1[i].indexOf(value) !== -1) {\n          return i;\n        }\n      }\n      return undefined;\n    };\n    // tslint:disable-next-line: deprecation\n    return new TaggedUnionType(name, function (u) {\n      if (UnknownRecord.is(u)) {\n        var i = find_1(u[tag_1]);\n        return i !== undefined ? codecs[i].is(u) : false;\n      }\n      return false;\n    }, function (u, c) {\n      var e = UnknownRecord.validate(u, c);\n      if (isLeft(e)) {\n        return e;\n      }\n      var r = e.right;\n      var i = find_1(r[tag_1]);\n      if (i === undefined) {\n        return failure(u, c);\n      }\n      var codec = codecs[i];\n      return codec.validate(r, appendContext(c, String(i), codec, r));\n    }, useIdentity(codecs) ? identity : function (a) {\n      var i = find_1(a[tag_1]);\n      if (i === undefined) {\n        // https://github.com/gcanti/io-ts/pull/305\n        throw new Error(\"no codec found to encode value in union codec \".concat(name));\n      } else {\n        return codecs[i].encode(a);\n      }\n    }, codecs, tag_1);\n  } else {\n    return new UnionType(name, function (u) {\n      return codecs.some(function (type) {\n        return type.is(u);\n      });\n    }, function (u, c) {\n      var errors = [];\n      for (var i = 0; i < codecs.length; i++) {\n        var codec = codecs[i];\n        var result = codec.validate(u, appendContext(c, String(i), codec, u));\n        if (isLeft(result)) {\n          pushAll(errors, result.left);\n        } else {\n          return success(result.right);\n        }\n      }\n      return failures(errors);\n    }, useIdentity(codecs) ? identity : function (a) {\n      for (var _i = 0, codecs_1 = codecs; _i < codecs_1.length; _i++) {\n        var codec = codecs_1[_i];\n        if (codec.is(a)) {\n          return codec.encode(a);\n        }\n      }\n      // https://github.com/gcanti/io-ts/pull/305\n      throw new Error(\"no codec found to encode value in union type \".concat(name));\n    }, codecs);\n  }\n}\n/**\n * @since 1.0.0\n */\nvar IntersectionType = /** @class */function (_super) {\n  __extends(IntersectionType, _super);\n  function IntersectionType(name, is, validate, encode, types) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.types = types;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'IntersectionType';\n    return _this;\n  }\n  return IntersectionType;\n}(Type);\nexport { IntersectionType };\nexport function intersection(codecs, name) {\n  if (name === void 0) {\n    name = \"(\".concat(codecs.map(function (type) {\n      return type.name;\n    }).join(' & '), \")\");\n  }\n  var len = codecs.length;\n  return new IntersectionType(name, function (u) {\n    return codecs.every(function (type) {\n      return type.is(u);\n    });\n  }, codecs.length === 0 ? success : function (u, c) {\n    var us = [];\n    var errors = [];\n    for (var i = 0; i < len; i++) {\n      var codec = codecs[i];\n      var result = codec.validate(u, appendContext(c, String(i), codec, u));\n      if (isLeft(result)) {\n        pushAll(errors, result.left);\n      } else {\n        us.push(result.right);\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(mergeAll(u, us));\n  }, codecs.length === 0 ? identity : function (a) {\n    return mergeAll(a, codecs.map(function (codec) {\n      return codec.encode(a);\n    }));\n  }, codecs);\n}\n/**\n * @since 1.0.0\n */\nvar TupleType = /** @class */function (_super) {\n  __extends(TupleType, _super);\n  function TupleType(name, is, validate, encode, types) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.types = types;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'TupleType';\n    return _this;\n  }\n  return TupleType;\n}(Type);\nexport { TupleType };\nexport function tuple(codecs, name) {\n  if (name === void 0) {\n    name = \"[\".concat(codecs.map(function (type) {\n      return type.name;\n    }).join(', '), \"]\");\n  }\n  var len = codecs.length;\n  return new TupleType(name, function (u) {\n    return UnknownArray.is(u) && u.length === len && codecs.every(function (type, i) {\n      return type.is(u[i]);\n    });\n  }, function (u, c) {\n    var e = UnknownArray.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var us = e.right;\n    var as = us.length > len ? us.slice(0, len) : us; // strip additional components\n    var errors = [];\n    for (var i = 0; i < len; i++) {\n      var a = us[i];\n      var type_3 = codecs[i];\n      var result = type_3.validate(a, appendContext(c, String(i), type_3, a));\n      if (isLeft(result)) {\n        pushAll(errors, result.left);\n      } else {\n        var va = result.right;\n        if (va !== a) {\n          /* istanbul ignore next */\n          if (as === us) {\n            as = us.slice();\n          }\n          as[i] = va;\n        }\n      }\n    }\n    return errors.length > 0 ? failures(errors) : success(as);\n  }, useIdentity(codecs) ? identity : function (a) {\n    return codecs.map(function (type, i) {\n      return type.encode(a[i]);\n    });\n  }, codecs);\n}\n/**\n * @since 1.0.0\n */\nvar ReadonlyType = /** @class */function (_super) {\n  __extends(ReadonlyType, _super);\n  function ReadonlyType(name, is, validate, encode, type) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.type = type;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'ReadonlyType';\n    return _this;\n  }\n  return ReadonlyType;\n}(Type);\nexport { ReadonlyType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function readonly(codec, name) {\n  if (name === void 0) {\n    name = \"Readonly<\".concat(codec.name, \">\");\n  }\n  return new ReadonlyType(name, codec.is, codec.validate, codec.encode, codec);\n}\n/**\n * @since 1.0.0\n */\nvar ReadonlyArrayType = /** @class */function (_super) {\n  __extends(ReadonlyArrayType, _super);\n  function ReadonlyArrayType(name, is, validate, encode, type) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.type = type;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'ReadonlyArrayType';\n    return _this;\n  }\n  return ReadonlyArrayType;\n}(Type);\nexport { ReadonlyArrayType };\n/**\n * @category combinators\n * @since 1.0.0\n */\nexport function readonlyArray(item, name) {\n  if (name === void 0) {\n    name = \"ReadonlyArray<\".concat(item.name, \">\");\n  }\n  var codec = array(item);\n  return new ReadonlyArrayType(name, codec.is, codec.validate, codec.encode, item);\n}\n/**\n * Strips additional properties, equivalent to `exact(type(props))`.\n *\n * @category combinators\n * @since 1.0.0\n */\nexport var strict = function (props, name) {\n  return exact(type(props), name);\n};\n/**\n * @since 1.1.0\n */\nvar ExactType = /** @class */function (_super) {\n  __extends(ExactType, _super);\n  function ExactType(name, is, validate, encode, type) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.type = type;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'ExactType';\n    return _this;\n  }\n  return ExactType;\n}(Type);\nexport { ExactType };\n/**\n * Strips additional properties.\n *\n * @category combinators\n * @since 1.1.0\n */\nexport function exact(codec, name) {\n  if (name === void 0) {\n    name = getExactTypeName(codec);\n  }\n  var props = getProps(codec);\n  return new ExactType(name, codec.is, function (u, c) {\n    var e = UnknownRecord.validate(u, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var ce = codec.validate(u, c);\n    if (isLeft(ce)) {\n      return ce;\n    }\n    return right(stripKeys(ce.right, props));\n  }, function (a) {\n    return codec.encode(stripKeys(a, props));\n  }, codec);\n}\n/**\n * @since 1.0.0\n */\nvar FunctionType = /** @class */function (_super) {\n  __extends(FunctionType, _super);\n  function FunctionType() {\n    var _this = _super.call(this, 'Function',\n    // tslint:disable-next-line:strict-type-predicates\n    function (u) {\n      return typeof u === 'function';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'FunctionType';\n    return _this;\n  }\n  return FunctionType;\n}(Type);\nexport { FunctionType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var Function = new FunctionType();\n/**\n * @since 1.0.0\n */\nvar NeverType = /** @class */function (_super) {\n  __extends(NeverType, _super);\n  function NeverType() {\n    var _this = _super.call(this, 'never', function (_) {\n      return false;\n    }, function (u, c) {\n      return failure(u, c);\n    }, /* istanbul ignore next */\n    function () {\n      throw new Error('cannot encode never');\n    }) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'NeverType';\n    return _this;\n  }\n  return NeverType;\n}(Type);\nexport { NeverType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var never = new NeverType();\n/**\n * @since 1.0.0\n */\nvar AnyType = /** @class */function (_super) {\n  __extends(AnyType, _super);\n  function AnyType() {\n    var _this = _super.call(this, 'any', function (_) {\n      return true;\n    }, success, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'AnyType';\n    return _this;\n  }\n  return AnyType;\n}(Type);\nexport { AnyType };\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var any = new AnyType();\nexport function refinement(codec, predicate, name) {\n  if (name === void 0) {\n    name = \"(\".concat(codec.name, \" | \").concat(getFunctionName(predicate), \")\");\n  }\n  return new RefinementType(name, function (u) {\n    return codec.is(u) && predicate(u);\n  }, function (i, c) {\n    var e = codec.validate(i, c);\n    if (isLeft(e)) {\n      return e;\n    }\n    var a = e.right;\n    return predicate(a) ? success(a) : failure(a, c);\n  }, codec.encode, codec, predicate);\n}\n/**\n * @category primitives\n * @since 1.0.0\n */\nexport var Integer = refinement(number, Number.isInteger, 'Integer');\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * @since 1.3.0\n * @deprecated\n */\nvar TaggedUnionType = /** @class */function (_super) {\n  __extends(TaggedUnionType, _super);\n  function TaggedUnionType(name,\n  // tslint:disable-next-line: deprecation\n  is,\n  // tslint:disable-next-line: deprecation\n  validate,\n  // tslint:disable-next-line: deprecation\n  encode, codecs, tag) {\n    var _this = _super.call(this, name, is, validate, encode, codecs) /* istanbul ignore next */ // <= workaround for https://github.com/Microsoft/TypeScript/issues/13455\n    || this;\n    _this.tag = tag;\n    return _this;\n  }\n  return TaggedUnionType;\n}(UnionType);\nexport { TaggedUnionType };\n/**\n * Use `union` instead.\n *\n * @category combinators\n * @since 1.3.0\n * @deprecated\n */\nexport var taggedUnion = function (tag, codecs, name\n// tslint:disable-next-line: deprecation\n) {\n  if (name === void 0) {\n    name = getUnionName(codecs);\n  }\n  var U = union(codecs, name);\n  // tslint:disable-next-line: deprecation\n  if (U instanceof TaggedUnionType) {\n    return U;\n  } else {\n    console.warn(\"[io-ts] Cannot build a tagged union for \".concat(name, \", returning a de-optimized union\"));\n    // tslint:disable-next-line: deprecation\n    return new TaggedUnionType(name, U.is, U.validate, U.encode, codecs, tag);\n  }\n};\nexport {\n/**\n * Use `UnknownArray` instead.\n *\n * @category primitives\n * @deprecated\n * @since 1.0.0\n */\nUnknownArray as Array };\nexport {\n/**\n * Use `type` instead.\n *\n * @category combinators\n * @deprecated\n * @since 1.0.0\n */\ntype as interface };\n/**\n * @since 1.0.0\n * @deprecated\n */\nexport var getValidationError /* istanbul ignore next */ = function (value, context) {\n  return {\n    value: value,\n    context: context\n  };\n};\n/**\n * @since 1.0.0\n * @deprecated\n */\nexport var getDefaultContext /* istanbul ignore next */ = function (decoder) {\n  return [{\n    key: '',\n    type: decoder\n  }];\n};\n/**\n * Use `UnknownRecord` instead.\n *\n * @category primitives\n * @since 1.0.0\n * @deprecated\n */\nexport var Dictionary = UnknownRecord;\n/**\n * @since 1.0.0\n * @deprecated\n */\nvar ObjectType = /** @class */function (_super) {\n  __extends(ObjectType, _super);\n  function ObjectType() {\n    var _this = _super.call(this, 'object', function (u) {\n      return u !== null && typeof u === 'object';\n    }, function (u, c) {\n      return _this.is(u) ? success(u) : failure(u, c);\n    }, identity) || this;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'ObjectType';\n    return _this;\n  }\n  return ObjectType;\n}(Type);\nexport { ObjectType };\n/**\n * Use `UnknownRecord` instead.\n *\n * @category primitives\n * @since 1.0.0\n * @deprecated\n */\n// tslint:disable-next-line: deprecation\nexport var object = new ObjectType();\n/**\n * Use `record` instead.\n *\n * @category combinators\n * @since 1.0.0\n * @deprecated\n */\nexport var dictionary = record;\n/**\n * @since 1.0.0\n * @deprecated\n */\nvar StrictType = /** @class */function (_super) {\n  __extends(StrictType, _super);\n  function StrictType(name,\n  // tslint:disable-next-line: deprecation\n  is,\n  // tslint:disable-next-line: deprecation\n  validate,\n  // tslint:disable-next-line: deprecation\n  encode, props) {\n    var _this = _super.call(this, name, is, validate, encode) || this;\n    _this.props = props;\n    /**\n     * @since 1.0.0\n     */\n    _this._tag = 'StrictType';\n    return _this;\n  }\n  return StrictType;\n}(Type);\nexport { StrictType };\n/**\n * Drops the codec \"kind\".\n *\n * @category combinators\n * @since 1.1.0\n * @deprecated\n */\nexport function clean(codec) {\n  return codec;\n}\nexport function alias(codec) {\n  return function () {\n    return codec;\n  };\n}"],"names":["left","right","flatMap","ma","f","isLeft","_map","fa","map","_ap","fab","ap","_reduce","b","reduce","_foldMap","M","foldMapM","foldMap","_reduceRight","reduceRight","_traverse","F","traverseF","traverse","ta","_bimap","g","bimap","_mapLeft","mapLeft","_alt","that","alt","_extend","wa","extend","_chainRec","a","startWith","ab","_tag","tailRec","e","URI","getShow","SE","SA","show","concat","getEq","EL","EA","equals","x","y","isRight","getSemigroup","S","getCompactable","empty","_E","undefined","compact","value","separate","getFilterable","_a","filter","predicate","filterMap","ob","partition","p","partitionMap","getWitherable","F_","C","sequence","wither","Traversable","wilt","getApplicativeValidation","of","getAltValidation","me","ea","as","asUnit","Pointed","apW","chain","Monad","Foldable","Bifunctor","altW","Alt","Extend","ChainRec","chainRec","throwError","MonadThrow","fromEither","fromPredicate","fromOption","matchW","onLeft","onRight","foldW","match","fold","getOrElseW","getOrElse","flap","apFirst","apFirstW","apSecond","apSecondW","tap","flattenW","flatten","duplicate","fromOptionK","chainOptionK","chainOptionKW","_FromEither","liftNullable","liftOption","_FlatMap","flatMapNullable","flatMapOption","filterOrElse","filterOrElseW","swap","orElseW","orElse","fromNullable","tryCatch","onThrow","tryCatchK","_i","arguments","length","apply","fromNullableK","from","chainNullableK","toUnion","toError","Error","String","elem","E","elemE_1","exists","Do","bindTo","let_","bind","bindW","apS","apSW","ApT","traverseReadonlyNonEmptyArrayWithIndex","out","i","e_1","push","traverseReadonlyArrayWithIndex","traverseArrayWithIndex","traverseArray","_","sequenceArray","chainW","chainFirst","chainFirstW","parseJSON","s","onError","JSON","parse","stringifyJSON","u","stringify","either","getApplySemigroup","getApplyMonoid","getValidationSemigroup","getValidationMonoid","MA","getValidation","extendStatics","__extends","d","Object","setPrototypeOf","__proto__","Array","prototype","hasOwnProperty","call","TypeError","__","this","constructor","create","__assign","assign","t","n","__spreadArray","to","pack","ar","l","slice","failures","failure","context","message","success","Type","name","is","validate","encode","decode","pipe","_this","c","identity","asDecoder","asEncoder","key","type","actual","getFunctionName","displayName","getContextEntry","decoder","appendContext","len","r","pushAll","xs","ys","getNameFromProps","props","keys","k","join","useIdentity","codecs","getInterfaceTypeName","getPartialTypeName","inner","getDomainKeys","domain","isLiteralC","literal_1","string","isUnionC","types","some","undefinedType","getUnionName","mergeAll","base","us","equal","primitive","baseIsNotADictionary","UnknownRecord","us_1","us_2","getProps","codec","stripKeys","o","getOwnPropertyNames","shouldStrip","emptyTags","intersect","a_1","v","indexOf","isAnyC","isTypeC","lazyCodecs","getTags","isStrictC","index","prop","isExactC","isRefinementC","isIntersectionC","tags","intersection_1","mergeTags","intersectTags","isRecursiveC","pop","getIndex","_loop_1","all","values","keys_1","state_1","NullType","_super","nullType","UndefinedType","VoidType","voidType","UnknownType","unknown","StringType","NumberType","number","BigIntType","bigint","BooleanType","boolean","AnyArrayType","isArray","UnknownArray","AnyDictionaryType","LiteralType","literal","KeyofType","keyof","RefinementType","brand","refinement","Int","Number","isInteger","RecursiveType","runDefinition","recursion","definition","cache","Self","defineProperty","get","enumerable","configurable","ArrayType","array","item","every","errors","ui","result","ai","InterfaceType","uk","ak","type_1","vak","PartialType","partial","type_2","DictionaryType","codomain","record","changed","ok","codomainResult","vok","enumerableRecord","domainResult","vk","nonEnumerableRecord","UnionType","union","tag_1","groups_1","len_1","find_1","TaggedUnionType","codecs_1","IntersectionType","intersection","TupleType","tuple","type_3","va","ReadonlyType","readonly","ReadonlyArrayType","readonlyArray","strict","exact","ExactType","isPartialC","getExactTypeName","ce","FunctionType","Function","NeverType","never","AnyType","any","Integer","tag","taggedUnion","U","console","warn","getValidationError","getDefaultContext","Dictionary","ObjectType","object","dictionary","StrictType","clean","alias"],"sourceRoot":""}