import { Subject } from 'rxjs';
import { filter, switchMap } from 'rxjs/operators';
import { HttpClient } from '@angular/common/http';
import { createSelector } from 'reselect';

const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
function merge(target, ...sources) {
    return mergeDeep(target, ...sources);
}
/* eslint-enable */
/**
 * deep merge of two or more objects
 *
 * @param target immutable target
 * @param sources immutable sources to apply to target
 * @returns a new merged object
 */
// TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mergeDeep = (target, ...sources) => {
    const output = Object.assign({}, target);
    if (!sources.length) {
        return output;
    }
    const source = sources.shift();
    if (isObject(target) && isObject(source)) {
        Object.keys(source).forEach((key) => {
            if (isObject(source[key])) {
                if (!(key in target)) {
                    /* istanbul ignore next */
                    Object.assign(output, { [key]: source[key] });
                }
                else {
                    output[key] = mergeDeep(target[key], source[key]);
                }
            }
            else {
                Object.assign(output, { [key]: source[key] });
            }
        });
    }
    return mergeDeep(output, ...sources);
};
/* istanbul ignore next */
const mergeAll = (array) => array.reduce((prev, next) => mergeDeep(prev, next), {});

/**
 * Default xhr configuration
 */
const DEFAULT_XHR_CONFIG = {
    url: null,
    method: 'GET',
    responseType: 'json',
    headers: {},
    body: null,
    withCredentials: false,
    timeout: 0,
};
async function xhr(urlOrConfig) {
    // create the configuration and apply the default values
    let config = typeof urlOrConfig === 'string' ? { url: urlOrConfig } : urlOrConfig;
    config = Object.assign({}, DEFAULT_XHR_CONFIG, config);
    // create the promise
    return new Promise((resolve, reject) => {
        // configure and open the request
        const request = new XMLHttpRequest();
        request.open(config.method, config.url, true);
        request.responseType = config.responseType;
        Object.keys(config.headers || {}).map((name) => request.setRequestHeader(name, config.headers[name]));
        request.withCredentials = config.withCredentials;
        request.timeout = config.timeout;
        // called in case of timeout
        request.ontimeout = function () {
            reject(`Request timeout after ${request.timeout} milliseconds`);
        };
        // called after the response is received
        request.onload = function () {
            if (request.status === 200) {
                // the response is loaded properly
                resolve(request.response);
            }
            else {
                // status error
                reject(`Request failed with status ${request.status} (${request.statusText})`);
            }
        };
        // called in case of generic error
        request.onerror = function () {
            reject(`Request failed`);
        };
        // send the request
        request.send(config.body);
    });
}
/* eslint-enable */

class UxErrorOutput {
    constructor(info, errorFeedback, subErrors, errGroupMap) {
        this.severity = UxMessageSeverity.danger;
        if (!subErrors) {
            Object.assign(this, { ...info }, { ...errorFeedback });
        }
        else {
            Object.assign(this, { ...info }, { ...errorFeedback }, { subErrors }, { errGroupMap });
        }
    }
    getFeedBacks(byKey) {
        if (this.subErrors) {
            return this.subErrors
                .filter((err) => {
                if (err instanceof UxValidationErrorClass) {
                    if (byKey && err.attributes) {
                        return this.checkAttribute(byKey, err.attributes);
                    }
                    else if (byKey && !err.attributes) {
                        return false;
                    }
                    else if (!byKey) {
                        return true;
                    }
                }
            })
                .map((err) => ({
                msgId: err.msgId,
                description: err.description,
                severity: err.severity,
                attributes: err.attributes,
                errGroupId: err.errGroupId,
                br: err.br,
                doc: err.doc,
            }));
        }
        else {
            if (!byKey) {
                return [{ msgId: this.msgId, description: this.description, severity: this.severity, doc: this.doc }];
            }
            else {
                return [];
            }
        }
    }
    checkAttribute(key, attributes) {
        return attributes.some((attr) => key === attr.key);
    }
}
class UxErrorGroupOnClickEvent {
    constructor(groupId, err) {
        this.groupId = groupId;
        this.err = err;
    }
}
var UxMessageSeverity;
(function (UxMessageSeverity) {
    UxMessageSeverity["info"] = "info";
    UxMessageSeverity["warning"] = "warning";
    UxMessageSeverity["danger"] = "danger";
    UxMessageSeverity["success"] = "success";
})(UxMessageSeverity || (UxMessageSeverity = {}));
var UxMessageSeverityMetrics;
(function (UxMessageSeverityMetrics) {
    UxMessageSeverityMetrics[UxMessageSeverityMetrics["info"] = 0] = "info";
    UxMessageSeverityMetrics[UxMessageSeverityMetrics["warning"] = 1] = "warning";
    UxMessageSeverityMetrics[UxMessageSeverityMetrics["danger"] = 2] = "danger";
    UxMessageSeverityMetrics[UxMessageSeverityMetrics["success"] = 3] = "success";
})(UxMessageSeverityMetrics || (UxMessageSeverityMetrics = {}));
class UxValidationErrorClass {
    constructor(data) {
        this.severity = UxMessageSeverity.danger;
        Object.assign(this, data);
    }
}
const transformToUxHttpResponse = (resp, mapper) => {
    const updatedErr = resp;
    updatedErr.uxHttpErrorOutput = mapper(resp.error);
    return updatedErr;
};
class UxPublishErrorFeedbackEvent {
    constructor(err, id, groupId, accumulate) {
        this.err = err;
        this.id = id;
        this.groupId = groupId;
        this.accumulate = accumulate;
    }
}
class UxClearErrorFeedbackEvent {
    constructor(id, groupId) {
        this.id = id;
        this.groupId = groupId;
    }
}

class UxBadgeLegacy {
    constructor(values = {}) {
        this.typeClass = 'secondary';
        Object.assign(this, values);
    }
}
class UxLinkLegacy {
    constructor(values = {}) {
        this.urlExternalTarget = '_blank';
        this.disabled = false;
        this.hasIconBg = false;
        this.active = false;
        this.visible = true;
        this.expanded = false;
        this.hasMarker = false;
        this.hasTag = false;
        this.badgeTypeClass = 'secondary';
        this.isHome = false;
        this.isSeparator = false;
        this.isScreenReaderClickable = false;
        this.selected = false;
        this.indeterminate = false;
        Object.assign(this, values);
        if (this.id === null || this.id === undefined) {
            this.id = 'no_id';
        }
        this.e2eAttr = 'ux-link-e2e-' + this.id;
    }
    get hasChildren() {
        return this.children != null;
    }
}

class EuiService {
    constructor(defaultState) {
        this.onStateChange = new Subject();
        this.stateInstance = defaultState;
    }
    initEuiService() {
        this.unSubscribe();
        this.$stateSubs = this.getState().subscribe((newState) => {
            // set previous state of service
            this.prevStateInstance = this.copy(this.stateInstance);
            // update state before emit event
            this.stateInstance = this.copy(newState);
            // inform about state change
            this.onStateChange.next(newState);
        });
    }
    unSubscribe() {
        if (this.$stateSubs && this.$stateSubs.unsubscribe) {
            this.$stateSubs.unsubscribe();
        }
        if (this.$stateLazyLoadSubs && this.$stateLazyLoadSubs.unsubscribe) {
            this.$stateLazyLoadSubs.unsubscribe();
        }
    }
    /**
     * deep merge two objects
     * @param target the object that will be merged into
     * @param source the object that will be merged from
     */
    deepMerge(target, source) {
        const output = Object.assign({}, target);
        if (this.isObject(target) && this.isObject(source)) {
            Object.keys(source).forEach(key => {
                // Check if source[key] is an object and target[key] is either undefined, null, or an object
                if (this.isObject(source[key])) {
                    if (!(key in target) || target[key] === null) {
                        // If target[key] doesn't exist or is null, directly assign source[key]
                        Object.assign(output, { [key]: structuredClone(source[key]) });
                    }
                    else {
                        // Only deep merge if target[key] is also an object
                        output[key] = this.isObject(target[key])
                            ? this.deepMerge(target[key], source[key])
                            : structuredClone(source[key]);
                    }
                }
                else {
                    Object.assign(output, { [key]: source[key] });
                }
            });
        }
        return output;
    }
    /**
     * checks if the given item is an object
     * @param item the item that will be checked
     */
    isObject(item) {
        return item && typeof item === 'object' && !Array.isArray(item);
    }
    /**
     * returns a copy of the given value whether this value is object or primitive. For the arrays it will cover
     * multidimensional arrays, but it will not cover an object that contain functions. JSON.parse and JSON.stringify
     * might have performance issues on large scale objects but that's an edge case scenario. In case that happens in
     * the future follow the technique of NGRX with function caching.
     *
     * @param state
     */
    copy(state) {
        if (typeof state === 'undefined') {
            return undefined;
        }
        return JSON.parse(JSON.stringify(state));
    }
}
const getAppLoadedConfigModules$1 = (state) => state?.app?.loadedConfigModules;
class EuiLazyService extends EuiService {
    constructor(defaultState) {
        super(defaultState);
    }
    // todo it should use abstract store service
    initEuiService(storeForLazyLoad) {
        super.initEuiService();
        if (storeForLazyLoad) {
            this.$stateLazyLoadSubs = storeForLazyLoad
                .select(getAppLoadedConfigModules$1)
                .pipe(filter((loadedConfigModules) => loadedConfigModules?.modulesConfig?.[loadedConfigModules.lastAddedModule] ? true : false), switchMap((loadedConfigModules) => this.lazyLoadInit(loadedConfigModules.modulesConfig[loadedConfigModules.lastAddedModule], loadedConfigModules.lastAddedModule)))
                .subscribe(null);
        }
    }
}

/**
 * Abstract Log Appender
 */
class LogAppender {
    constructor(config, injector = null) {
        this.config = config;
        this.injector = injector;
    }
    /**
     * Gets the config
     *
     * @returns the config
     */
    getConfig() {
        return this.config;
    }
}

/** Log level */
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["OFF"] = 0] = "OFF";
    LogLevel[LogLevel["FATAL"] = 1] = "FATAL";
    LogLevel[LogLevel["ERROR"] = 2] = "ERROR";
    LogLevel[LogLevel["WARN"] = 3] = "WARN";
    LogLevel[LogLevel["INFO"] = 4] = "INFO";
    LogLevel[LogLevel["DEBUG"] = 5] = "DEBUG";
    LogLevel[LogLevel["TRACE"] = 6] = "TRACE";
    LogLevel[LogLevel["ALL"] = 7] = "ALL";
})(LogLevel || (LogLevel = {}));
/** Associated log level names */
var LogLevelName;
(function (LogLevelName) {
    LogLevelName["FATAL"] = "FATAL";
    LogLevelName["ERROR"] = "ERROR";
    LogLevelName["WARN"] = "WARNING";
    LogLevelName["INFO"] = "INFO";
    LogLevelName["DEBUG"] = "DEBUG";
    LogLevelName["TRACE"] = "TRACE";
})(LogLevelName || (LogLevelName = {}));

/** Default console prefix converters */
const DEFAULT_CONSOLE_APPENDER_PREFIX_CONVERTERS = {
    '{level}': (event) => event.levelName,
    '{logger}': (event) => event.loggerName,
    '{date}': (event) => event.timestamp.toLocaleDateString(),
    '{time}': (event) => event.timestamp.toLocaleTimeString(),
};
/**
 * Console Appender
 */
class ConsoleAppender extends LogAppender {
    constructor(config = {}) {
        super(config);
        this.config = config;
        // apply the default prefix converters
        config.prefixConverters = Object.assign({}, DEFAULT_CONSOLE_APPENDER_PREFIX_CONVERTERS, config.prefixConverters);
    }
    /**
     * Logs an event in the console
     */
    append(event) {
        // retrieve the prefix
        const prefix = this.getPrefix(event);
        // append it to the message array
        const messages = prefix ? [prefix, ...event.messages] : event.messages;
        // log the event in the console
        switch (event.level) {
            case LogLevel.FATAL:
            case LogLevel.ERROR:
                console.error(...messages);
                break;
            case LogLevel.WARN:
                console.warn(...messages);
                break;
            default:
                console.log(...messages);
                break;
        }
    }
    /**
     * Returns the prefix to be added to the messages
     *
     * @param event the log event
     * @returns the formatted prefix, as string
     */
    getPrefix(event) {
        // in case of no prefixFormat, return null
        if (!this.config || !this.config.prefixFormat) {
            return null;
        }
        // start creating the prefix from the format
        let prefix = this.config.prefixFormat;
        // apply the prefix converters
        Object.keys(this.config.prefixConverters).forEach((key) => {
            prefix = this.convert(prefix, key, this.config.prefixConverters[key](event));
        });
        return prefix;
    }
    /**
     * Utility method to replace a placeholder
     *
     * @param str the string with placeholders
     * @param find the placeholder
     * @param replace the string to replace the placeholder
     * @returns the converted string
     */
    convert(str, find, replace) {
        return str.replace(new RegExp(find, 'g'), replace);
    }
}

/**
 * Logger
 */
class Logger {
    constructor(name, level, appenders) {
        this.name = name;
        this.level = level;
        this.appenders = appenders;
        this.isDisabled = () => this.level === LogLevel.OFF;
        this.isEnabledFor = (level) => Logger.isEnabledFor(this.level, level);
        this.isFatalEnabled = () => this.isEnabledFor(LogLevel.FATAL);
        this.isErrorEnabled = () => this.isEnabledFor(LogLevel.ERROR);
        this.isWarnEnabled = () => this.isEnabledFor(LogLevel.WARN);
        this.isInfoEnabled = () => this.isEnabledFor(LogLevel.INFO);
        this.isDebugEnabled = () => this.isEnabledFor(LogLevel.DEBUG);
        this.isTraceEnabled = () => this.isEnabledFor(LogLevel.TRACE);
        this.isAllEnabled = () => this.isEnabledFor(LogLevel.ALL);
    }
    static isEnabledFor(enabledFromLevel, level) {
        return enabledFromLevel >= level;
    }
    /**
     * Gets the logger name
     *
     * @returns the logger name
     */
    getName() {
        return this.name;
    }
    /**
     * Gets the log level
     *
     * @returns the log level
     */
    getLevel() {
        return this.level;
    }
    /**
     * Sets the log level
     *
     * @param level log level
     */
    setLevel(level) {
        this.level = level;
    }
    /**
     * Fatal log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    fatal(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.FATAL,
            levelName: LogLevelName.FATAL,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Error log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    error(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.ERROR,
            levelName: LogLevelName.ERROR,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Warning log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    warn(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.WARN,
            levelName: LogLevelName.WARN,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Info log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    info(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.INFO,
            levelName: LogLevelName.INFO,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Debug log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    debug(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.DEBUG,
            levelName: LogLevelName.DEBUG,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Trace log
     *
     * @param message mandatory message
     * @param additionalMessages optional messages
     */
    trace(message, ...additionalMessages) {
        return this.log({
            level: LogLevel.TRACE,
            levelName: LogLevelName.TRACE,
            loggerName: this.name,
            timestamp: new Date(),
            messages: [message, ...additionalMessages],
        });
    }
    /**
     * Generic log method, checking the log level and calling the specified appenders
     *
     * @param event the log event
     */
    log(event) {
        this.appenders
            // filter the appender by their custom logLevel or the logger (main) logLevel
            .filter((appender) => Logger.isEnabledFor(appender.getConfig().logLevel || this.level, event.level), this)
            // execute the remaining appenders
            .forEach((appender) => appender.append(event));
    }
}

class LoggerMock extends Logger {
    constructor() {
        super(null, null, null);
        this.isDisabled = () => false;
        this.isEnabledFor = () => false;
        this.isFatalEnabled = () => false;
        this.isErrorEnabled = () => false;
        this.isWarnEnabled = () => false;
        this.isInfoEnabled = () => false;
        this.isDebugEnabled = () => false;
        this.isTraceEnabled = () => false;
        this.isAllEnabled = () => false;
    }
    getLevel() {
        return null;
    }
    setLevel() {
        /* empty */
    }
    fatal() {
        /* empty */
    }
    error() {
        /* empty */
    }
    warn() {
        /* empty */
    }
    info() {
        /* empty */
    }
    debug() {
        /* empty */
    }
    trace() {
        /* empty */
    }
}

/**
 * Url Appender
 */
class UrlAppender extends LogAppender {
    constructor(config, injector) {
        super(config, injector);
        this.config = config;
        this.injector = injector;
        // set the http client
        this.http = injector && injector.get(HttpClient, null);
        if (!this.http) {
            console.error('UrlAppender needs HttpClient service to be defined as a provider.');
        }
    }
    /**
     * Logs an event to a server
     */
    append(event) {
        // eventual http errors will be caught by the HttpErrorHandlerInterceptor
        if (this.http) {
            this.http.post(this.config.url, this.toUrlEvent(event)).subscribe();
        }
    }
    /**
     * Maps a LogEvent into a UrlLogEvent
     */
    toUrlEvent(event) {
        // check if the urlEventFromLevel allows the mapping to url log event
        const toUrlEvent = this.config.detailedEventFromLevel && Logger.isEnabledFor(this.config.detailedEventFromLevel, event.level);
        // returns the url event or the regular log event
        return toUrlEvent
            ? Object.assign({}, this.filterErrorType(event), {
                position: this.getPosition(),
                location: this.getLocation(),
            })
            : event;
    }
    /**
     * returns the code position from where the log has been triggered
     */
    getPosition() {
        // create a dummy error, just for the stack trace
        const error = new Error();
        try {
            // throw it ...
            throw error;
        }
        catch (e) {
            // ... and catch it
            try {
                // extract the correct stack line
                let stackLine = error.stack.split('\n')[3].trim();
                if (stackLine.startsWith('at ')) {
                    stackLine = stackLine.substring('at '.length);
                }
                // if the path is specified in parentheses
                if (stackLine.lastIndexOf('(') > 0) {
                    stackLine = stackLine.substring(stackLine.lastIndexOf('(') + 1, stackLine.indexOf(')'));
                }
                // strip base path, then parse file, line and column
                const data = stackLine.substring(stackLine.lastIndexOf('/') + 1).split(':');
                // if the data is parsed correctly
                if (data.length === 3) {
                    return {
                        file: data[0],
                        line: +data[1],
                        column: +data[2],
                    };
                }
            }
            catch (err) {
                /* empty */
            }
        }
        /* istanbul ignore next */
        return null;
    }
    /**
     * returns the url of the current page
     */
    getLocation() {
        return window && window.location && window.location.href;
    }
    /**
     * check messages if object type is Error and make its properties enumerable
     */
    filterErrorType(event) {
        event.messages = event.messages.map((m) => (m instanceof Error ? Object.getOwnPropertyDescriptors(m) : m));
        return event;
    }
}

const getI18nServiceConfigFromBase = (baseGlobalConfig) => {
    if (!baseGlobalConfig)
        throw new Error('baseGlobalConfig is required');
    const i18nServiceConfig = baseGlobalConfig && baseGlobalConfig.i18n && baseGlobalConfig.i18n.i18nService;
    const { languages, defaultLanguage } = getI18nServiceConfig(i18nServiceConfig);
    return { languages, defaultLanguage };
};
const getI18nServiceConfig = (config) => Object.assign({}, config);
const getI18nLoaderConfig = (config) => {
    const { i18nFolders, i18nServices, i18nResources } = Object.assign({}, config);
    return { i18nFolders, i18nServices, i18nResources };
};
/**
 * returns a language code based on https://tools.ietf.org/rfc/bcp/bcp47.txt specification. To get the Browser's
 * it's using the navigator.language, splits by hyphen and get the first part.
 */
const getBrowserDefaultLanguage = () => navigator.language.split('-')[0];
/**
 * returns an array of DOMStrings representing the user's preferred languages. The language is described using BCP 47
 * language tags. In the returned array they are ordered by preference with the most preferred language first.
 * The array languages will be lower cased 2 char code.
 */
const getBrowserPreferredLanguages = () => navigator.languages.map((lang) => lang.split('-')[0]);

/**
 * responsible to extract the attributes "available" and "id" from the locale configuration
 */
const getLocaleServiceConfigFromBase = (baseGlobalConfig) => {
    const { bindWithTranslate } = baseGlobalConfig.locale;
    return { bindWithTranslate };
};

const initialUserPreferences = Object.assign({}, {
    lang: null,
    dashboard: null,
});

const getAppState = (state) => state.app;
const getUserState = (state) => state.user;
const getNotificationsState = (state) => state.notifications;
const getI18nState = (state) => state.i18n;
const getLocaleState = (state) => state.locale;

const getAppVersion = createSelector(getAppState, (state) => state.version);
const getAppConnection = createSelector(getAppState, (state) => state.connected);
/**
 * Returns the loaded config modules from the app state
 * @deprecated It will be removed in the future.
 */
const getAppLoadedConfigModules = createSelector(getAppState, (state) => state.loadedConfigModules);
/**
 * Returns the last added module from the app state
 * @deprecated It will be removed in the future.
 */
const getLastAddedModule = createSelector(getAppState, (state) => state.loadedConfigModules.lastAddedModule);
const getAppStatus = createSelector(getAppState, (state) => state.status);
const getCurrentModule = createSelector(getAppState, (state) => state.currentModule);
const getApiQueue = createSelector(getAppState, (state) => state.apiQueue);
const getApiQueueItem = (itemId) => createSelector(getAppState, (state) => state.apiQueue[itemId]);

const getActiveLang = createSelector(getI18nState, (state) => state.activeLang);

const getUserDetails = createSelector(getUserState, (state) => state);
const getUserPreferences = createSelector(getUserState, (state) => state.preferences);
const getUserId = createSelector(getUserDetails, (state) => state.userId);
const getUserFirstName = createSelector(getUserDetails, (state) => state.firstName);
const getUserLastName = createSelector(getUserDetails, (state) => state.lastName);
const getUserFullName = createSelector(getUserDetails, (state) => state.fullName);
const getUserLang = createSelector(getUserPreferences, (state) => state.lang);
const getUserRights = createSelector(getUserState, (state) => state.rights);
const getUserRight = (rightId) => createSelector(getUserRights, (state) => state.find((right) => right && right.id === rightId));
const getUserRightPermissions = (rightId) => createSelector(getUserRight(rightId), (state) => state && state.permissions);
const getUserDashboard = createSelector(getUserPreferences, (state) => state.dashboard);

const getNotificationsList = createSelector(getNotificationsState, (state) => state.list);

const initialAppState = Object.assign({}, {
    version: '0.0.0',
    connected: true,
    loadedConfigModules: {
        modulesConfig: {},
    },
    status: 'idle',
    currentModule: '',
    apiQueue: {},
});

const initialUserState = Object.assign({}, {
    userId: '',
    firstName: '',
    lastName: '',
    fullName: '',
    preferences: initialUserPreferences,
    rights: [],
});

/**
 * The initial state of the notifications state.
 */
const initialNotificationsState = {
    list: [],
};

const initialI18nState = {
    activeLang: null,
};

/**
 * The initial state of the locale state. The default locale is English US ('en').
 */
const initialLocaleState = {
    id: 'en',
};

const initialCoreState = Object.assign({}, {
    app: initialAppState,
    user: initialUserState,
    notifications: initialNotificationsState,
    i18n: initialI18nState,
    locale: initialLocaleState,
});

const DefaultConfig = {
    totalItems: 0,
    pageSize: 10,
    currentPage: 1,
    pageWindowSize: 5,
};
class EuiPagination {
    constructor(totalItems = DefaultConfig.totalItems, pageSize = DefaultConfig.pageSize, currentPage = DefaultConfig.currentPage, pageWindowSize = DefaultConfig.pageWindowSize) {
        this.totalItems = totalItems;
        this.pageSize = pageSize;
        this.currentPage = currentPage;
        this.pageWindowSize = pageWindowSize;
    }
    static create(config = DefaultConfig) {
        if (config.totalItems < 0) {
            throw new Error('total items cannot be negative');
        }
        if (config.pageSize <= 0) {
            throw new Error('page size must be bigger than zero');
        }
        if (config.pageWindowSize <= 0) {
            throw new Error('page window size must be bigger than zero');
        }
        return new EuiPagination(config.totalItems, config.pageSize, config.currentPage, config.pageWindowSize);
    }
    getFirstPage() {
        return 1;
    }
    getLastPage() {
        return this.getPagesCount();
    }
    isFirstPageActive() {
        return this.getCurrentPage() === 1;
    }
    isLastPageActive() {
        return this.getCurrentPage() === this.getPagesCount();
    }
    hasItems() {
        return this.getTotalItems() > 0;
    }
    getPagesCount() {
        const pagesCount = Math.ceil(this.totalItems / this.pageSize);
        return Math.max(pagesCount, 1);
    }
    getPages() {
        const pageWindowSize = this.getPageWindowSize();
        const pagesCount = this.getPagesCount();
        const currentPage = this.getCurrentPage();
        let leftPageWindowSize;
        let rightPageWindowSize;
        let startPage;
        let endPage;
        // should not be bigger than pages count
        const truncatedPageWindowSize = Math.min(...[this.getPageWindowSize(), this.getPagesCount()]);
        if (truncatedPageWindowSize % 2 === 0) {
            // nonsymetrical pager (...*....)
            leftPageWindowSize = truncatedPageWindowSize / 2 - 1;
            rightPageWindowSize = leftPageWindowSize + 1;
        }
        else {
            // symmetrical pager (...*...)
            leftPageWindowSize = rightPageWindowSize = Math.floor(pageWindowSize / 2);
        }
        if (currentPage <= leftPageWindowSize) {
            // start
            startPage = 1;
            endPage = truncatedPageWindowSize;
        }
        else if (currentPage > pagesCount - rightPageWindowSize) {
            // end
            startPage = pagesCount - truncatedPageWindowSize + 1;
            endPage = pagesCount;
        }
        else {
            // middle
            startPage = currentPage - leftPageWindowSize;
            endPage = currentPage + rightPageWindowSize;
        }
        return range(startPage, endPage + 1);
    }
    goToPage(page) {
        const pagesCount = this.getPagesCount();
        const upperTrunc = Math.min(...[page, pagesCount]);
        const truncated = Math.max(...[upperTrunc, 1]);
        this.currentPage = truncated;
    }
    goToFirstPage() {
        this.goToPage(1);
    }
    goToLastPage() {
        const lastPage = this.getPagesCount();
        this.goToPage(lastPage);
    }
    goToNextPage() {
        const nextPage = this.getCurrentPage() + 1;
        this.goToPage(nextPage);
    }
    goToPreviousPage() {
        const previousPage = this.getCurrentPage() - 1;
        this.goToPage(previousPage);
    }
    hasPreviousPage() {
        return this.getCurrentPage() > 1;
    }
    hasNextPage() {
        return this.getCurrentPage() < this.getPagesCount();
    }
    getTotalItems() {
        return this.totalItems;
    }
    getPageSize() {
        return this.pageSize;
    }
    setPageSize(size) {
        const truncated = Math.max(...[size, 1]);
        this.pageSize = truncated;
    }
    getCurrentPage() {
        return this.currentPage;
    }
    getPageWindowSize() {
        return this.pageWindowSize;
    }
    setPageWindowSize(size) {
        const truncated = Math.max(...[size, 1]);
        this.pageWindowSize = truncated;
    }
    getShowingFrom() {
        const startingIndex = (this.getCurrentPage() - 1) * this.getPageSize();
        let startingPage = startingIndex + 1;
        if (!this.hasItems()) {
            startingPage = 0;
        }
        return startingPage;
    }
    getShowingTo() {
        const displayStartItem = this.getShowingFrom();
        const pageSize = this.getPageSize();
        const totalItems = this.getTotalItems();
        if (!this.hasItems()) {
            return 0;
        }
        const pageEnd = Math.min(...[displayStartItem + pageSize - 1, totalItems]);
        return pageEnd;
    }
}
const range = (start, end, step = 1) => {
    const output = [];
    if (typeof end === 'undefined') {
        end = start;
        start = 0;
    }
    for (let i = start; i < end; i += step) {
        output.push(i);
    }
    return output;
};

const EUI_COLORS = {
    text: '#333333',
    default: '#333333',
    black: '#000000',
    white: '#ffffff',
    primary: '#004494',
    primaryDark: '#003e8c',
    primaryDarker: '#003581',
    primaryDarkest: '#002d77',
    primaryDarkester: '#001f65',
    primaryDarkester2: '#00174c',
    primaryLight: '#2660a4',
    primaryLighter: '#4d7cb4',
    primaryLightest: '#80a2ca',
    primaryLightester: '#b3c7df',
    primaryLightester2: '#e0e9f2 ',
    accent: '#ffeb3b',
    accentDark: '#ffd114',
    accentDarker: '#fc1',
    accentDarkest: '#ffc60d',
    accentDarkester: '#ffbc07',
    accentDarkester2: '#edad00',
    accentLight: '#ffdc3a',
    accentLighter: '#ffe25d',
    accentLightest: '#ffeb8b',
    accentLightester: '#fff3b9',
    accentLightester2: '#fffae3',
    info: '#03a9f4',
    infoDark: '#039be5',
    infoDarker: '#0288d1',
    infoDarkest: '#0277bd',
    infoDarkester: '#01579b',
    infoDarkester2: '#003473',
    infoLight: '#29b6f6',
    infoLighter: '#4fc3f7',
    infoLightest: '#81d4fa',
    infoLightester: '#b3e5fc',
    infoLightester2: '#e0eef6',
    success: '#4caf50',
    successDark: '#3f7233',
    successDarker: '#37672c',
    successDarkest: '#2f5d24',
    successDarkester: '#204a17',
    successDarkester2: '#183711',
    successLight: '#628e57',
    successLighter: '#7ea274',
    successLightest: '#a3bd9c',
    successLightester: '#c8d7c4',
    successLightester2: '#e9efe7',
    warning: '#ff9800',
    warningDark: '#f08d23',
    warningDarker: '#ee821d',
    warningDarkest: '#ec7817',
    warningDarkester: '#e8670e',
    warningDarkester2: '#d05c0d',
    warningLight: '#f4a547',
    warningLighter: '#f6b568',
    warningLightest: '#f9ca93',
    warningLightester: '#fbdfbe',
    warningLightester2: '#fdf2e5',
    danger: '#f44336',
    dangerDark: '#d61d2b',
    dangerDarker: '#d01824',
    dangerDarkest: '#cb141e',
    dangerDarkester: '#c20b13',
    dangerDarkester2: '#aa0a11',
    dangerLight: '#e0424f',
    dangerLighter: '#e5646e',
    dangerLightest: '#ed9098',
    dangerLightester: '#f4bcc1',
    dangerLightester2: '#fbe4e6',
    grey: '#9e9e9e',
    greyDark: '#757575',
    greyDarker: '#616161',
    greyDarkest: '#424242',
    greyDarkester: '#212121',
    greyDarkester2: '#141414',
    greyLight: '#bdbdbd',
    greyLighter: '#d2d2d2',
    greyLightest: '#eeeeee',
    greyLightester: '#f5f5f5',
    greyLightester2: '#fafafa',
};

const EUI_DEFAULT_AUTH_CONFIG = {
    isLoggedIn: true,
    redirectUrl: '',
    loginPageUrl: '',
};

class EuiEuLanguages {
    static { this.languages = {
        bg: {
            code: 'bg',
            label: 'български',
        },
        cs: {
            code: 'cs',
            label: 'čeština',
        },
        da: {
            code: 'da',
            label: 'dansk',
        },
        de: {
            code: 'de',
            label: 'Deutsch',
        },
        et: {
            code: 'et',
            label: 'eesti keel',
        },
        el: {
            code: 'el',
            label: 'ελληνικά',
        },
        en: {
            code: 'en',
            label: 'English',
        },
        es: {
            code: 'es',
            label: 'español',
        },
        fr: {
            code: 'fr',
            label: 'français',
        },
        ga: {
            code: 'ga',
            label: 'Gaeilge',
        },
        hr: {
            code: 'hr',
            label: 'hrvatski',
        },
        it: {
            code: 'it',
            label: 'italiano',
        },
        lv: {
            code: 'lv',
            label: 'latviešu valoda',
        },
        lt: {
            code: 'lt',
            label: 'lietuvių kalba',
        },
        hu: {
            code: 'hu',
            label: 'magyar',
        },
        mt: {
            code: 'mt',
            label: 'Malti',
        },
        nl: {
            code: 'nl',
            label: 'Nederlands',
        },
        pl: {
            code: 'pl',
            label: 'polski',
        },
        pt: {
            code: 'pt',
            label: 'português',
        },
        ro: {
            code: 'ro',
            label: 'română',
        },
        sk: {
            code: 'sk',
            label: 'slovenčina',
        },
        sl: {
            code: 'sl',
            label: 'slovenščina',
        },
        fi: {
            code: 'fi',
            label: 'suomi',
        },
        sv: {
            code: 'sv',
            label: 'svenska',
        },
    }; }
    static { this.allLanguages = [
        { code: 'aa', label: 'Afaraf' },
        { code: 'ab', label: 'аҧсуа' },
        { code: 'ae', label: 'avesta' },
        { code: 'af', label: 'Afrikaans' },
        { code: 'ak', label: 'Akan' },
        { code: 'am', label: 'አማርኛ' },
        { code: 'an', label: 'Aragonés' },
        { code: 'ar', label: 'العربية', isRtl: true },
        { code: 'as', label: 'অসমীয়া' },
        { code: 'av', label: 'авар мацӀ, магӀарул мацӀ' },
        { code: 'ay', label: 'aymar aru' },
        { code: 'az', label: 'azərbaycan dili' },
        { code: 'ba', label: 'башҡорт теле' },
        { code: 'be', label: 'Беларуская' },
        { code: 'bg', label: 'български' },
        { code: 'bh', label: 'भोजपुरी' },
        { code: 'bi', label: 'Bislama' },
        { code: 'bm', label: 'bamanankan' },
        { code: 'bn', label: 'বাংলা' },
        { code: 'bo', label: 'བོད་ཡིག' },
        { code: 'br', label: 'brezhoneg' },
        { code: 'bs', label: 'bosanski jezik' },
        { code: 'ca', label: 'Català' },
        { code: 'ce', label: 'нохчийн мотт' },
        { code: 'ch', label: 'Chamoru' },
        { code: 'co', label: 'corsu, lingua corsa' },
        { code: 'cr', label: 'ᓀᐦᐃᔭᐍᐏᐣ' },
        { code: 'cs', label: 'čeština' },
        { code: 'cu', label: 'ѩзыкъ словѣньскъ' },
        { code: 'cv', label: 'чӑваш чӗлхи' },
        { code: 'cy', label: 'Cymraeg' },
        { code: 'da', label: 'dansk' },
        { code: 'de', label: 'Deutsch' },
        { code: 'dv', label: 'ދިވެހި' },
        { code: 'ee', label: 'Eʋegbe' },
        { code: 'el', label: 'Ελληνικά' },
        { code: 'en', label: 'English' },
        { code: 'eo', label: 'Esperanto' },
        { code: 'es', label: 'español' },
        { code: 'et', label: 'eesti' },
        { code: 'eu', label: 'euskara, euskera' },
        { code: 'fa', label: 'فارسی', isRtl: true },
        { code: 'ff', label: 'Fulfulde, Pulaar, Pular' },
        { code: 'fi', label: 'suomi' },
        { code: 'fj', label: 'vosa Vakaviti' },
        { code: 'fo', label: 'føroyskt' },
        { code: 'fr', label: 'français' },
        { code: 'fy', label: 'Frysk' },
        { code: 'ga', label: 'Gaeilge' },
        { code: 'gd', label: 'Gàidhlig' },
        { code: 'gl', label: 'Galego' },
        { code: 'gn', label: 'Avañeẽ' },
        { code: 'gu', label: 'ગુજરાતી' },
        { code: 'gv', label: 'Gaelg, Gailck' },
        { code: 'ha', label: 'Hausa, هَوُسَ' },
        { code: 'he', label: 'עברית', isRtl: true },
        { code: 'hi', label: 'हिन्दी, हिंदी' },
        { code: 'ho', label: 'Hiri Motu' },
        { code: 'hr', label: 'hrvatski' },
        { code: 'ht', label: 'Kreyòl ayisyen' },
        { code: 'hu', label: 'Magyar' },
        { code: 'hy', label: 'Հայերեն' },
        { code: 'hz', label: 'Otjiherero' },
        { code: 'ia', label: 'Interlingua' },
        { code: 'id', label: 'Bahasa Indonesia' },
        { code: 'ie', label: 'Originally called Occidental' },
        { code: 'ig', label: 'Asụsụ Igbo' },
        { code: 'ii', label: 'ꆈꌠ꒿ Nuosuhxop' },
        { code: 'ik', label: 'Iñupiaq, Iñupiatun' },
        { code: 'io', label: 'Ido' },
        { code: 'is', label: 'Íslenska' },
        { code: 'it', label: 'Italiano' },
        { code: 'iu', label: 'ᐃᓄᒃᑎᑐᑦ' },
        { code: 'ja', label: '日本語' },
        { code: 'jv', label: 'basa Jawa' },
        { code: 'ka', label: 'ქართული' },
        { code: 'kg', label: 'KiKongo' },
        { code: 'ki', label: 'Gĩkũyũ' },
        { code: 'kj', label: 'Kuanyama' },
        { code: 'kk', label: 'Қазақ тілі' },
        { code: 'kl', label: 'kalaallisut' },
        { code: 'km', label: 'ភាសាខ្មែរ' },
        { code: 'kn', label: 'ಕನ್ನಡ' },
        { code: 'ko', label: '한국어 (韓國語), 조선말 (朝鮮語)' },
        { code: 'kr', label: 'Kanuri' },
        { code: 'ks', label: 'कश्मीरी, كشميري‎' },
        { code: 'ku', label: 'Kurdî, كوردی‎', isRtl: true },
        { code: 'kv', label: 'коми кыв' },
        { code: 'kw', label: 'Kernewek' },
        { code: 'ky', label: 'кыргыз тили' },
        { code: 'la', label: 'latine' },
        { code: 'lb', label: 'Lëtzebuergesch' },
        { code: 'lg', label: 'Luganda' },
        { code: 'li', label: 'Limburgs' },
        { code: 'ln', label: 'Lingála' },
        { code: 'lo', label: 'ພາສາລາວ' },
        { code: 'lt', label: 'lietuvių kalba' },
        { code: 'lu', label: 'Lëtzebuergesch' },
        { code: 'lv', label: 'latviešu valoda' },
        { code: 'me', label: 'crnogorski jezik' },
        { code: 'mg', label: 'Malagasy fiteny' },
        { code: 'mh', label: 'Kajin M̧ajeļ' },
        { code: 'mi', label: 'te reo Māori' },
        { code: 'mk', label: 'македонски јазик' },
        { code: 'ml', label: 'മലയാളം' },
        { code: 'mn', label: 'монгол' },
        { code: 'mr', label: 'मराठी' },
        { code: 'ms', label: 'bahasa Melayu, بهاس ملايو‎' },
        { code: 'mt', label: 'Malti' },
        { code: 'my', label: 'ဗမာစာ' },
        { code: 'na', label: 'Ekakairũ Naoero' },
        { code: 'nb', label: 'Norsk bokmål' },
        { code: 'nd', label: 'isiNdebele' },
        { code: 'ne', label: 'नेपाली' },
        { code: 'ng', label: 'Owambo' },
        { code: 'nl', label: 'Nederlands' },
        { code: 'nn', label: 'Norsk nynorsk' },
        { code: 'no', label: 'Norsk' },
        { code: 'nr', label: 'isiNdebele' },
        { code: 'nv', label: 'Diné bizaad, Dinékʼehǰí' },
        { code: 'ny', label: 'chiCheŵa, chinyanja' },
        { code: 'oc', label: 'Occitan' },
        { code: 'oj', label: 'ᐊᓂᔑᓈᐯᒧᐎᓐ' },
        { code: 'om', label: 'Afaan Oromoo' },
        { code: 'or', label: 'ଓଡ଼ିଆ' },
        { code: 'os', label: 'ирон æвзаг' },
        { code: 'pa', label: 'ਪੰਜਾਬੀ, پنجابی‎' },
        { code: 'pi', label: 'पाऴि' },
        { code: 'pl', label: 'polski' },
        { code: 'ps', label: 'پښتو' },
        { code: 'pt', label: 'Português' },
        { code: 'qu', label: 'Runa Simi, Kichwa' },
        { code: 'rm', label: 'rumantsch grischun' },
        { code: 'rn', label: 'kiRundi' },
        { code: 'ro', label: 'română' },
        { code: 'ru', label: 'русский язык' },
        { code: 'rw', label: 'Ikinyarwanda' },
        { code: 'sa', label: 'संस्कृतम्' },
        { code: 'sc', label: 'sardu' },
        { code: 'sd', label: 'सिन्धी, سنڌي، سندھی‎' },
        { code: 'se', label: 'Davvisámegiella' },
        { code: 'sg', label: 'yângâ tî sängö' },
        { code: 'si', label: 'සිංහල' },
        { code: 'sk', label: 'slovenčina' },
        { code: 'sl', label: 'slovenščina' },
        { code: 'sm', label: 'gagana faa Samoa' },
        { code: 'sn', label: 'chiShona' },
        { code: 'so', label: 'Soomaaliga, af Soomaali' },
        { code: 'sq', label: 'Shqip' },
        { code: 'sr', label: 'српски језик' },
        { code: 'ss', label: 'SiSwati' },
        { code: 'st', label: 'Sesotho' },
        { code: 'su', label: 'Basa Sunda' },
        { code: 'sv', label: 'svenska' },
        { code: 'sw', label: 'Kiswahili' },
        { code: 'ta', label: 'தமிழ்' },
        { code: 'te', label: 'తెలుగు' },
        { code: 'tg', label: 'тоҷикӣ, toğikī, تاجیکی‎' },
        { code: 'th', label: 'ไทย' },
        { code: 'ti', label: 'ትግርኛ' },
        { code: 'tk', label: 'Türkmen, Түркмен' },
        { code: 'tl', label: 'Wikang Tagalog' },
        { code: 'tn', label: 'Setswana' },
        { code: 'to', label: 'faka Tonga' },
        { code: 'tr', label: 'Türkçe' },
        { code: 'ts', label: 'Xitsonga' },
        { code: 'tt', label: 'татарча, tatarça, تاتارچا‎' },
        { code: 'tw', label: 'Twi' },
        { code: 'ty', label: 'Reo Tahiti' },
        { code: 'ug', label: 'Uyƣurqə, ئۇيغۇرچە‎' },
        { code: 'uk', label: 'українська' },
        { code: 'ur', label: 'اردو', isRtl: true },
        { code: 'uz', label: 'zbek, Ўзбек, أۇزبېك‎' },
        { code: 've', label: 'Tshivenḓa' },
        { code: 'vi', label: 'Tiếng Việt' },
        { code: 'vo', label: 'Volapük' },
        { code: 'wa', label: 'Walon' },
        { code: 'wo', label: 'Wollof' },
        { code: 'xh', label: 'isiXhosa' },
        { code: 'yi', label: 'ייִדיש' },
        { code: 'yo', label: 'Yorùbá' },
        { code: 'za', label: 'Saɯ cueŋƅ, Saw cuengh' },
        { code: 'zh', label: '中文 (Zhōngwén), 汉语, 漢語' },
    ]; }
    /**
     * Matches the given string array to the EU languages and returns a EuiLanguage array.
     * In case that no codes provided it returns the EU Languages array.
     *
     * @param codes A string array of 2 char codes
     */
    static getLanguages(codes = Object.keys(this.languages)) {
        return this.filterInvalidLanguageCodes(codes).map((c) => (typeof c === 'string' ? this.languages[c] : c));
    }
    /**
     * filters and removes language codes that are not part of the EULanguage
     * e.g. 'ko' does not map to any EULanguage code on the array.
     *      { code: 'ko', label: 'whatever' } is valid though
     *
     * @param codes codes A string array of 2 char codescodes A string array of 2 char codes
     */
    static filterInvalidLanguageCodes(codes) {
        return codes.filter((c) => (typeof c === 'string' ? Object.keys(this.languages).indexOf(c) !== -1 : true));
    }
    /**
     * return the given list ordered based on the EULanguage order
     *
     * @param codes codes A string array of 2 char codes
     */
    static getOrderedLanguages(codes = Object.keys(this.languages)) {
        return this.getLanguages(codes).sort((a, b) => Object.keys(this.languages).findIndex((c) => c === a.code) - Object.keys(this.languages).findIndex((c) => c === b.code));
    }
    /**
     * retrieve language codes (string array) from a given array of string and EuiLanguage items
     *
     * @param array It can be an mixed array of string and EuiLanguage items
     */
    static getLanguageCodes(array) {
        return array.map((language) => (typeof language === 'string' ? language : language.code));
    }
    /**
     * filter non EU languages from given array
     *
     * @param array An array of EuiLanguage items
     */
    static filterNonEULanguages(array) {
        return array ? array.filter((lang) => !Object.keys(this.languages).includes(lang.code)) : [];
    }
    /**
     * filter EU Languages from given array
     *
     * @param array An array of EuiLanguage items
     */
    static filterEULanguages(array) {
        return array ? array.filter((lang) => Object.keys(this.languages).includes(lang.code)) : [];
    }
    /**
     * @param code language code, ex. 'lu'
     */
    static getLanguageByCode(code) {
        return code ? this.allLanguages.find(lang => lang.code === code) : undefined;
    }
    /**
     * @param code language code, ex. 'lu'
     */
    static isEuLanguage(code) {
        return Object.keys(this.languages).includes(code);
    }
    /**
     * Returns array of EuiLanguage that match the given codes. If codes array is empty, returns all languages.
     * @param codes A string array of 2 char codes, ex. ['en', 'de']
     */
    static getAllLanguagesByCodes(codes) {
        return (codes && codes.length > 0) ? this.allLanguages.filter(el => codes.includes(el.code)) : this.allLanguages;
    }
}

if (typeof crypto === 'object' && typeof crypto.randomUUID !== 'function') {
    crypto.randomUUID = () => {
        console.warn('usage of crypto.randomUUID() outside of HTTPS poses a ' +
            'security risk for you application and its users');
        const pattern = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
        return pattern.replace(/[xy]/g, (c) => {
            const r = (Math.random() * 16) | 0;
            const v = c === 'x' ? r : (r & 0x3) | 0x8;
            return v.toString(16);
        });
    };
}

/**
 * Generated bundle index. Do not edit.
 */

export { ConsoleAppender, DEFAULT_CONSOLE_APPENDER_PREFIX_CONVERTERS, DEFAULT_XHR_CONFIG, DefaultConfig, EUI_COLORS, EUI_DEFAULT_AUTH_CONFIG, EuiEuLanguages, EuiLazyService, EuiPagination, EuiService, LogAppender, LogLevel, LogLevelName, Logger, LoggerMock, UrlAppender, UxBadgeLegacy, UxClearErrorFeedbackEvent, UxErrorGroupOnClickEvent, UxErrorOutput, UxLinkLegacy, UxMessageSeverity, UxMessageSeverityMetrics, UxPublishErrorFeedbackEvent, UxValidationErrorClass, getActiveLang, getApiQueue, getApiQueueItem, getAppConnection, getAppLoadedConfigModules, getAppState, getAppStatus, getAppVersion, getBrowserDefaultLanguage, getBrowserPreferredLanguages, getCurrentModule, getI18nLoaderConfig, getI18nServiceConfig, getI18nServiceConfigFromBase, getI18nState, getLastAddedModule, getLocaleServiceConfigFromBase, getLocaleState, getNotificationsList, getNotificationsState, getUserDashboard, getUserDetails, getUserFirstName, getUserFullName, getUserId, getUserLang, getUserLastName, getUserPreferences, getUserRight, getUserRightPermissions, getUserRights, getUserState, initialAppState, initialCoreState, initialI18nState, initialLocaleState, initialNotificationsState, initialUserPreferences, initialUserState, isObject, merge, mergeAll, mergeDeep, range, transformToUxHttpResponse, xhr };
//# sourceMappingURL=eui-base.mjs.map
