@flarehr/apollo-benefits 0.1.109 → 0.3.53405

package/dist/lib/esm/delay-115d4292.js

@@ -1,200 +0,0 @@
-import { O as Observable, s as subscribeToArray, c as scheduleArray, d as async, a as Subscriber } from './async-68e9cad7.js';
-
-const EMPTY = new Observable(subscriber => subscriber.complete());
-function empty(scheduler) {
-    return scheduler ? emptyScheduled(scheduler) : EMPTY;
-}
-function emptyScheduled(scheduler) {
-    return new Observable(subscriber => scheduler.schedule(() => subscriber.complete()));
-}
-
-function isScheduler(value) {
-    return value && typeof value.schedule === 'function';
-}
-
-function fromArray(input, scheduler) {
-    if (!scheduler) {
-        return new Observable(subscribeToArray(input));
-    }
-    else {
-        return scheduleArray(input, scheduler);
-    }
-}
-
-function of(...args) {
-    let scheduler = args[args.length - 1];
-    if (isScheduler(scheduler)) {
-        args.pop();
-        return scheduleArray(args, scheduler);
-    }
-    else {
-        return fromArray(args);
-    }
-}
-
-function throwError(error, scheduler) {
-    if (!scheduler) {
-        return new Observable(subscriber => subscriber.error(error));
-    }
-    else {
-        return new Observable(subscriber => scheduler.schedule(dispatch, 0, { error, subscriber }));
-    }
-}
-function dispatch({ error, subscriber }) {
-    subscriber.error(error);
-}
-
-var NotificationKind;
-(function (NotificationKind) {
-    NotificationKind["NEXT"] = "N";
-    NotificationKind["ERROR"] = "E";
-    NotificationKind["COMPLETE"] = "C";
-})(NotificationKind || (NotificationKind = {}));
-class Notification {
-    constructor(kind, value, error) {
-        this.kind = kind;
-        this.value = value;
-        this.error = error;
-        this.hasValue = kind === 'N';
-    }
-    observe(observer) {
-        switch (this.kind) {
-            case 'N':
-                return observer.next && observer.next(this.value);
-            case 'E':
-                return observer.error && observer.error(this.error);
-            case 'C':
-                return observer.complete && observer.complete();
-        }
-    }
-    do(next, error, complete) {
-        const kind = this.kind;
-        switch (kind) {
-            case 'N':
-                return next && next(this.value);
-            case 'E':
-                return error && error(this.error);
-            case 'C':
-                return complete && complete();
-        }
-    }
-    accept(nextOrObserver, error, complete) {
-        if (nextOrObserver && typeof nextOrObserver.next === 'function') {
-            return this.observe(nextOrObserver);
-        }
-        else {
-            return this.do(nextOrObserver, error, complete);
-        }
-    }
-    toObservable() {
-        const kind = this.kind;
-        switch (kind) {
-            case 'N':
-                return of(this.value);
-            case 'E':
-                return throwError(this.error);
-            case 'C':
-                return empty();
-        }
-        throw new Error('unexpected notification kind value');
-    }
-    static createNext(value) {
-        if (typeof value !== 'undefined') {
-            return new Notification('N', value);
-        }
-        return Notification.undefinedValueNotification;
-    }
-    static createError(err) {
-        return new Notification('E', undefined, err);
-    }
-    static createComplete() {
-        return Notification.completeNotification;
-    }
-}
-Notification.completeNotification = new Notification('C');
-Notification.undefinedValueNotification = new Notification('N', undefined);
-
-function isDate(value) {
-    return value instanceof Date && !isNaN(+value);
-}
-
-function delay(delay, scheduler = async) {
-    const absoluteDelay = isDate(delay);
-    const delayFor = absoluteDelay ? (+delay - scheduler.now()) : Math.abs(delay);
-    return (source) => source.lift(new DelayOperator(delayFor, scheduler));
-}
-class DelayOperator {
-    constructor(delay, scheduler) {
-        this.delay = delay;
-        this.scheduler = scheduler;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new DelaySubscriber(subscriber, this.delay, this.scheduler));
-    }
-}
-class DelaySubscriber extends Subscriber {
-    constructor(destination, delay, scheduler) {
-        super(destination);
-        this.delay = delay;
-        this.scheduler = scheduler;
-        this.queue = [];
-        this.active = false;
-        this.errored = false;
-    }
-    static dispatch(state) {
-        const source = state.source;
-        const queue = source.queue;
-        const scheduler = state.scheduler;
-        const destination = state.destination;
-        while (queue.length > 0 && (queue[0].time - scheduler.now()) <= 0) {
-            queue.shift().notification.observe(destination);
-        }
-        if (queue.length > 0) {
-            const delay = Math.max(0, queue[0].time - scheduler.now());
-            this.schedule(state, delay);
-        }
-        else {
-            this.unsubscribe();
-            source.active = false;
-        }
-    }
-    _schedule(scheduler) {
-        this.active = true;
-        const destination = this.destination;
-        destination.add(scheduler.schedule(DelaySubscriber.dispatch, this.delay, {
-            source: this, destination: this.destination, scheduler: scheduler
-        }));
-    }
-    scheduleNotification(notification) {
-        if (this.errored === true) {
-            return;
-        }
-        const scheduler = this.scheduler;
-        const message = new DelayMessage(scheduler.now() + this.delay, notification);
-        this.queue.push(message);
-        if (this.active === false) {
-            this._schedule(scheduler);
-        }
-    }
-    _next(value) {
-        this.scheduleNotification(Notification.createNext(value));
-    }
-    _error(err) {
-        this.errored = true;
-        this.queue = [];
-        this.destination.error(err);
-        this.unsubscribe();
-    }
-    _complete() {
-        this.scheduleNotification(Notification.createComplete());
-        this.unsubscribe();
-    }
-}
-class DelayMessage {
-    constructor(time, notification) {
-        this.time = time;
-        this.notification = notification;
-    }
-}
-
-export { Notification as N, delay as d, empty as e, isScheduler as i, of as o };

package/dist/lib/esm/distinctUntilChanged-bf69e0f8.js

@@ -1,363 +0,0 @@
-import { a as Subscriber, h as hostReportError, o as observable, s as subscribeToArray, i as isObject, O as Observable, S as Subscription, c as scheduleArray } from './async-68e9cad7.js';
-
-function map(project, thisArg) {
-    return function mapOperation(source) {
-        if (typeof project !== 'function') {
-            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
-        }
-        return source.lift(new MapOperator(project, thisArg));
-    };
-}
-class MapOperator {
-    constructor(project, thisArg) {
-        this.project = project;
-        this.thisArg = thisArg;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
-    }
-}
-class MapSubscriber extends Subscriber {
-    constructor(destination, project, thisArg) {
-        super(destination);
-        this.project = project;
-        this.count = 0;
-        this.thisArg = thisArg || this;
-    }
-    _next(value) {
-        let result;
-        try {
-            result = this.project.call(this.thisArg, value, this.count++);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        this.destination.next(result);
-    }
-}
-
-const subscribeToPromise = (promise) => (subscriber) => {
-    promise.then((value) => {
-        if (!subscriber.closed) {
-            subscriber.next(value);
-            subscriber.complete();
-        }
-    }, (err) => subscriber.error(err))
-        .then(null, hostReportError);
-    return subscriber;
-};
-
-function getSymbolIterator() {
-    if (typeof Symbol !== 'function' || !Symbol.iterator) {
-        return '@@iterator';
-    }
-    return Symbol.iterator;
-}
-const iterator = getSymbolIterator();
-
-const subscribeToIterable = (iterable) => (subscriber) => {
-    const iterator$1 = iterable[iterator]();
-    do {
-        let item;
-        try {
-            item = iterator$1.next();
-        }
-        catch (err) {
-            subscriber.error(err);
-            return subscriber;
-        }
-        if (item.done) {
-            subscriber.complete();
-            break;
-        }
-        subscriber.next(item.value);
-        if (subscriber.closed) {
-            break;
-        }
-    } while (true);
-    if (typeof iterator$1.return === 'function') {
-        subscriber.add(() => {
-            if (iterator$1.return) {
-                iterator$1.return();
-            }
-        });
-    }
-    return subscriber;
-};
-
-const subscribeToObservable = (obj) => (subscriber) => {
-    const obs = obj[observable]();
-    if (typeof obs.subscribe !== 'function') {
-        throw new TypeError('Provided object does not correctly implement Symbol.observable');
-    }
-    else {
-        return obs.subscribe(subscriber);
-    }
-};
-
-const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');
-
-function isPromise(value) {
-    return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
-}
-
-const subscribeTo = (result) => {
-    if (!!result && typeof result[observable] === 'function') {
-        return subscribeToObservable(result);
-    }
-    else if (isArrayLike(result)) {
-        return subscribeToArray(result);
-    }
-    else if (isPromise(result)) {
-        return subscribeToPromise(result);
-    }
-    else if (!!result && typeof result[iterator] === 'function') {
-        return subscribeToIterable(result);
-    }
-    else {
-        const value = isObject(result) ? 'an invalid object' : `'${result}'`;
-        const msg = `You provided ${value} where a stream was expected.`
-            + ' You can provide an Observable, Promise, Array, or Iterable.';
-        throw new TypeError(msg);
-    }
-};
-
-function scheduleObservable(input, scheduler) {
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        sub.add(scheduler.schedule(() => {
-            const observable$1 = input[observable]();
-            sub.add(observable$1.subscribe({
-                next(value) { sub.add(scheduler.schedule(() => subscriber.next(value))); },
-                error(err) { sub.add(scheduler.schedule(() => subscriber.error(err))); },
-                complete() { sub.add(scheduler.schedule(() => subscriber.complete())); },
-            }));
-        }));
-        return sub;
-    });
-}
-
-function schedulePromise(input, scheduler) {
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        sub.add(scheduler.schedule(() => input.then(value => {
-            sub.add(scheduler.schedule(() => {
-                subscriber.next(value);
-                sub.add(scheduler.schedule(() => subscriber.complete()));
-            }));
-        }, err => {
-            sub.add(scheduler.schedule(() => subscriber.error(err)));
-        })));
-        return sub;
-    });
-}
-
-function scheduleIterable(input, scheduler) {
-    if (!input) {
-        throw new Error('Iterable cannot be null');
-    }
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        let iterator$1;
-        sub.add(() => {
-            if (iterator$1 && typeof iterator$1.return === 'function') {
-                iterator$1.return();
-            }
-        });
-        sub.add(scheduler.schedule(() => {
-            iterator$1 = input[iterator]();
-            sub.add(scheduler.schedule(function () {
-                if (subscriber.closed) {
-                    return;
-                }
-                let value;
-                let done;
-                try {
-                    const result = iterator$1.next();
-                    value = result.value;
-                    done = result.done;
-                }
-                catch (err) {
-                    subscriber.error(err);
-                    return;
-                }
-                if (done) {
-                    subscriber.complete();
-                }
-                else {
-                    subscriber.next(value);
-                    this.schedule();
-                }
-            }));
-        }));
-        return sub;
-    });
-}
-
-function isInteropObservable(input) {
-    return input && typeof input[observable] === 'function';
-}
-
-function isIterable(input) {
-    return input && typeof input[iterator] === 'function';
-}
-
-function scheduled(input, scheduler) {
-    if (input != null) {
-        if (isInteropObservable(input)) {
-            return scheduleObservable(input, scheduler);
-        }
-        else if (isPromise(input)) {
-            return schedulePromise(input, scheduler);
-        }
-        else if (isArrayLike(input)) {
-            return scheduleArray(input, scheduler);
-        }
-        else if (isIterable(input) || typeof input === 'string') {
-            return scheduleIterable(input, scheduler);
-        }
-    }
-    throw new TypeError((input !== null && typeof input || input) + ' is not observable');
-}
-
-function from(input, scheduler) {
-    if (!scheduler) {
-        if (input instanceof Observable) {
-            return input;
-        }
-        return new Observable(subscribeTo(input));
-    }
-    else {
-        return scheduled(input, scheduler);
-    }
-}
-
-class SimpleInnerSubscriber extends Subscriber {
-    constructor(parent) {
-        super();
-        this.parent = parent;
-    }
-    _next(value) {
-        this.parent.notifyNext(value);
-    }
-    _error(error) {
-        this.parent.notifyError(error);
-        this.unsubscribe();
-    }
-    _complete() {
-        this.parent.notifyComplete();
-        this.unsubscribe();
-    }
-}
-class SimpleOuterSubscriber extends Subscriber {
-    notifyNext(innerValue) {
-        this.destination.next(innerValue);
-    }
-    notifyError(err) {
-        this.destination.error(err);
-    }
-    notifyComplete() {
-        this.destination.complete();
-    }
-}
-function innerSubscribe(result, innerSubscriber) {
-    if (innerSubscriber.closed) {
-        return undefined;
-    }
-    if (result instanceof Observable) {
-        return result.subscribe(innerSubscriber);
-    }
-    return subscribeTo(result)(innerSubscriber);
-}
-
-function filter(predicate, thisArg) {
-    return function filterOperatorFunction(source) {
-        return source.lift(new FilterOperator(predicate, thisArg));
-    };
-}
-class FilterOperator {
-    constructor(predicate, thisArg) {
-        this.predicate = predicate;
-        this.thisArg = thisArg;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
-    }
-}
-class FilterSubscriber extends Subscriber {
-    constructor(destination, predicate, thisArg) {
-        super(destination);
-        this.predicate = predicate;
-        this.thisArg = thisArg;
-        this.count = 0;
-    }
-    _next(value) {
-        let result;
-        try {
-            result = this.predicate.call(this.thisArg, value, this.count++);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        if (result) {
-            this.destination.next(value);
-        }
-    }
-}
-
-function distinctUntilChanged(compare, keySelector) {
-    return (source) => source.lift(new DistinctUntilChangedOperator(compare, keySelector));
-}
-class DistinctUntilChangedOperator {
-    constructor(compare, keySelector) {
-        this.compare = compare;
-        this.keySelector = keySelector;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
-    }
-}
-class DistinctUntilChangedSubscriber extends Subscriber {
-    constructor(destination, compare, keySelector) {
-        super(destination);
-        this.keySelector = keySelector;
-        this.hasKey = false;
-        if (typeof compare === 'function') {
-            this.compare = compare;
-        }
-    }
-    compare(x, y) {
-        return x === y;
-    }
-    _next(value) {
-        let key;
-        try {
-            const { keySelector } = this;
-            key = keySelector ? keySelector(value) : value;
-        }
-        catch (err) {
-            return this.destination.error(err);
-        }
-        let result = false;
-        if (this.hasKey) {
-            try {
-                const { compare } = this;
-                result = compare(this.key, key);
-            }
-            catch (err) {
-                return this.destination.error(err);
-            }
-        }
-        else {
-            this.hasKey = true;
-        }
-        if (!result) {
-            this.key = key;
-            this.destination.next(value);
-        }
-    }
-}
-
-export { SimpleOuterSubscriber as S, SimpleInnerSubscriber as a, filter as b, distinctUntilChanged as d, from as f, innerSubscribe as i, map as m };

package/dist/lib/esm/dom-utils-109a7d75.js

@@ -1,55 +0,0 @@
-const getConfirmation = (win, message, callback) => (callback(win.confirm(message)));
-const isModifiedEvent = (ev) => (ev.metaKey || ev.altKey || ev.ctrlKey || ev.shiftKey);
-/**
- * Returns true if the HTML5 history API is supported. Taken from Modernizr.
- *
- * https://github.com/Modernizr/Modernizr/blob/master/LICENSE
- * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
- * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586
- */
-const supportsHistory = (win) => {
-    const ua = win.navigator.userAgent;
-    if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&
-        ua.indexOf('Mobile Safari') !== -1 &&
-        ua.indexOf('Chrome') === -1 &&
-        ua.indexOf('Windows Phone') === -1) {
-        return false;
-    }
-    return win.history && 'pushState' in win.history;
-};
-/**
- * Returns true if browser fires popstate on hash change.
- * IE10 and IE11 do not.
- */
-const supportsPopStateOnHashChange = (nav) => (nav.userAgent.indexOf('Trident') === -1);
-/**
- * Returns false if using go(n) with hash history causes a full page reload.
- */
-const supportsGoWithoutReloadUsingHash = (nav) => (nav.userAgent.indexOf('Firefox') === -1);
-const isExtraneousPopstateEvent = (nav, event) => (event.state === undefined &&
-    nav.userAgent.indexOf('CriOS') === -1);
-const storageAvailable = (win, type) => {
-    const storage = win[type];
-    const x = '__storage_test__';
-    try {
-        storage.setItem(x, x);
-        storage.removeItem(x);
-        return true;
-    }
-    catch (e) {
-        return e instanceof DOMException && (
-        // everything except Firefox
-        e.code === 22 ||
-            // Firefox
-            e.code === 1014 ||
-            // test name field too, because code might not be present
-            // everything except Firefox
-            e.name === 'QuotaExceededError' ||
-            // Firefox
-            e.name === 'NS_ERROR_DOM_QUOTA_REACHED') &&
-            // acknowledge QuotaExceededError only if there's something already stored
-            storage.length !== 0;
-    }
-};
-
-export { supportsHistory as a, supportsPopStateOnHashChange as b, isExtraneousPopstateEvent as c, supportsGoWithoutReloadUsingHash as d, getConfirmation as g, isModifiedEvent as i, storageAvailable as s };

package/dist/lib/esm/fl-button_2.entry.js

@@ -1,45 +0,0 @@
-import { r as registerInstance, h } from './index-19c4d245.js';
-
-const buttonCss = ":host button,:host button:focus,:host button:active,:host button.focus,:host button.active{box-shadow:none;border-radius:var(--fl-rounding-button) !important}:host button.disabled,:host button:disabled{opacity:1 !important;cursor:not-allowed !important;color:var(--fl-color-disabled)}:host button .label{font-weight:600 !important}:host button.is-primary{color:var(--fl-color-primary-text);background-color:var(--fl-color-primary);border:none}:host button.is-primary.disabled,:host button.is-primary:disabled{background-color:var(--fl-color-primary-disabled)}:host button.is-primary:hover:not(.disabled),:host button.is-primary:hover:not(:disabled){background-color:var(--fl-color-primary-hover)}:host button.is-primary:active:not(.disabled),:host button.is-primary:active:not(:disabled){background-color:var(--fl-color-primary-focus)}:host button.is-secondary{color:var(--fl-color-secondary-text);background-color:var(--fl-color-secondary)}:host button.is-secondary.disabled,:host button.is-secondary:disabled{background-color:var(--fl-color-secondary-disabled)}:host button.is-secondary:hover:not(.disabled),:host button.is-secondary:hover:not(:disabled){background-color:var(--fl-color-secondary-hover)}:host button.is-secondary:active:not(.disabled),:host button.is-secondary:active:not(:disabled){background-color:var(--fl-color-secondary-focus)}:host button.is-block{display:block}:host button:disabled,:host button.disabled{pointer-events:none}";
-
-const ButtonComponent = class {
-  constructor(hostRef) {
-    registerInstance(this, hostRef);
-    this.isBlockElement = false;
-    this.disabled = false;
-    this.variant = 'primary';
-  }
-  render() {
-    return (h("button", { class: {
-        'btn position-relative px-3 py-2': true,
-        'is-primary': this.variant === 'primary',
-        'is-secondary': this.variant === 'secondary',
-        'btn-block': this.isBlockElement,
-        disabled: this.disabled
-      }, style: {
-        'pointer-events': this.disabled ? 'none' : 'auto'
-      }, disabled: this.disabled }, h("span", { class: "label" }, h("slot", null))));
-  }
-};
-ButtonComponent.style = buttonCss;
-
-const loadingIndicatorCss = "fl-loading-indicator .dots-container{width:36px}fl-loading-indicator .dot-flashing.theme-default{position:relative;width:8px;height:8px;border-radius:4px;background-color:#66efc5;color:#9880ff;animation:dot-flashing-default 2s infinite linear;animation-delay:0.5s}@keyframes dot-flashing-default{0%{background-color:#66efc5}25%{background-color:#12aa7c}50%,100%{background-color:#66efc5}}fl-loading-indicator .dot-flashing.theme-default::before,fl-loading-indicator .dot-flashing.theme-default::after{content:\"\";display:inline-block;position:absolute;top:0}fl-loading-indicator .dot-flashing.theme-default::before{left:-12px;width:8px;height:8px;border-radius:4px;background-color:#66efc5;color:#9880ff;animation:dot-flashing-default 2s infinite linear;animation-delay:0s}@keyframes dot-flashing-default{0%{background-color:#66efc5}25%{background-color:#12aa7c}50%,100%{background-color:#66efc5}}fl-loading-indicator .dot-flashing.theme-default::after{left:12px;width:8px;height:8px;border-radius:4px;background-color:#66efc5;color:#9880ff;animation:dot-flashing-default 2s infinite linear;animation-delay:1s}@keyframes dot-flashing-default{0%{background-color:#66efc5}25%{background-color:#12aa7c}50%,100%{background-color:#66efc5}}fl-loading-indicator .dot-flashing.theme-dark{position:relative;width:8px;height:8px;border-radius:4px;background-color:#a7a7a7;color:#9880ff;animation:dot-flashing-dark 2s infinite linear;animation-delay:0.5s}@keyframes dot-flashing-dark{0%{background-color:#a7a7a7}25%{background-color:#5b5a5a}50%,100%{background-color:#a7a7a7}}fl-loading-indicator .dot-flashing.theme-dark::before,fl-loading-indicator .dot-flashing.theme-dark::after{content:\"\";display:inline-block;position:absolute;top:0}fl-loading-indicator .dot-flashing.theme-dark::before{left:-12px;width:8px;height:8px;border-radius:4px;background-color:#a7a7a7;color:#9880ff;animation:dot-flashing-dark 2s infinite linear;animation-delay:0s}@keyframes dot-flashing-dark{0%{background-color:#a7a7a7}25%{background-color:#5b5a5a}50%,100%{background-color:#a7a7a7}}fl-loading-indicator .dot-flashing.theme-dark::after{left:12px;width:8px;height:8px;border-radius:4px;background-color:#a7a7a7;color:#9880ff;animation:dot-flashing-dark 2s infinite linear;animation-delay:1s}@keyframes dot-flashing-dark{0%{background-color:#a7a7a7}25%{background-color:#5b5a5a}50%,100%{background-color:#a7a7a7}}";
-
-const LoadingIndicator = class {
-  constructor(hostRef) {
-    registerInstance(this, hostRef);
-    this.theme = 'default';
-  }
-  render() {
-    return (h("span", { class: {
-        'dots-container d-inline-flex justify-content-center': true
-      } }, h("span", { class: {
-        'dot-flashing': true,
-        'theme-default': this.theme === 'default',
-        'theme-dark': this.theme === 'dark'
-      } })));
-  }
-};
-LoadingIndicator.style = loadingIndicatorCss;
-
-export { ButtonComponent as fl_button, LoadingIndicator as fl_loading_indicator };