@flarehr/apollo-super-selection 5.54.16008 → 5.55.16332

package/dist/lib/esm/custom-fund-choice.api-45fa478c.js

@@ -0,0 +1,3022 @@
+import { e as getRenderingRef, f as forceUpdate, h } from './index-107d7c24.js';
+import { A as ActiveRouter } from './active-router-d18b36fb.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.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 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 = getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        });
+        on('set', (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        });
+        on('reset', () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(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);
+
+var SuperSelectionAppRoutes;
+(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/";
+})(SuperSelectionAppRoutes || (SuperSelectionAppRoutes = {}));
+const superSelectionAppStencilRoutes = [
+  h("stencil-route", { url: SuperSelectionAppRoutes.ExistingChoicePage, component: "sss-existing-choice-page" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.SuperCampaign, component: "sss-super-campaign-host" }),
+  h("stencil-route", { exact: true, url: SuperSelectionAppRoutes.ChoicePage, component: "sss-choice-router" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.MyOwnFund, component: "sss-super-byof-host" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.MyOwnFundEngagementStep, component: "sss-my-own-fund-engagement-step-host" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.PrefillInvalidMyOwnFundPage, component: "sss-prefill-invalid-my-own-fund" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.Prefill, component: "sss-prefill" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.PrefillMyOwnFundPage, component: "sss-prefill-my-own-fund" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.PrefillSMSFPage, component: "sss-prefill-smsf" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.PrefillInvalidSMSFPage, component: "sss-prefill-invalid-smsf" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.SelfManagedFund, component: "sss-super-smsf-host" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.DefaultFund, component: "sss-default-fund" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.FeaturedFunds, component: "sss-super-campaign-featured-funds" }),
+  h("stencil-route", { url: SuperSelectionAppRoutes.StandardChoice, component: "sss-standard-choice-form" }),
+  h("stencil-route", { url: 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();
+
+var SuperCampaignComponentStatus;
+(function (SuperCampaignComponentStatus) {
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["NotLoaded"] = 1] = "NotLoaded";
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["Loaded"] = 2] = "Loaded";
+  SuperCampaignComponentStatus[SuperCampaignComponentStatus["NotWorking"] = 3] = "NotWorking";
+})(SuperCampaignComponentStatus || (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: 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 === SuperCampaignComponentStatus.Loaded) {
+      this._state.superCampaignComponentStatus = 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 === 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, 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();
+
+export { Option as O, SuperSelectionAppRoutes as S, superSelectionAppService as a, navigationService as b, injectHistory as c, createStore as d, superSelectionApi as e, buildBackendApiClient as f, customFundChoiceApi as g, isNone as h, isSome as i, getPromotedFundId as j, getSuperChoiceUsi as k, getSuperChoiceMemberNumber as l, state as m, none as n, slate as o, SuperCampaignComponentStatus as p, iframe as q, superSelectionAppStencilRoutes as r, some as s, toUndefined as t, factory as u, fromNullable as v };