rox-browser/dist/rox-browser.js

Rollout.io ROX JS SDK Client

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("axios"));
	else if(typeof define === 'function' && define.amd)
		define(["axios"], factory);
	else if(typeof exports === 'object')
		exports["Rox"] = factory(require("axios"));
	else
		root["Rox"] = factory(root["axios"]);
})(globalThis, (__WEBPACK_EXTERNAL_MODULE__65__) => {
return /******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ([
/* 0 */,
/* 1 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _RoxClient__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _FreezeOptions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87);
/* harmony import */ var rox_base__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33);
/* harmony import */ var rox_base__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(86);
/* harmony import */ var rox_base__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
/* harmony import */ var rox_base__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6);
/* harmony import */ var _RoxStringBrowser__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(83);
/* harmony import */ var _RoxNumberBrowser__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(89);
/* harmony import */ var _RoxFlagBrowser__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(90);
/* harmony import */ var _DebuggerUI__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(91);
/* harmony import */ var _Overrider__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(88);








class Rox {
    constructor() {
        this.RoxString = _RoxStringBrowser__WEBPACK_IMPORTED_MODULE_6__["default"];
        this.RoxNumber = _RoxNumberBrowser__WEBPACK_IMPORTED_MODULE_7__["default"];
        this.setContext = rox_base__WEBPACK_IMPORTED_MODULE_3__.setContext;
        this.Flag = _RoxFlagBrowser__WEBPACK_IMPORTED_MODULE_8__["default"];
        this.showOverrides = _DebuggerUI__WEBPACK_IMPORTED_MODULE_9__.open;
        this.overrides = _Overrider__WEBPACK_IMPORTED_MODULE_10__;
    }
    /**
     * Initiate connection with ROX servers for the application identified by the application key. The registered containers will be synced and Rox entities will get the appropriate values.
     * @param {String} appKey application key as appears in ROX dashboard
     * @param {Object} options optional configuration object
     */
    setup(appKey, options = {}) {
        rox_base__WEBPACK_IMPORTED_MODULE_4__["default"].setVerboseMode(options.debugLevel);
        if (options.proxy) {
            rox_base__WEBPACK_IMPORTED_MODULE_5__["default"].setProxy(options.proxy);
        }
        if (options.freeze) {
            (0,_FreezeOptions__WEBPACK_IMPORTED_MODULE_1__.setDefaultFreezeOption)(options.freeze);
        }
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setKey(appKey, options);
        if (options.configuration) {
            rox_base__WEBPACK_IMPORTED_MODULE_5__["default"].setActive(options.configuration);
        }
        else if (options.hosting) {
            rox_base__WEBPACK_IMPORTED_MODULE_5__["default"].setHosting(options.hosting);
        }
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setup(options);
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].sendState();
        if (options.disableNetworkFetch) {
            return _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].fetchCacheOnly();
        }
        else {
            return _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].fetchWithCacheAndProceed();
        }
    }
    fetch() {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"] && _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].fetch();
    }
    setCustomStringProperty(key, value) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setCustomProperty(key, String, value);
    }
    setCustomDateProperty(key, value) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setCustomProperty(key, Date, value);
    }
    setCustomNumberProperty(key, value) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setCustomProperty(key, Number, value);
    }
    setCustomBooleanProperty(key, value) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setCustomProperty(key, Boolean, value);
    }
    setCustomSemverProperty(key, value) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setSemverCustomProperty(key, value);
    }
    /**
     * Register a container of Rox entities by specifying a namespace.
     * @param {String} name Container name
     * @param {Object} container Object literal whose properties are Rox entities
     */
    register(name, container) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].register(name, container);
    }
    unfreeze(namespace) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].unfreeze(namespace);
    }
    get flags() {
        return rox_base__WEBPACK_IMPORTED_MODULE_2__["default"].flags;
    }
    get dynamicApi() {
        return _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].dynamicApi;
    }
    setUserspaceUnhandledErrorHandler(handler) {
        _RoxClient__WEBPACK_IMPORTED_MODULE_0__["default"].setUserspaceUnhandledErrorHandler(handler);
    }
}
const instance = new Rox();
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (instance);


/***/ }),
/* 2 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var rox_base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
/* harmony import */ var _DeviceProperties__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(66);
/* harmony import */ var _DefaultSetupOptions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(74);
/* harmony import */ var _DefaultProperties__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(75);
/* harmony import */ var _RoxCache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(69);
/* harmony import */ var _RoxCrypto__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(78);
/* harmony import */ var _EntitiesProvider__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(82);







/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((0,rox_base__WEBPACK_IMPORTED_MODULE_0__.createRoxClient)({
    DeviceProperties: _DeviceProperties__WEBPACK_IMPORTED_MODULE_1__["default"],
    getDefaultCustomProperties: _DefaultProperties__WEBPACK_IMPORTED_MODULE_3__.getDefaultCustomProperties,
    DefaultSetupOptions: _DefaultSetupOptions__WEBPACK_IMPORTED_MODULE_2__.defaultSetupOptions,
    RoxCache: _RoxCache__WEBPACK_IMPORTED_MODULE_4__["default"],
    RoxCrypto: _RoxCrypto__WEBPACK_IMPORTED_MODULE_5__["default"],
    EntitiesProvider: _EntitiesProvider__WEBPACK_IMPORTED_MODULE_6__["default"]
}));


/***/ }),
/* 3 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Client: () => (/* binding */ Client),
/* harmony export */   createRoxClient: () => (/* binding */ createRoxClient)
/* harmony export */ });
/* harmony import */ var _BugsnagReporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39);
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
/* harmony import */ var _repositories__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(32);
/* harmony import */ var _repositories__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(34);
/* harmony import */ var _repositories__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(33);
/* harmony import */ var _repositories__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(31);
/* harmony import */ var _DynamicApi__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(42);
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(6);
/* harmony import */ var _entities__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(43);
/* harmony import */ var _parsers__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(27);
/* harmony import */ var _ImpressionHandler__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(41);
/* harmony import */ var _UserspaceUnhandledErrorInvoker__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(36);
/* harmony import */ var _Analytics__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(44);
/* harmony import */ var _notifications_notification_listener__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(45);
/* harmony import */ var _InternalFlags__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(26);
/* harmony import */ var _DynamicProperties__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(35);
/* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(46);
/* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_18___default = /*#__PURE__*/__webpack_require__.n(lodash_debounce__WEBPACK_IMPORTED_MODULE_18__);
/* harmony import */ var _FetcherResults__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(37);
/* harmony import */ var _StateSender__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(60);
/* harmony import */ var _NetworkSender__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(63);
/* harmony import */ var _AxiosWrapper__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(64);


















const MINIMUM_INTERVAL_SEC = 30;
const DISABLED_INTERVAL_THRESOLD = 0;
const SEND_STATE_DEBOUNCE_TIMEOUT_MS = 5000;
let _deps = {
    ClassRegister: ___WEBPACK_IMPORTED_MODULE_2__["default"],
};
class Client {
    constructor(sendStateDebounceTimeoutMs = SEND_STATE_DEBOUNCE_TIMEOUT_MS) {
        this.classRegisterer = new _deps.ClassRegister();
        this.sendStateDebounceNoCheck = lodash_debounce__WEBPACK_IMPORTED_MODULE_18___default()(() => {
            this._sendState();
        }, sendStateDebounceTimeoutMs, {
            maxWait: sendStateDebounceTimeoutMs,
            leading: false,
            trailing: true,
        });
        this.sendStateDebounced = () => {
            if (this.appKey) {
                this.sendStateDebounceNoCheck();
            }
        };
        this.onConfigurationFetched = this.onConfigurationFetched.bind(this);
    }
    get dynamicApi() {
        return this._dynamicApi;
    }
    get appKey() {
        return this.app_key;
    }
    setKey(apiKey, options) {
        const mongoRegex = /^[a-f\d]{24}$/i;
        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
        const isRolloutValidKey = mongoRegex.test(apiKey);
        const isPlatformValidKey = uuidRegex.test(apiKey);
        if (!isRolloutValidKey && !isPlatformValidKey) {
            throw Error('invalid rollout apikey');
        }
        else {
            this.app_key = apiKey;
            if (isPlatformValidKey) {
                _config__WEBPACK_IMPORTED_MODULE_9__["default"].setHosting('platform');
                options.disableSignatureVerification = true;
            }
        }
    }
    setup(options) {
        var _a;
        try {
            // Bootstrap Options
            this.handleOptions(options);
            // Bootstrap Device Properties
            _deps.DeviceProperties = _deps.DeviceProperties.create
                ? _deps.DeviceProperties.create(_deps)
                : _deps.DeviceProperties;
            this.app_release && _deps.DeviceProperties.setAppRelease(this.app_release);
            this.distinct_id && _deps.DeviceProperties.setDistinctId(this.distinct_id);
            this.platform && _deps.DeviceProperties.setPlatform(this.platform);
            this.deviceProperties = _deps.DeviceProperties;
            this.deviceProperties.setRealPlatform(this.realPlatform);
            // Bootstrap Error Reporter
            this.selfManagedMode &&
                _config__WEBPACK_IMPORTED_MODULE_9__["default"].setErrorReporter(new _BugsnagReporter__WEBPACK_IMPORTED_MODULE_0__.BugsnagReporter(this.appKey, _deps.DeviceProperties, this.networkOptions, this.networkApi));
            // Bootstap Configuration Fetcher
            this.configurationFetcher = new ___WEBPACK_IMPORTED_MODULE_1__["default"](this.appKey, this.deviceProperties, this.devModeSecret, _deps, this.embeddedConfiguration, {
                roxyUrl: this.roxyUrl,
                selfManagedMode: this.selfManagedMode,
                disableSignatureVerification: this.disableSignatureVerification,
            }, this.networkOptions, this.networkApi);
            if (!this.roxyUrl) {
                this.stateSender = new _StateSender__WEBPACK_IMPORTED_MODULE_20__["default"](this.appKey, this.deviceProperties, this.devModeSecret, this.networkOptions, { selfManagedMode: this.selfManagedMode }, this.disableSignatureVerification, this.networkApi);
                if (!this.disableNetwork) {
                    (0,_ImpressionHandler__WEBPACK_IMPORTED_MODULE_12__.setAnalytics)(new _Analytics__WEBPACK_IMPORTED_MODULE_14__["default"](this.appKey, Object.assign({}, this.analyticsOptions), _deps.DeviceProperties, this.networkOptions, this.networkApi));
                }
            }
            // Bootstrap Custom Properties
            _deps
                .getDefaultCustomProperties(this.deviceProperties, this.appKey)
                .map(_repositories__WEBPACK_IMPORTED_MODULE_4__["default"].setIfNotExists.bind(_repositories__WEBPACK_IMPORTED_MODULE_4__["default"]));
        }
        catch (e) {
            const message = 'Uh oh! An error occurred during setup.';
            ___WEBPACK_IMPORTED_MODULE_3__["default"].error(message, e);
            (_a = _config__WEBPACK_IMPORTED_MODULE_9__["default"].getErrorReporter()) === null || _a === void 0 ? void 0 : _a.error(message, e);
        }
        return Promise.resolve(this);
    }
    handleOptions(options) {
        const realPlatform = _deps.DefaultSetupOptions.platform;
        const _options = Object.assign({}, _deps.DefaultSetupOptions, options);
        if (_options.selfManaged && typeof _options.selfManaged === 'object') {
            if (!_options.selfManaged.analyticsURL) {
                throw new Error('analyticsURL is required on self managed mode');
            }
            else if (!_options.selfManaged.serverURL) {
                throw new Error('serverURL is required on self managed mode');
            }
            if (options.selfManaged.configurationURL) {
                _options.selfManaged.configurationURL =
                    options.selfManaged.configurationURL.endsWith('/')
                        ? options.selfManaged.configurationURL
                        : `${options.selfManaged.configurationURL}/`;
            }
            if (options.selfManaged.stateURL) {
                _options.selfManaged.stateURL = options.selfManaged.stateURL.endsWith('/')
                    ? options.selfManaged.stateURL
                    : `${options.selfManaged.stateURL}/`;
            }
            _config__WEBPACK_IMPORTED_MODULE_9__["default"].setSelfManagedMode(_options.selfManaged);
            (0,_InternalFlags__WEBPACK_IMPORTED_MODULE_16__.setDefaultsMode)(true);
            this.selfManagedMode = true;
        }
        if (_options.configuration && _options.configuration.disableNetwork) {
            this.disableNetwork = true;
        }
        this.embeddedConfiguration = _options.embedded;
        this.fetchIntervalInSec = _options.fetchIntervalInSec;
        this.disablePushUpdateListener =
            this.disableNetwork || (this.selfManagedMode && !_options.selfManaged.pushUpdateURL)
                ? true
                : _options.disablePushUpdateListener;
        this.configurationFetchedHandler = _options.configurationFetchedHandler;
        this.impressionHandler = _options.impressionHandler;
        this.dynamicPropertyRuleHandler = _options.dynamicPropertyRuleHandler;
        this.app_release = _options.version;
        this.distinct_id = _options.distinctId;
        this.devModeSecret = _options.devModeSecret;
        this.platform = _options.platform;
        this.fetchFunction = _options.fetchFunction;
        this.networkApi = _options.networkApi;
        if (this.networkApi) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].debug('network: using custom');
        }
        else {
            if (this.fetchFunction) {
                ___WEBPACK_IMPORTED_MODULE_3__["default"].debug('network: using fetch');
                this.networkApi = new _NetworkSender__WEBPACK_IMPORTED_MODULE_21__.FetchNetwork(this.fetchFunction);
            }
            else {
                ___WEBPACK_IMPORTED_MODULE_3__["default"].debug('network: using axios');
                this.networkApi = new _AxiosWrapper__WEBPACK_IMPORTED_MODULE_22__.AxiosNetwork();
            }
        }
        this.realPlatform = realPlatform;
        this.roxyUrl = _options.roxy;
        this.networkOptions = {
            httpAgent: _options.httpAgent,
            httpsAgent: _options.httpsAgent,
        };
        this.disableSignatureVerification = _options.disableSignatureVerification || false;
        this.analyticsOptions = _options.analytics;
        this.eventSourceImpl = _options.eventSourceImpl;
        (0,_ImpressionHandler__WEBPACK_IMPORTED_MODULE_12__.setHandler)(this.impressionHandler);
        if (options.logger) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].setLogger(options.logger);
        }
        if (this.dynamicPropertyRuleHandler) {
            (0,_DynamicProperties__WEBPACK_IMPORTED_MODULE_17__.setDynamicPropertyHandler)(this.dynamicPropertyRuleHandler);
        }
    }
    fetchPeriodically() {
        if (!this.app_key) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].warn('no app key');
            return Promise.reject();
        }
        if (this.fetchIntervalInSec <= DISABLED_INTERVAL_THRESOLD)
            return Promise.resolve();
        if (this.fetchIntervalInSec < MINIMUM_INTERVAL_SEC)
            this.fetchIntervalInSec = MINIMUM_INTERVAL_SEC;
        const fetchPromise = this._fetch({ useCache: false });
        this.configurationFetcher.dispatchPeriodically({
            handler: this.onConfigurationFetched,
            periodTimeInSec: this.fetchIntervalInSec,
        });
        return fetchPromise;
    }
    fetchCacheOnly() {
        return this._fetch({ useCache: true, skipNetwork: true });
    }
    fetchWithCacheAndProceed() {
        return this._fetch({ useCache: true });
    }
    fetch() {
        return this._fetch({ useCache: false });
    }
    _fetchFromPush() {
        return this._fetch({ useCache: false, source: 'push' });
    }
    sendState() {
        this._sendState();
    }
    _sendState() {
        this.sendStateDebounceNoCheck.cancel();
        if (!this.app_key) {
            return;
        }
        if (this.disableNetwork) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].debug('send state - disabled network');
            return;
        }
        if (this.stateSender) {
            this.stateSender.send();
        }
    }
    _fetch(options = {}) {
        if (!this.app_key) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].warn('no app key');
            return;
        }
        if (!this.configurationFetcher) {
            return;
        }
        if (this.disableNetwork) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].debug('fetch - disabling network');
            options.skipNetwork = true;
        }
        return this.configurationFetcher.dispatch({
            handler: this.onConfigurationFetched,
            options,
        });
    }
    register(name, container) {
        if (container === undefined && typeof name === 'object' && name !== null) {
            container = name;
            name = '';
        }
        ___WEBPACK_IMPORTED_MODULE_3__["default"].debug(`Registering container '${name}' = ${JSON.stringify(container)}`);
        this.classRegisterer.handleContainer(name, container);
        this.sendStateDebounced();
    }
    setSemverCustomProperty(name, value) {
        this.setCustomProperty(name, _entities__WEBPACK_IMPORTED_MODULE_10__["default"].semverTypeName, value);
    }
    setCustomProperty(name, type, value) {
        const property = new _entities__WEBPACK_IMPORTED_MODULE_10__["default"](name, type, value);
        const isNew = !_repositories__WEBPACK_IMPORTED_MODULE_4__["default"].has(property);
        _repositories__WEBPACK_IMPORTED_MODULE_4__["default"].set(property);
        isNew && this.sendStateDebounced();
    }
    unfreeze(namespace, freezeLevel) {
        const namespaceFilter = (flag) => {
            if (!flag.name || typeof namespace !== 'string')
                return true;
            const flagNameParts = flag.name.split('.');
            if (flagNameParts.length === 1 && namespace === '') {
                return true;
            }
            else if (flagNameParts.slice(0, flagNameParts.length - 1).join('.') === namespace) {
                return true;
            }
            return false;
        };
        _repositories__WEBPACK_IMPORTED_MODULE_6__["default"].flags.filter(namespaceFilter).forEach((flag) => {
            flag.unfreeze(freezeLevel);
        });
    }
    get metadata() {
        const _roxxTrueToBoolean = (val) => (val === 'true' ? true : false);
        const parser = new _parsers__WEBPACK_IMPORTED_MODULE_11__["default"]();
        const targetGroups = _repositories__WEBPACK_IMPORTED_MODULE_7__["default"].targetGroups.map((tg) => ({
            name: tg.name,
            isEnabled: parser.evaluateExpression(tg.condition),
        }));
        const experiments = _repositories__WEBPACK_IMPORTED_MODULE_5__["default"].experiments.map((e) => ({
            name: e.name,
            isEnabled: _roxxTrueToBoolean(parser.evaluateExpression(e.deploymentConfiguration.condition)),
        }));
        const flags = _repositories__WEBPACK_IMPORTED_MODULE_6__["default"].flags.map((f) => ({
            name: f.name,
            value: f._peek(),
        }));
        return { targetGroups, experiments, flags };
    }
    onConfigurationFetched(data) {
        try {
            if (data.fetcherStatus !== _FetcherResults__WEBPACK_IMPORTED_MODULE_19__.FetcherStatus.ERROR_FETCH_FAILED) {
                this.startOrStopPushUpdatesListener();
            }
        }
        catch (ex) {
            ___WEBPACK_IMPORTED_MODULE_3__["default"].warn(`Cound not start or stop push notification listener. exception: ${ex}`);
        }
        if (this.configurationFetchedHandler instanceof Function) {
            try {
                return this.configurationFetchedHandler(data);
            }
            catch (e) {
                _UserspaceUnhandledErrorInvoker__WEBPACK_IMPORTED_MODULE_13__["default"].invoke(_UserspaceUnhandledErrorInvoker__WEBPACK_IMPORTED_MODULE_13__.ExceptionTrigger.CONFIGURATION_FETCHED_HANDLER, e);
            }
        }
    }
    startOrStopPushUpdatesListener() {
        if (!this.disablePushUpdateListener && (0,_InternalFlags__WEBPACK_IMPORTED_MODULE_16__.isEnabled)('rox.internal.pushUpdates')) {
            if (this.app_key) {
                if (!this.pushUpdatesListener) {
                    this.pushUpdatesListener = new _notifications_notification_listener__WEBPACK_IMPORTED_MODULE_15__["default"](_config__WEBPACK_IMPORTED_MODULE_9__["default"].get('NOTIFICATIONS_ENDPOINT'), this.app_key, this.eventSourceImpl, this.networkOptions);
                    this.pushUpdatesListener.on('changed', () => {
                        this._fetchFromPush();
                    });
                }
            }
        }
        else {
            if (this.pushUpdatesListener) {
                this.pushUpdatesListener.stop();
                this.pushUpdatesListener = null;
            }
        }
    }
    setUserspaceUnhandledErrorHandler(handler) {
        _UserspaceUnhandledErrorInvoker__WEBPACK_IMPORTED_MODULE_13__["default"].setHandler(handler);
    }
    get cacheURL() {
        if (!this.configurationFetcher || !this.configurationFetcher.cacheURL) {
            throw new Error('Rox was not initialized. Please call setup() before calling cacheURL()');
        }
        return this.configurationFetcher.cacheURL;
    }
}
const instance = new Client();
function createRoxClient(deps = {}) {
    _deps = Object.assign({}, _deps, deps);
    instance._dynamicApi = new _DynamicApi__WEBPACK_IMPORTED_MODULE_8__["default"](deps.EntitiesProvider, _repositories__WEBPACK_IMPORTED_MODULE_6__["default"], instance);
    return instance;
}


/***/ }),
/* 4 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BugsnagReporter: () => (/* binding */ BugsnagReporter)
/* harmony export */ });
/* harmony import */ var _RoxLogger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
var __rest = (undefined && undefined.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};


const BS_API_KEY = 'abbf3bd9c6e80eb1e8c0566c35b08748';
const BS_NOTIFY_ENDPOINT = 'https://notify.bugsnag.com';
class BugsnagReporter {
    constructor(app_key, deviceProperties, networkOptions, networkSender) {
        const _a = deviceProperties.getProperties(), { distinct_id, app_release, platform, api_version, lib_version } = _a, device = __rest(_a, ["distinct_id", "app_release", "platform", "api_version", "lib_version"]);
        this.device = device;
        this.header = {
            apiKey: BS_API_KEY,
            notifier: {
                name: 'Rollout JavaScript SDK',
                version: lib_version,
                url: (typeof window !== 'undefined' && window.location && window.location.href) ||
                    undefined,
            },
        };
        this.networkOptions = networkOptions;
        this.networkSender = networkSender;
        this.user = { distinct_id, app_release, app_key, platform };
        this.app = { api_version, lib_version };
    }
    error(message, exception) {
        return this._notify('error', message, exception);
    }
    _notify(severity, message, exception) {
        const event = {
            payloadVersion: 4,
            exceptions: [],
            app: this.app,
            user: this.user,
            device: this.device,
            metaData: {
                data: {
                    message,
                    exception: exception.toString(),
                },
            },
            severity,
        };
        if (exception instanceof Error) {
            event.exceptions.push({
                errorClass: exception.name,
                message: message + '\n' + exception.message,
                stacktrace: exception.stack || '',
            });
            event.groupingHash = exception.fileName;
        }
        else {
            event.exceptions.push({
                errorClass: 'Error',
                message: message,
                stacktrace: [],
            });
        }
        return this._send([event]);
    }
    _send(events) {
        const data = Object.assign({ events }, this.header);
        _RoxLogger__WEBPACK_IMPORTED_MODULE_0__["default"].debug('Sending bugsnag error report.');
        const request = { url: BS_NOTIFY_ENDPOINT, data, options: this.networkOptions };
        _config__WEBPACK_IMPORTED_MODULE_1__["default"].getProxy().applyProxyToRequest(request);
        try {
            this.networkSender
                .post(request.url, request.data, request.options)
                .then(() => {
                _RoxLogger__WEBPACK_IMPORTED_MODULE_0__["default"].debug('Successfully sent error report.');
            })
                .catch((err) => {
                _RoxLogger__WEBPACK_IMPORTED_MODULE_0__["default"].debug('Failed to send error report', err);
            });
        }
        catch (e) {
            _RoxLogger__WEBPACK_IMPORTED_MODULE_0__["default"].debug('Failed to send error report.', e);
        }
    }
}


/***/ }),
/* 5 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
const levels = {
    debug: 0,
    info: 1,
    warn: 2,
    error: 3
};
let level = 'error';
class Logger {
    constructor() {
        this.debug = (data, ...args) => {
            if (levels[level] <= levels.debug && console /* console not present on old IEs */) {
                console.log(data, ...args); // eslint-disable-line no-console
            }
        };
        this.info = (data, ...args) => {
            if (levels[level] <= levels.info && console /* console not present on old IEs */) {
                console.info(data, ...args); // eslint-disable-line no-console
            }
        };
        this.warn = (data, ...args) => {
            if (levels[level] <= levels.warn && console /* console not present on old IEs */) {
                console.warn(data, ...args); // eslint-disable-line no-console
            }
        };
        this.error = (data, ...args) => {
            if (console /* console not present on old IEs */) {
                console.error(data, ...args); // eslint-disable-line no-console
            }
        };
        this.setVerboseMode = debugLevel => {
            if (debugLevel === 'verbose') {
                level = 'debug';
                this.debug('Active verbose mode');
            }
            else {
                level = 'error';
            }
        };
        this.setLogger = (newLogger) => {
            logger = newLogger;
        };
    }
}
let logger = new Logger();
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (logger);


/***/ }),
/* 6 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _ProxyConfig__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);

var ApiProvider;
(function (ApiProvider) {
    ApiProvider["RolloutEu"] = "eu";
    ApiProvider["Platform"] = "platform";
})(ApiProvider || (ApiProvider = {}));
const API_HOST = 'x-api.rollout.io';
let _proxyConfig = new _ProxyConfig__WEBPACK_IMPORTED_MODULE_0__["default"]();
const DEFAULT_CONFIGURATION = (hostProvider) => {
    let apiHost = API_HOST;
    if (hostProvider == ApiProvider.RolloutEu) {
        apiHost = `${'eu-'}${API_HOST}`; // as this goes into the url, not using the roxOptions.hosting value. instead using RoxOptions.hosting === "eu" as indication to use "eu-x-api..."
    }
    const configuration = {
        API_HOST: apiHost,
        CD_API_ENDPOINT: `https://${apiHost}/device/get_configuration`,
        CD_S3_ENDPOINT: `https://conf.rollout.io/`,
        SS_API_ENDPOINT: `https://${apiHost}/device/update_state_store/`,
        SS_S3_ENDPOINT: `https://statestore.rollout.io/`,
        CLIENT_DATA_CACHE_KEY: 'client_data',
        NOTIFICATIONS_ENDPOINT: `https://push.rollout.io/sse`,
        ANALYTICS_ENDPOINT: `https://analytic.rollout.io`,
        ERROR_REPORTER: undefined,
    };
    if (hostProvider == ApiProvider.Platform) {
        configuration.API_HOST = 'api.cloudbees.io';
        configuration.CD_API_ENDPOINT = 'https://api.cloudbees.io/device/get_configuration';
        configuration.CD_S3_ENDPOINT = 'https://rox-conf.cloudbees.io/';
        configuration.SS_API_ENDPOINT = 'https://api.cloudbees.io/device/update_state_store/';
        configuration.SS_S3_ENDPOINT = 'https://rox-state.cloudbees.io/';
        configuration.ANALYTICS_ENDPOINT = 'https://fm-analytics.cloudbees.io';
        configuration.NOTIFICATIONS_ENDPOINT =
            'https://sdk-notification-service.cloudbees.io/sse';
    }
    return configuration;
};
const SELFMANAGEDMODE_CONFIGURATION = ({ analyticsURL, serverURL, pushUpdateURL, configurationURL, stateURL, }) => ({
    CD_API_ENDPOINT: `${serverURL}/device/get_configuration`,
    SS_API_ENDPOINT: `${serverURL}/device/update_state_store/`,
    CLIENT_DATA_CACHE_KEY: 'client_data',
    ANALYTICS_ENDPOINT: analyticsURL,
    NOTIFICATIONS_ENDPOINT: `${pushUpdateURL}/sse`,
    CD_S3_ENDPOINT: configurationURL,
    SS_S3_ENDPOINT: stateURL,
    ERROR_REPORTER: undefined,
});
let _activeConfiguration = Object.assign({}, DEFAULT_CONFIGURATION());
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
    get: (key) => _activeConfiguration[key],
    set: (key, value) => {
        _activeConfiguration[key] = value;
    },
    setActive: function (newConfiguration) {
        _activeConfiguration = Object.assign({}, newConfiguration);
    },
    setProxy: function (proxySettings) {
        _proxyConfig = new _ProxyConfig__WEBPACK_IMPORTED_MODULE_0__["default"](proxySettings);
    },
    getProxy: () => _proxyConfig,
    setHosting: function (hosting) {
        if (hosting === ApiProvider.RolloutEu) {
            _activeConfiguration = Object.assign({}, DEFAULT_CONFIGURATION('eu-'));
        }
        if (hosting === ApiProvider.Platform) {
            _activeConfiguration = Object.assign({}, DEFAULT_CONFIGURATION(hosting));
        }
    },
    setSelfManagedMode: function (conf) {
        _activeConfiguration = Object.assign({}, DEFAULT_CONFIGURATION(), SELFMANAGEDMODE_CONFIGURATION(conf));
    },
    setErrorReporter: function (errorReporter) {
        _activeConfiguration.ERROR_REPORTER = errorReporter;
    },
    /**
     * Get the error reporter, or undefined if there is none configured.
     * Don't forget to check for undefined before using!
     */
    getErrorReporter: () => _activeConfiguration.ERROR_REPORTER,
});


/***/ }),
/* 7 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (/* binding */ ProxyConfig)
/* harmony export */ });
/* harmony import */ var js_base64__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8);

const TARGET_URL_QUERY_PARAM_NAME = 'roxTargetUrl';
const AUTH_QUERY_PARAM_NAME = 'roxAuth';
class ProxyConfig {
    constructor(proxySettings) {
        this._proxyUrl = '';
        this._proxyAuthHeader = '';
        this._proxySettings = false;
        if (proxySettings) {
            this._proxySettings = Object.assign({}, proxySettings);
            // calculating constants
            this._proxyUrl = `${this._proxySettings.protocol}://${this._proxySettings.host}${this._proxySettings.port ? `:${this._proxySettings.port}` : ''}`;
            if (this._proxySettings.auth &&
                this._proxySettings.auth.username &&
                this._proxySettings.auth.password) {
                this._proxyAuthHeader = `Basic ${(0,js_base64__WEBPACK_IMPORTED_MODULE_0__.encode)(`${this._proxySettings.auth.username}:${this._proxySettings.auth.password}`)}`;
                this._proxyAuthHeaderEncoded = encodeURIComponent(this._proxyAuthHeader);
            }
        }
    }
    applyProxyToRequest(request) {
        if (this._proxySettings) {
            request.options = request.options ? Object.assign({}, request.options) : {};
            const options = request.options;
            options.params = options.params || {};
            options.params[TARGET_URL_QUERY_PARAM_NAME] = request.url;
            if (this._proxyAuthHeader) {
                options.params[AUTH_QUERY_PARAM_NAME] = this._proxyAuthHeader;
            }
            request.url = this._proxyUrl;
        }
    }
    applyProxyToSseRequest(request) {
        if (this._proxySettings) {
            request.url = `${this._proxyUrl}?${TARGET_URL_QUERY_PARAM_NAME}=${encodeURIComponent(request.url)}`;
            if (this._proxyAuthHeaderEncoded) {
                request.url = `${request.url}&${AUTH_QUERY_PARAM_NAME}=${this._proxyAuthHeaderEncoded}`;
            }
        }
    }
    get proxyUrl() {
        return this._proxyUrl;
    }
}


/***/ }),
/* 8 */
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Base64: () => (/* binding */ gBase64),
/* harmony export */   VERSION: () => (/* binding */ VERSION),
/* harmony export */   atob: () => (/* binding */ _atob),
/* harmony export */   atobPolyfill: () => (/* binding */ atobPolyfill),
/* harmony export */   btoa: () => (/* binding */ _btoa),
/* harmony export */   btoaPolyfill: () => (/* binding */ btoaPolyfill),
/* harmony export */   btou: () => (/* binding */ btou),
/* harmony export */   decode: () => (/* binding */ decode),
/* harmony export */   encode: () => (/* binding */ encode),
/* harmony export */   encodeURI: () => (/* binding */ encodeURI),
/* harmony export */   encodeURL: () => (/* binding */ encodeURI),
/* harmony export */   extendBuiltins: () => (/* binding */ extendBuiltins),
/* harmony export */   extendString: () => (/* binding */ extendString),
/* harmony export */   extendUint8Array: () => (/* binding */ extendUint8Array),
/* harmony export */   fromBase64: () => (/* binding */ decode),
/* harmony export */   fromUint8Array: () => (/* binding */ fromUint8Array),
/* harmony export */   isValid: () => (/* binding */ isValid),
/* harmony export */   toBase64: () => (/* binding */ encode),
/* harmony export */   toUint8Array: () => (/* binding */ toUint8Array),
/* harmony export */   utob: () => (/* binding */ utob),
/* harmony export */   version: () => (/* binding */ version)
/* harmony export */ });
/**
 *  base64.ts
 *
 *  Licensed under the BSD 3-Clause License.
 *    http://opensource.org/licenses/BSD-3-Clause
 *
 *  References:
 *    http://en.wikipedia.org/wiki/Base64
 *
 * @author Dan Kogai (https://github.com/dankogai)
 */
const version = '3.7.2';
/**
 * @deprecated use lowercase `version`.
 */
const VERSION = version;
const _hasatob = typeof atob === 'function';
const _hasbtoa = typeof btoa === 'function';
const _hasBuffer = typeof Buffer === 'function';
const _TD = typeof TextDecoder === 'function' ? new TextDecoder() : undefined;
const _TE = typeof TextEncoder === 'function' ? new TextEncoder() : undefined;
const b64ch = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
const b64chs = Array.prototype.slice.call(b64ch);
const b64tab = ((a) => {
    let tab = {};
    a.forEach((c, i) => tab[c] = i);
    return tab;
})(b64chs);
const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
const _fromCC = String.fromCharCode.bind(String);
const _U8Afrom = typeof Uint8Array.from === 'function'
    ? Uint8Array.from.bind(Uint8Array)
    : (it, fn = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn));
const _mkUriSafe = (src) => src
    .replace(/=/g, '').replace(/[+\/]/g, (m0) => m0 == '+' ? '-' : '_');
const _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, '');
/**
 * polyfill version of `btoa`
 */
const btoaPolyfill = (bin) => {
    // console.log('polyfilled');
    let u32, c0, c1, c2, asc = '';
    const pad = bin.length % 3;
    for (let i = 0; i < bin.length;) {
        if ((c0 = bin.charCodeAt(i++)) > 255 ||
            (c1 = bin.charCodeAt(i++)) > 255 ||
            (c2 = bin.charCodeAt(i++)) > 255)
            throw new TypeError('invalid character found');
        u32 = (c0 << 16) | (c1 << 8) | c2;
        asc += b64chs[u32 >> 18 & 63]
            + b64chs[u32 >> 12 & 63]
            + b64chs[u32 >> 6 & 63]
            + b64chs[u32 & 63];
    }
    return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
};
/**
 * does what `window.btoa` of web browsers do.
 * @param {String} bin binary string
 * @returns {string} Base64-encoded string
 */
const _btoa = _hasbtoa ? (bin) => btoa(bin)
    : _hasBuffer ? (bin) => Buffer.from(bin, 'binary').toString('base64')
        : btoaPolyfill;
const _fromUint8Array = _hasBuffer
    ? (u8a) => Buffer.from(u8a).toString('base64')
    : (u8a) => {
        // cf. https://stackoverflow.com/questions/12710001/how-to-convert-uint8-array-to-base64-encoded-string/12713326#12713326
        const maxargs = 0x1000;
        let strs = [];
        for (let i = 0, l = u8a.length; i < l; i += maxargs) {
            strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
        }
        return _btoa(strs.join(''));
    };
/**
 * converts a Uint8Array to a Base64 string.
 * @param {boolean} [urlsafe] URL-and-filename-safe a la RFC4648 §5
 * @returns {string} Base64 string
 */
const fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
// This trick is found broken https://github.com/dankogai/js-base64/issues/130
// const utob = (src: string) => unescape(encodeURIComponent(src));
// reverting good old fationed regexp
const cb_utob = (c) => {
    if (c.length < 2) {
        var cc = c.charCodeAt(0);
        return cc < 0x80 ? c
            : cc < 0x800 ? (_fromCC(0xc0 | (cc >>> 6))
                + _fromCC(0x80 | (cc & 0x3f)))
                : (_fromCC(0xe0 | ((cc >>> 12) & 0x0f))
                    + _fromCC(0x80 | ((cc >>> 6) & 0x3f))
                    + _fromCC(0x80 | (cc & 0x3f)));
    }
    else {
        var cc = 0x10000
            + (c.charCodeAt(0) - 0xD800) * 0x400
            + (c.charCodeAt(1) - 0xDC00);
        return (_fromCC(0xf0 | ((cc >>> 18) & 0x07))
            + _fromCC(0x80 | ((cc >>> 12) & 0x3f))
            + _fromCC(0x80 | ((cc >>> 6) & 0x3f))
            + _fromCC(0x80 | (cc & 0x3f)));
    }
};
const re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
/**
 * @deprecated should have been internal use only.
 * @param {string} src UTF-8 string
 * @returns {string} UTF-16 string
 */
const utob = (u) => u.replace(re_utob, cb_utob);
//
const _encode = _hasBuffer
    ? (s) => Buffer.from(s, 'utf8').toString('base64')
    : _TE
        ? (s) => _fromUint8Array(_TE.encode(s))
        : (s) => _btoa(utob(s));
/**
 * converts a UTF-8-encoded string to a Base64 string.
 * @param {boolean} [urlsafe] if `true` make the result URL-safe
 * @returns {string} Base64 string
 */
const encode = (src, urlsafe = false) => urlsafe
    ? _mkUriSafe(_encode(src))
    : _encode(src);
/**
 * converts a UTF-8-encoded string to URL-safe Base64 RFC4648 §5.
 * @returns {string} Base64 string
 */
const encodeURI = (src) => encode(src, true);
// This trick is found broken https://github.com/dankogai/js-base64/issues/130
// const btou = (src: string) => decodeURIComponent(escape(src));
// reverting good old fationed regexp
const re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
const cb_btou = (cccc) => {
    switch (cccc.length) {
        case 4:
            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
                | ((0x3f & cccc.charCodeAt(1)) << 12)
                | ((0x3f & cccc.charCodeAt(2)) << 6)
                | (0x3f & cccc.charCodeAt(3)), offset = cp - 0x10000;
            return (_fromCC((offset >>> 10) + 0xD800)
                + _fromCC((offset & 0x3FF) + 0xDC00));
        case 3:
            return _fromCC(((0x0f & cccc.charCodeAt(0)) << 12)
                | ((0x3f & cccc.charCodeAt(1)) << 6)
                | (0x3f & cccc.charCodeAt(2)));
        default:
            return _fromCC(((0x1f & cccc.charCodeAt(0)) << 6)
                | (0x3f & cccc.charCodeAt(1)));
    }
};
/**
 * @deprecated should have been internal use only.
 * @param {string} src UTF-16 string
 * @returns {string} UTF-8 string
 */
const btou = (b) => b.replace(re_btou, cb_btou);
/**
 * polyfill version of `atob`
 */
const atobPolyfill = (asc) => {
    // console.log('polyfilled');
    asc = asc.replace(/\s+/g, '');
    if (!b64re.test(asc))
        throw new TypeError('malformed base64.');
    asc += '=='.slice(2 - (asc.length & 3));
    let u24, bin = '', r1, r2;
    for (let i = 0; i < asc.length;) {
        u24 = b64tab[asc.charAt(i++)] << 18
            | b64tab[asc.charAt(i++)] << 12
            | (r1 = b64tab[asc.charAt(i++)]) << 6
            | (r2 = b64tab[asc.charAt(i++)]);
        bin += r1 === 64 ? _fromCC(u24 >> 16 & 255)
            : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255)
                : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
    }
    return bin;
};
/**
 * does what `window.atob` of web browsers do.
 * @param {String} asc Base64-encoded string
 * @returns {string} binary string
 */
const _atob = _hasatob ? (asc) => atob(_tidyB64(asc))
    : _hasBuffer ? (asc) => Buffer.from(asc, 'base64').toString('binary')
        : atobPolyfill;
//
const _toUint8Array = _hasBuffer
    ? (a) => _U8Afrom(Buffer.from(a, 'base64'))
    : (a) => _U8Afrom(_atob(a), c => c.charCodeAt(0));
/**
 * converts a Base64 string to a Uint8Array.
 */
const toUint8Array = (a) => _toUint8Array(_unURI(a));
//
const _decode = _hasBuffer
    ? (a) => Buffer.from(a, 'base64').toString('utf8')
    : _TD
        ? (a) => _TD.decode(_toUint8Array(a))
        : (a) => btou(_atob(a));
const _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == '-' ? '+' : '/'));
/**
 * converts a Base64 string to a UTF-8 string.
 * @param {String} src Base64 string.  Both normal and URL-safe are supported
 * @returns {string} UTF-8 string
 */
const decode = (src) => _decode(_unURI(src));
/**
 * check if a value is a valid Base64 string
 * @param {String} src a value to check
  */
const isValid = (src) => {
    if (typeof src !== 'string')
        return false;
    const s = src.replace(/\s+/g, '').replace(/={0,2}$/, '');
    return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
};
//
const _noEnum = (v) => {
    return {
        value: v, enumerable: false, writable: true, configurable: true
    };
};
/**
 * extend String.prototype with relevant methods
 */
const extendString = function () {
    const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));
    _add('fromBase64', function () { return decode(this); });
    _add('toBase64', function (urlsafe) { return encode(this, urlsafe); });
    _add('toBase64URI', function () { return encode(this, true); });
    _add('toBase64URL', function () { return encode(this, true); });
    _add('toUint8Array', function () { return toUint8Array(this); });
};
/**
 * extend Uint8Array.prototype with relevant methods
 */
const extendUint8Array = function () {
    const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
    _add('toBase64', function (urlsafe) { return fromUint8Array(this, urlsafe); });
    _add('toBase64URI', function () { return fromUint8Array(this, true); });
    _add('toBase64URL', function () { return fromUint8Array(this, true); });
};
/**
 * extend Builtin prototypes with relevant methods
 */
const extendBuiltins = () => {
    extendString();
    extendUint8Array();
};
const gBase64 = {
    version: version,
    VERSION: VERSION,
    atob: _atob,
    atobPolyfill: atobPolyfill,
    btoa: _btoa,
    btoaPolyfill: btoaPolyfill,
    fromBase64: decode,
    toBase64: encode,
    encode: encode,
    encodeURI: encodeURI,
    encodeURL: encodeURI,
    utob: utob,
    btou: btou,
    decode: decode,
    isValid: isValid,
    fromUint8Array: fromUint8Array,
    toUint8Array: toUint8Array,
    extendString: extendString,
    extendUint8Array: extendUint8Array,
    extendBuiltins: extendBuiltins,
};
// makecjs:CUT //




















// and finally,



/***/ }),
/* 9 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _RequestConfiguration__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
/* harmony import */ var _RequestConfigurationBuilder__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(13);
/* harmony import */ var _parsers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19);
/* harmony import */ var _setters__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(25);
/* harmony import */ var _InternalFlags__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(26);
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6);
/* harmony import */ var _repositories_TargetGroupRepository__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(31);
/*