@flarehr/apollo-super-selection 5.54.16008 → 5.56.16984

package/dist/lib/cjs/custom-fund-choice.api-713823d3.js

@@ -0,0 +1,3043 @@
+'use strict';
+
+const index = require('./index-eb4f212f.js');
+const activeRouter = require('./active-router-1f555f75.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);
+}
+/**
+ * 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 isNone(ma) ? undefined : ma.value;
+}
+
+function injectHistory(Component) {
+    activeRouter.ActiveRouter.injectProps(Component, ['history', 'location']);
+}
+
+function appReady() {
+  postMessage({
+    type: 'appReady'
+  });
+}
+function postMessage(message, origin) {
+  if (origin === undefined)
+    origin = '*';
+  message.sender = 'flare';
+  window.parent.postMessage(message, origin);
+}
+function resize(height, width) {
+  postMessage({
+    type: 'contentResized',
+    height,
+    width
+  });
+}
+function navigation(url) {
+  postMessage({
+    type: 'pageNavigated',
+    url
+  });
+}
+function complete() {
+  postMessage({ type: 'complete' });
+}
+function submitSuccess() {
+  postMessage({
+    type: 'submitSuccess'
+  });
+}
+const iframe = { appReady, resize, navigation, complete, submitSuccess };
+
+const appendToMap = (map, propName, value) => {
+    const items = map.get(propName);
+    if (!items) {
+        map.set(propName, [value]);
+    }
+    else if (!items.includes(value)) {
+        items.push(value);
+    }
+};
+const debounce = (fn, ms) => {
+    let timeoutId;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = 0;
+            fn(...args);
+        }, ms);
+    };
+};
+
+/**
+ * Check if a possible element isConnected.
+ * The property might not be there, so we check for it.
+ *
+ * We want it to return true if isConnected is not a property,
+ * otherwise we would remove these elements and would not update.
+ *
+ * Better leak in Edge than to be useless.
+ */
+const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
+const cleanupElements = debounce((map) => {
+    for (let key of map.keys()) {
+        map.set(key, map.get(key).filter(isConnected));
+    }
+}, 2000);
+const stencilSubscription = ({ on }) => {
+    const elmsToUpdate = new Map();
+    if (typeof index.getRenderingRef === 'function') {
+        // If we are not in a stencil project, we do nothing.
+        // This function is not really exported by @stencil/core.
+        on('dispose', () => {
+            elmsToUpdate.clear();
+        });
+        on('get', (propName) => {
+            const elm = index.getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        });
+        on('set', (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(index.forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        });
+        on('reset', () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(index.forceUpdate));
+            cleanupElements(elmsToUpdate);
+        });
+    }
+};
+
+const createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
+    let states = new Map(Object.entries(defaultState !== null && defaultState !== void 0 ? defaultState : {}));
+    const handlers = {
+        dispose: [],
+        get: [],
+        set: [],
+        reset: [],
+    };
+    const reset = () => {
+        states = new Map(Object.entries(defaultState !== null && defaultState !== void 0 ? defaultState : {}));
+        handlers.reset.forEach((cb) => cb());
+    };
+    const dispose = () => {
+        // Call first dispose as resetting the state would
+        // cause less updates ;)
+        handlers.dispose.forEach((cb) => cb());
+        reset();
+    };
+    const get = (propName) => {
+        handlers.get.forEach((cb) => cb(propName));
+        return states.get(propName);
+    };
+    const set = (propName, value) => {
+        const oldValue = states.get(propName);
+        if (shouldUpdate(value, oldValue, propName)) {
+            states.set(propName, value);
+            handlers.set.forEach((cb) => cb(propName, value, oldValue));
+        }
+    };
+    const state = (typeof Proxy === 'undefined'
+        ? {}
+        : new Proxy(defaultState, {
+            get(_, propName) {
+                return get(propName);
+            },
+            ownKeys(_) {
+                return Array.from(states.keys());
+            },
+            getOwnPropertyDescriptor() {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            has(_, propName) {
+                return states.has(propName);
+            },
+            set(_, propName, value) {
+                set(propName, value);
+                return true;
+            },
+        }));
+    const on = (eventName, callback) => {
+        handlers[eventName].push(callback);
+        return () => {
+            removeFromArray(handlers[eventName], callback);
+        };
+    };
+    const onChange = (propName, cb) => {
+        const unSet = on('set', (key, newValue) => {
+            if (key === propName) {
+                cb(newValue);
+            }
+        });
+        const unReset = on('reset', () => cb(defaultState[propName]));
+        return () => {
+            unSet();
+            unReset();
+        };
+    };
+    const use = (...subscriptions) => subscriptions.forEach((subscription) => {
+        if (subscription.set) {
+            on('set', subscription.set);
+        }
+        if (subscription.get) {
+            on('get', subscription.get);
+        }
+        if (subscription.reset) {
+            on('reset', subscription.reset);
+        }
+    });
+    return {
+        state,
+        get,
+        set,
+        on,
+        onChange,
+        use,
+        dispose,
+        reset,
+    };
+};
+const removeFromArray = (array, item) => {
+    const index = array.indexOf(item);
+    if (index >= 0) {
+        array[index] = array[array.length - 1];
+        array.length--;
+    }
+};
+
+const createStore = (defaultState, shouldUpdate) => {
+    const map = createObservableMap(defaultState, shouldUpdate);
+    stencilSubscription(map);
+    return map;
+};
+
+const initial = {
+  handleSubmitFn: async function () {
+    return;
+  },
+  fundName: '',
+  fundDetails: { type: 'null' },
+  promotedFundId: undefined
+};
+const { state } = createStore(initial);
+
+(function (SuperSelectionAppRoutes) {
+  SuperSelectionAppRoutes["ExistingChoicePage"] = "/existing";
+  SuperSelectionAppRoutes["SuperCampaign"] = "/super-campaign";
+  SuperSelectionAppRoutes["ChoicePage"] = "/";
+  SuperSelectionAppRoutes["MyOwnFund"] = "/super-choice/my-own-fund/";
+  SuperSelectionAppRoutes["MyOwnFundEngagementStep"] = "/super-choice/my-own-fund-engagement/";
+  SuperSelectionAppRoutes["Prefill"] = "/super-choice/prefill/";
+  SuperSelectionAppRoutes["PrefillInvalidMyOwnFundPage"] = "/super-choice/sss-prefill-invalid-my-own-fund/";
+  SuperSelectionAppRoutes["PrefillMyOwnFundPage"] = "/super-choice/prefill-my-own-fund/";
+  SuperSelectionAppRoutes["PrefillSMSFPage"] = "/super-choice/prefill-smsf/";
+  SuperSelectionAppRoutes["PrefillInvalidSMSFPage"] = "/super-choice/prefill-invalid-smsf/";
+  SuperSelectionAppRoutes["SelfManagedFund"] = "/super-choice/smsf/";
+  SuperSelectionAppRoutes["DefaultFund"] = "/super-choice/default/";
+  SuperSelectionAppRoutes["FeaturedFunds"] = "/super-choice/featured-funds/";
+  SuperSelectionAppRoutes["StandardChoice"] = "/standard-choice/";
+  SuperSelectionAppRoutes["Success"] = "/success/";
+})(exports.SuperSelectionAppRoutes || (exports.SuperSelectionAppRoutes = {}));
+const superSelectionAppStencilRoutes = [
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.ExistingChoicePage, component: "sss-existing-choice-page" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.SuperCampaign, component: "sss-super-campaign-host" }),
+  index.h("stencil-route", { exact: true, url: exports.SuperSelectionAppRoutes.ChoicePage, component: "sss-choice-router" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.MyOwnFund, component: "sss-super-byof-host" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.MyOwnFundEngagementStep, component: "sss-my-own-fund-engagement-step-host" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.PrefillInvalidMyOwnFundPage, component: "sss-prefill-invalid-my-own-fund" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.Prefill, component: "sss-prefill" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.PrefillMyOwnFundPage, component: "sss-prefill-my-own-fund" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.PrefillSMSFPage, component: "sss-prefill-smsf" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.PrefillInvalidSMSFPage, component: "sss-prefill-invalid-smsf" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.SelfManagedFund, component: "sss-super-smsf-host" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.DefaultFund, component: "sss-default-fund" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.FeaturedFunds, component: "sss-super-campaign-featured-funds" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.StandardChoice, component: "sss-standard-choice-form" }),
+  index.h("stencil-route", { url: exports.SuperSelectionAppRoutes.Success, component: "sss-success" })
+];
+
+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 have the same behavior of `A.sequence(O.option)` but it's optimized and perform 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 have the same behavior of `A.sequence(O.option)` but it's optimized and perform 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);
+});
+
+function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";var r="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r(t)}}function n(e){this.message=e;}function o(e,r){if("string"!=typeof e)throw new n("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t(e.split(".")[o]))}catch(e){throw new n("Invalid token specified: "+e.message)}}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+var mix = function (one, two, mergeArrays) {
+    if (mergeArrays === void 0) { mergeArrays = false; }
+    if (!one || !two || typeof one !== "object" || typeof two !== "object")
+        return one;
+    var clone = __assign({}, one);
+    for (var prop in two) {
+        if (two.hasOwnProperty(prop)) {
+            if (two[prop] instanceof Array && one[prop] instanceof Array) {
+                clone[prop] = mergeArrays ? __spreadArrays(one[prop], two[prop]) : two[prop];
+            }
+            else if (typeof two[prop] === "object" && typeof one[prop] === "object") {
+                clone[prop] = mix(one[prop], two[prop], mergeArrays);
+            }
+            else {
+                clone[prop] = two[prop];
+            }
+        }
+    }
+    return clone;
+};
+
+var __spreadArrays$1 = (undefined && undefined.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+var config = {
+    // Default options
+    defaults: {},
+    // Error type
+    errorType: null,
+    // Polyfills
+    polyfills: {
+        fetch: null,
+        FormData: null,
+        URLSearchParams: null,
+        performance: null,
+        PerformanceObserver: null,
+        AbortController: null
+    },
+    polyfill: function (p, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.doThrow, doThrow = _c === void 0 ? true : _c, _d = _b.instance, instance = _d === void 0 ? false : _d;
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        var res = this.polyfills[p] ||
+            (typeof self !== "undefined" ? self[p] : null) ||
+            (typeof global !== "undefined" ? global[p] : null);
+        if (doThrow && !res)
+            throw new Error(p + " is not defined");
+        return instance && res ? new (res.bind.apply(res, __spreadArrays$1([void 0], args)))() : res;
+    }
+};
+
+var onMatch = function (entries, name, callback, _performance) {
+    if (!entries.getEntriesByName)
+        return false;
+    var matches = entries.getEntriesByName(name);
+    if (matches && matches.length > 0) {
+        callback(matches.reverse()[0]);
+        if (_performance.clearMeasures)
+            _performance.clearMeasures(name);
+        perfs.callbacks.delete(name);
+        if (perfs.callbacks.size < 1) {
+            perfs.observer.disconnect();
+            if (_performance.clearResourceTimings) {
+                _performance.clearResourceTimings();
+            }
+        }
+        return true;
+    }
+    return false;
+};
+var lazyObserver = function (_performance, _observer) {
+    if (!perfs.observer && _performance && _observer) {
+        perfs.observer = new _observer(function (entries) {
+            perfs.callbacks.forEach(function (callback, name) {
+                onMatch(entries, name, callback, _performance);
+            });
+        });
+        if (_performance.clearResourceTimings)
+            _performance.clearResourceTimings();
+    }
+    return perfs.observer;
+};
+var perfs = {
+    callbacks: new Map(),
+    observer: null,
+    observe: function (name, callback) {
+        if (!name || !callback)
+            return;
+        var _performance = config.polyfill("performance", { doThrow: false });
+        var _observer = config.polyfill("PerformanceObserver", { doThrow: false });
+        if (!lazyObserver(_performance, _observer))
+            return;
+        if (!onMatch(_performance, name, callback, _performance)) {
+            if (perfs.callbacks.size < 1)
+                perfs.observer.observe({ entryTypes: ["resource", "measure"] });
+            perfs.callbacks.set(name, callback);
+        }
+    }
+};
+
+var middlewareHelper = function (middlewares) { return function (fetchFunction) {
+    return (middlewares.length === 0 ?
+        fetchFunction :
+        middlewares.length === 1 ?
+            middlewares[0](fetchFunction) :
+            middlewares.reduceRight(function (acc, curr, idx) {
+                return (idx === middlewares.length - 2) ? curr(acc(fetchFunction)) : curr(acc);
+            }));
+}; };
+
+var WretchErrorWrapper = /** @class */ (function () {
+    function WretchErrorWrapper(error) {
+        this.error = error;
+    }
+    return WretchErrorWrapper;
+}());
+var resolver = function (wretcher) {
+    var url = wretcher._url, _catchers = wretcher._catchers, resolvers = wretcher._resolvers, middlewares = wretcher._middlewares, opts = wretcher._options;
+    var catchers = new Map(_catchers);
+    var finalOptions = mix(config.defaults, opts);
+    var fetchController = config.polyfill("AbortController", { doThrow: false, instance: true });
+    if (!finalOptions["signal"] && fetchController) {
+        finalOptions["signal"] = fetchController.signal;
+    }
+    // Request timeout
+    var timeout = {
+        ref: null,
+        clear: function () {
+            if (timeout.ref) {
+                clearTimeout(timeout.ref);
+                timeout.ref = null;
+            }
+        }
+    };
+    // The generated fetch request
+    var fetchRequest = middlewareHelper(middlewares)(config.polyfill("fetch"))(url, finalOptions);
+    // Throws on an http error
+    var throwingPromise = fetchRequest
+        .catch(function (error) {
+        throw new WretchErrorWrapper(error);
+    })
+        .then(function (response) {
+        timeout.clear();
+        if (!response.ok) {
+            return response[config.errorType || "text"]().then(function (msg) {
+                // Enhances the error object
+                var err = new Error(msg);
+                err[config.errorType || "text"] = msg;
+                err["status"] = response.status;
+                err["response"] = response;
+                throw err;
+            });
+        }
+        return response;
+    });
+    // Wraps the Promise in order to dispatch the error to a matching catcher
+    var catchersWrapper = function (promise) {
+        return promise.catch(function (err) {
+            timeout.clear();
+            var error = err instanceof WretchErrorWrapper ? err.error : err;
+            if (err instanceof WretchErrorWrapper && catchers.has("__fromFetch"))
+                return catchers.get("__fromFetch")(error, wretcher);
+            else if (catchers.has(error.status))
+                return catchers.get(error.status)(error, wretcher);
+            else if (catchers.has(error.name))
+                return catchers.get(error.name)(error, wretcher);
+            else
+                throw error;
+        });
+    };
+    var bodyParser = function (funName) { return function (cb) { return funName ?
+        // If a callback is provided, then callback with the body result otherwise return the parsed body itself.
+        catchersWrapper(throwingPromise.then(function (_) { return _ && _[funName](); }).then(function (_) { return cb ? cb(_) : _; })) :
+        // No body parsing method - return the response
+        catchersWrapper(throwingPromise.then(function (_) { return cb ? cb(_) : _; })); }; };
+    var responseChain = {
+        /**
+         * Retrieves the raw result as a promise.
+         */
+        res: bodyParser(null),
+        /**
+         * Retrieves the result as a parsed JSON object.
+         */
+        json: bodyParser("json"),
+        /**
+         * Retrieves the result as a Blob object.
+         */
+        blob: bodyParser("blob"),
+        /**
+         * Retrieves the result as a FormData object.
+         */
+        formData: bodyParser("formData"),
+        /**
+         * Retrieves the result as an ArrayBuffer object.
+         */
+        arrayBuffer: bodyParser("arrayBuffer"),
+        /**
+         * Retrieves the result as a string.
+         */
+        text: bodyParser("text"),
+        /**
+         * Performs a callback on the API performance timings of the request.
+         *
+         * Warning: Still experimental on browsers and node.js
+         */
+        perfs: function (cb) {
+            fetchRequest.then(function (res) { return perfs.observe(res.url, cb); });
+            return responseChain;
+        },
+        /**
+         * Aborts the request after a fixed time.
+         *
+         * @param time Time in milliseconds
+         * @param controller A custom controller
+         */
+        setTimeout: function (time, controller) {
+            if (controller === void 0) { controller = fetchController; }
+            timeout.clear();
+            timeout.ref = setTimeout(function () { return controller.abort(); }, time);
+            return responseChain;
+        },
+        /**
+         * Returns the automatically generated AbortController alongside the current wretch response as a pair.
+         */
+        controller: function () { return [fetchController, responseChain]; },
+        /**
+         * Catches an http response with a specific error code or name and performs a callback.
+         */
+        error: function (errorId, cb) {
+            catchers.set(errorId, cb);
+            return responseChain;
+        },
+        /**
+         * Catches a bad request (http code 400) and performs a callback.
+         */
+        badRequest: function (cb) { return responseChain.error(400, cb); },
+        /**
+         * Catches an unauthorized request (http code 401) and performs a callback.
+         */
+        unauthorized: function (cb) { return responseChain.error(401, cb); },
+        /**
+         * Catches a forbidden request (http code 403) and performs a callback.
+         */
+        forbidden: function (cb) { return responseChain.error(403, cb); },
+        /**
+         * Catches a "not found" request (http code 404) and performs a callback.
+         */
+        notFound: function (cb) { return responseChain.error(404, cb); },
+        /**
+         * Catches a timeout (http code 408) and performs a callback.
+         */
+        timeout: function (cb) { return responseChain.error(408, cb); },
+        /**
+         * Catches an internal server error (http code 500) and performs a callback.
+         */
+        internalError: function (cb) { return responseChain.error(500, cb); },
+        /**
+         * Catches errors thrown when calling the fetch function and performs a callback.
+         */
+        fetchError: function (cb) { return responseChain.error("__fromFetch", cb); },
+        /**
+         * Catches an AbortError and performs a callback.
+         */
+        onAbort: function (cb) { return responseChain.error("AbortError", cb); }
+    };
+    return resolvers.reduce(function (chain, r) { return r(chain, wretcher); }, responseChain);
+};
+
+var __assign$1 = (undefined && undefined.__assign) || function () {
+    __assign$1 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$1.apply(this, arguments);
+};
+var __spreadArrays$2 = (undefined && undefined.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+var JSON_MIME = "application/json";
+var CONTENT_TYPE_HEADER = "Content-Type";
+/**
+ * The Wretcher class used to perform easy fetch requests.
+ *
+ * Immutability : almost every method of this class return a fresh Wretcher object.
+ */
+var Wretcher = /** @class */ (function () {
+    function Wretcher(_url, _options, _catchers, _resolvers, _middlewares, _deferredChain) {
+        if (_catchers === void 0) { _catchers = new Map(); }
+        if (_resolvers === void 0) { _resolvers = []; }
+        if (_middlewares === void 0) { _middlewares = []; }
+        if (_deferredChain === void 0) { _deferredChain = []; }
+        this._url = _url;
+        this._options = _options;
+        this._catchers = _catchers;
+        this._resolvers = _resolvers;
+        this._middlewares = _middlewares;
+        this._deferredChain = _deferredChain;
+    }
+    Wretcher.factory = function (url, options) {
+        if (url === void 0) { url = ""; }
+        if (options === void 0) { options = {}; }
+        return new Wretcher(url, options);
+    };
+    Wretcher.prototype.selfFactory = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.url, url = _c === void 0 ? this._url : _c, _d = _b.options, options = _d === void 0 ? this._options : _d, _e = _b.catchers, catchers = _e === void 0 ? this._catchers : _e, _f = _b.resolvers, resolvers = _f === void 0 ? this._resolvers : _f, _g = _b.middlewares, middlewares = _g === void 0 ? this._middlewares : _g, _h = _b.deferredChain, deferredChain = _h === void 0 ? this._deferredChain : _h;
+        return new Wretcher(url, __assign$1({}, options), new Map(catchers), __spreadArrays$2(resolvers), __spreadArrays$2(middlewares), __spreadArrays$2(deferredChain));
+    };
+    /**
+     * Sets the default fetch options used for every subsequent fetch call.
+     * @param options New default options
+     * @param mixin If true, mixes in instead of replacing the existing options
+     */
+    Wretcher.prototype.defaults = function (options, mixin) {
+        if (mixin === void 0) { mixin = false; }
+        config.defaults = mixin ? mix(config.defaults, options) : options;
+        return this;
+    };
+    /**
+     * Sets the method (text, json ...) used to parse the data contained in the response body in case of an HTTP error.
+     *
+     * Persists for every subsequent requests.
+     *
+     * Default is "text".
+     */
+    Wretcher.prototype.errorType = function (method) {
+        config.errorType = method;
+        return this;
+    };
+    /**
+     * Sets the non-global polyfills which will be used for every subsequent calls.
+     *
+     * Needed for libraries like [fetch-ponyfill](https://github.com/qubyte/fetch-ponyfill).
+     *
+     * @param polyfills An object containing the polyfills.
+     */
+    Wretcher.prototype.polyfills = function (polyfills) {
+        config.polyfills = __assign$1(__assign$1({}, config.polyfills), polyfills);
+        return this;
+    };
+    /**
+     * Returns a new Wretcher object with the argument url appended and the same options.
+     * @param url String url
+     * @param replace Boolean If true, replaces the current url instead of appending
+     */
+    Wretcher.prototype.url = function (url, replace) {
+        if (replace === void 0) { replace = false; }
+        if (replace)
+            return this.selfFactory({ url: url });
+        var split = this._url.split("?");
+        return this.selfFactory({
+            url: split.length > 1 ?
+                split[0] + url + "?" + split[1] :
+                this._url + url
+        });
+    };
+    /**
+     * Returns a new Wretcher object with the same url and new options.
+     * @param options New options
+     * @param mixin If true, mixes in instead of replacing the existing options
+     */
+    Wretcher.prototype.options = function (options, mixin) {
+        if (mixin === void 0) { mixin = true; }
+        return this.selfFactory({ options: mixin ? mix(this._options, options) : options });
+    };
+    /**
+     * Converts a javascript object to query parameters,
+     * then appends this query string to the current url.
+     *
+     * If given a string, use the string as the query verbatim.
+     *
+     * ```
+     * let w = wretch("http://example.com") // url is http://example.com
+     *
+     * // Chain query calls
+     * w = w.query({ a: 1, b : 2 }) // url is now http://example.com?a=1&b=2
+     * w = w.query("foo-bar-baz-woz") // url is now http://example.com?a=1&b=2&foo-bar-baz-woz
+     *
+     * // Pass true as the second argument to replace existing query parameters
+     * w = w.query("c=3&d=4", true) // url is now http://example.com?c=3&d=4
+     * ```
+     *
+     * @param qp An object which will be converted, or a string which will be used verbatim.
+     */
+    Wretcher.prototype.query = function (qp, replace) {
+        if (replace === void 0) { replace = false; }
+        return this.selfFactory({ url: appendQueryParams(this._url, qp, replace) });
+    };
+    /**
+     * Set request headers.
+     * @param headerValues An object containing header keys and values
+     */
+    Wretcher.prototype.headers = function (headerValues) {
+        return this.selfFactory({ options: mix(this._options, { headers: headerValues || {} }) });
+    };
+    /**
+     * Shortcut to set the "Accept" header.
+     * @param headerValue Header value
+     */
+    Wretcher.prototype.accept = function (headerValue) {
+        return this.headers({ Accept: headerValue });
+    };
+    /**
+     * Shortcut to set the "Content-Type" header.
+     * @param headerValue Header value
+     */
+    Wretcher.prototype.content = function (headerValue) {
+        var _a;
+        return this.headers((_a = {}, _a[CONTENT_TYPE_HEADER] = headerValue, _a));
+    };
+    /**
+     * Shortcut to set the "Authorization" header.
+     * @param headerValue Header value
+     */
+    Wretcher.prototype.auth = function (headerValue) {
+        return this.headers({ Authorization: headerValue });
+    };
+    /**
+     * Adds a default catcher which will be called on every subsequent request error when the error code matches.
+     * @param errorId Error code or name
+     * @param catcher: The catcher method
+     */
+    Wretcher.prototype.catcher = function (errorId, catcher) {
+        var newMap = new Map(this._catchers);
+        newMap.set(errorId, catcher);
+        return this.selfFactory({ catchers: newMap });
+    };
+    /**
+     * Associates a custom signal with the request.
+     * @param controller : An AbortController
+     */
+    Wretcher.prototype.signal = function (controller) {
+        return this.selfFactory({ options: __assign$1(__assign$1({}, this._options), { signal: controller.signal }) });
+    };
+    /**
+     * Program a resolver to perform response chain tasks automatically.
+     * @param doResolve : Resolver callback
+     */
+    Wretcher.prototype.resolve = function (doResolve, clear) {
+        if (clear === void 0) { clear = false; }
+        return this.selfFactory({ resolvers: clear ? [doResolve] : __spreadArrays$2(this._resolvers, [doResolve]) });
+    };
+    /**
+     * Defer wretcher methods that will be chained and called just before the request is performed.
+     */
+    Wretcher.prototype.defer = function (callback, clear) {
+        if (clear === void 0) { clear = false; }
+        return this.selfFactory({
+            deferredChain: clear ? [callback] : __spreadArrays$2(this._deferredChain, [callback])
+        });
+    };
+    /**
+     * Add middlewares to intercept a request before being sent.
+     */
+    Wretcher.prototype.middlewares = function (middlewares, clear) {
+        if (clear === void 0) { clear = false; }
+        return this.selfFactory({
+            middlewares: clear ? middlewares : __spreadArrays$2(this._middlewares, middlewares)
+        });
+    };
+    Wretcher.prototype.method = function (method, options, body) {
+        if (options === void 0) { options = {}; }
+        if (body === void 0) { body = null; }
+        var headers = this._options.headers;
+        var baseWretcher = !body ? this :
+            typeof body === "object" && (!headers ||
+                Object.entries(headers).every(function (_a) {
+                    var k = _a[0], v = _a[1];
+                    return k.toLowerCase() !== CONTENT_TYPE_HEADER.toLowerCase() ||
+                        v.startsWith(JSON_MIME);
+                })) ? this.json(body) :
+                this.body(body);
+        baseWretcher = baseWretcher.options(__assign$1(__assign$1({}, options), { method: method }));
+        var deferredWretcher = baseWretcher._deferredChain.reduce(function (acc, curr) { return curr(acc, acc._url, acc._options); }, baseWretcher);
+        return resolver(deferredWretcher);
+    };
+    /**
+     * Performs a get request.
+     */
+    Wretcher.prototype.get = function (options) {
+        return this.method("GET", options);
+    };
+    /**
+     * Performs a delete request.
+     */
+    Wretcher.prototype.delete = function (options) {
+        return this.method("DELETE", options);
+    };
+    /**
+     * Performs a put request.
+     */
+    Wretcher.prototype.put = function (body, options) {
+        return this.method("PUT", options, body);
+    };
+    /**
+     * Performs a post request.
+     */
+    Wretcher.prototype.post = function (body, options) {
+        return this.method("POST", options, body);
+    };
+    /**
+     * Performs a patch request.
+     */
+    Wretcher.prototype.patch = function (body, options) {
+        return this.method("PATCH", options, body);
+    };
+    /**
+     * Performs a head request.
+     */
+    Wretcher.prototype.head = function (options) {
+        return this.method("HEAD", options);
+    };
+    /**
+     * Performs an options request
+     */
+    Wretcher.prototype.opts = function (options) {
+        return this.method("OPTIONS", options);
+    };
+    /**
+     * Replay a request.
+     */
+    Wretcher.prototype.replay = function (options) {
+        return this.method(this._options.method, options);
+    };
+    /**
+     * Sets the request body with any content.
+     * @param contents The body contents
+     */
+    Wretcher.prototype.body = function (contents) {
+        return this.selfFactory({ options: __assign$1(__assign$1({}, this._options), { body: contents }) });
+    };
+    /**
+     * Sets the content type header, stringifies an object and sets the request body.
+     * @param jsObject An object which will be serialized into a JSON
+     */
+    Wretcher.prototype.json = function (jsObject) {
+        var _a;
+        var preservedContentType = (_a = Object.entries(this._options.headers || {}).find(function (_a) {
+            var k = _a[0], v = _a[1];
+            return k.toLowerCase() === CONTENT_TYPE_HEADER.toLowerCase() && v.startsWith(JSON_MIME);
+        })) === null || _a === void 0 ? void 0 : _a[1];
+        return this.content(preservedContentType || JSON_MIME).body(JSON.stringify(jsObject));
+    };
+    /**
+     * Converts the javascript object to a FormData and sets the request body.
+     * @param formObject An object which will be converted to a FormData
+     * @param recursive If `true`, will recurse through all nested objects
+     * Can be set as an array of string to exclude specific keys.
+     * See https://github.com/elbywan/wretch/issues/68 for more details.
+     */
+    Wretcher.prototype.formData = function (formObject, recursive) {
+        if (recursive === void 0) { recursive = false; }
+        return this.body(convertFormData(formObject, recursive));
+    };
+    /**
+     * Converts the input to an url encoded string and sets the content-type header and body.
+     * If the input argument is already a string, skips the conversion part.
+     *
+     * @param input An object to convert into an url encoded string or an already encoded string
+     */
+    Wretcher.prototype.formUrl = function (input) {
+        return this
+            .body(typeof input === "string" ? input : convertFormUrl(input))
+            .content("application/x-www-form-urlencoded");
+    };
+    return Wretcher;
+}());
+// Internal helpers
+var appendQueryParams = function (url, qp, replace) {
+    var queryString;
+    if (typeof qp === "string") {
+        queryString = qp;
+    }
+    else {
+        var usp = config.polyfill("URLSearchParams", { instance: true });
+        for (var key in qp) {
+            if (qp[key] instanceof Array) {
+                for (var _i = 0, _a = qp[key]; _i < _a.length; _i++) {
+                    var val = _a[_i];
+                    usp.append(key, val);
+                }
+            }
+            else {
+                usp.append(key, qp[key]);
+            }
+        }
+        queryString = usp.toString();
+    }
+    var split = url.split("?");
+    if (replace || split.length < 2)
+        return split[0] + "?" + queryString;
+    return url + "&" + queryString;
+};
+function convertFormData(formObject, recursive, formData, ancestors) {
+    if (recursive === void 0) { recursive = false; }
+    if (formData === void 0) { formData = config.polyfill("FormData", { instance: true }); }
+    if (ancestors === void 0) { ancestors = []; }
+    Object.entries(formObject).forEach(function (_a) {
+        var key = _a[0], value = _a[1];
+        var formKey = ancestors.reduce(function (acc, ancestor) { return (acc ? acc + "[" + ancestor + "]" : ancestor); }, null);
+        formKey = formKey ? formKey + "[" + key + "]" : key;
+        if (value instanceof Array) {
+            for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+                var item = value_1[_i];
+                formData.append(formKey + "[]", item);
+            }
+        }
+        else if (recursive &&
+            typeof value === "object" &&
+            (!(recursive instanceof Array) ||
+                !recursive.includes(key))) {
+            if (value !== null) {
+                convertFormData(value, recursive, formData, __spreadArrays$2(ancestors, [key]));
+            }
+        }
+        else {
+            formData.append(formKey, value);
+        }
+    });
+    return formData;
+}
+function encodeQueryValue(key, value) {
+    return encodeURIComponent(key) +
+        "=" +
+        encodeURIComponent(typeof value === "object" ?
+            JSON.stringify(value) :
+            "" + value);
+}
+function convertFormUrl(formObject) {
+    return Object.keys(formObject)
+        .map(function (key) {
+        var value = formObject[key];
+        if (value instanceof Array) {
+            return value.map(function (v) { return encodeQueryValue(key, v); }).join("&");
+        }
+        return encodeQueryValue(key, value);
+    })
+        .join("&");
+}
+
+var factory = Wretcher.factory;
+factory["default"] = Wretcher.factory;
+
+function buildBackendApiClient() {
+  const jwt = superSelectionAppService.jwt;
+  const profileId = superSelectionAppService.profileId;
+  const accountId = superSelectionAppService.accountIdOrDefault;
+  const partnerId = superSelectionAppService.partnerIdOrDefault;
+  return factory(superSelectionAppService.apiBaseUrl).headers({
+    Authorization: `Bearer ${jwt}`,
+    'X-PROFILE-ID': profileId,
+    'X-PARTNER-ID': partnerId,
+    'X-ACCOUNT-ID': accountId
+  });
+}
+
+const slate = {
+  fundId: 'slate',
+  usi: '32367272075001'
+};
+
+function hydratePromotedFundChoiceDtoKind(dto) {
+  if ('slate' in dto) {
+    dto.kind = 'slate';
+  }
+  else if ('australianRetirementTrust' in dto) {
+    dto.kind = 'australianRetirementTrust';
+  }
+  else if ('aware' in dto) {
+    dto.kind = 'aware';
+  }
+  else if ('active' in dto) {
+    dto.kind = 'active';
+  }
+  else if ('australianEthical' in dto) {
+    dto.kind = 'australianEthical';
+  }
+  else if ('virgin' in dto) {
+    dto.kind = 'virgin';
+  }
+  else if ('spirit' in dto) {
+    dto.kind = 'spirit';
+  }
+  else if ('firstSuper' in dto) {
+    dto.kind = 'firstSuper';
+  }
+  else if ('mercerMyChoice' in dto) {
+    dto.kind = 'mercerMyChoice';
+  }
+  else if ('generic' in dto) {
+    dto.kind = 'generic';
+  }
+}
+function getPromotedFundUsi(dto) {
+  switch (dto.kind) {
+    case 'slate':
+      return slate.usi;
+    case 'australianRetirementTrust':
+      return dto.australianRetirementTrust.usi;
+    case 'aware':
+      return dto.aware.usi;
+    case 'active':
+      return dto.active.usi;
+    case 'australianEthical':
+      return dto.australianEthical.usi;
+    case 'virgin':
+      return dto.virgin.usi;
+    case 'spirit':
+      return dto.spirit.usi;
+    case 'firstSuper':
+      return dto.firstSuper.usi;
+    case 'mercerMyChoice':
+      return dto.mercerMyChoice.usi;
+    case 'generic':
+      return dto.generic.usi;
+    default:
+      return '';
+  }
+}
+function getPromotedFundId(dto) {
+  switch (dto.kind) {
+    case 'slate':
+      return slate.fundId;
+    case 'australianRetirementTrust':
+      return 'australian-retirement-trust';
+    case 'aware':
+      return 'aware';
+    case 'active':
+      return 'active';
+    case 'australianEthical':
+      return 'australian-ethical';
+    case 'virgin':
+      return 'virgin';
+    case 'spirit':
+      return 'spirit';
+    case 'firstSuper':
+      return 'first-super';
+    case 'mercerMyChoice':
+      return 'mercermychoice';
+    case 'generic':
+      return dto.generic.fundId;
+    default:
+      return '';
+  }
+}
+function getSuperChoiceUsi(dto) {
+  switch (dto.kind) {
+    case 'Promoted':
+      return some(getPromotedFundUsi(dto.promoted));
+    case 'MyOwnFund':
+      return some(dto.myOwnFund.usi);
+    case 'SMSF':
+      return none;
+    case 'Default':
+      return some(dto.default.usi);
+    case 'PromotedDefault':
+      return some(dto.promotedDefault.usi);
+    case 'DefinedBenefits':
+      return some(dto.definedBenefits.usi);
+    case 'PromotedDefaultWithJoin':
+      return some(dto.promotedDefaultWithJoin.usi);
+    default:
+      return none;
+  }
+}
+function getPromotedFundMemberNumber(dto) {
+  switch (dto.kind) {
+    case 'slate':
+      return dto.slate.memberNumber;
+    case 'australianRetirementTrust':
+      return dto.australianRetirementTrust.memberNumber;
+    case 'aware':
+      return dto.aware.memberNumber;
+    case 'active':
+      return dto.active.memberNumber;
+    case 'australianEthical':
+      return dto.australianEthical.memberNumber;
+    case 'virgin':
+      return dto.virgin.memberNumber;
+    case 'spirit':
+      return dto.spirit.memberNumber;
+    case 'firstSuper':
+      return dto.firstSuper.memberNumber;
+    case 'mercerMyChoice':
+      return dto.mercerMyChoice.memberNumber;
+    case 'generic':
+      return dto.generic.memberNumber;
+    default:
+      return '';
+  }
+}
+function getSuperChoiceMemberNumber(dto) {
+  switch (dto.kind) {
+    case 'Promoted':
+      return some(getPromotedFundMemberNumber(dto.promoted));
+    case 'MyOwnFund':
+      return some(dto.myOwnFund.memberNumber);
+    case 'DefinedBenefits':
+      return some(dto.definedBenefits.memberNumber);
+    case 'PromotedDefaultWithJoin':
+      return some(dto.promotedDefaultWithJoin.memberNumber);
+    case 'SMSF':
+    case 'Default':
+    case 'PromotedDefault':
+      return none;
+    default:
+      return none;
+  }
+}
+function hydrateSuperChoiceDetailsDtoKind(dto) {
+  if ('promoted' in dto) {
+    dto.kind = 'Promoted';
+  }
+  else if ('myOwnFund' in dto) {
+    dto.kind = 'MyOwnFund';
+  }
+  else if ('smsf' in dto) {
+    dto.kind = 'SMSF';
+  }
+  else if ('default' in dto) {
+    dto.kind = 'Default';
+  }
+  else if ('promotedDefault' in dto) {
+    dto.kind = 'PromotedDefault';
+  }
+  else if ('definedBenefits' in dto) {
+    dto.kind = 'DefinedBenefits';
+  }
+  else if ('promotedDefaultWithJoin' in dto) {
+    dto.kind = 'PromotedDefaultWithJoin';
+  }
+}
+
+class SuperSelectionApi {
+  async getAustralianFundsAsync(searchFilter, includeInactive = false) {
+    return buildBackendApiClient()
+      .url(`super-choice/australian-funds-v2?${this.toQueryString(includeInactive, searchFilter)}`)
+      .get()
+      .notFound(() => {
+      throw new Error('Failed to fetch the list of australian super funds.');
+    })
+      .json();
+  }
+  async getAustralianFundAsync(usi, includeInactive) {
+    const queryStr = includeInactive ? '?includeInactive=true' : '';
+    return buildBackendApiClient()
+      .url(`super-choice/australian-funds/${usi}${queryStr}`)
+      .get()
+      .notFound(() => {
+      throw new Error('Failed to fetch australian super fund.');
+    })
+      .json();
+  }
+  async getAppStateAsync() {
+    var _a;
+    const response = await buildBackendApiClient()
+      .url('client-app-state')
+      .get()
+      .notFound(() => {
+      throw new Error('Failed to fetch application configuration.');
+    })
+      .json();
+    if ((_a = response.superBuyer.superChoice) === null || _a === void 0 ? void 0 : _a.choiceDetails) {
+      hydrateSuperChoiceDetailsDtoKind(response.superBuyer.superChoice.choiceDetails);
+      switch (response.superBuyer.superChoice.choiceDetails.kind) {
+        case 'Promoted':
+          hydratePromotedFundChoiceDtoKind(response.superBuyer.superChoice.choiceDetails.promoted);
+          break;
+      }
+    }
+    return response;
+  }
+  async clickPromotedTileAsync(payload) {
+    return buildBackendApiClient().url('click-promoted-tile').post(payload).res();
+  }
+  async viewSuperFundPanelAsync(payload) {
+    return buildBackendApiClient().url('view-super-fund-panel').post(payload).res();
+  }
+  toSearchFilterQueryString(searchFilter) {
+    return (`search=${searchFilter.searchString}` +
+      (searchFilter.maxRecordCount > 0 ? '&maxRecordCount=' + searchFilter.maxRecordCount : ''));
+  }
+  toQueryString(includeInactive, searchFilter) {
+    const search = this.toSearchFilterQueryString(searchFilter);
+    const inactive = includeInactive ? 'includeInactive=true' : '';
+    const isNotEmpty = (s) => s && s.length;
+    return [search, inactive].filter(isNotEmpty).join('&');
+  }
+}
+const superSelectionApi = new SuperSelectionApi();
+
+(function (SuperCampaignComponentStatus) {
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["NotLoaded"] = 1] = "NotLoaded";
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["Loaded"] = 2] = "Loaded";
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["NotWorking"] = 3] = "NotWorking";
+})(exports.SuperCampaignComponentStatus || (exports.SuperCampaignComponentStatus = {}));
+class SuperCampaignState {
+  constructor() {
+    this._promotedFundsShown = [];
+  }
+  get PromotedFundIds() {
+    return this._promotedFundsShown.map((p) => p.fundId);
+  }
+  set promotedFundsShown(value) {
+    this._promotedFundsShown = value;
+  }
+  get DefaultFundPosition() {
+    const index = this._promotedFundsShown.findIndex((value) => value.fundType === 'promoted-default');
+    if (index === -1)
+      return undefined;
+    return index + 1;
+  }
+}
+const initialState = {
+  apiBaseUrl: Option.none,
+  appBaseUrl: Option.none,
+  profileId: Option.none,
+  jwt: Option.none,
+  superBuyer: Option.none,
+  superChoicePrefill: Option.none,
+  promotedFunds: Option.none,
+  accountConfiguration: Option.none,
+  profileConfiguration: Option.none,
+  hasSuccessPageBeenAcknowledged: false,
+  hasSuperSelectionBeenSubmitted: false,
+  isDefinedBenefitsEligible: Option.none,
+  superCampaignEnabled: true,
+  superCampaignState: undefined,
+  superCampaignComponentStatus: exports.SuperCampaignComponentStatus.NotLoaded,
+  hideFooterSection: false,
+  bringYourOwnFundCustomStepEnabled: false,
+  featuredFundsEnabled: false
+};
+
+class SuperSelectionAppService {
+  constructor() {
+    const { state, onChange } = createStore(initialState);
+    this._state = state;
+    this._onChange = onChange;
+    onChange('jwt', (jwt) => {
+      this._state.profileId = _function.pipe(jwt, Option.chain((jwtValue) => Option.fromNullable(o(jwtValue).sub)));
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  get onChange() {
+    return this._onChange;
+  }
+  get superBuyer() {
+    if (Option.isNone(this._state.superBuyer)) {
+      throw Error('User information is not set');
+    }
+    return this._state.superBuyer.value;
+  }
+  get apiBaseUrl() {
+    if (Option.isNone(this._state.apiBaseUrl)) {
+      throw Error('API base URL is not set');
+    }
+    return this._state.apiBaseUrl.value;
+  }
+  get appBaseUrl() {
+    if (Option.isNone(this._state.appBaseUrl)) {
+      throw Error('App base URL is not set');
+    }
+    return this._state.appBaseUrl.value;
+  }
+  get promotedFunds() {
+    if (this.state.superCampaignEnabled && this.superCampaignState !== undefined) {
+      return this.superCampaignState.PromotedFundIds;
+    }
+    if (Option.isNone(this._state.promotedFunds)) {
+      throw Error('Promoted Funds is not set');
+    }
+    return this._state.promotedFunds.value;
+  }
+  get promotedDefaultFundPosition() {
+    if (this.state.superCampaignEnabled && this.superCampaignState !== undefined) {
+      return Option.fromNullable(this.superCampaignState.DefaultFundPosition);
+    }
+    return Option.none;
+  }
+  get promotedFundsConfig() {
+    return {
+      shownFunds: this.promotedFunds,
+      promotedDefaultFundPosition: Option.toUndefined(this.promotedDefaultFundPosition),
+      promotedFundsConfigSource: this.isUsingSuperCampaign ? 'superCampaign' : 'superSelection'
+    };
+  }
+  get profileId() {
+    if (Option.isNone(this._state.profileId)) {
+      throw Error('Failed to get Profile ID from JWT');
+    }
+    return this._state.profileId.value;
+  }
+  get defaultFundUsi() {
+    const profileConfigDefaultFundUsi = _function.pipe(this._state.profileConfiguration, Option.map((config) => Option.fromNullable(config.defaultFundUsi)), Option.flatten);
+    if (Option.isSome(profileConfigDefaultFundUsi)) {
+      return profileConfigDefaultFundUsi;
+    }
+    return _function.pipe(this._state.accountConfiguration, Option.map((config) => Option.fromNullable(config.defaultFundUsi)), Option.flatten);
+  }
+  get accountIdOrDefault() {
+    return _function.pipe(this._state.accountConfiguration, Option.map((config) => config.accountId), Option.getOrElse(() => ''));
+  }
+  get partnerIdOrDefault() {
+    return _function.pipe(this._state.superBuyer, Option.map((superBuyer) => superBuyer.partnerId), Option.getOrElse(() => ''));
+  }
+  get jwt() {
+    if (Option.isNone(this._state.jwt)) {
+      throw Error('No authentication information was found');
+    }
+    return this._state.jwt.value;
+  }
+  completeSuperSelectionFlow() {
+    this._state.hasSuccessPageBeenAcknowledged = true;
+  }
+  markSuperSelectionAsSubmitted() {
+    this._state.hasSuperSelectionBeenSubmitted = true;
+  }
+  get isDefinedBenefitsEligible() {
+    return this._state.isDefinedBenefitsEligible;
+  }
+  async loadAppStateAsync() {
+    const appStateResponse = await superSelectionApi.getAppStateAsync();
+    this._state.accountConfiguration = Option.fromNullable(appStateResponse.accountConfiguration);
+    this._state.profileConfiguration = Option.fromNullable(appStateResponse.profileConfiguration);
+    this._state.superBuyer = Option.fromNullable(appStateResponse.superBuyer);
+    this._state.promotedFunds = Option.fromNullable(appStateResponse.promotedFunds);
+    this._state.bringYourOwnFundCustomStepEnabled =
+      appStateResponse.bringYourOwnFundCustomStepEnabled;
+    this._state.featuredFundsEnabled = appStateResponse.featuredFundsEnabled;
+    this._state.superChoicePrefill = Option.fromNullable(appStateResponse.prefill);
+    this._state.isDefinedBenefitsEligible = Option.fromNullable(appStateResponse.isDefinedBenefitsEligible);
+    if (Option.isSome(this._state.accountConfiguration)) {
+      if (this._state.accountConfiguration.value.featureSet.type === 'basic') {
+        this._state.superCampaignEnabled = false;
+      }
+    }
+  }
+  setSuperCampaignPromotedFundsShown(shownFunds) {
+    if (this._state.superCampaignState !== undefined)
+      this._state.superCampaignState.promotedFundsShown = shownFunds;
+    else
+      throw new Error('Cannot set shown funds for SuperCampaing state because it is undefined');
+  }
+  viewSuperFundPanelAsync(placementId, promotedFundIdListOverride) {
+    return superSelectionApi.viewSuperFundPanelAsync(Object.assign(Object.assign({}, this.promotedFundsConfig), { shownFunds: promotedFundIdListOverride
+        ? promotedFundIdListOverride
+        : this.promotedFundsConfig.shownFunds, placementId }));
+  }
+  get superCampaignState() {
+    return this._state.superCampaignState;
+  }
+  get superCampaignComponentStatus() {
+    return this._state.superCampaignComponentStatus;
+  }
+  set superCampaignComponentStatus(value) {
+    if (value === exports.SuperCampaignComponentStatus.Loaded) {
+      this._state.superCampaignComponentStatus = exports.SuperCampaignComponentStatus.Loaded;
+      this._state.superCampaignState = new SuperCampaignState();
+    }
+    else {
+      this._state.superCampaignComponentStatus = value;
+      this._state.superCampaignState = undefined;
+    }
+  }
+  get isUsingSuperCampaign() {
+    return this.state.superCampaignEnabled && this.superCampaignState !== undefined;
+  }
+  get isBringYourOwnFundCustomStepEnabled() {
+    return this.state.bringYourOwnFundCustomStepEnabled;
+  }
+  get isFeaturedFundsEnabled() {
+    return this.state.featuredFundsEnabled;
+  }
+  get superCampaignCanNotBeActivated() {
+    return (!this.state.superCampaignEnabled ||
+      this.superCampaignComponentStatus === exports.SuperCampaignComponentStatus.NotWorking);
+  }
+  get hideFooterSection() {
+    return this._state.hideFooterSection;
+  }
+  set hideFooterSection(value) {
+    this._state.hideFooterSection = value;
+  }
+  get backendUrl() {
+    return Option.map(this.getBaseUrl)(this.state.apiBaseUrl);
+  }
+  getBaseUrl(url) {
+    const parsedUrl = new URL(url);
+    return `${parsedUrl.protocol}//${parsedUrl.hostname}${parsedUrl.port.length > 0 ? `:${parsedUrl.port}` : ''}`;
+  }
+}
+const superSelectionAppService = new SuperSelectionAppService();
+
+class NavigationService {
+  navigateInternally(history, route) {
+    const path = `${this.appBaseUrl}${this.toRouteWithLeadingSlash(route)}`;
+    iframe.navigation(path);
+    history.push(path);
+  }
+  navigateInternallyToStandardChoice(options) {
+    state.handleSubmitFn = options.handleSubmitFn;
+    state.fundName = options.fundName;
+    state.fundDetails = options.fundDetails;
+    state.promotedFundId = options.promotedFundId;
+    this.navigateInternally(options.history, exports.SuperSelectionAppRoutes.StandardChoice);
+  }
+  toExternalUrl(url) {
+    const externalUrl = new URL(url);
+    externalUrl.searchParams.append('_extnav', 'true');
+    return externalUrl.href;
+  }
+  get appBaseUrl() {
+    const baseUrl = superSelectionAppService.appBaseUrl;
+    return baseUrl.replace(/\/$/, '');
+  }
+  toRouteWithLeadingSlash(route) {
+    return route.length > 0 && route[0] === '/' ? route : `/${route}`;
+  }
+}
+const navigationService = new NavigationService();
+
+class CustomFundChoiceApi {
+  async submitDefaultFundChoiceAsync(dto) {
+    return buildBackendApiClient()
+      .url('super-choice/default')
+      .post(dto)
+      .badRequest(() => {
+      throw new Error('Failed to process default fund join request');
+    })
+      .text();
+  }
+  async submitCustomFundChoiceAsync(dto) {
+    return buildBackendApiClient()
+      .url('super-choice/custom-fund')
+      .post(dto)
+      .badRequest(() => {
+      throw new Error('Failed to process custom fund join request');
+    })
+      .text();
+  }
+  async submitSelfManagedFundChoiceAsync(dto) {
+    return buildBackendApiClient()
+      .url('super-choice/smsf')
+      .post(dto)
+      .badRequest(() => {
+      throw new Error('Failed to process SMSF choice request');
+    })
+      .text();
+  }
+  async submitDefinedBenefitsChoiceAsync(dto) {
+    return buildBackendApiClient()
+      .url('super-choice/defined-benefits')
+      .post(dto)
+      .badRequest(() => {
+      throw new Error('Failed to process Defined Benefits choice request');
+    })
+      .text();
+  }
+  async validateAbnForSMSF(abn) {
+    const response = await buildBackendApiClient()
+      .url(`super-choice/smsf/${abn}/validate`)
+      .get()
+      .badRequest(() => {
+      throw new Error('Failed to verify that if the provided abn is used for regulated fund');
+    })
+      .json();
+    return response.result;
+  }
+}
+const customFundChoiceApi = new CustomFundChoiceApi();
+
+exports.Option = Option;
+exports.buildBackendApiClient = buildBackendApiClient;
+exports.createStore = createStore;
+exports.customFundChoiceApi = customFundChoiceApi;
+exports.factory = factory;
+exports.fromNullable = fromNullable;
+exports.getPromotedFundId = getPromotedFundId;
+exports.getSuperChoiceMemberNumber = getSuperChoiceMemberNumber;
+exports.getSuperChoiceUsi = getSuperChoiceUsi;
+exports.iframe = iframe;
+exports.injectHistory = injectHistory;
+exports.isNone = isNone;
+exports.isSome = isSome;
+exports.navigationService = navigationService;
+exports.none = none;
+exports.slate = slate;
+exports.some = some;
+exports.state = state;
+exports.superSelectionApi = superSelectionApi;
+exports.superSelectionAppService = superSelectionAppService;
+exports.superSelectionAppStencilRoutes = superSelectionAppStencilRoutes;
+exports.toUndefined = toUndefined;