@flarehr/apollo-benefits 0.1.109 → 0.3.53405

package/dist/lib/cjs/session.query-d61ba7ec.js

@@ -1,1731 +0,0 @@
-'use strict';
-
-const datoramaAkita = require('./datorama-akita-31d23240.js');
-
-// -------------------------------------------------------------------------------------
-// guards
-// -------------------------------------------------------------------------------------
-/**
- * Returns `true` if the option is an instance of `Some`, `false` otherwise.
- *
- * @example
- * import { some, none, isSome } from 'fp-ts/Option'
- *
- * assert.strictEqual(isSome(some(1)), true)
- * assert.strictEqual(isSome(none), false)
- *
- * @category guards
- * @since 2.0.0
- */
-var isSome = function (fa) { return fa._tag === 'Some'; };
-/**
- * Returns `true` if the option is `None`, `false` otherwise.
- *
- * @example
- * import { some, none, isNone } from 'fp-ts/Option'
- *
- * assert.strictEqual(isNone(some(1)), false)
- * assert.strictEqual(isNone(none), true)
- *
- * @category guards
- * @since 2.0.0
- */
-var isNone = function (fa) { return fa._tag === 'None'; };
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.
- *
- * @category constructors
- * @since 2.0.0
- */
-var none = { _tag: 'None' };
-/**
- * Constructs a `Some`. Represents an optional value that exists.
- *
- * @category constructors
- * @since 2.0.0
- */
-var some = function (a) { return ({ _tag: 'Some', value: a }); };
-/**
- * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise
- * returns the value wrapped in a `Some`.
- *
- * @example
- * import { none, some, fromNullable } from 'fp-ts/Option'
- *
- * assert.deepStrictEqual(fromNullable(undefined), none)
- * assert.deepStrictEqual(fromNullable(null), none)
- * assert.deepStrictEqual(fromNullable(1), some(1))
- *
- * @category constructors
- * @since 2.0.0
- */
-function fromNullable(a) {
-    return a == null ? none : some(a);
-}
-// -------------------------------------------------------------------------------------
-// destructors
-// -------------------------------------------------------------------------------------
-/**
- * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is
- * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.
- *
- * @example
- * import { some, none, fold } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     fold(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a some containing 1'
- * )
- *
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     fold(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a none'
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-function fold(onNone, onSome) {
-    return function (ma) { return (isNone(ma) ? onNone() : onSome(ma.value)); };
-}
-/**
- * Less strict version of [`getOrElse`](#getOrElse).
- *
- * @category destructors
- * @since 2.6.0
- */
-var getOrElseW = function (onNone) { return function (ma) { return (isNone(ma) ? onNone() : ma.value); }; };
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns the given default value
- *
- * @example
- * import { some, none, getOrElse } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     getOrElse(() => 0)
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     getOrElse(() => 0)
- *   ),
- *   0
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-var getOrElse = getOrElseW;
-
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-var _function = createCommonjsModule(function (module, exports) {
-/**
- * @since 2.0.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bindTo_ = exports.bind_ = exports.hole = exports.pipe = exports.untupled = exports.tupled = exports.absurd = exports.decrement = exports.increment = exports.tuple = exports.flow = exports.flip = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.constant = exports.not = exports.unsafeCoerce = exports.identity = void 0;
-/**
- * @since 2.0.0
- */
-function identity(a) {
-    return a;
-}
-exports.identity = identity;
-/**
- * @since 2.0.0
- */
-exports.unsafeCoerce = identity;
-/**
- * @since 2.0.0
- */
-function not(predicate) {
-    return function (a) { return !predicate(a); };
-}
-exports.not = not;
-/**
- * @since 2.0.0
- */
-function constant(a) {
-    return function () { return a; };
-}
-exports.constant = constant;
-/**
- * A thunk that returns always `true`.
- *
- * @since 2.0.0
- */
-exports.constTrue = 
-/*#__PURE__*/
-constant(true);
-/**
- * A thunk that returns always `false`.
- *
- * @since 2.0.0
- */
-exports.constFalse = 
-/*#__PURE__*/
-constant(false);
-/**
- * A thunk that returns always `null`.
- *
- * @since 2.0.0
- */
-exports.constNull = 
-/*#__PURE__*/
-constant(null);
-/**
- * A thunk that returns always `undefined`.
- *
- * @since 2.0.0
- */
-exports.constUndefined = 
-/*#__PURE__*/
-constant(undefined);
-/**
- * A thunk that returns always `void`.
- *
- * @since 2.0.0
- */
-exports.constVoid = exports.constUndefined;
-// TODO: remove in v3
-/**
- * Flips the order of the arguments of a function of two arguments.
- *
- * @since 2.0.0
- */
-function flip(f) {
-    return function (b, a) { return f(a, b); };
-}
-exports.flip = flip;
-function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
-    switch (arguments.length) {
-        case 1:
-            return ab;
-        case 2:
-            return function () {
-                return bc(ab.apply(this, arguments));
-            };
-        case 3:
-            return function () {
-                return cd(bc(ab.apply(this, arguments)));
-            };
-        case 4:
-            return function () {
-                return de(cd(bc(ab.apply(this, arguments))));
-            };
-        case 5:
-            return function () {
-                return ef(de(cd(bc(ab.apply(this, arguments)))));
-            };
-        case 6:
-            return function () {
-                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-            };
-        case 7:
-            return function () {
-                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-            };
-        case 8:
-            return function () {
-                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-            };
-        case 9:
-            return function () {
-                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-            };
-    }
-    return;
-}
-exports.flow = flow;
-/**
- * @since 2.0.0
- */
-function tuple() {
-    var t = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        t[_i] = arguments[_i];
-    }
-    return t;
-}
-exports.tuple = tuple;
-/**
- * @since 2.0.0
- */
-function increment(n) {
-    return n + 1;
-}
-exports.increment = increment;
-/**
- * @since 2.0.0
- */
-function decrement(n) {
-    return n - 1;
-}
-exports.decrement = decrement;
-/**
- * @since 2.0.0
- */
-function absurd(_) {
-    throw new Error('Called `absurd` function which should be uncallable');
-}
-exports.absurd = absurd;
-/**
- * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
- *
- * @example
- * import { tupled } from 'fp-ts/function'
- *
- * const add = tupled((x: number, y: number): number => x + y)
- *
- * assert.strictEqual(add([1, 2]), 3)
- *
- * @since 2.4.0
- */
-function tupled(f) {
-    return function (a) { return f.apply(void 0, a); };
-}
-exports.tupled = tupled;
-/**
- * Inverse function of `tupled`
- *
- * @since 2.4.0
- */
-function untupled(f) {
-    return function () {
-        var a = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            a[_i] = arguments[_i];
-        }
-        return f(a);
-    };
-}
-exports.untupled = untupled;
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st) {
-    switch (arguments.length) {
-        case 1:
-            return a;
-        case 2:
-            return ab(a);
-        case 3:
-            return bc(ab(a));
-        case 4:
-            return cd(bc(ab(a)));
-        case 5:
-            return de(cd(bc(ab(a))));
-        case 6:
-            return ef(de(cd(bc(ab(a)))));
-        case 7:
-            return fg(ef(de(cd(bc(ab(a))))));
-        case 8:
-            return gh(fg(ef(de(cd(bc(ab(a)))))));
-        case 9:
-            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-        case 10:
-            return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
-        case 11:
-            return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
-        case 12:
-            return kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))));
-        case 13:
-            return lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))));
-        case 14:
-            return mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))));
-        case 15:
-            return no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))));
-        case 16:
-            return op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))));
-        case 17:
-            return pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))));
-        case 18:
-            return qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))));
-        case 19:
-            return rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))))));
-        case 20:
-            return st(rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))))));
-    }
-    return;
-}
-exports.pipe = pipe;
-/**
- * Type hole simulation
- *
- * @since 2.7.0
- */
-exports.hole = absurd;
-/**
- * @internal
- */
-var bind_ = function (a, name, b) {
-    var _a;
-    return Object.assign({}, a, (_a = {}, _a[name] = b, _a));
-};
-exports.bind_ = bind_;
-/**
- * @internal
- */
-var bindTo_ = function (name) { return function (b) {
-    var _a;
-    return (_a = {}, _a[name] = b, _a);
-}; };
-exports.bindTo_ = bindTo_;
-});
-
-var Option = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApplySemigroup = exports.getOrd = exports.getEq = exports.getShow = exports.URI = exports.wilt = exports.wither = exports.sequence = exports.traverse = exports.partitionMap = exports.partition = exports.filterMap = exports.filter = exports.separate = exports.compact = exports.reduceRight = exports.foldMap = exports.reduce = exports.duplicate = exports.extend = exports.throwError = exports.zero = exports.alt = exports.altW = exports.flatten = exports.chainFirst = exports.chain = exports.of = exports.apSecond = exports.apFirst = exports.ap = exports.map = exports.chainNullableK = exports.mapNullable = exports.fromNullableK = exports.getOrElse = exports.getOrElseW = exports.toUndefined = exports.toNullable = exports.fold = exports.fromEither = exports.getRight = exports.getLeft = exports.tryCatch = exports.fromPredicate = exports.fromNullable = exports.some = exports.none = exports.isNone = exports.isSome = void 0;
-exports.sequenceArray = exports.traverseArray = exports.traverseArrayWithIndex = exports.apS = exports.bind = exports.bindTo = exports.Do = exports.getRefinement = exports.exists = exports.elem = exports.option = exports.MonadThrow = exports.Witherable = exports.Traversable = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.Alt = exports.Foldable = exports.Monad = exports.Applicative = exports.Functor = exports.getMonoid = exports.getLastMonoid = exports.getFirstMonoid = exports.getApplyMonoid = void 0;
-
-// -------------------------------------------------------------------------------------
-// guards
-// -------------------------------------------------------------------------------------
-/**
- * Returns `true` if the option is an instance of `Some`, `false` otherwise.
- *
- * @example
- * import { some, none, isSome } from 'fp-ts/Option'
- *
- * assert.strictEqual(isSome(some(1)), true)
- * assert.strictEqual(isSome(none), false)
- *
- * @category guards
- * @since 2.0.0
- */
-var isSome = function (fa) { return fa._tag === 'Some'; };
-exports.isSome = isSome;
-/**
- * Returns `true` if the option is `None`, `false` otherwise.
- *
- * @example
- * import { some, none, isNone } from 'fp-ts/Option'
- *
- * assert.strictEqual(isNone(some(1)), false)
- * assert.strictEqual(isNone(none), true)
- *
- * @category guards
- * @since 2.0.0
- */
-var isNone = function (fa) { return fa._tag === 'None'; };
-exports.isNone = isNone;
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-/**
- * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.
- *
- * @category constructors
- * @since 2.0.0
- */
-exports.none = { _tag: 'None' };
-/**
- * Constructs a `Some`. Represents an optional value that exists.
- *
- * @category constructors
- * @since 2.0.0
- */
-var some = function (a) { return ({ _tag: 'Some', value: a }); };
-exports.some = some;
-/**
- * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise
- * returns the value wrapped in a `Some`.
- *
- * @example
- * import { none, some, fromNullable } from 'fp-ts/Option'
- *
- * assert.deepStrictEqual(fromNullable(undefined), none)
- * assert.deepStrictEqual(fromNullable(null), none)
- * assert.deepStrictEqual(fromNullable(1), some(1))
- *
- * @category constructors
- * @since 2.0.0
- */
-function fromNullable(a) {
-    return a == null ? exports.none : exports.some(a);
-}
-exports.fromNullable = fromNullable;
-function fromPredicate(predicate) {
-    return function (a) { return (predicate(a) ? exports.some(a) : exports.none); };
-}
-exports.fromPredicate = fromPredicate;
-/**
- * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a
- * `Some`.
- *
- * @example
- * import { none, some, tryCatch } from 'fp-ts/Option'
- *
- * assert.deepStrictEqual(
- *   tryCatch(() => {
- *     throw new Error()
- *   }),
- *   none
- * )
- * assert.deepStrictEqual(tryCatch(() => 1), some(1))
- *
- * @category constructors
- * @since 2.0.0
- */
-function tryCatch(f) {
-    try {
-        return exports.some(f());
-    }
-    catch (e) {
-        return exports.none;
-    }
-}
-exports.tryCatch = tryCatch;
-/**
- * Returns the `Left` value of an `Either` if possible.
- *
- * @example
- * import { getLeft, none, some } from 'fp-ts/Option'
- * import { right, left } from 'fp-ts/Either'
- *
- * assert.deepStrictEqual(getLeft(right(1)), none)
- * assert.deepStrictEqual(getLeft(left('a')), some('a'))
- *
- * @category constructors
- * @since 2.0.0
- */
-function getLeft(ma) {
-    return ma._tag === 'Right' ? exports.none : exports.some(ma.left);
-}
-exports.getLeft = getLeft;
-/**
- * Returns the `Right` value of an `Either` if possible.
- *
- * @example
- * import { getRight, none, some } from 'fp-ts/Option'
- * import { right, left } from 'fp-ts/Either'
- *
- * assert.deepStrictEqual(getRight(right(1)), some(1))
- * assert.deepStrictEqual(getRight(left('a')), none)
- *
- * @category constructors
- * @since 2.0.0
- */
-function getRight(ma) {
-    return ma._tag === 'Left' ? exports.none : exports.some(ma.right);
-}
-exports.getRight = getRight;
-/**
- * Transforms an `Either` to an `Option` discarding the error.
- *
- * Alias of [getRight](#getRight)
- *
- * Derivable from `MonadThrow`.
- *
- * @category constructors
- * @since 2.0.0
- */
-exports.fromEither = getRight;
-// -------------------------------------------------------------------------------------
-// destructors
-// -------------------------------------------------------------------------------------
-/**
- * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is
- * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.
- *
- * @example
- * import { some, none, fold } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     fold(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a some containing 1'
- * )
- *
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     fold(() => 'a none', a => `a some containing ${a}`)
- *   ),
- *   'a none'
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-function fold(onNone, onSome) {
-    return function (ma) { return (exports.isNone(ma) ? onNone() : onSome(ma.value)); };
-}
-exports.fold = fold;
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns `null`.
- *
- * @example
- * import { some, none, toNullable } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     toNullable
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     toNullable
- *   ),
- *   null
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-function toNullable(ma) {
-    return exports.isNone(ma) ? null : ma.value;
-}
-exports.toNullable = toNullable;
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.
- *
- * @example
- * import { some, none, toUndefined } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     toUndefined
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     toUndefined
- *   ),
- *   undefined
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-function toUndefined(ma) {
-    return exports.isNone(ma) ? undefined : ma.value;
-}
-exports.toUndefined = toUndefined;
-/**
- * Less strict version of [`getOrElse`](#getOrElse).
- *
- * @category destructors
- * @since 2.6.0
- */
-var getOrElseW = function (onNone) { return function (ma) { return (exports.isNone(ma) ? onNone() : ma.value); }; };
-exports.getOrElseW = getOrElseW;
-/**
- * Extracts the value out of the structure, if it exists. Otherwise returns the given default value
- *
- * @example
- * import { some, none, getOrElse } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     getOrElse(() => 0)
- *   ),
- *   1
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     getOrElse(() => 0)
- *   ),
- *   0
- * )
- *
- * @category destructors
- * @since 2.0.0
- */
-exports.getOrElse = exports.getOrElseW;
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-/**
- * Returns a *smart constructor* from a function that returns a nullable value.
- *
- * @example
- * import { fromNullableK, none, some } from 'fp-ts/Option'
- *
- * const f = (s: string): number | undefined => {
- *   const n = parseFloat(s)
- *   return isNaN(n) ? undefined : n
- * }
- *
- * const g = fromNullableK(f)
- *
- * assert.deepStrictEqual(g('1'), some(1))
- * assert.deepStrictEqual(g('a'), none)
- *
- * @category combinators
- * @since 2.9.0
- */
-function fromNullableK(f) {
-    return function () {
-        var a = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            a[_i] = arguments[_i];
-        }
-        return fromNullable(f.apply(void 0, a));
-    };
-}
-exports.fromNullableK = fromNullableK;
-/**
- * @category combinators
- * @since 2.0.0
- * @deprecated
- */
-exports.mapNullable = chainNullableK;
-/**
- * This is `chain` + `fromNullable`, useful when working with optional values.
- *
- * @example
- * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * interface Employee {
- *   company?: {
- *     address?: {
- *       street?: {
- *         name?: string
- *       }
- *     }
- *   }
- * }
- *
- * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     fromNullable(employee1.company),
- *     chainNullableK(company => company.address),
- *     chainNullableK(address => address.street),
- *     chainNullableK(street => street.name)
- *   ),
- *   some('high street')
- * )
- *
- * const employee2: Employee = { company: { address: { street: {} } } }
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     fromNullable(employee2.company),
- *     chainNullableK(company => company.address),
- *     chainNullableK(address => address.street),
- *     chainNullableK(street => street.name)
- *   ),
- *   none
- * )
- *
- * @category combinators
- * @since 2.9.0
- */
-function chainNullableK(f) {
-    return function (ma) { return (exports.isNone(ma) ? exports.none : fromNullable(f(ma.value))); };
-}
-exports.chainNullableK = chainNullableK;
-// -------------------------------------------------------------------------------------
-// non-pipeables
-// -------------------------------------------------------------------------------------
-var map_ = function (fa, f) { return _function.pipe(fa, exports.map(f)); };
-var ap_ = function (fab, fa) { return _function.pipe(fab, exports.ap(fa)); };
-var chain_ = function (ma, f) { return _function.pipe(ma, exports.chain(f)); };
-var reduce_ = function (fa, b, f) { return _function.pipe(fa, exports.reduce(b, f)); };
-var foldMap_ = function (M) {
-    var foldMapM = exports.foldMap(M);
-    return function (fa, f) { return _function.pipe(fa, foldMapM(f)); };
-};
-var reduceRight_ = function (fa, b, f) { return _function.pipe(fa, exports.reduceRight(b, f)); };
-var traverse_ = function (F) {
-    var traverseF = exports.traverse(F);
-    return function (ta, f) { return _function.pipe(ta, traverseF(f)); };
-};
-/* istanbul ignore next */
-var alt_ = function (fa, that) { return _function.pipe(fa, exports.alt(that)); };
-var filter_ = function (fa, predicate) {
-    return _function.pipe(fa, exports.filter(predicate));
-};
-/* istanbul ignore next */
-var filterMap_ = function (fa, f) { return _function.pipe(fa, exports.filterMap(f)); };
-/* istanbul ignore next */
-var extend_ = function (wa, f) { return _function.pipe(wa, exports.extend(f)); };
-/* istanbul ignore next */
-var partition_ = function (fa, predicate) { return _function.pipe(fa, exports.partition(predicate)); };
-/* istanbul ignore next */
-var partitionMap_ = function (fa, f) { return _function.pipe(fa, exports.partitionMap(f)); };
-/* istanbul ignore next */
-var wither_ = function (F) {
-    var witherF = exports.wither(F);
-    return function (fa, f) { return _function.pipe(fa, witherF(f)); };
-};
-/* istanbul ignore next */
-var wilt_ = function (F) {
-    var wiltF = exports.wilt(F);
-    return function (fa, f) { return _function.pipe(fa, wiltF(f)); };
-};
-// -------------------------------------------------------------------------------------
-// pipeables
-// -------------------------------------------------------------------------------------
-/**
- * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
- * use the type constructor `F` to represent some computational context.
- *
- * @category Functor
- * @since 2.0.0
- */
-var map = function (f) { return function (fa) {
-    return exports.isNone(fa) ? exports.none : exports.some(f(fa.value));
-}; };
-exports.map = map;
-/**
- * Apply a function to an argument under a type constructor.
- *
- * @category Apply
- * @since 2.0.0
- */
-var ap = function (fa) { return function (fab) {
-    return exports.isNone(fab) ? exports.none : exports.isNone(fa) ? exports.none : exports.some(fab.value(fa.value));
-}; };
-exports.ap = ap;
-/**
- * Combine two effectful actions, keeping only the result of the first.
- *
- * Derivable from `Apply`.
- *
- * @category combinators
- * @since 2.0.0
- */
-var apFirst = function (fb) {
-    return _function.flow(exports.map(function (a) { return function () { return a; }; }), exports.ap(fb));
-};
-exports.apFirst = apFirst;
-/**
- * Combine two effectful actions, keeping only the result of the second.
- *
- * Derivable from `Apply`.
- *
- * @category combinators
- * @since 2.0.0
- */
-var apSecond = function (fb) {
-    return _function.flow(exports.map(function () { return function (b) { return b; }; }), exports.ap(fb));
-};
-exports.apSecond = apSecond;
-/**
- * Wrap a value into the type constructor.
- *
- * @category Applicative
- * @since 2.7.0
- */
-exports.of = exports.some;
-/**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
- *
- * @category Monad
- * @since 2.0.0
- */
-var chain = function (f) { return function (ma) {
-    return exports.isNone(ma) ? exports.none : f(ma.value);
-}; };
-exports.chain = chain;
-/**
- * Composes computations in sequence, using the return value of one computation to determine the next computation and
- * keeping only the result of the first.
- *
- * Derivable from `Monad`.
- *
- * @category combinators
- * @since 2.0.0
- */
-var chainFirst = function (f) {
-    return exports.chain(function (a) {
-        return _function.pipe(f(a), exports.map(function () { return a; }));
-    });
-};
-exports.chainFirst = chainFirst;
-/**
- * Derivable from `Monad`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.flatten = 
-/*#__PURE__*/
-exports.chain(_function.identity);
-/**
- * Less strict version of [`alt`](#alt).
- *
- * @category Alt
- * @since 2.9.0
- */
-var altW = function (that) { return function (fa) {
-    return exports.isNone(fa) ? that() : fa;
-}; };
-exports.altW = altW;
-/**
- * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to
- * types of kind `* -> *`.
- *
- * In case of `Option` returns the left-most non-`None` value.
- *
- * @example
- * import * as O from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     O.some('a'),
- *     O.alt(() => O.some('b'))
- *   ),
- *   O.some('a')
- * )
- * assert.deepStrictEqual(
- *   pipe(
- *     O.none,
- *     O.alt(() => O.some('b'))
- *   ),
- *   O.some('b')
- * )
- *
- * @category Alt
- * @since 2.0.0
- */
-exports.alt = exports.altW;
-/**
- * @category Alternative
- * @since 2.7.0
- */
-var zero = function () { return exports.none; };
-exports.zero = zero;
-/**
- * @category MonadThrow
- * @since 2.7.0
- */
-var throwError = function () { return exports.none; };
-exports.throwError = throwError;
-/**
- * @category Extend
- * @since 2.0.0
- */
-var extend = function (f) { return function (wa) {
-    return exports.isNone(wa) ? exports.none : exports.some(f(wa));
-}; };
-exports.extend = extend;
-/**
- * Derivable from `Extend`.
- *
- * @category combinators
- * @since 2.0.0
- */
-exports.duplicate = 
-/*#__PURE__*/
-exports.extend(_function.identity);
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var reduce = function (b, f) { return function (fa) {
-    return exports.isNone(fa) ? b : f(b, fa.value);
-}; };
-exports.reduce = reduce;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var foldMap = function (M) { return function (f) { return function (fa) {
-    return exports.isNone(fa) ? M.empty : f(fa.value);
-}; }; };
-exports.foldMap = foldMap;
-/**
- * @category Foldable
- * @since 2.0.0
- */
-var reduceRight = function (b, f) { return function (fa) {
-    return exports.isNone(fa) ? b : f(fa.value, b);
-}; };
-exports.reduceRight = reduceRight;
-/**
- * @category Compactable
- * @since 2.0.0
- */
-exports.compact = exports.flatten;
-var defaultSeparate = { left: exports.none, right: exports.none };
-/**
- * @category Compactable
- * @since 2.0.0
- */
-var separate = function (ma) {
-    var o = _function.pipe(ma, exports.map(function (e) { return ({
-        left: getLeft(e),
-        right: getRight(e)
-    }); }));
-    return exports.isNone(o) ? defaultSeparate : o.value;
-};
-exports.separate = separate;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var filter = function (predicate) { return function (fa) { return (exports.isNone(fa) ? exports.none : predicate(fa.value) ? fa : exports.none); }; };
-exports.filter = filter;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var filterMap = function (f) { return function (fa) {
-    return exports.isNone(fa) ? exports.none : f(fa.value);
-}; };
-exports.filterMap = filterMap;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var partition = function (predicate) { return function (fa) {
-    return {
-        left: filter_(fa, function (a) { return !predicate(a); }),
-        right: filter_(fa, predicate)
-    };
-}; };
-exports.partition = partition;
-/**
- * @category Filterable
- * @since 2.0.0
- */
-var partitionMap = function (f) { return _function.flow(exports.map(f), exports.separate); };
-exports.partitionMap = partitionMap;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var traverse = function (F) { return function (f) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(f(ta.value), exports.some)); }; }; };
-exports.traverse = traverse;
-/**
- * @category Traversable
- * @since 2.6.3
- */
-var sequence = function (F) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(ta.value, exports.some)); }; };
-exports.sequence = sequence;
-/**
- * @category Witherable
- * @since 2.6.5
- */
-var wither = function (F) { return function (f) { return function (fa) { return (exports.isNone(fa) ? F.of(exports.none) : f(fa.value)); }; }; };
-exports.wither = wither;
-/**
- * @category Witherable
- * @since 2.6.5
- */
-var wilt = function (F) { return function (f) { return function (fa) {
-    return exports.isNone(fa)
-        ? F.of({
-            left: exports.none,
-            right: exports.none
-        })
-        : F.map(f(fa.value), function (e) { return ({
-            left: getLeft(e),
-            right: getRight(e)
-        }); });
-}; }; };
-exports.wilt = wilt;
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.URI = 'Option';
-/**
- * @category instances
- * @since 2.0.0
- */
-function getShow(S) {
-    return {
-        show: function (ma) { return (exports.isNone(ma) ? 'none' : "some(" + S.show(ma.value) + ")"); }
-    };
-}
-exports.getShow = getShow;
-/**
- * @example
- * import { none, some, getEq } from 'fp-ts/Option'
- * import { eqNumber } from 'fp-ts/Eq'
- *
- * const E = getEq(eqNumber)
- * assert.strictEqual(E.equals(none, none), true)
- * assert.strictEqual(E.equals(none, some(1)), false)
- * assert.strictEqual(E.equals(some(1), none), false)
- * assert.strictEqual(E.equals(some(1), some(2)), false)
- * assert.strictEqual(E.equals(some(1), some(1)), true)
- *
- * @category instances
- * @since 2.0.0
- */
-function getEq(E) {
-    return {
-        equals: function (x, y) { return x === y || (exports.isNone(x) ? exports.isNone(y) : exports.isNone(y) ? false : E.equals(x.value, y.value)); }
-    };
-}
-exports.getEq = getEq;
-/**
- * The `Ord` instance allows `Option` values to be compared with
- * `compare`, whenever there is an `Ord` instance for
- * the type the `Option` contains.
- *
- * `None` is considered to be less than any `Some` value.
- *
- *
- * @example
- * import { none, some, getOrd } from 'fp-ts/Option'
- * import { ordNumber } from 'fp-ts/Ord'
- *
- * const O = getOrd(ordNumber)
- * assert.strictEqual(O.compare(none, none), 0)
- * assert.strictEqual(O.compare(none, some(1)), -1)
- * assert.strictEqual(O.compare(some(1), none), 1)
- * assert.strictEqual(O.compare(some(1), some(2)), -1)
- * assert.strictEqual(O.compare(some(1), some(1)), 0)
- *
- * @category instances
- * @since 2.0.0
- */
-function getOrd(O) {
-    return {
-        equals: getEq(O).equals,
-        compare: function (x, y) { return (x === y ? 0 : exports.isSome(x) ? (exports.isSome(y) ? O.compare(x.value, y.value) : 1) : -1); }
-    };
-}
-exports.getOrd = getOrd;
-/**
- * `Apply` semigroup
- *
- * | x       | y       | concat(x, y)       |
- * | ------- | ------- | ------------------ |
- * | none    | none    | none               |
- * | some(a) | none    | none               |
- * | none    | some(a) | none               |
- * | some(a) | some(b) | some(concat(a, b)) |
- *
- * @example
- * import { getApplySemigroup, some, none } from 'fp-ts/Option'
- * import { semigroupSum } from 'fp-ts/Semigroup'
- *
- * const S = getApplySemigroup(semigroupSum)
- * assert.deepStrictEqual(S.concat(none, none), none)
- * assert.deepStrictEqual(S.concat(some(1), none), none)
- * assert.deepStrictEqual(S.concat(none, some(1)), none)
- * assert.deepStrictEqual(S.concat(some(1), some(2)), some(3))
- *
- * @category instances
- * @since 2.0.0
- */
-function getApplySemigroup(S) {
-    return {
-        concat: function (x, y) { return (exports.isSome(x) && exports.isSome(y) ? exports.some(S.concat(x.value, y.value)) : exports.none); }
-    };
-}
-exports.getApplySemigroup = getApplySemigroup;
-/**
- * @category instances
- * @since 2.0.0
- */
-function getApplyMonoid(M) {
-    return {
-        concat: getApplySemigroup(M).concat,
-        empty: exports.some(M.empty)
-    };
-}
-exports.getApplyMonoid = getApplyMonoid;
-/**
- * Monoid returning the left-most non-`None` value
- *
- * | x       | y       | concat(x, y) |
- * | ------- | ------- | ------------ |
- * | none    | none    | none         |
- * | some(a) | none    | some(a)      |
- * | none    | some(a) | some(a)      |
- * | some(a) | some(b) | some(a)      |
- *
- * @example
- * import { getFirstMonoid, some, none } from 'fp-ts/Option'
- *
- * const M = getFirstMonoid<number>()
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))
- *
- * @category instances
- * @since 2.0.0
- */
-function getFirstMonoid() {
-    return {
-        concat: function (x, y) { return (exports.isNone(x) ? y : x); },
-        empty: exports.none
-    };
-}
-exports.getFirstMonoid = getFirstMonoid;
-/**
- * Monoid returning the right-most non-`None` value
- *
- * | x       | y       | concat(x, y) |
- * | ------- | ------- | ------------ |
- * | none    | none    | none         |
- * | some(a) | none    | some(a)      |
- * | none    | some(a) | some(a)      |
- * | some(a) | some(b) | some(b)      |
- *
- * @example
- * import { getLastMonoid, some, none } from 'fp-ts/Option'
- *
- * const M = getLastMonoid<number>()
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))
- *
- * @category instances
- * @since 2.0.0
- */
-function getLastMonoid() {
-    return {
-        concat: function (x, y) { return (exports.isNone(y) ? x : y); },
-        empty: exports.none
-    };
-}
-exports.getLastMonoid = getLastMonoid;
-/**
- * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are
- * concatenated using the provided `Semigroup`
- *
- * | x       | y       | concat(x, y)       |
- * | ------- | ------- | ------------------ |
- * | none    | none    | none               |
- * | some(a) | none    | some(a)            |
- * | none    | some(a) | some(a)            |
- * | some(a) | some(b) | some(concat(a, b)) |
- *
- * @example
- * import { getMonoid, some, none } from 'fp-ts/Option'
- * import { semigroupSum } from 'fp-ts/Semigroup'
- *
- * const M = getMonoid(semigroupSum)
- * assert.deepStrictEqual(M.concat(none, none), none)
- * assert.deepStrictEqual(M.concat(some(1), none), some(1))
- * assert.deepStrictEqual(M.concat(none, some(1)), some(1))
- * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))
- *
- * @category instances
- * @since 2.0.0
- */
-function getMonoid(S) {
-    return {
-        concat: function (x, y) { return (exports.isNone(x) ? y : exports.isNone(y) ? x : exports.some(S.concat(x.value, y.value))); },
-        empty: exports.none
-    };
-}
-exports.getMonoid = getMonoid;
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Functor = {
-    URI: exports.URI,
-    map: map_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Applicative = {
-    URI: exports.URI,
-    map: map_,
-    ap: ap_,
-    of: exports.of
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Monad = {
-    URI: exports.URI,
-    map: map_,
-    ap: ap_,
-    of: exports.of,
-    chain: chain_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Foldable = {
-    URI: exports.URI,
-    reduce: reduce_,
-    foldMap: foldMap_,
-    reduceRight: reduceRight_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alt = {
-    URI: exports.URI,
-    map: map_,
-    alt: alt_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Alternative = {
-    URI: exports.URI,
-    map: map_,
-    ap: ap_,
-    of: exports.of,
-    alt: alt_,
-    zero: exports.zero
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Extend = {
-    URI: exports.URI,
-    map: map_,
-    extend: extend_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Compactable = {
-    URI: exports.URI,
-    compact: exports.compact,
-    separate: exports.separate
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Filterable = {
-    URI: exports.URI,
-    map: map_,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: filter_,
-    filterMap: filterMap_,
-    partition: partition_,
-    partitionMap: partitionMap_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Traversable = {
-    URI: exports.URI,
-    map: map_,
-    reduce: reduce_,
-    foldMap: foldMap_,
-    reduceRight: reduceRight_,
-    traverse: traverse_,
-    sequence: exports.sequence
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.Witherable = {
-    URI: exports.URI,
-    map: map_,
-    reduce: reduce_,
-    foldMap: foldMap_,
-    reduceRight: reduceRight_,
-    traverse: traverse_,
-    sequence: exports.sequence,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: filter_,
-    filterMap: filterMap_,
-    partition: partition_,
-    partitionMap: partitionMap_,
-    wither: wither_,
-    wilt: wilt_
-};
-/**
- * @category instances
- * @since 2.7.0
- */
-exports.MonadThrow = {
-    URI: exports.URI,
-    map: map_,
-    ap: ap_,
-    of: exports.of,
-    chain: chain_,
-    throwError: exports.throwError
-};
-// TODO: remove in v3
-/**
- * @category instances
- * @since 2.0.0
- */
-exports.option = {
-    URI: exports.URI,
-    map: map_,
-    of: exports.of,
-    ap: ap_,
-    chain: chain_,
-    reduce: reduce_,
-    foldMap: foldMap_,
-    reduceRight: reduceRight_,
-    traverse: traverse_,
-    sequence: exports.sequence,
-    zero: exports.zero,
-    alt: alt_,
-    extend: extend_,
-    compact: exports.compact,
-    separate: exports.separate,
-    filter: filter_,
-    filterMap: filterMap_,
-    partition: partition_,
-    partitionMap: partitionMap_,
-    wither: wither_,
-    wilt: wilt_,
-    throwError: exports.throwError
-};
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-/**
- * Returns `true` if `ma` contains `a`
- *
- * @example
- * import { some, none, elem } from 'fp-ts/Option'
- * import { eqNumber } from 'fp-ts/Eq'
- *
- * assert.strictEqual(elem(eqNumber)(1, some(1)), true)
- * assert.strictEqual(elem(eqNumber)(2, some(1)), false)
- * assert.strictEqual(elem(eqNumber)(1, none), false)
- *
- * @since 2.0.0
- */
-function elem(E) {
-    return function (a, ma) { return (exports.isNone(ma) ? false : E.equals(a, ma.value)); };
-}
-exports.elem = elem;
-/**
- * Returns `true` if the predicate is satisfied by the wrapped value
- *
- * @example
- * import { some, none, exists } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 0)
- *   ),
- *   true
- * )
- * assert.strictEqual(
- *   pipe(
- *     some(1),
- *     exists(n => n > 1)
- *   ),
- *   false
- * )
- * assert.strictEqual(
- *   pipe(
- *     none,
- *     exists(n => n > 0)
- *   ),
- *   false
- * )
- *
- * @since 2.0.0
- */
-function exists(predicate) {
-    return function (ma) { return (exports.isNone(ma) ? false : predicate(ma.value)); };
-}
-exports.exists = exists;
-/**
- * Returns a `Refinement` (i.e. a custom type guard) from a `Option` returning function.
- * This function ensures that a custom type guard definition is type-safe.
- *
- * ```ts
- * import { some, none, getRefinement } from 'fp-ts/Option'
- *
- * type A = { type: 'A' }
- * type B = { type: 'B' }
- * type C = A | B
- *
- * const isA = (c: C): c is A => c.type === 'B' // <= typo but typescript doesn't complain
- * const isA = getRefinement<C, A>(c => (c.type === 'B' ? some(c) : none)) // static error: Type '"B"' is not assignable to type '"A"'
- * ```
- *
- * @since 2.0.0
- */
-function getRefinement(getOption) {
-    return function (a) { return exports.isSome(getOption(a)); };
-}
-exports.getRefinement = getRefinement;
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.9.0
- */
-exports.Do = 
-/*#__PURE__*/
-exports.of({});
-/**
- * @since 2.8.0
- */
-var bindTo = function (name) { return exports.map(_function.bindTo_(name)); };
-exports.bindTo = bindTo;
-/**
- * @since 2.8.0
- */
-var bind = function (name, f) {
-    return exports.chain(function (a) {
-        return _function.pipe(f(a), exports.map(function (b) { return _function.bind_(a, name, b); }));
-    });
-};
-exports.bind = bind;
-// -------------------------------------------------------------------------------------
-// pipeable sequence S
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.8.0
- */
-var apS = function (name, fb) {
-    return _function.flow(exports.map(function (a) { return function (b) { return _function.bind_(a, name, b); }; }), exports.ap(fb));
-};
-exports.apS = apS;
-// -------------------------------------------------------------------------------------
-// array utils
-// -------------------------------------------------------------------------------------
-/**
- *
- * @since 2.9.0
- */
-var traverseArrayWithIndex = function (f) { return function (arr) {
-    // tslint:disable-next-line: readonly-array
-    var result = [];
-    for (var i = 0; i < arr.length; i++) {
-        var b = f(i, arr[i]);
-        if (exports.isNone(b)) {
-            return exports.none;
-        }
-        result.push(b.value);
-    }
-    return exports.some(result);
-}; };
-exports.traverseArrayWithIndex = traverseArrayWithIndex;
-/**
- * Runs an action for every element in array and accumulates the results in option
- *
- * this function has the same behavior of `A.sequence(O.option)` but it's optimized and performs better
- *
- * @example
- *
- * import * as A from 'fp-ts/Array'
- * import { traverseArray, some, fromPredicate, none } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * const arr = A.range(0, 10)
- * assert.deepStrictEqual(pipe(arr, traverseArray(some)), some(arr))
- * assert.deepStrictEqual(pipe(arr, traverseArray(fromPredicate((x) => x > 5))), none)
- *
- * @since 2.9.0
- */
-var traverseArray = function (f) { return exports.traverseArrayWithIndex(function (_, a) { return f(a); }); };
-exports.traverseArray = traverseArray;
-/**
- * get an array of option and convert it to option of array
- *
- * this function has the same behavior of `A.sequence(O.option)` but it's optimized and performs better
- *
- * @example
- *
- * import * as A from 'fp-ts/Array'
- * import { sequenceArray, some, none, fromPredicate } from 'fp-ts/Option'
- * import { pipe } from 'fp-ts/function'
- *
- * const arr = A.range(0, 10)
- * assert.deepStrictEqual(pipe(arr, A.map(some), sequenceArray), some(arr))
- * assert.deepStrictEqual(pipe(arr, A.map(fromPredicate(x => x > 8)), sequenceArray), none)
- *
- * @since 2.9.0
- */
-exports.sequenceArray = 
-/*#__PURE__*/
-exports.traverseArray(_function.identity);
-});
-
-class AppConfigurationService {
-  set apiBaseUrl(url) {
-    AppConfigurationService._apiBaseUrl = Option.fromNullable(url);
-  }
-  get apiBaseUrl() {
-    if (Option.isNone(AppConfigurationService._apiBaseUrl)) {
-      throw Error('API base URL is not set');
-    }
-    return AppConfigurationService._apiBaseUrl.value;
-  }
-}
-const appConfigurationService = new AppConfigurationService();
-
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-function createInitialState() {
-  return {
-    vehicle: {
-      make: none,
-      makeId: none,
-      model: none,
-      modelId: none,
-      year: none,
-      bodyType: none,
-      bodyTypeId: none,
-      selectedVariant: none,
-      isUsedCarRequested: some(false),
-      approximatePrice: none
-    },
-    user: {
-      annualSalary: none,
-      annualKms: none,
-      paymentPeriod: none,
-      state: none,
-      term: none
-    },
-    quote: {
-      afterTaxEffectPerPayCycle: none,
-      taxSaving: none,
-      residualValue: none,
-      financedAmount: none,
-      fuel: none,
-      serviceAndMaintenance: none,
-      registrationAndCtp: none,
-      comprehensiveInsurance: none,
-      managementFee: none,
-      quoteState: 'Not calculated'
-    },
-    userDetails: {
-      employerName: none,
-      userFirstName: none,
-      userLastName: none,
-      contactNumber: none,
-      emailAddress: none
-    },
-    refLists: {
-      makeList: none,
-      modelList: none,
-      yearList: none,
-      bodyTypeList: none,
-      modelVariantsList: none
-    }
-  };
-}
-let SessionStore = class SessionStore extends datoramaAkita.Store {
-  constructor() {
-    super(createInitialState());
-  }
-  updateQuote(quote) {
-    this.update({
-      quote: quote
-    });
-  }
-  setVehicleState(key, value) {
-    this.update((state) => (Object.assign(Object.assign({}, state), { vehicle: Object.assign(Object.assign({}, state.vehicle), { [key]: value === null ? none : some(value) }) })));
-  }
-  updateList(name, value) {
-    this.update((state) => (Object.assign(Object.assign({}, state), { refLists: Object.assign(Object.assign({}, state.refLists), { [name]: some(value) }) })));
-  }
-};
-SessionStore = __decorate([
-  datoramaAkita.StoreConfig({ name: 'cars-calc-session', resettable: true })
-], SessionStore);
-const sessionStore = new SessionStore();
-
-class SessionQuery extends datoramaAkita.Query {
-  constructor(store) {
-    super(store);
-    this.store = store;
-    this.vehicle$ = this.select((state) => state.vehicle);
-    this.user$ = this.select((state) => state.user);
-    this.result$ = this.select((state) => state.quote);
-    this.userDetails$ = this.select((state) => state.userDetails);
-    this.makeList$ = this.select((state) => state.refLists.makeList);
-    this.modelList$ = this.select((state) => state.refLists.modelList);
-    this.yearList$ = this.select((state) => state.refLists.yearList);
-    this.bodyTypeList$ = this.select((state) => state.refLists.bodyTypeList);
-    this.modelVariantsList$ = this.select((state) => state.refLists.modelVariantsList);
-    this.selectedVariant$ = this.select((state) => state.vehicle.selectedVariant);
-    this.quote$ = this.select((state) => state.quote);
-  }
-  get selectedVariant() {
-    return this.getValue().vehicle.selectedVariant;
-  }
-  get vehicle() {
-    return this.getValue().vehicle;
-  }
-  get user() {
-    return this.getValue().user;
-  }
-  get result() {
-    return this.getValue().quote;
-  }
-  get userDetails() {
-    return this.getValue().userDetails;
-  }
-}
-const sessionQuery = new SessionQuery(sessionStore);
-
-exports.appConfigurationService = appConfigurationService;
-exports.fold = fold;
-exports.fromNullable = fromNullable;
-exports.getOrElse = getOrElse;
-exports.getOrElseW = getOrElseW;
-exports.isNone = isNone;
-exports.isSome = isSome;
-exports.none = none;
-exports.sessionQuery = sessionQuery;
-exports.sessionStore = sessionStore;
-exports.some = some;