@slicemachine/manager 0.22.2-alpha.dani-snippets.7 → 0.22.2-alpha.dani-repeatable-links-codegen.1

package/dist/_node_modules/fp-ts/es6/Option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Option.js","sources":["../../../../../../node_modules/fp-ts/es6/Option.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 { chainEitherK as chainEitherK_, fromEitherK as fromEitherK_, tapEither as tapEither_ } from './FromEither';\nimport { constNull, constUndefined, dual, flow, identity, pipe } from './function';\nimport { as as as_, asUnit as asUnit_, bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { not } from './Predicate';\nimport { first, last } from './Semigroup';\nimport { separated } from './Separated';\nimport { wiltDefault, witherDefault } from './Witherable';\nimport { guard as guard_ } from './Zero';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var none = _.none;\n/**\n * Constructs a `Some`. Represents an optional value that exists.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var some = _.some;\nexport function fromPredicate(predicate) {\n    return function (a) { return (predicate(a) ? some(a) : none); };\n}\n/**\n * Returns the `Left` value of an `Either` if possible.\n *\n * @example\n * import { getLeft, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getLeft(right(1)), none)\n * assert.deepStrictEqual(getLeft(left('a')), some('a'))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var getLeft = function (ma) { return (ma._tag === 'Right' ? none : some(ma.left)); };\n/**\n * Returns the `Right` value of an `Either` if possible.\n *\n * @example\n * import { getRight, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getRight(right(1)), some(1))\n * assert.deepStrictEqual(getRight(left('a')), none)\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var getRight = function (ma) { return (ma._tag === 'Left' ? none : some(ma.right)); };\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _ap = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\nvar _foldMap = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\nvar _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar _traverse = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\nvar _filter = function (fa, predicate) { return pipe(fa, filter(predicate)); };\n/* istanbul ignore next */\nvar _filterMap = function (fa, f) { return pipe(fa, filterMap(f)); };\n/* istanbul ignore next */\nvar _extend = function (wa, f) { return pipe(wa, extend(f)); };\n/* istanbul ignore next */\nvar _partition = function (fa, predicate) {\n    return pipe(fa, partition(predicate));\n};\n/* istanbul ignore next */\nvar _partitionMap = function (fa, f) { return pipe(fa, partitionMap(f)); };\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Option';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = function (S) { return ({\n    show: function (ma) { return (isNone(ma) ? 'none' : \"some(\".concat(S.show(ma.value), \")\")); }\n}); };\n/**\n * @example\n * import { none, some, getEq } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals(none, none), true)\n * assert.strictEqual(E.equals(none, some(1)), false)\n * assert.strictEqual(E.equals(some(1), none), false)\n * assert.strictEqual(E.equals(some(1), some(2)), false)\n * assert.strictEqual(E.equals(some(1), some(1)), true)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = function (E) { return ({\n    equals: function (x, y) { return x === y || (isNone(x) ? isNone(y) : isNone(y) ? false : E.equals(x.value, y.value)); }\n}); };\n/**\n * The `Ord` instance allows `Option` values to be compared with\n * `compare`, whenever there is an `Ord` instance for\n * the type the `Option` contains.\n *\n * `None` is considered to be less than any `Some` value.\n *\n *\n * @example\n * import { none, some, getOrd } from 'fp-ts/Option'\n * import * as N from 'fp-ts/number'\n *\n * const O = getOrd(N.Ord)\n * assert.strictEqual(O.compare(none, none), 0)\n * assert.strictEqual(O.compare(none, some(1)), -1)\n * assert.strictEqual(O.compare(some(1), none), 1)\n * assert.strictEqual(O.compare(some(1), some(2)), -1)\n * assert.strictEqual(O.compare(some(1), some(1)), 0)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getOrd = function (O) { return ({\n    equals: getEq(O).equals,\n    compare: function (x, y) { return (x === y ? 0 : isSome(x) ? (isSome(y) ? O.compare(x.value, y.value) : 1) : -1); }\n}); };\n/**\n * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | some(a)            |\n * | none    | some(b) | some(b)            |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getMonoid, some, none } from 'fp-ts/Option'\n * import { SemigroupSum } from 'fp-ts/number'\n *\n * const M = getMonoid(SemigroupSum)\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = function (S) { return ({\n    concat: function (x, y) { return (isNone(x) ? y : isNone(y) ? x : some(S.concat(x.value, y.value))); },\n    empty: none\n}); };\n/**\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) {\n    return isNone(fa) ? none : some(f(fa.value));\n}; };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * Maps the `Some` value of this `Option` to the specified constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var as = dual(2, as_(Functor));\n/**\n * Maps the `Some` value of this `Option` to the void constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var asUnit = asUnit_(Functor);\n/**\n * @category constructors\n * @since 2.7.0\n */\nexport var of = some;\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n    URI: URI,\n    of: of\n};\n/**\n * @since 2.0.0\n */\nexport var ap = function (fa) { return function (fab) {\n    return isNone(fab) ? none : isNone(fa) ? none : some(fab.value(fa.value));\n}; };\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n    URI: URI,\n    map: _map,\n    ap: _ap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of\n};\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, function (ma, f) { return (isNone(ma) ? none : f(ma.value)); });\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = function (b, f) { return function (fa) {\n    return isNone(fa) ? b : f(b, fa.value);\n}; };\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n    return isNone(fa) ? M.empty : f(fa.value);\n}; }; };\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) { return function (fa) {\n    return isNone(fa) ? b : f(fa.value, b);\n}; };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight\n};\n/**\n * Returns the provided `Option` `that` if `self` is `None`, otherwise returns `self`.\n *\n * @param self - The first `Option` to be checked.\n * @param that - The `Option` to return if `self` is `None`.\n *\n * @example\n * import * as O from \"fp-ts/Option\"\n *\n * assert.deepStrictEqual(O.orElse(O.none, () => O.none), O.none)\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.none), O.some(1))\n * assert.deepStrictEqual(O.orElse(O.none, () => O.some('b')), O.some('b'))\n * assert.deepStrictEqual(O.orElse(O.some(1), () => O.some('b')), O.some(1))\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var orElse = dual(2, function (self, that) { return (isNone(self) ? that() : self); });\n/**\n * Alias of `orElse`.\n *\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @category legacy\n * @since 2.9.0\n */\nexport var altW = orElse;\n/**\n * Alias of `orElse`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var alt = orElse;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: _map,\n    alt: _alt\n};\n/**\n * @since 2.7.0\n */\nexport var zero = function () { return none; };\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Zero = {\n    URI: URI,\n    zero: zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexport var guard = /*#__PURE__*/ guard_(Zero, Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    alt: _alt,\n    zero: zero\n};\n/**\n * @since 2.0.0\n */\nexport var extend = function (f) { return function (wa) {\n    return isNone(wa) ? none : some(f(wa));\n}; };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n    URI: URI,\n    map: _map,\n    extend: _extend\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var compact = /*#__PURE__*/ flatMap(identity);\nvar defaultSeparated = /*#__PURE__*/ separated(none, none);\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var separate = function (ma) {\n    return isNone(ma) ? defaultSeparated : separated(getLeft(ma.value), getRight(ma.value));\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var filter = function (predicate) {\n    return function (fa) {\n        return isNone(fa) ? none : predicate(fa.value) ? fa : none;\n    };\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var filterMap = function (f) { return function (fa) {\n    return isNone(fa) ? none : f(fa.value);\n}; };\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var partition = function (predicate) {\n    return function (fa) {\n        return separated(_filter(fa, not(predicate)), _filter(fa, predicate));\n    };\n};\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionMap = function (f) { return flow(map(f), separate); };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: _map,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    return function (f) {\n        return function (ta) {\n            return isNone(ta) ? F.of(none) : F.map(f(ta.value), some);\n        };\n    };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n    return function (ta) {\n        return isNone(ta) ? F.of(none) : F.map(ta.value, some);\n    };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: _map,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence\n};\nvar _wither = /*#__PURE__*/ witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/ wiltDefault(Traversable, Compactable);\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n    var _witherF = _wither(F);\n    return function (f) { return function (fa) { return _witherF(fa, f); }; };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n    var _wiltF = _wilt(F);\n    return function (f) { return function (fa) { return _wiltF(fa, f); }; };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: _map,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    wither: _wither,\n    wilt: _wilt\n};\n/**\n * @since 2.7.0\n */\nexport var throwError = function () { return none; };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadThrow = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap,\n    throwError: throwError\n};\n/**\n * Transforms an `Either` to an `Option` discarding the error.\n *\n * Alias of [getRight](#getright)\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromEither = getRight;\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var FromEither = {\n    URI: URI,\n    fromEither: fromEither\n};\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the option is an instance of `Some`, `false` otherwise.\n *\n * @example\n * import { some, none, isSome } from 'fp-ts/Option'\n *\n * assert.strictEqual(isSome(some(1)), true)\n * assert.strictEqual(isSome(none), false)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isSome = _.isSome;\n/**\n * Returns `true` if the option is `None`, `false` otherwise.\n *\n * @example\n * import { some, none, isNone } from 'fp-ts/Option'\n *\n * assert.strictEqual(isNone(some(1)), false)\n * assert.strictEqual(isNone(none), true)\n *\n * @category refinements\n * @since 2.0.0\n */\nexport var isNone = function (fa) { return fa._tag === 'None'; };\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = function (onNone, onSome) {\n    return function (ma) {\n        return isNone(ma) ? onNone() : onSome(ma.value);\n    };\n};\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchW;\n/**\n * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is\n * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.\n *\n * @example\n * import { some, none, match } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a some containing 1'\n * )\n *\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     match(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a none'\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = matchW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var fold = match;\n/**\n * Less strict version of [`getOrElse`](#getorelse).\n *\n * The `W` suffix (short for **W**idening) means that the handler return type will be merged.\n *\n * @category error handling\n * @since 2.6.0\n */\nexport var getOrElseW = function (onNone) {\n    return function (ma) {\n        return isNone(ma) ? onNone() : ma.value;\n    };\n};\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns the given default value\n *\n * @example\n * import { some, none, getOrElse } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var apFirst = /*#__PURE__*/ apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.0.0\n */\nexport var apSecond = /*#__PURE__*/ apSecond_(Apply);\n/**\n * @category sequencing\n * @since 2.0.0\n */\nexport var flatten = compact;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category combinators\n * @since 2.15.0\n */\nexport var tap = /*#__PURE__*/ dual(2, chainable.tap(Chain));\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n * import * as E from 'fp-ts/Either'\n *\n * const compute = (value: number) => pipe(\n *   O.of(value),\n *   O.tapEither((value) => value > 0 ? E.right('ok') : E.left('error')),\n * )\n *\n * assert.deepStrictEqual(compute(1), O.of(1))\n * assert.deepStrictEqual(compute(-42), O.none)\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapEither = /*#__PURE__*/ dual(2, tapEither_(FromEither, Chain));\n/**\n * @since 2.0.0\n */\nexport var duplicate = /*#__PURE__*/ extend(identity);\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = /*#__PURE__*/ fromEitherK_(FromEither);\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainEitherK = \n/*#__PURE__*/ chainEitherK_(FromEither, Chain);\n/**\n * Alias of `tapEither`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherK = tapEither;\n/**\n * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise\n * returns the value wrapped in a `Some`.\n *\n * @example\n * import { none, some, fromNullable } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(fromNullable(undefined), none)\n * assert.deepStrictEqual(fromNullable(null), none)\n * assert.deepStrictEqual(fromNullable(1), some(1))\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromNullable = function (a) { return (a == null ? none : some(a)); };\n/**\n * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a\n * `Some`.\n *\n * See also [`tryCatchK`](#trycatchk).\n *\n * @example\n * import { none, some, tryCatch } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   tryCatch(() => {\n *     throw new Error()\n *   }),\n *   none\n * )\n * assert.deepStrictEqual(tryCatch(() => 1), some(1))\n *\n * @category interop\n * @since 2.0.0\n */\nexport var tryCatch = function (f) {\n    try {\n        return some(f());\n    }\n    catch (e) {\n        return none;\n    }\n};\n/**\n * Converts a function that may throw to one returning a `Option`.\n *\n * @category interop\n * @since 2.10.0\n */\nexport var tryCatchK = function (f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return tryCatch(function () { return f.apply(void 0, a); });\n    };\n};\n/**\n * Returns a *smart constructor* from a function that returns a nullable value.\n *\n * @example\n * import { fromNullableK, none, some } from 'fp-ts/Option'\n *\n * const f = (s: string): number | undefined => {\n *   const n = parseFloat(s)\n *   return isNaN(n) ? undefined : n\n * }\n *\n * const g = fromNullableK(f)\n *\n * assert.deepStrictEqual(g('1'), some(1))\n * assert.deepStrictEqual(g('a'), none)\n *\n * @category lifting\n * @since 2.9.0\n */\nexport var fromNullableK = function (f) { return flow(f, fromNullable); };\n/**\n * This is `chain` + `fromNullable`, useful when working with optional values.\n *\n * @example\n * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Employee {\n *   readonly company?: {\n *     readonly address?: {\n *       readonly street?: {\n *         readonly name?: string\n *       }\n *     }\n *   }\n * }\n *\n * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee1.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   some('high street')\n * )\n *\n * const employee2: Employee = { company: { address: { street: {} } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee2.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   none\n * )\n *\n * @category sequencing\n * @since 2.9.0\n */\nexport var chainNullableK = function (f) {\n    return function (ma) {\n        return isNone(ma) ? none : fromNullable(f(ma.value));\n    };\n};\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `null`.\n *\n * @example\n * import { some, none, toNullable } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toNullable\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toNullable\n *   ),\n *   null\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var toNullable = /*#__PURE__*/ match(constNull, identity);\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.\n *\n * @example\n * import { some, none, toUndefined } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toUndefined\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toUndefined\n *   ),\n *   undefined\n * )\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var toUndefined = /*#__PURE__*/ match(constUndefined, identity);\nexport function elem(E) {\n    return function (a, ma) {\n        if (ma === undefined) {\n            var elemE_1 = elem(E);\n            return function (ma) { return elemE_1(a, ma); };\n        }\n        return isNone(ma) ? false : E.equals(a, ma.value);\n    };\n}\n/**\n * Returns `true` if the predicate is satisfied by the wrapped value\n *\n * @example\n * import { some, none, exists } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 0)\n *   ),\n *   true\n * )\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 1)\n *   ),\n *   false\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     exists(n => n > 0)\n *   ),\n *   false\n * )\n *\n * @since 2.0.0\n */\nexport var exists = function (predicate) {\n    return function (ma) {\n        return isNone(ma) ? false : predicate(ma.value);\n    };\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/ of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/ bindTo_(Functor);\nvar let_ = /*#__PURE__*/ let__(Functor);\nexport { \n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/ chainable.bind(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/ apS_(Apply);\n/**\n * @since 2.11.0\n */\nexport var ApT = /*#__PURE__*/ of(_.emptyReadonlyArray);\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n    return function (as) {\n        var o = f(0, _.head(as));\n        if (isNone(o)) {\n            return none;\n        }\n        var out = [o.value];\n        for (var i = 1; i < as.length; i++) {\n            var o_1 = f(i, as[i]);\n            if (isNone(o_1)) {\n                return none;\n            }\n            out.push(o_1.value);\n        }\n        return some(out);\n    };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyArrayWithIndex = function (f) {\n    var g = traverseReadonlyNonEmptyArrayWithIndex(f);\n    return function (as) { return (_.isNonEmpty(as) ? g(as) : ApT); };\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) { return f(a); });\n};\n/**\n * Equivalent to `ReadonlyArray#sequence(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/ traverseArray(identity);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chainFirst = tap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `Refinement` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getRefinement(getOption) {\n    return function (a) { return isSome(getOption(a)); };\n}\n/**\n * Use [`chainNullableK`](#chainnullablek) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var mapNullable = chainNullableK;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `O.Functor` instead of `O.option`\n * (where `O` is from `import O from 'fp-ts/Option'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var option = {\n    URI: URI,\n    map: _map,\n    of: of,\n    ap: _ap,\n    chain: flatMap,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence,\n    zero: zero,\n    alt: _alt,\n    extend: _extend,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    wither: _wither,\n    wilt: _wilt,\n    throwError: throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplySemigroup = /*#__PURE__*/ getApplySemigroup_(Apply);\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplyMonoid = /*#__PURE__*/ getApplicativeMonoid(Applicative);\n/**\n * Use\n *\n * ```ts\n * import { first } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(first())\n * ```\n *\n * instead.\n *\n * Monoid returning the left-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(a)      |\n *\n * @example\n * import { getFirstMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getFirstMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFirstMonoid = function () { return getMonoid(first()); };\n/**\n * Use\n *\n * ```ts\n * import { last } from 'fp-ts/Semigroup'\n * import { getMonoid } from 'fp-ts/Option'\n *\n * getMonoid(last())\n * ```\n *\n * instead.\n *\n * Monoid returning the right-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(b) | some(b)      |\n * | some(a) | some(b) | some(b)      |\n *\n * @example\n * import { getLastMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getLastMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(2)), some(2))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getLastMonoid = function () { return getMonoid(last()); };\n"],"names":["_.none","_.some","as_","asUnit_","guard_","_.isSome","flap_","apFirst_","apSecond_","chainable.tap","tapEither_","fromEitherK_","chainEitherK_","ma","_.emptyRecord","bindTo_","let__","chainable.bind","apS_","_.emptyReadonlyArray","as","_.head","_.isNonEmpty","getApplySemigroup_"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/OptionT.cjs

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Apply = require("./Apply.cjs");
+const _function = require("./function.cjs");
+const Functor = require("./Functor.cjs");
+const Option = require("./Option.cjs");
+function some(F) {
+  return _function.flow(Option.some, F.of);
+}
+function zero(F) {
+  return _function.constant(F.of(Option.none));
+}
+function fromF(F) {
+  return function(ma) {
+    return F.map(ma, Option.some);
+  };
+}
+function fromNullable(F) {
+  return _function.flow(Option.fromNullable, F.of);
+}
+function fromNullableK(F) {
+  var fromNullableF = fromNullable(F);
+  return function(f) {
+    return _function.flow(f, fromNullableF);
+  };
+}
+function chainNullableK(M) {
+  var chainM = chain(M);
+  var fromNullableKM = fromNullableK(M);
+  return function(f) {
+    return chainM(fromNullableKM(f));
+  };
+}
+function fromOptionK(F) {
+  return function(f) {
+    return _function.flow(f, F.of);
+  };
+}
+function chainOptionK(M) {
+  var chainM = chain(M);
+  var fromOptionKM = fromOptionK(M);
+  return function(f) {
+    return chainM(fromOptionKM(f));
+  };
+}
+function fromPredicate(F) {
+  return function(predicate) {
+    return function(a) {
+      return F.of(Option.fromPredicate(predicate)(a));
+    };
+  };
+}
+function fromEither(F) {
+  return _function.flow(Option.fromEither, F.of);
+}
+function match(F) {
+  return function(onNone, onSome) {
+    return function(ma) {
+      return F.map(ma, Option.match(onNone, onSome));
+    };
+  };
+}
+function matchE(M) {
+  return function(onNone, onSome) {
+    return function(ma) {
+      return M.chain(ma, Option.match(onNone, onSome));
+    };
+  };
+}
+function getOrElse(M) {
+  return function(onNone) {
+    return function(fa) {
+      return M.chain(fa, Option.match(onNone, M.of));
+    };
+  };
+}
+function map(F) {
+  return Functor.map(F, Option.Functor);
+}
+function ap(F) {
+  return Apply.ap(F, Option.Apply);
+}
+function chain(M) {
+  var flatMapM = flatMap(M);
+  return function(f) {
+    return function(ma) {
+      return flatMapM(ma, f);
+    };
+  };
+}
+function flatMap(M) {
+  var zeroM = zero(M);
+  return function(ma, f) {
+    return M.chain(ma, Option.match(function() {
+      return zeroM();
+    }, f));
+  };
+}
+function alt(M) {
+  var _some = some(M);
+  return function(second) {
+    return function(first) {
+      return M.chain(first, Option.match(second, _some));
+    };
+  };
+}
+function getOptionM(M) {
+  var apM = ap(M);
+  var mapM = map(M);
+  var chainM = chain(M);
+  var altM = alt(M);
+  var foldM = matchE(M);
+  var getOrElseM = getOrElse(M);
+  var zeroM = zero(M);
+  return {
+    map: function(fa, f) {
+      return _function.pipe(fa, mapM(f));
+    },
+    ap: function(fab, fa) {
+      return _function.pipe(fab, apM(fa));
+    },
+    of: some(M),
+    chain: function(ma, f) {
+      return _function.pipe(ma, chainM(f));
+    },
+    alt: function(fa, that) {
+      return _function.pipe(fa, altM(that));
+    },
+    fold: function(fa, onNone, onSome) {
+      return _function.pipe(fa, foldM(onNone, onSome));
+    },
+    getOrElse: function(fa, onNone) {
+      return _function.pipe(fa, getOrElseM(onNone));
+    },
+    fromM: fromF(M),
+    none: function() {
+      return zeroM();
+    }
+  };
+}
+exports.alt = alt;
+exports.ap = ap;
+exports.chain = chain;
+exports.chainNullableK = chainNullableK;
+exports.chainOptionK = chainOptionK;
+exports.flatMap = flatMap;
+exports.fromEither = fromEither;
+exports.fromF = fromF;
+exports.fromNullable = fromNullable;
+exports.fromNullableK = fromNullableK;
+exports.fromOptionK = fromOptionK;
+exports.fromPredicate = fromPredicate;
+exports.getOptionM = getOptionM;
+exports.getOrElse = getOrElse;
+exports.map = map;
+exports.match = match;
+exports.matchE = matchE;
+exports.some = some;
+exports.zero = zero;
+//# sourceMappingURL=OptionT.cjs.map

package/dist/_node_modules/fp-ts/es6/OptionT.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionT.cjs","sources":["../../../../../../node_modules/fp-ts/es6/OptionT.js"],"sourcesContent":["import { ap as ap_ } from './Apply';\nimport { constant, flow, pipe } from './function';\nimport { map as map_ } from './Functor';\nimport * as O from './Option';\nexport function some(F) {\n    return flow(O.some, F.of);\n}\nexport function zero(F) {\n    return constant(F.of(O.none));\n}\nexport function fromF(F) {\n    return function (ma) { return F.map(ma, O.some); };\n}\nexport function fromNullable(F) {\n    return flow(O.fromNullable, F.of);\n}\nexport function fromNullableK(F) {\n    var fromNullableF = fromNullable(F);\n    return function (f) { return flow(f, fromNullableF); };\n}\nexport function chainNullableK(M) {\n    var chainM = chain(M);\n    var fromNullableKM = fromNullableK(M);\n    return function (f) { return chainM(fromNullableKM(f)); };\n}\nexport function fromOptionK(F) {\n    return function (f) { return flow(f, F.of); };\n}\nexport function chainOptionK(M) {\n    var chainM = chain(M);\n    var fromOptionKM = fromOptionK(M);\n    return function (f) { return chainM(fromOptionKM(f)); };\n}\nexport function fromPredicate(F) {\n    return function (predicate) {\n        return function (a) {\n            return F.of(O.fromPredicate(predicate)(a));\n        };\n    };\n}\nexport function fromEither(F) {\n    return flow(O.fromEither, F.of);\n}\nexport function match(F) {\n    return function (onNone, onSome) { return function (ma) { return F.map(ma, O.match(onNone, onSome)); }; };\n}\nexport function matchE(M) {\n    return function (onNone, onSome) { return function (ma) { return M.chain(ma, O.match(onNone, onSome)); }; };\n}\nexport function getOrElse(M) {\n    return function (onNone) { return function (fa) { return M.chain(fa, O.match(onNone, M.of)); }; };\n}\nexport function map(F) {\n    return map_(F, O.Functor);\n}\nexport function ap(F) {\n    return ap_(F, O.Apply);\n}\nexport function chain(M) {\n    var flatMapM = flatMap(M);\n    return function (f) { return function (ma) { return flatMapM(ma, f); }; };\n}\n/** @internal */\nexport function flatMap(M) {\n    var zeroM = zero(M);\n    return function (ma, f) {\n        return M.chain(ma, O.match(function () { return zeroM(); }, f));\n    };\n}\nexport function alt(M) {\n    var _some = some(M);\n    return function (second) { return function (first) { return M.chain(first, O.match(second, _some)); }; };\n}\n/** @deprecated */\nexport function getOptionM(M) {\n    var apM = ap(M);\n    var mapM = map(M);\n    var chainM = chain(M);\n    var altM = alt(M);\n    var foldM = matchE(M);\n    var getOrElseM = getOrElse(M);\n    var zeroM = zero(M);\n    return {\n        map: function (fa, f) { return pipe(fa, mapM(f)); },\n        ap: function (fab, fa) { return pipe(fab, apM(fa)); },\n        of: some(M),\n        chain: function (ma, f) { return pipe(ma, chainM(f)); },\n        alt: function (fa, that) { return pipe(fa, altM(that)); },\n        fold: function (fa, onNone, onSome) { return pipe(fa, foldM(onNone, onSome)); },\n        getOrElse: function (fa, onNone) { return pipe(fa, getOrElseM(onNone)); },\n        fromM: fromF(M),\n        none: function () { return zeroM(); }\n    };\n}\n"],"names":["flow","O.some","constant","O.none","O.fromNullable","O.fromPredicate","O.fromEither","O.match","map_","O.Functor","ap_","O.Apply","pipe"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/OptionT.js

@@ -0,0 +1,160 @@
+import { ap as ap$1 } from "./Apply.js";
+import { flow, constant, pipe } from "./function.js";
+import { map as map$1 } from "./Functor.js";
+import { some as some$1, none, fromNullable as fromNullable$1, fromPredicate as fromPredicate$1, fromEither as fromEither$1, match as match$1, Functor, Apply } from "./Option.js";
+function some(F) {
+  return flow(some$1, F.of);
+}
+function zero(F) {
+  return constant(F.of(none));
+}
+function fromF(F) {
+  return function(ma) {
+    return F.map(ma, some$1);
+  };
+}
+function fromNullable(F) {
+  return flow(fromNullable$1, F.of);
+}
+function fromNullableK(F) {
+  var fromNullableF = fromNullable(F);
+  return function(f) {
+    return flow(f, fromNullableF);
+  };
+}
+function chainNullableK(M) {
+  var chainM = chain(M);
+  var fromNullableKM = fromNullableK(M);
+  return function(f) {
+    return chainM(fromNullableKM(f));
+  };
+}
+function fromOptionK(F) {
+  return function(f) {
+    return flow(f, F.of);
+  };
+}
+function chainOptionK(M) {
+  var chainM = chain(M);
+  var fromOptionKM = fromOptionK(M);
+  return function(f) {
+    return chainM(fromOptionKM(f));
+  };
+}
+function fromPredicate(F) {
+  return function(predicate) {
+    return function(a) {
+      return F.of(fromPredicate$1(predicate)(a));
+    };
+  };
+}
+function fromEither(F) {
+  return flow(fromEither$1, F.of);
+}
+function match(F) {
+  return function(onNone, onSome) {
+    return function(ma) {
+      return F.map(ma, match$1(onNone, onSome));
+    };
+  };
+}
+function matchE(M) {
+  return function(onNone, onSome) {
+    return function(ma) {
+      return M.chain(ma, match$1(onNone, onSome));
+    };
+  };
+}
+function getOrElse(M) {
+  return function(onNone) {
+    return function(fa) {
+      return M.chain(fa, match$1(onNone, M.of));
+    };
+  };
+}
+function map(F) {
+  return map$1(F, Functor);
+}
+function ap(F) {
+  return ap$1(F, Apply);
+}
+function chain(M) {
+  var flatMapM = flatMap(M);
+  return function(f) {
+    return function(ma) {
+      return flatMapM(ma, f);
+    };
+  };
+}
+function flatMap(M) {
+  var zeroM = zero(M);
+  return function(ma, f) {
+    return M.chain(ma, match$1(function() {
+      return zeroM();
+    }, f));
+  };
+}
+function alt(M) {
+  var _some = some(M);
+  return function(second) {
+    return function(first) {
+      return M.chain(first, match$1(second, _some));
+    };
+  };
+}
+function getOptionM(M) {
+  var apM = ap(M);
+  var mapM = map(M);
+  var chainM = chain(M);
+  var altM = alt(M);
+  var foldM = matchE(M);
+  var getOrElseM = getOrElse(M);
+  var zeroM = zero(M);
+  return {
+    map: function(fa, f) {
+      return pipe(fa, mapM(f));
+    },
+    ap: function(fab, fa) {
+      return pipe(fab, apM(fa));
+    },
+    of: some(M),
+    chain: function(ma, f) {
+      return pipe(ma, chainM(f));
+    },
+    alt: function(fa, that) {
+      return pipe(fa, altM(that));
+    },
+    fold: function(fa, onNone, onSome) {
+      return pipe(fa, foldM(onNone, onSome));
+    },
+    getOrElse: function(fa, onNone) {
+      return pipe(fa, getOrElseM(onNone));
+    },
+    fromM: fromF(M),
+    none: function() {
+      return zeroM();
+    }
+  };
+}
+export {
+  alt,
+  ap,
+  chain,
+  chainNullableK,
+  chainOptionK,
+  flatMap,
+  fromEither,
+  fromF,
+  fromNullable,
+  fromNullableK,
+  fromOptionK,
+  fromPredicate,
+  getOptionM,
+  getOrElse,
+  map,
+  match,
+  matchE,
+  some,
+  zero
+};
+//# sourceMappingURL=OptionT.js.map

package/dist/_node_modules/fp-ts/es6/OptionT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionT.js","sources":["../../../../../../node_modules/fp-ts/es6/OptionT.js"],"sourcesContent":["import { ap as ap_ } from './Apply';\nimport { constant, flow, pipe } from './function';\nimport { map as map_ } from './Functor';\nimport * as O from './Option';\nexport function some(F) {\n    return flow(O.some, F.of);\n}\nexport function zero(F) {\n    return constant(F.of(O.none));\n}\nexport function fromF(F) {\n    return function (ma) { return F.map(ma, O.some); };\n}\nexport function fromNullable(F) {\n    return flow(O.fromNullable, F.of);\n}\nexport function fromNullableK(F) {\n    var fromNullableF = fromNullable(F);\n    return function (f) { return flow(f, fromNullableF); };\n}\nexport function chainNullableK(M) {\n    var chainM = chain(M);\n    var fromNullableKM = fromNullableK(M);\n    return function (f) { return chainM(fromNullableKM(f)); };\n}\nexport function fromOptionK(F) {\n    return function (f) { return flow(f, F.of); };\n}\nexport function chainOptionK(M) {\n    var chainM = chain(M);\n    var fromOptionKM = fromOptionK(M);\n    return function (f) { return chainM(fromOptionKM(f)); };\n}\nexport function fromPredicate(F) {\n    return function (predicate) {\n        return function (a) {\n            return F.of(O.fromPredicate(predicate)(a));\n        };\n    };\n}\nexport function fromEither(F) {\n    return flow(O.fromEither, F.of);\n}\nexport function match(F) {\n    return function (onNone, onSome) { return function (ma) { return F.map(ma, O.match(onNone, onSome)); }; };\n}\nexport function matchE(M) {\n    return function (onNone, onSome) { return function (ma) { return M.chain(ma, O.match(onNone, onSome)); }; };\n}\nexport function getOrElse(M) {\n    return function (onNone) { return function (fa) { return M.chain(fa, O.match(onNone, M.of)); }; };\n}\nexport function map(F) {\n    return map_(F, O.Functor);\n}\nexport function ap(F) {\n    return ap_(F, O.Apply);\n}\nexport function chain(M) {\n    var flatMapM = flatMap(M);\n    return function (f) { return function (ma) { return flatMapM(ma, f); }; };\n}\n/** @internal */\nexport function flatMap(M) {\n    var zeroM = zero(M);\n    return function (ma, f) {\n        return M.chain(ma, O.match(function () { return zeroM(); }, f));\n    };\n}\nexport function alt(M) {\n    var _some = some(M);\n    return function (second) { return function (first) { return M.chain(first, O.match(second, _some)); }; };\n}\n/** @deprecated */\nexport function getOptionM(M) {\n    var apM = ap(M);\n    var mapM = map(M);\n    var chainM = chain(M);\n    var altM = alt(M);\n    var foldM = matchE(M);\n    var getOrElseM = getOrElse(M);\n    var zeroM = zero(M);\n    return {\n        map: function (fa, f) { return pipe(fa, mapM(f)); },\n        ap: function (fab, fa) { return pipe(fab, apM(fa)); },\n        of: some(M),\n        chain: function (ma, f) { return pipe(ma, chainM(f)); },\n        alt: function (fa, that) { return pipe(fa, altM(that)); },\n        fold: function (fa, onNone, onSome) { return pipe(fa, foldM(onNone, onSome)); },\n        getOrElse: function (fa, onNone) { return pipe(fa, getOrElseM(onNone)); },\n        fromM: fromF(M),\n        none: function () { return zeroM(); }\n    };\n}\n"],"names":["O.some","O.none","O.fromNullable","O.fromPredicate","O.fromEither","O.match","map_","O.Functor","ap_","O.Apply"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/Ord.cjs

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Eq = require("./Eq.cjs");
+const _function = require("./function.cjs");
+var equalsDefault = function(compare2) {
+  return function(first, second) {
+    return first === second || compare2(first, second) === 0;
+  };
+};
+var fromCompare = function(compare2) {
+  return {
+    equals: equalsDefault(compare2),
+    compare: function(first, second) {
+      return first === second ? 0 : compare2(first, second);
+    }
+  };
+};
+var tuple = function() {
+  var ords = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    ords[_i] = arguments[_i];
+  }
+  return fromCompare(function(first, second) {
+    var i = 0;
+    for (; i < ords.length - 1; i++) {
+      var r = ords[i].compare(first[i], second[i]);
+      if (r !== 0) {
+        return r;
+      }
+    }
+    return ords[i].compare(first[i], second[i]);
+  });
+};
+var reverse = function(O) {
+  return fromCompare(function(first, second) {
+    return O.compare(second, first);
+  });
+};
+var contramap_ = function(fa, f) {
+  return _function.pipe(fa, contramap(f));
+};
+var contramap = function(f) {
+  return function(fa) {
+    return fromCompare(function(first, second) {
+      return fa.compare(f(first), f(second));
+    });
+  };
+};
+var URI = "Ord";
+var getSemigroup = function() {
+  return {
+    concat: function(first, second) {
+      return fromCompare(function(a, b) {
+        var ox = first.compare(a, b);
+        return ox !== 0 ? ox : second.compare(a, b);
+      });
+    }
+  };
+};
+var getMonoid = function() {
+  return {
+    concat: getSemigroup().concat,
+    empty: fromCompare(function() {
+      return 0;
+    })
+  };
+};
+var Contravariant = {
+  URI,
+  contramap: contramap_
+};
+var trivial = {
+  equals: _function.constTrue,
+  compare: /* @__PURE__ */ _function.constant(0)
+};
+var equals = function(O) {
+  return function(second) {
+    return function(first) {
+      return first === second || O.compare(first, second) === 0;
+    };
+  };
+};
+var lt = function(O) {
+  return function(first, second) {
+    return O.compare(first, second) === -1;
+  };
+};
+var gt = function(O) {
+  return function(first, second) {
+    return O.compare(first, second) === 1;
+  };
+};
+var leq = function(O) {
+  return function(first, second) {
+    return O.compare(first, second) !== 1;
+  };
+};
+var geq = function(O) {
+  return function(first, second) {
+    return O.compare(first, second) !== -1;
+  };
+};
+var min = function(O) {
+  return function(first, second) {
+    return first === second || O.compare(first, second) < 1 ? first : second;
+  };
+};
+var max = function(O) {
+  return function(first, second) {
+    return first === second || O.compare(first, second) > -1 ? first : second;
+  };
+};
+var clamp = function(O) {
+  var minO = min(O);
+  var maxO = max(O);
+  return function(low, hi) {
+    return function(a) {
+      return maxO(minO(a, hi), low);
+    };
+  };
+};
+var between = function(O) {
+  var ltO = lt(O);
+  var gtO = gt(O);
+  return function(low, hi) {
+    return function(a) {
+      return ltO(a, low) || gtO(a, hi) ? false : true;
+    };
+  };
+};
+var getTupleOrd = tuple;
+var getDualOrd = reverse;
+var ord = Contravariant;
+function compare(first, second) {
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+var strictOrd = {
+  equals: Eq.eqStrict.equals,
+  compare
+};
+var ordBoolean = strictOrd;
+var ordString = strictOrd;
+var ordNumber = strictOrd;
+var ordDate = /* @__PURE__ */ _function.pipe(
+  ordNumber,
+  /* @__PURE__ */ contramap(function(date) {
+    return date.valueOf();
+  })
+);
+exports.Contravariant = Contravariant;
+exports.URI = URI;
+exports.between = between;
+exports.clamp = clamp;
+exports.contramap = contramap;
+exports.equals = equals;
+exports.equalsDefault = equalsDefault;
+exports.fromCompare = fromCompare;
+exports.geq = geq;
+exports.getDualOrd = getDualOrd;
+exports.getMonoid = getMonoid;
+exports.getSemigroup = getSemigroup;
+exports.getTupleOrd = getTupleOrd;
+exports.gt = gt;
+exports.leq = leq;
+exports.lt = lt;
+exports.max = max;
+exports.min = min;
+exports.ord = ord;
+exports.ordBoolean = ordBoolean;
+exports.ordDate = ordDate;
+exports.ordNumber = ordNumber;
+exports.ordString = ordString;
+exports.reverse = reverse;
+exports.trivial = trivial;
+exports.tuple = tuple;
+//# sourceMappingURL=Ord.cjs.map

package/dist/_node_modules/fp-ts/es6/Ord.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ord.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Ord.js"],"sourcesContent":["import { eqStrict } from './Eq';\nimport { constant, constTrue, pipe } from './function';\n// -------------------------------------------------------------------------------------\n// defaults\n// -------------------------------------------------------------------------------------\n/**\n * @category defaults\n * @since 2.10.0\n */\nexport var equalsDefault = function (compare) {\n    return function (first, second) {\n        return first === second || compare(first, second) === 0;\n    };\n};\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromCompare = function (compare) { return ({\n    equals: equalsDefault(compare),\n    compare: function (first, second) { return (first === second ? 0 : compare(first, second)); }\n}); };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Given a tuple of `Ord`s returns an `Ord` for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Ord'\n * import * as B from 'fp-ts/boolean'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n *\n * const O = tuple(S.Ord, N.Ord, B.Ord)\n * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n    var ords = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        ords[_i] = arguments[_i];\n    }\n    return fromCompare(function (first, second) {\n        var i = 0;\n        for (; i < ords.length - 1; i++) {\n            var r = ords[i].compare(first[i], second[i]);\n            if (r !== 0) {\n                return r;\n            }\n        }\n        return ords[i].compare(first[i], second[i]);\n    });\n};\n/**\n * @since 2.10.0\n */\nexport var reverse = function (O) { return fromCompare(function (first, second) { return O.compare(second, first); }); };\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) { return pipe(fa, contramap(f)); };\n/**\n * A typical use case for `contramap` would be like, given some `User` type, to construct an `Ord<User>`.\n *\n * We can do so with a function from `User -> X` where `X` is some value that we know how to compare\n * for ordering (meaning we have an `Ord<X>`)\n *\n * For example, given the following `User` type, there are lots of possible choices for `X`,\n * but let's say we want to sort a list of users by `lastName`.\n *\n * If we have a way of comparing `lastName`s for ordering (`ordLastName: Ord<string>`) and we know how to go from `User -> string`,\n * using `contramap` we can do this\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import { contramap, Ord } from 'fp-ts/Ord'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as S from 'fp-ts/string'\n *\n * interface User {\n *   readonly firstName: string\n *   readonly lastName: string\n * }\n *\n * const ordLastName: Ord<string> = S.Ord\n *\n * const ordByLastName: Ord<User> = pipe(\n *   ordLastName,\n *   contramap((user) => user.lastName)\n * )\n *\n * assert.deepStrictEqual(\n *   RA.sort(ordByLastName)([\n *     { firstName: 'a', lastName: 'd' },\n *     { firstName: 'c', lastName: 'b' }\n *   ]),\n *   [\n *     { firstName: 'c', lastName: 'b' },\n *     { firstName: 'a', lastName: 'd' }\n *   ]\n * )\n *\n * @since 2.0.0\n */\nexport var contramap = function (f) { return function (fa) {\n    return fromCompare(function (first, second) { return fa.compare(f(first), f(second)); });\n}; };\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Ord';\n/**\n * A typical use case for the `Semigroup` instance of `Ord` is merging two or more orderings.\n *\n * For example the following snippet builds an `Ord` for a type `User` which\n * sorts by `created` date descending, and **then** `lastName`\n *\n * @example\n * import * as D from 'fp-ts/Date'\n * import { pipe } from 'fp-ts/function'\n * import { contramap, getSemigroup, Ord, reverse } from 'fp-ts/Ord'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as S from 'fp-ts/string'\n *\n * interface User {\n *   readonly id: string\n *   readonly lastName: string\n *   readonly created: Date\n * }\n *\n * const ordByLastName: Ord<User> = pipe(\n *   S.Ord,\n *   contramap((user) => user.lastName)\n * )\n *\n * const ordByCreated: Ord<User> = pipe(\n *   D.Ord,\n *   contramap((user) => user.created)\n * )\n *\n * const ordUserByCreatedDescThenLastName = getSemigroup<User>().concat(\n *   reverse(ordByCreated),\n *   ordByLastName\n * )\n *\n * assert.deepStrictEqual(\n *   RA.sort(ordUserByCreatedDescThenLastName)([\n *     { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) },\n *     { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },\n *     { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) }\n *   ]),\n *   [\n *     { id: 'e', lastName: 'f', created: new Date(1980, 10, 30) },\n *     { id: 'a', lastName: 'b', created: new Date(1973, 10, 30) },\n *     { id: 'c', lastName: 'd', created: new Date(1973, 10, 30) }\n *   ]\n * )\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = function () { return ({\n    concat: function (first, second) {\n        return fromCompare(function (a, b) {\n            var ox = first.compare(a, b);\n            return ox !== 0 ? ox : second.compare(a, b);\n        });\n    }\n}); };\n/**\n * Returns a `Monoid` such that:\n *\n * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`\n * - its `empty` value is an `Ord` that always considers compared elements equal\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import { contramap, reverse, getMonoid } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as B from 'fp-ts/boolean'\n * import { pipe } from 'fp-ts/function'\n * import { concatAll } from 'fp-ts/Monoid'\n * import * as N from 'fp-ts/number'\n *\n * interface User {\n *   readonly id: number\n *   readonly name: string\n *   readonly age: number\n *   readonly rememberMe: boolean\n * }\n *\n * const byName = pipe(\n *   S.Ord,\n *   contramap((p: User) => p.name)\n * )\n *\n * const byAge = pipe(\n *   N.Ord,\n *   contramap((p: User) => p.age)\n * )\n *\n * const byRememberMe = pipe(\n *   B.Ord,\n *   contramap((p: User) => p.rememberMe)\n * )\n *\n * const M = getMonoid<User>()\n *\n * const users: Array<User> = [\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }\n * ]\n *\n * // sort by name, then by age, then by `rememberMe`\n * const O1 = concatAll(M)([byName, byAge, byRememberMe])\n * assert.deepStrictEqual(sort(O1)(users), [\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * // now `rememberMe = true` first, then by name, then by age\n * const O2 = concatAll(M)([reverse(byRememberMe), byName, byAge])\n * assert.deepStrictEqual(sort(O2)(users), [\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * @category instances\n * @since 2.4.0\n */\nexport var getMonoid = function () { return ({\n    concat: getSemigroup().concat,\n    empty: fromCompare(function () { return 0; })\n}); };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Contravariant = {\n    URI: URI,\n    contramap: contramap_\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var trivial = {\n    equals: constTrue,\n    compare: /*#__PURE__*/ constant(0)\n};\n/**\n * @since 2.11.0\n */\nexport var equals = function (O) {\n    return function (second) {\n        return function (first) {\n            return first === second || O.compare(first, second) === 0;\n        };\n    };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly less than_ another\n *\n * @since 2.0.0\n */\nexport var lt = function (O) {\n    return function (first, second) {\n        return O.compare(first, second) === -1;\n    };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport var gt = function (O) {\n    return function (first, second) {\n        return O.compare(first, second) === 1;\n    };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly less than_ another\n *\n * @since 2.0.0\n */\nexport var leq = function (O) {\n    return function (first, second) {\n        return O.compare(first, second) !== 1;\n    };\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport var geq = function (O) {\n    return function (first, second) {\n        return O.compare(first, second) !== -1;\n    };\n};\n// TODO: curry in v3\n/**\n * Take the minimum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport var min = function (O) {\n    return function (first, second) {\n        return first === second || O.compare(first, second) < 1 ? first : second;\n    };\n};\n// TODO: curry in v3\n/**\n * Take the maximum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport var max = function (O) {\n    return function (first, second) {\n        return first === second || O.compare(first, second) > -1 ? first : second;\n    };\n};\n/**\n * Clamp a value between a minimum and a maximum\n *\n * @since 2.0.0\n */\nexport var clamp = function (O) {\n    var minO = min(O);\n    var maxO = max(O);\n    return function (low, hi) { return function (a) { return maxO(minO(a, hi), low); }; };\n};\n/**\n * Test whether a value is between a minimum and a maximum (inclusive)\n *\n * @since 2.0.0\n */\nexport var between = function (O) {\n    var ltO = lt(O);\n    var gtO = gt(O);\n    return function (low, hi) { return function (a) { return ltO(a, low) || gtO(a, hi) ? false : true; }; };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleOrd = tuple;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualOrd = reverse;\n/**\n * Use [`Contravariant`](#contravariant) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ord = Contravariant;\n// default compare for primitive types\nfunction compare(first, second) {\n    return first < second ? -1 : first > second ? 1 : 0;\n}\nvar strictOrd = {\n    equals: eqStrict.equals,\n    compare: compare\n};\n/**\n * Use [`Ord`](./boolean.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordBoolean = strictOrd;\n/**\n * Use [`Ord`](./string.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordString = strictOrd;\n/**\n * Use [`Ord`](./number.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordNumber = strictOrd;\n/**\n * Use [`Ord`](./Date.ts.html#ord) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ordDate = /*#__PURE__*/ pipe(ordNumber, \n/*#__PURE__*/\ncontramap(function (date) { return date.valueOf(); }));\n"],"names":["compare","pipe","constTrue","constant","eqStrict"],"mappings":"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","x_google_ignoreList":[0]}