{"version":3,"file":"js/7213dcb12386d103e8ca.chunk.js","mappings":"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","sources":["webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/lang/objectAssign.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/services/splitHttpClient.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/constants/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/services/splitApi.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/syncTask.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/submitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/eventsSubmitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/lang/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/impressionsSubmitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/impressionCountsSubmitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/readiness/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/mode.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/split.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/splits.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/splitFilters.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/impressionsMode.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/key.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/trafficType.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/apiKey.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/timeTracker/timer.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/telemetrySubmitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/uniqueKeysSubmitter.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/submitters/submitterManager.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/consent/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/syncManagerOnline.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/Backoff.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/SSEHandler/NotificationParser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/SSEHandler/NotificationKeeper.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/SSEHandler/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/UpdateWorkers/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/base64/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/jwt/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/murmur3/utfx.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/murmur3/common.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/murmur3/murmur3.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/AuthClient/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/SSEClient/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/key/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/SSEHandler/types.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/decompress/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/mySegmentsV2utils.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/lang/sets.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/murmur3/murmur3_128.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/murmur3/murmur3_64.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/streaming/pushManager.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/fetchers/mySegmentsFetcher.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/promise/timeout.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/updaters/mySegmentsUpdater.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/syncTasks/mySegmentsSyncTask.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/fetchers/splitChangesFetcher.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/updaters/splitChangesUpdater.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/syncTasks/splitsSyncTask.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/ImpressionsCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/time/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inRedis/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/ImpressionCountsCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/EventsCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/KeyBuilder.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/KeyBuilderCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/env/isLocalStorageAvailable.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/AbstractSplitsCacheSync.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inLocalStorage/constants.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inLocalStorage/SplitsCacheInLocal.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/AbstractSegmentsCacheSync.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/MySegmentsCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/SplitsCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/constants/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/findLatencyIndex.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/TelemetryCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/UniqueKeysCacheInMemoryCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorageCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inLocalStorage/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/promise/thenable.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/isOperational.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/labels/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/splitExistance.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkManager/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/storages/inMemory/AttributesCacheInMemory.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/attribute.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/attributes.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/clientAttributesDecoration.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/clientCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/matcherTypes.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchersTransform/segment.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchersTransform/whitelist.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchersTransform/set.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchersTransform/unaryNumeric.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/convertions/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchersTransform/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/treatments/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/all.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/segment.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/whitelist.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/eq.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/gte.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/lte.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/between.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/eq_set.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/cont_any.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/cont_all.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/part_of.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/ew.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/sw.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/cont_str.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/dependency.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/boolean.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/string.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/matchers/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/value/sanitize.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/value/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/condition/engineUtils.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/condition/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/combiners/ifelseif.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/combiners/and.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/parser/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/Engine.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/evaluator/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/trafficTypeExistance.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/impressionObserver/utils.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/client.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/event.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/eventValue.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/inputValidation/eventProperties.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/clientInputValidation.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/sdkClient.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethodCSWithTT.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/lang/maps.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/LRUCache/LinkedList.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/LRUCache/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/impressionObserver/ImpressionObserver.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/impressionObserver/buildKey.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/pluggable.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/ga/GaToSplit.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/ga/GoogleAnalyticsToSplit.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/ga/SplitToGa.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/ga/SplitToGoogleAnalytics.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/integrations/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/storage/storageCS.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/promise/wrapper.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/readiness/readinessManager.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/readiness/sdkReadinessManager.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/impressionsTracker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/eventTracker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/telemetryTracker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/sdkLogger.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/strategy/strategyDebug.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/strategy/strategyOptimized.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/strategy/strategyNone.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/trackers/uniqueKeysTracker.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sdkFactory/index.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/consent/sdkUserConsent.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/runtime.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/env/isNode.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/messages/error.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/messages/warn.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/messages/info.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/logger/messages/debug.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/commons.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/offline/splitsParser/parseCondition.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/offline/splitsParser/splitsParserFromSettings.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/offline/syncTasks/fromObjectSyncTask.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/offline/syncManagerOffline.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/sync/offline/LocalhostFromObject.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/consent.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/settings/defaults/version.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/settings/defaults/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/settings/storage/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/integrations/common.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/settingsValidation/integrations/configurable.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/settings/integrations/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/settings/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/platform/EventEmitter.js","webpack:///../../../../node_modules/unfetch/dist/unfetch.module.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/platform/getFetch/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/platform/getEventSource/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/listeners/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio-commons/esm/utils/timeTracker/now/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/platform/browser.js","webpack:///../../../../node_modules/@splitsoftware/splitio/es/factory/browser.js"],"sourcesContent":["/*\nAdaptation of \"object-assign\" library (https://www.npmjs.com/package/object-assign)\nexported as an ES module instead of CommonJS, to avoid extra configuration steps when using\nthe ESM build of the SDK with tools that doesn't support CommonJS by default (e.g. Rollup).\n\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n/* eslint-disable */\n// @ts-nocheck\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\nfunction toObject(val) {\n    if (val === null || val === undefined) {\n        throw new TypeError('Object.assign cannot be called with null or undefined');\n    }\n    return Object(val);\n}\nfunction shouldUseNative() {\n    try {\n        if (!Object.assign) {\n            return false;\n        }\n        // Detect buggy property enumeration order in older V8 versions.\n        // https://bugs.chromium.org/p/v8/issues/detail?id=4118\n        var test1 = new String('abc');\n        test1[5] = 'de';\n        if (Object.getOwnPropertyNames(test1)[0] === '5') {\n            return false;\n        }\n        // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n        var test2 = {};\n        for (var i = 0; i < 10; i++) {\n            test2['_' + String.fromCharCode(i)] = i;\n        }\n        var order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n            return test2[n];\n        });\n        if (order2.join('') !== '0123456789') {\n            return false;\n        }\n        // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n        var test3 = {};\n        'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n            test3[letter] = letter;\n        });\n        if (Object.keys(Object.assign({}, test3)).join('') !==\n            'abcdefghijklmnopqrst') {\n            return false;\n        }\n        return true;\n    }\n    catch (err) {\n        // We don't expect any of the above to throw, but better to be safe.\n        return false;\n    }\n}\nexport var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {\n    var from;\n    var to = toObject(target);\n    var symbols;\n    for (var s = 1; s < arguments.length; s++) {\n        from = Object(arguments[s]);\n        // eslint-disable-next-line no-restricted-syntax\n        for (var key in from) {\n            if (hasOwnProperty.call(from, key)) {\n                to[key] = from[key];\n            }\n        }\n        if (getOwnPropertySymbols) {\n            symbols = getOwnPropertySymbols(from);\n            for (var i = 0; i < symbols.length; i++) {\n                if (propIsEnumerable.call(from, symbols[i])) {\n                    to[symbols[i]] = from[symbols[i]];\n                }\n            }\n        }\n    }\n    return to;\n};\n","/**\n * Message codes used to trim string log messages from commons and client-side API modules,\n * in order to reduce the minimal SDK size for Browser and eventually other client-side environments.\n *\n * Modules related to the server-side API (e.g., segmentsSyncTask), platform-specific components (e.g., signal listeners)\n * and pluggable components (e.g., pluggable integrations & storages) can use the logger with string literals.\n */\nexport var ENGINE_COMBINER_AND = 0;\nexport var ENGINE_COMBINER_IFELSEIF = 1;\nexport var ENGINE_COMBINER_IFELSEIF_NO_TREATMENT = 2;\nexport var ENGINE_BUCKET = 3;\nexport var ENGINE_MATCHER_ALL = 4;\nexport var ENGINE_MATCHER_BETWEEN = 5;\nexport var ENGINE_MATCHER_BOOLEAN = 6;\nexport var ENGINE_MATCHER_CONTAINS_ALL = 7;\nexport var ENGINE_MATCHER_CONTAINS_ANY = 8;\nexport var ENGINE_MATCHER_CONTAINS_STRING = 9;\nexport var ENGINE_MATCHER_DEPENDENCY = 10;\nexport var ENGINE_MATCHER_DEPENDENCY_PRE = 11;\nexport var ENGINE_MATCHER_EQUAL = 12;\nexport var ENGINE_MATCHER_EQUAL_TO_SET = 13;\nexport var ENGINE_MATCHER_ENDS_WITH = 14;\nexport var ENGINE_MATCHER_GREATER = 15;\nexport var ENGINE_MATCHER_LESS = 16;\nexport var ENGINE_MATCHER_PART_OF = 17;\nexport var ENGINE_MATCHER_SEGMENT = 18;\nexport var ENGINE_MATCHER_STRING = 19;\nexport var ENGINE_MATCHER_STRING_INVALID = 20;\nexport var ENGINE_MATCHER_STARTS_WITH = 21;\nexport var ENGINE_MATCHER_WHITELIST = 22;\nexport var ENGINE_VALUE = 23;\nexport var ENGINE_SANITIZE = 24;\nexport var CLEANUP_REGISTERING = 25;\nexport var CLEANUP_DEREGISTERING = 26;\nexport var RETRIEVE_CLIENT_DEFAULT = 27;\nexport var RETRIEVE_CLIENT_EXISTING = 28;\nexport var RETRIEVE_MANAGER = 29;\nexport var SYNC_OFFLINE_DATA = 30;\nexport var SYNC_SPLITS_FETCH = 31;\nexport var SYNC_SPLITS_NEW = 32;\nexport var SYNC_SPLITS_REMOVED = 33;\nexport var SYNC_SPLITS_SEGMENTS = 34;\nexport var STREAMING_NEW_MESSAGE = 35;\nexport var SYNC_TASK_START = 36;\nexport var SYNC_TASK_EXECUTE = 37;\nexport var SYNC_TASK_STOP = 38;\nexport var SETTINGS_SPLITS_FILTER = 39;\nexport var CLIENT_READY_FROM_CACHE = 100;\nexport var CLIENT_READY = 101;\nexport var IMPRESSION = 102;\nexport var IMPRESSION_QUEUEING = 103;\nexport var NEW_SHARED_CLIENT = 104;\nexport var NEW_FACTORY = 105;\nexport var POLLING_SMART_PAUSING = 106;\nexport var POLLING_START = 107;\nexport var POLLING_STOP = 108;\nexport var SYNC_SPLITS_FETCH_RETRY = 109;\nexport var STREAMING_REFRESH_TOKEN = 110;\nexport var STREAMING_RECONNECT = 111;\nexport var STREAMING_CONNECTING = 112;\nexport var STREAMING_DISABLED = 113;\nexport var STREAMING_DISCONNECTING = 114;\nexport var SUBMITTERS_PUSH_FULL_QUEUE = 115;\nexport var SUBMITTERS_PUSH = 116;\nexport var SYNC_START_POLLING = 117;\nexport var SYNC_CONTINUE_POLLING = 118;\nexport var SYNC_STOP_POLLING = 119;\nexport var EVENTS_TRACKER_SUCCESS = 120;\nexport var IMPRESSIONS_TRACKER_SUCCESS = 121;\nexport var USER_CONSENT_UPDATED = 122;\nexport var USER_CONSENT_NOT_UPDATED = 123;\nexport var USER_CONSENT_INITIAL = 124;\nexport var ENGINE_VALUE_INVALID = 200;\nexport var ENGINE_VALUE_NO_ATTRIBUTES = 201;\nexport var CLIENT_NO_LISTENER = 202;\nexport var CLIENT_NOT_READY = 203;\nexport var SYNC_MYSEGMENTS_FETCH_RETRY = 204;\nexport var SYNC_SPLITS_FETCH_FAILS = 205;\nexport var STREAMING_PARSING_ERROR_FAILS = 206;\nexport var STREAMING_PARSING_MESSAGE_FAILS = 207;\nexport var STREAMING_FALLBACK = 208;\nexport var SUBMITTERS_PUSH_FAILS = 209;\nexport var SUBMITTERS_PUSH_RETRY = 210;\nexport var WARN_SETTING_NULL = 211;\nexport var WARN_TRIMMING_PROPERTIES = 212;\nexport var WARN_CONVERTING = 213;\nexport var WARN_TRIMMING = 214;\nexport var WARN_NOT_EXISTENT_SPLIT = 215;\nexport var WARN_LOWERCASE_TRAFFIC_TYPE = 216;\nexport var WARN_NOT_EXISTENT_TT = 217;\nexport var WARN_INTEGRATION_INVALID = 218;\nexport var WARN_SPLITS_FILTER_IGNORED = 219;\nexport var WARN_SPLITS_FILTER_INVALID = 220;\nexport var WARN_SPLITS_FILTER_EMPTY = 221;\nexport var WARN_API_KEY = 222;\nexport var STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;\nexport var ERROR_ENGINE_COMBINER_IFELSEIF = 300;\nexport var ERROR_LOGLEVEL_INVALID = 301;\nexport var ERROR_CLIENT_LISTENER = 302;\nexport var ERROR_CLIENT_CANNOT_GET_READY = 303;\nexport var ERROR_SYNC_OFFLINE_LOADING = 304;\nexport var ERROR_STREAMING_SSE = 305;\nexport var ERROR_STREAMING_AUTH = 306;\nexport var ERROR_IMPRESSIONS_TRACKER = 307;\nexport var ERROR_IMPRESSIONS_LISTENER = 308;\nexport var ERROR_EVENTS_TRACKER = 309;\nexport var ERROR_EVENT_TYPE_FORMAT = 310;\nexport var ERROR_NOT_PLAIN_OBJECT = 311;\nexport var ERROR_SIZE_EXCEEDED = 312;\nexport var ERROR_NOT_FINITE = 313;\nexport var ERROR_CLIENT_DESTROYED = 314;\nexport var ERROR_NULL = 315;\nexport var ERROR_TOO_LONG = 316;\nexport var ERROR_INVALID_KEY_OBJECT = 317;\nexport var ERROR_INVALID = 318;\nexport var ERROR_EMPTY = 319;\nexport var ERROR_EMPTY_ARRAY = 320;\nexport var ERROR_INVALID_CONFIG_PARAM = 321;\nexport var ERROR_HTTP = 322;\nexport var ERROR_LOCALHOST_MODULE_REQUIRED = 323;\nexport var ERROR_STORAGE_INVALID = 324;\nexport var ERROR_NOT_BOOLEAN = 325;\nexport var ERROR_MIN_CONFIG_PARAM = 326;\n// Log prefixes (a.k.a. tags or categories)\nexport var LOG_PREFIX_SETTINGS = 'settings';\nexport var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';\nexport var LOG_PREFIX_ENGINE = 'engine';\nexport var LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';\nexport var LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';\nexport var LOG_PREFIX_ENGINE_VALUE = LOG_PREFIX_ENGINE + ':value: ';\nexport var LOG_PREFIX_SYNC = 'sync';\nexport var LOG_PREFIX_SYNC_MANAGER = LOG_PREFIX_SYNC + ':sync-manager: ';\nexport var LOG_PREFIX_SYNC_OFFLINE = LOG_PREFIX_SYNC + ':offline: ';\nexport var LOG_PREFIX_SYNC_STREAMING = LOG_PREFIX_SYNC + ':streaming: ';\nexport var LOG_PREFIX_SYNC_SPLITS = LOG_PREFIX_SYNC + ':split-changes: ';\nexport var LOG_PREFIX_SYNC_SEGMENTS = LOG_PREFIX_SYNC + ':segment-changes: ';\nexport var LOG_PREFIX_SYNC_MYSEGMENTS = LOG_PREFIX_SYNC + ':my-segments: ';\nexport var LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';\nexport var LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';\nexport var LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';\nexport var LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';\nexport var LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';\nexport var LOG_PREFIX_CLEANUP = 'cleanup: ';\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';\nvar messageNoFetch = 'Global fetch API is not available.';\n/**\n * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.\n *\n * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers\n * @param options global request options\n * @param fetch optional http client to use instead of the global Fetch (for environments where Fetch API is not available such as Node)\n */\nexport function splitHttpClientFactory(settings, getFetch, getOptions) {\n    var log = settings.log, authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;\n    var options = getOptions && getOptions();\n    var fetch = getFetch && getFetch();\n    // if fetch is not available, log Error\n    if (!fetch)\n        log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);\n    var headers = {\n        'Accept': 'application/json',\n        'Content-Type': 'application/json',\n        'Authorization': \"Bearer \" + authorizationKey,\n        'SplitSDKVersion': version\n    };\n    if (ip)\n        headers['SplitSDKMachineIP'] = ip;\n    if (hostname)\n        headers['SplitSDKMachineName'] = hostname;\n    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {\n        if (reqOpts === void 0) { reqOpts = {}; }\n        if (latencyTracker === void 0) { latencyTracker = function () { }; }\n        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }\n        var request = objectAssign({\n            headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,\n            method: reqOpts.method || 'GET',\n            body: reqOpts.body\n        }, options);\n        // using `fetch(url, options)` signature to work with unfetch, a lightweight ponyfill of fetch API.\n        return fetch ? fetch(url, request)\n            // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful\n            .then(function (response) {\n            if (!response.ok) {\n                return response.text().then(function (message) { return Promise.reject({ response: response, message: message }); });\n            }\n            latencyTracker();\n            return response;\n        })\n            .catch(function (error) {\n            var resp = error && error.response;\n            var msg = '';\n            if (resp) { // An HTTP error\n                switch (resp.status) {\n                    case 404:\n                        msg = 'Invalid API key or resource not found.';\n                        break;\n                    // Don't use resp.statusText since reason phrase is removed in HTTP/2\n                    default:\n                        msg = error.message;\n                        break;\n                }\n            }\n            else { // Something else, either an error making the request or a Network error.\n                msg = error.message || 'Network Error';\n            }\n            if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.\n                log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]);\n            }\n            var networkError = new Error(msg);\n            // passes `undefined` as statusCode if not an HTTP error (resp === undefined)\n            networkError.statusCode = resp && resp.status;\n            latencyTracker(networkError);\n            throw networkError;\n        }) : Promise.reject(new Error(messageNoFetch));\n    };\n}\n","// Special treatments\nexport var CONTROL = 'control';\nexport var CONTROL_WITH_CONFIG = {\n    treatment: CONTROL,\n    config: null\n};\n// Constants for unknown and not-applicable values\nexport var UNKNOWN = 'unknown';\nexport var NA = 'NA';\n// Integration data types\nexport var SPLIT_IMPRESSION = 'IMPRESSION';\nexport var SPLIT_EVENT = 'EVENT';\n// Impression collection modes\nexport var DEBUG = 'DEBUG';\nexport var OPTIMIZED = 'OPTIMIZED';\nexport var NONE = 'NONE';\n// SDK Modes\nexport var LOCALHOST_MODE = 'localhost';\nexport var STANDALONE_MODE = 'standalone';\nexport var PRODUCER_MODE = 'producer';\nexport var CONSUMER_MODE = 'consumer';\nexport var CONSUMER_PARTIAL_MODE = 'consumer_partial';\n// Storage types\nexport var STORAGE_MEMORY = 'MEMORY';\nexport var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';\nexport var STORAGE_REDIS = 'REDIS';\nexport var STORAGE_PLUGGABLE = 'PLUGGABLE';\n// User consent\nexport var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions\nexport var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions\nexport var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions\n// Telemetry\nexport var QUEUED = 0;\nexport var DROPPED = 1;\nexport var DEDUPED = 2;\nexport var STANDALONE_ENUM = 0;\nexport var CONSUMER_ENUM = 1;\nexport var CONSUMER_PARTIAL_ENUM = 2;\nexport var OPTIMIZED_ENUM = 0;\nexport var DEBUG_ENUM = 1;\nexport var NONE_ENUM = 2;\nexport var SPLITS = 'sp';\nexport var IMPRESSIONS = 'im';\nexport var IMPRESSIONS_COUNT = 'ic';\nexport var EVENTS = 'ev';\nexport var TELEMETRY = 'te';\nexport var TOKEN = 'to';\nexport var SEGMENT = 'se';\nexport var MY_SEGMENT = 'ms';\nexport var TREATMENT = 't';\nexport var TREATMENTS = 'ts';\nexport var TREATMENT_WITH_CONFIG = 'tc';\nexport var TREATMENTS_WITH_CONFIG = 'tcs';\nexport var TRACK = 'tr';\nexport var CONNECTION_ESTABLISHED = 0;\nexport var OCCUPANCY_PRI = 10;\nexport var OCCUPANCY_SEC = 20;\nexport var STREAMING_STATUS = 30;\nexport var SSE_CONNECTION_ERROR = 40;\nexport var TOKEN_REFRESH = 50;\nexport var ABLY_ERROR = 60;\nexport var SYNC_MODE_UPDATE = 70;\nexport var AUTH_REJECTION = 80;\nexport var STREAMING = 0;\nexport var POLLING = 1;\nexport var REQUESTED = 0;\nexport var NON_REQUESTED = 1;\nexport var DISABLED = 0;\nexport var ENABLED = 1;\nexport var PAUSED = 2;\n","import { splitHttpClientFactory } from './splitHttpClient';\nimport { objectAssign } from '../utils/lang/objectAssign';\nimport { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';\nvar noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };\nfunction userKeyToQueryParam(userKey) {\n    return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.\n}\n/**\n * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK\n *\n * @param settings validated settings object\n * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies\n */\nexport function splitApiFactory(settings, platform, telemetryTracker) {\n    var urls = settings.urls;\n    var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;\n    var SplitSDKImpressionsMode = settings.sync.impressionsMode;\n    var splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);\n    return {\n        getSdkAPIHealthCheck: function () {\n            var url = urls.sdk + \"/version\";\n            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });\n        },\n        getEventsAPIHealthCheck: function () {\n            var url = urls.events + \"/version\";\n            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });\n        },\n        fetchAuth: function (userMatchingKeys) {\n            var url = urls.auth + \"/v2/auth\";\n            if (userMatchingKeys) { // accounting the possibility that `userMatchingKeys` is undefined (server-side API)\n                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');\n                if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty\n                    url += '?' + queryParams;\n            }\n            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));\n        },\n        fetchSplitChanges: function (since, noCache, till) {\n            var url = urls.sdk + \"/splitChanges?since=\" + since + (till ? '&till=' + till : '') + (filterQueryString || '');\n            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));\n        },\n        fetchSegmentChanges: function (since, segmentName, noCache, till) {\n            var url = urls.sdk + \"/segmentChanges/\" + segmentName + \"?since=\" + since + (till ? '&till=' + till : '');\n            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));\n        },\n        fetchMySegments: function (userMatchingKey, noCache) {\n            /**\n             * URI encoding of user keys in order to:\n             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'\n             *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'\n             *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'\n             */\n            var url = urls.sdk + \"/mySegments/\" + encodeURIComponent(userMatchingKey);\n            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));\n        },\n        /**\n         * Post events.\n         *\n         * @param body  Events bulk payload\n         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.\n         */\n        postEventsBulk: function (body, headers) {\n            var url = urls.events + \"/events/bulk\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));\n        },\n        /**\n         * Post impressions.\n         *\n         * @param body  Impressions bulk payload\n         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.\n         */\n        postTestImpressionsBulk: function (body, headers) {\n            var url = urls.events + \"/testImpressions/bulk\";\n            return splitHttpClient(url, {\n                // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.\n                method: 'POST',\n                body: body,\n                headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)\n            }, telemetryTracker.trackHttp(IMPRESSIONS));\n        },\n        /**\n         * Post impressions counts.\n         *\n         * @param body  Impressions counts payload\n         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.\n         */\n        postTestImpressionsCount: function (body, headers) {\n            var url = urls.events + \"/testImpressions/count\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));\n        },\n        /**\n         * Post unique keys for client side.\n         *\n         * @param body  unique keys payload\n         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.\n         */\n        postUniqueKeysBulkCs: function (body, headers) {\n            var url = urls.telemetry + \"/v1/keys/cs\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));\n        },\n        /**\n         * Post unique keys for server side.\n         *\n         * @param body  unique keys payload\n         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.\n         */\n        postUniqueKeysBulkSs: function (body, headers) {\n            var url = urls.telemetry + \"/v1/keys/ss\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));\n        },\n        postMetricsConfig: function (body, headers) {\n            var url = urls.telemetry + \"/v1/metrics/config\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);\n        },\n        postMetricsUsage: function (body, headers) {\n            var url = urls.telemetry + \"/v1/metrics/usage\";\n            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);\n        }\n    };\n}\n","import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';\n/**\n * Creates an object that handles the periodic execution of a given task via \"start\" and \"stop\" methods.\n * The task can be also executed by calling the \"execute\" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).\n *\n * @param log  Logger instance.\n * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.\n * @param period  Period in milliseconds to execute the task.\n * @param taskName  Optional task name for logging.\n * @returns A sync task that wraps the given task.\n */\nexport function syncTaskFactory(log, task, period, taskName) {\n    if (taskName === void 0) { taskName = 'task'; }\n    // Flag that indicates if the task is executing\n    var executing = 0;\n    // Promise chain to resolve tasks sequentially\n    var promiseChain;\n    // flag that indicates if the task periodic execution has been started/stopped.\n    var running = false;\n    // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently\n    var runningId = 0;\n    // Params passed to `task` when called periodically\n    var runningArgs;\n    // Id of the periodic call timeout\n    var timeoutID;\n    function execute() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        executing++;\n        log.debug(SYNC_TASK_EXECUTE, [taskName]);\n        // Update `promiseChain` with last promise, to run tasks serially\n        promiseChain = (promiseChain ? promiseChain.then(function () { return task.apply(void 0, args); }) : task.apply(void 0, args))\n            .then(function (result) {\n            executing--;\n            return result;\n        });\n        return promiseChain;\n    }\n    function periodicExecute(currentRunningId) {\n        return execute.apply(void 0, runningArgs).then(function (result) {\n            // Call `setTimeout` if periodic execution was started and `currentRunningId === runningId`\n            // to avoid a race condition when calling `start`, `stop` and `start` again\n            if (running && currentRunningId === runningId)\n                timeoutID = setTimeout(periodicExecute, period, currentRunningId);\n            return result;\n        });\n    }\n    return {\n        execute: execute,\n        isExecuting: function () {\n            return executing > 0;\n        },\n        start: function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            if (!running) {\n                running = true;\n                runningId++;\n                runningArgs = args;\n                log.debug(SYNC_TASK_START, [taskName, period]);\n                return periodicExecute(runningId);\n            }\n        },\n        stop: function () {\n            running = false;\n            if (timeoutID) {\n                log.debug(SYNC_TASK_STOP, [taskName]);\n                clearTimeout(timeoutID);\n                timeoutID = undefined;\n            }\n        },\n        isRunning: function () {\n            return running;\n        }\n    };\n}\n","import { syncTaskFactory } from '../syncTask';\nimport { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';\n/**\n * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter\n */\nexport function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs // true for telemetry submitters\n) {\n    if (maxRetries === void 0) { maxRetries = 0; }\n    var retries = 0;\n    var data;\n    function postData() {\n        if (sourceCache.isEmpty() && !data)\n            return Promise.resolve();\n        data = sourceCache.pop(data);\n        var dataCountMessage = typeof data.length === 'number' ? data.length + \" \" + dataName : dataName;\n        log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCountMessage]);\n        var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);\n        if (!maxRetries)\n            data = undefined;\n        return postClient(jsonPayload).then(function () {\n            retries = 0;\n            data = undefined;\n        }).catch(function (err) {\n            if (!maxRetries) {\n                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);\n            }\n            else if (retries === maxRetries) {\n                retries = 0;\n                data = undefined;\n                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);\n            }\n            else {\n                retries++;\n                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);\n            }\n        });\n    }\n    return syncTaskFactory(log, postData, postRate, dataName + ' submitter');\n}\n/**\n * Decorates a provided submitter with a first execution window\n */\nexport function firstPushWindowDecorator(submitter, firstPushWindow) {\n    var running = false;\n    var stopEventPublisherTimeout;\n    var originalStart = submitter.start;\n    submitter.start = function () {\n        running = true;\n        stopEventPublisherTimeout = setTimeout(originalStart, firstPushWindow);\n    };\n    var originalStop = submitter.stop;\n    submitter.stop = function () {\n        running = false;\n        clearTimeout(stopEventPublisherTimeout);\n        originalStop();\n    };\n    submitter.isRunning = function () {\n        return running;\n    };\n    return submitter;\n}\n","import { submitterFactory, firstPushWindowDecorator } from './submitter';\nimport { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';\nvar DATA_NAME = 'events';\n/**\n * Submitter that periodically posts tracked events\n */\nexport function eventsSubmitterFactory(params) {\n    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.splitApi.postEventsBulk, events = params.storage.events;\n    // don't retry events.\n    var submitter = submitterFactory(log, postEventsBulk, events, eventsPushRate, DATA_NAME);\n    // Set a timer for the first push window of events.\n    if (eventsFirstPushWindow > 0)\n        submitter = firstPushWindowDecorator(submitter, eventsFirstPushWindow);\n    // register events submitter to be executed when events cache is full\n    events.setOnFullQueueCb(function () {\n        if (submitter.isRunning()) {\n            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);\n            submitter.execute();\n        }\n        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.\n        // Data will be sent when submitter is resumed.\n    });\n    return submitter;\n}\n","import { __spreadArray } from \"tslib\";\n/**\n * Checks if the target string ends with the sub string.\n */\nexport function endsWith(target, sub, caseInsensitive) {\n    if (caseInsensitive === void 0) { caseInsensitive = false; }\n    if (!(isString(target) && isString(sub))) {\n        return false;\n    }\n    if (caseInsensitive) {\n        target = target.toLowerCase();\n        sub = sub.toLowerCase();\n    }\n    return target.slice(target.length - sub.length) === sub;\n}\n/**\n * Loops through a source collection (an object or an array) running iteratee\n * against each element. It returns the first element for which iteratee returned\n * a truthy value and stops the loop.\n * Iteratee receives three arguments (element, key/index, collection)\n */\nexport function find(source, iteratee) {\n    var res;\n    if (isObject(source)) {\n        var keys = Object.keys(source);\n        for (var i = 0; i < keys.length && !res; i++) {\n            var key = keys[i];\n            var iterateeResult = iteratee(source[key], key, source);\n            if (iterateeResult)\n                res = source[key];\n        }\n    }\n    else if (Array.isArray(source)) {\n        for (var i = 0; i < source.length && !res; i++) {\n            var iterateeResult = iteratee(source[i], i, source);\n            if (iterateeResult)\n                res = source[i];\n        }\n    }\n    return res;\n}\n/**\n * Evaluates iteratee for each element of the source array. Returns the index of the first element\n * for which iteratee returns truthy. If no element is found or there's an issue with the params it returns -1.\n */\nexport function findIndex(source, iteratee) {\n    if (Array.isArray(source) && typeof iteratee === 'function') {\n        for (var i = 0; i < source.length; i++) {\n            if (iteratee(source[i], i, source) === true) {\n                return i;\n            }\n        }\n    }\n    return -1;\n}\n/**\n * Executes iteratee for given obj own props.\n */\nexport function forOwn(obj, iteratee) {\n    var keys = Object.keys(obj);\n    keys.forEach(function (key) { return iteratee(obj[key], key, obj); });\n    return obj;\n}\n/**\n * Safely retrieve the specified prop from obj. If we can't retrieve\n * that property value, we return the default value.\n */\nexport function get(obj, prop, val) {\n    var res = val;\n    try { // No risks nor lots of checks.\n        var pathPieces = prop.split('.');\n        var partial_1 = obj;\n        pathPieces.forEach(function (pathPiece) { return partial_1 = partial_1[pathPiece]; });\n        if (typeof partial_1 !== 'undefined')\n            res = partial_1;\n    }\n    catch (e) {\n        // noop\n    }\n    return res;\n}\n/**\n * Parses an array into a map of different arrays, grouping by the specified prop value.\n */\nexport function groupBy(source, prop) {\n    var map = {};\n    if (Array.isArray(source) && isString(prop)) {\n        for (var i = 0; i < source.length; i++) {\n            var key = source[i][prop];\n            // Skip the element if the key is not a string.\n            if (isString(key)) {\n                if (!map[key])\n                    map[key] = [];\n                map[key].push(source[i]);\n            }\n        }\n    }\n    return map;\n}\n/**\n * Checks if a given value is a boolean.\n */\nexport function isBoolean(val) {\n    return val === true || val === false;\n}\n/**\n * Checks if a given value is a finite value of number type or Number object.\n * Unlike `Number.isFinite`, it also tests Number object instances.\n * Unlike global `isFinite`, it returns false if the value is not a number or Number object instance.\n */\nexport function isFiniteNumber(val) {\n    if (val instanceof Number)\n        val = val.valueOf();\n    // @TODO remove `isFinite` once `Number.isFinite` is fully supported by targets\n    // eslint-disable-next-line compat/compat\n    if (typeof val === 'number')\n        return Number.isFinite ? Number.isFinite(val) : isFinite(val);\n    return false;\n}\n/**\n * Checks if a given value is an integer value of number type or Number object.\n * Unlike `Number.isInteger`, it also tests Number object instances.\n */\nexport function isIntegerNumber(val) {\n    if (val instanceof Number)\n        val = val.valueOf();\n    // eslint-disable-next-line compat/compat\n    if (typeof val === 'number')\n        return Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val;\n    return false;\n}\n/**\n * Checks if a given value is a NaN value of number type or Number object.\n * Unlike `Number.isNaN`, it also tests Number object instances.\n * Unlike global `isNan`, it returns false if the value is not a number or Number object instance.\n */\nexport function isNaNNumber(val) {\n    if (val instanceof Number)\n        val = val.valueOf();\n    // @TODO replace with `Number.isNaN` once it is fully supported by targets\n    return val !== val;\n}\n/**\n * Validates if a value is an object created by the Object constructor (plain object).\n * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.\n */\nexport function isObject(obj) {\n    return obj !== null && typeof obj === 'object' && (obj.constructor === Object ||\n        (obj.constructor != null && obj.constructor.name === 'Object'));\n}\n/**\n * Checks if a given value is a string.\n */\nexport function isString(val) {\n    return typeof val === 'string' || val instanceof String;\n}\n/**\n * String sanitizer. Returns the provided value converted to uppercase if it is a string.\n */\nexport function stringToUpperCase(val) {\n    return isString(val) ? val.toUpperCase() : val;\n}\n/**\n * Deep copy version of Object.assign using recursion.\n * There are some assumptions here. It's for internal use and we don't need verbose errors\n * or to ensure the data types or whatever. Parameters should always be correct (at least have a target and a source, of type object).\n */\nexport function merge(target, source) {\n    var rest = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        rest[_i - 2] = arguments[_i];\n    }\n    var res = target;\n    isObject(source) && Object.keys(source).forEach(function (key) {\n        var val = source[key];\n        if (isObject(val)) {\n            if (res[key] && isObject(res[key])) { // If both are objects, merge into a new one.\n                val = merge({}, res[key], val);\n            }\n            else { // else make a copy.\n                val = merge({}, val);\n            }\n        }\n        // We skip undefined values.\n        if (val !== undefined)\n            res[key] = val;\n    });\n    if (rest && rest.length) {\n        var nextSource = rest.splice(0, 1)[0];\n        res = merge.apply(void 0, __spreadArray([res, nextSource], rest, false));\n    }\n    return res;\n}\n/**\n * Checks if the target string starts with the sub string.\n */\nexport function startsWith(target, sub) {\n    if (!(isString(target) && isString(sub))) {\n        return false;\n    }\n    return target.slice(0, sub.length) === sub;\n}\n/**\n * Transforms a value into a number.\n * Note: We're not expecting anything fancy here. If we are at some point, add more type checks.\n */\nexport function toNumber(val) {\n    if (typeof val === 'number')\n        return val;\n    if (isObject(val) && typeof val.valueOf === 'function') {\n        var valOf = val.valueOf();\n        val = isObject(valOf) ? valOf + '' : valOf;\n    }\n    if (typeof val !== 'string') {\n        return val === 0 ? val : +val;\n    }\n    // Remove trailing whitespaces.\n    val = val.replace(/^\\s+|\\s+$/g, '');\n    return +val;\n}\n/**\n * Transforms a value into it's string representation.\n */\nexport function toString(val) {\n    if (val == null)\n        return '';\n    if (typeof val === 'string')\n        return val;\n    if (Array.isArray(val))\n        return val.map(function (val) { return isString(val) ? val : ''; }) + '';\n    var result = val + '';\n    return (result === '0' && (1 / val) === Number.NEGATIVE_INFINITY) ? '-0' : result;\n}\n/**\n * Removes duplicate items on an array of strings.\n */\nexport function uniq(arr) {\n    var seen = {};\n    return arr.filter(function (item) {\n        return Object.prototype.hasOwnProperty.call(seen, item) ? false : seen[item] = true;\n    });\n}\n/**\n * Removes duplicate items on an array of objects using an optional `stringify` function as equality criteria.\n * It uses JSON.stringify as default criteria.\n */\nexport function uniqAsStrings(arr, stringify) {\n    if (stringify === void 0) { stringify = JSON.stringify; }\n    var seen = {};\n    return arr.filter(function (item) {\n        var itemString = stringify(item);\n        return Object.prototype.hasOwnProperty.call(seen, itemString) ? false : seen[itemString] = true;\n    });\n}\nvar uniqueIdCounter = -1;\n/**\n * Returns a number to be used as ID, which will be unique.\n */\nexport function uniqueId() {\n    return uniqueIdCounter++;\n}\n","import { groupBy, forOwn } from '../../utils/lang';\nimport { submitterFactory } from './submitter';\nimport { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';\nvar DATA_NAME = 'impressions';\n/**\n * Converts `impressions` data from cache into request payload.\n */\nexport function fromImpressionsCollector(sendLabels, data) {\n    var groupedByFeature = groupBy(data, 'feature');\n    var dto = [];\n    // using forOwn instead of for...in since the last also iterates over prototype enumerables\n    forOwn(groupedByFeature, function (value, name) {\n        dto.push({\n            f: name,\n            i: value.map(function (entry) {\n                var keyImpression = {\n                    k: entry.keyName,\n                    t: entry.treatment,\n                    m: entry.time,\n                    c: entry.changeNumber,\n                    r: sendLabels ? entry.label : undefined,\n                    b: entry.bucketingKey ? entry.bucketingKey : undefined,\n                    pt: entry.pt ? entry.pt : undefined // Previous time\n                };\n                return keyImpression;\n            })\n        });\n    });\n    return dto;\n}\n/**\n * Submitter that periodically posts impressions data\n */\nexport function impressionsSubmitterFactory(params) {\n    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions;\n    // retry impressions only once.\n    var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, DATA_NAME, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);\n    // register impressions submitter to be executed when impressions cache is full\n    impressions.setOnFullQueueCb(function () {\n        if (syncTask.isRunning()) {\n            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);\n            syncTask.execute();\n        }\n        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.\n        // Data will be sent when submitter is resumed.\n    });\n    return syncTask;\n}\n","import { submitterFactory } from './submitter';\n/**\n * Converts `impressionCounts` data from cache into request payload.\n */\nexport function fromImpressionCountsCollector(impressionsCount) {\n    var pf = [];\n    var keys = Object.keys(impressionsCount);\n    for (var i = 0; i < keys.length; i++) {\n        var splitted = keys[i].split('::');\n        if (splitted.length !== 2)\n            continue;\n        var featureName = splitted[0];\n        var timeFrame = splitted[1];\n        var impressionsInTimeframe = {\n            f: featureName,\n            m: Number(timeFrame),\n            rc: impressionsCount[keys[i]] // Count\n        };\n        pf.push(impressionsInTimeframe);\n    }\n    return { pf: pf };\n}\nvar IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes\n/**\n * Submitter that periodically posts impression counts\n */\nexport function impressionCountsSubmitterFactory(params) {\n    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;\n    if (impressionCounts) {\n        // retry impressions counts only once.\n        return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);\n    }\n}\n","// Splits events:\nexport var SDK_SPLITS_ARRIVED = 'state::splits-arrived';\nexport var SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';\n// Segments events:\nexport var SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';\n// Readiness events:\nexport var SDK_READY_TIMED_OUT = 'init::timeout';\nexport var SDK_READY = 'init::ready';\nexport var SDK_READY_FROM_CACHE = 'init::cache-ready';\nexport var SDK_UPDATE = 'state::update';\n","import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';\nexport function mode(key, mode) {\n    // Leaving the comparison as is, in case we change the mode name but not the setting.\n    if (key === 'localhost')\n        return LOCALHOST_MODE;\n    if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(mode) === -1)\n        throw Error('Invalid mode provided');\n    return mode;\n}\n","import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';\nimport { isString } from '../lang';\n// include BOM and nbsp\nvar TRIMMABLE_SPACES_REGEX = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/;\nexport function validateSplit(log, maybeSplit, method, item) {\n    if (item === void 0) { item = 'split name'; }\n    if (maybeSplit == undefined) { // eslint-disable-line eqeqeq\n        log.error(ERROR_NULL, [method, item]);\n    }\n    else if (!isString(maybeSplit)) {\n        log.error(ERROR_INVALID, [method, item]);\n    }\n    else {\n        if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {\n            log.warn(WARN_TRIMMING, [method, item, maybeSplit]);\n            maybeSplit = maybeSplit.trim();\n        }\n        if (maybeSplit.length > 0) {\n            return maybeSplit;\n        }\n        else {\n            log.error(ERROR_EMPTY, [method, item]);\n        }\n    }\n    return false;\n}\n","import { ERROR_EMPTY_ARRAY } from '../../logger/constants';\nimport { uniq } from '../lang';\nimport { validateSplit } from './split';\nexport function validateSplits(log, maybeSplits, method, listName, item) {\n    if (listName === void 0) { listName = 'split_names'; }\n    if (item === void 0) { item = 'split name'; }\n    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {\n        var validatedArray_1 = [];\n        // Remove invalid values\n        maybeSplits.forEach(function (maybeSplit) {\n            var splitName = validateSplit(log, maybeSplit, method, item);\n            if (splitName)\n                validatedArray_1.push(splitName);\n        });\n        // Strip off duplicated values if we have valid split names then return\n        if (validatedArray_1.length)\n            return uniq(validatedArray_1);\n    }\n    log.error(ERROR_EMPTY_ARRAY, [method, listName]);\n    return false;\n}\n","import { STANDALONE_MODE } from '../constants';\nimport { validateSplits } from '../inputValidation/splits';\nimport { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS } from '../../logger/constants';\n// Split filters metadata.\n// Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`\nvar FILTERS_METADATA = [\n    {\n        type: 'byName',\n        maxLength: 400,\n        queryParam: 'names='\n    },\n    {\n        type: 'byPrefix',\n        maxLength: 50,\n        queryParam: 'prefixes='\n    }\n];\n/**\n * Validates that the given value is a valid filter type\n */\nfunction validateFilterType(maybeFilterType) {\n    return FILTERS_METADATA.some(function (filterMetadata) { return filterMetadata.type === maybeFilterType; });\n}\n/**\n * Validate, deduplicate and sort a given list of filter values.\n *\n * @param {string} type filter type string used for log messages\n * @param {string[]} values list of values to validate, deduplicate and sort\n * @param {number} maxLength\n * @returns list of valid, unique and alphabetically sorted non-empty strings. The list is empty if `values` param is not a non-empty array or all its values are invalid.\n *\n * @throws Error if the sanitized list exceeds the length indicated by `maxLength`\n */\nfunction validateSplitFilter(log, type, values, maxLength) {\n    // validate and remove invalid and duplicated values\n    var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, type + \" filter\", type + \" filter value\");\n    if (result) {\n        // check max length\n        if (result.length > maxLength)\n            throw new Error(maxLength + \" unique values can be specified at most for '\" + type + \"' filter. You passed \" + result.length + \". Please consider reducing the amount or using other filter.\");\n        // sort values\n        result.sort();\n    }\n    return result || []; // returns empty array if `result` is `false`\n}\n/**\n * Returns a string representing the URL encoded query component of /splitChanges URL.\n *\n * The possible formats of the query string are:\n *  - null: if all filters are empty\n *  - '&names=<comma-separated-values>': if only `byPrefix` filter is undefined\n *  - '&prefixes=<comma-separated-values>': if only `byName` filter is undefined\n *  - '&names=<comma-separated-values>&prefixes=<comma-separated-values>': if no one is undefined\n *\n * @param {Object} groupedFilters object of filters. Each filter must be a list of valid, unique and ordered string values.\n * @returns null or string with the `split filter query` component of the URL.\n */\nfunction queryStringBuilder(groupedFilters) {\n    var queryParams = [];\n    FILTERS_METADATA.forEach(function (_a) {\n        var type = _a.type, queryParam = _a.queryParam;\n        var filter = groupedFilters[type];\n        if (filter.length > 0)\n            queryParams.push(queryParam + filter.map(function (value) { return encodeURIComponent(value); }).join(','));\n    });\n    return queryParams.length > 0 ? '&' + queryParams.join('&') : null;\n}\n/**\n * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.\n *\n * @param {ILogger} log logger\n * @param {any} maybeSplitFilters split filters configuration param provided by the user\n * @param {string} mode settings mode\n * @returns it returns an object with the following properties:\n *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.\n *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.\n *  - `groupedFilters`: list of values grouped by filter type.\n *\n * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length\n */\nexport function validateSplitFilters(log, maybeSplitFilters, mode) {\n    // Validation result schema\n    var res = {\n        validFilters: [],\n        queryString: null,\n        groupedFilters: { byName: [], byPrefix: [] }\n    };\n    // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE\n    if (!maybeSplitFilters)\n        return res;\n    // Warn depending on the mode\n    if (mode !== STANDALONE_MODE) {\n        log.warn(WARN_SPLITS_FILTER_IGNORED, [STANDALONE_MODE]);\n        return res;\n    }\n    // Check collection type\n    if (!Array.isArray(maybeSplitFilters) || maybeSplitFilters.length === 0) {\n        log.warn(WARN_SPLITS_FILTER_EMPTY);\n        return res;\n    }\n    // Validate filters and group their values by filter type inside `groupedFilters` object\n    res.validFilters = maybeSplitFilters.filter(function (filter, index) {\n        if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {\n            res.groupedFilters[filter.type] = res.groupedFilters[filter.type].concat(filter.values);\n            return true;\n        }\n        else {\n            log.warn(WARN_SPLITS_FILTER_INVALID, [index]);\n        }\n        return false;\n    });\n    // By filter type, remove invalid and duplicated values and order them\n    FILTERS_METADATA.forEach(function (_a) {\n        var type = _a.type, maxLength = _a.maxLength;\n        if (res.groupedFilters[type].length > 0)\n            res.groupedFilters[type] = validateSplitFilter(log, type, res.groupedFilters[type], maxLength);\n    });\n    // build query string\n    res.queryString = queryStringBuilder(res.groupedFilters);\n    log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]);\n    return res;\n}\n","import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';\nimport { DEBUG, OPTIMIZED, NONE } from '../constants';\nimport { stringToUpperCase } from '../lang';\nexport function validImpressionsMode(log, impressionsMode) {\n    impressionsMode = stringToUpperCase(impressionsMode);\n    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)\n        return impressionsMode;\n    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);\n    return OPTIMIZED;\n}\n","import { isObject, isString, isFiniteNumber, toString } from '../lang';\nimport { ERROR_NULL, WARN_CONVERTING, ERROR_EMPTY, ERROR_TOO_LONG, ERROR_INVALID, ERROR_INVALID_KEY_OBJECT } from '../../logger/constants';\nvar KEY_MAX_LENGTH = 250;\nfunction validateKeyValue(log, maybeKey, method, type) {\n    if (maybeKey == undefined) { // eslint-disable-line eqeqeq\n        log.error(ERROR_NULL, [method, type]);\n        return false;\n    }\n    if (isFiniteNumber(maybeKey)) {\n        log.warn(WARN_CONVERTING, [method, type, maybeKey]);\n        return toString(maybeKey);\n    }\n    if (isString(maybeKey)) {\n        // It's a string, start by trimming the value.\n        maybeKey = maybeKey.trim();\n        // It's aaaaaall good.\n        if (maybeKey.length > 0 && maybeKey.length <= KEY_MAX_LENGTH)\n            return maybeKey;\n        if (maybeKey.length === 0) {\n            log.error(ERROR_EMPTY, [method, type]);\n        }\n        else if (maybeKey.length > KEY_MAX_LENGTH) {\n            log.error(ERROR_TOO_LONG, [method, type]);\n        }\n    }\n    else {\n        log.error(ERROR_INVALID, [method, type]);\n    }\n    return false;\n}\nexport function validateKey(log, maybeKey, method) {\n    if (isObject(maybeKey)) {\n        // Validate key object\n        var matchingKey = validateKeyValue(log, maybeKey.matchingKey, method, 'matchingKey');\n        var bucketingKey = validateKeyValue(log, maybeKey.bucketingKey, method, 'bucketingKey');\n        if (matchingKey && bucketingKey)\n            return {\n                matchingKey: matchingKey,\n                bucketingKey: bucketingKey\n            };\n        log.error(ERROR_INVALID_KEY_OBJECT, [method]);\n        return false;\n    }\n    else {\n        return validateKeyValue(log, maybeKey, method, 'key');\n    }\n}\n","import { ERROR_NULL, ERROR_INVALID, ERROR_EMPTY, WARN_LOWERCASE_TRAFFIC_TYPE } from '../../logger/constants';\nimport { isString } from '../lang';\nvar CAPITAL_LETTERS_REGEX = /[A-Z]/;\nvar item = 'traffic_type';\nexport function validateTrafficType(log, maybeTT, method) {\n    if (maybeTT == undefined) { // eslint-disable-line eqeqeq\n        log.error(ERROR_NULL, [method, item]);\n    }\n    else if (!isString(maybeTT)) {\n        log.error(ERROR_INVALID, [method, item]);\n    }\n    else {\n        if (maybeTT.length === 0) {\n            log.error(ERROR_EMPTY, [method, item]);\n        }\n        else {\n            if (CAPITAL_LETTERS_REGEX.test(maybeTT)) {\n                log.warn(WARN_LOWERCASE_TRAFFIC_TYPE, [method]);\n                maybeTT = maybeTT.toLowerCase();\n            }\n            return maybeTT;\n        }\n    }\n    return false;\n}\n","import { merge, get } from '../lang';\nimport { mode } from './mode';\nimport { validateSplitFilters } from './splitFilters';\nimport { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';\nimport { validImpressionsMode } from './impressionsMode';\nimport { validateKey } from '../inputValidation/key';\nimport { validateTrafficType } from '../inputValidation/trafficType';\nimport { ERROR_MIN_CONFIG_PARAM } from '../../logger/constants';\n// Exported for telemetry\nexport var base = {\n    // Define which kind of object you want to retrieve from SplitFactory\n    mode: STANDALONE_MODE,\n    core: {\n        // API token (tight to an environment)\n        authorizationKey: undefined,\n        // key used in your system (only required for browser version)\n        key: undefined,\n        // traffic type for the given key (only used on browser version)\n        trafficType: undefined,\n        // toggle impressions tracking of labels\n        labelsEnabled: true,\n        // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)\n        IPAddressesEnabled: undefined\n    },\n    scheduler: {\n        // fetch feature updates each 60 sec\n        featuresRefreshRate: 60,\n        // fetch segments updates each 60 sec\n        segmentsRefreshRate: 60,\n        // publish telemetry stats each 3600 secs (1 hour)\n        telemetryRefreshRate: 3600,\n        // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)\n        impressionsRefreshRate: 300,\n        // fetch offline changes each 15 sec\n        offlineRefreshRate: 15,\n        // publish events every 60 seconds after the first flush\n        eventsPushRate: 60,\n        // how many events will be queued before flushing\n        eventsQueueSize: 500,\n        // how many impressions will be queued before flushing\n        impressionsQueueSize: 30000,\n        // backoff base seconds to wait before re attempting to connect to push notifications\n        pushRetryBackoffBase: 1,\n    },\n    urls: {\n        // CDN having all the information for your environment\n        sdk: 'https://sdk.split.io/api',\n        // SDK event and impression endpoints\n        events: 'https://events.split.io/api',\n        // SDK Auth Server\n        auth: 'https://auth.split.io/api',\n        // Streaming Server\n        streaming: 'https://streaming.split.io',\n        // Telemetry Server\n        telemetry: 'https://telemetry.split.io/api',\n    },\n    // Defines which kind of storage we should instanciate.\n    storage: undefined,\n    // Defines if the logs are enabled, SDK wide.\n    debug: undefined,\n    // Defines the impression listener, but will only be used on NodeJS.\n    impressionListener: undefined,\n    // Instance version.\n    version: undefined,\n    // List of integrations.\n    integrations: undefined,\n    // toggle using (true) or not using (false) Server-Side Events for synchronizing storage\n    streamingEnabled: true,\n    sync: {\n        splitFilters: undefined,\n        // impressions collection mode\n        impressionsMode: OPTIMIZED,\n        localhostMode: undefined,\n        enabled: true\n    },\n    // Logger\n    log: undefined\n};\nfunction fromSecondsToMillis(n) {\n    return Math.round(n * 1000);\n}\n/**\n * Validates the given config and use it to build a settings object.\n * NOTE: it doesn't validate the Api Key. Call `validateApikey` or `validateAndTrackApiKey` for that after settings validation.\n *\n * @param config user defined configuration\n * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config\n */\nexport function settingsValidation(config, validationParams) {\n    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost, consent = validationParams.consent;\n    // creates a settings object merging base, defaults and config objects.\n    var withDefaults = merge({}, base, defaults, config);\n    // ensure a valid logger.\n    // First thing to validate, since other validators might use the logger.\n    var log = logger(withDefaults); // @ts-ignore, modify readonly prop\n    withDefaults.log = log;\n    // ensure a valid impressionsMode\n    withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);\n    function validateMinValue(paramName, actualValue, minValue) {\n        if (actualValue >= minValue)\n            return actualValue;\n        // actualValue is not a number or is lower than minValue\n        log.error(ERROR_MIN_CONFIG_PARAM, [paramName, minValue]);\n        return minValue;\n    }\n    // Scheduler periods\n    var scheduler = withDefaults.scheduler, startup = withDefaults.startup;\n    scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);\n    scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);\n    scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);\n    scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);\n    scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));\n    // Default impressionsRefreshRate for DEBUG mode is 60 secs\n    if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)\n        scheduler.impressionsRefreshRate = 60;\n    scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);\n    // Log deprecation for old telemetry param\n    if (scheduler.metricsRefreshRate)\n        log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');\n    // Startup periods\n    startup.requestTimeoutBeforeReady = fromSecondsToMillis(startup.requestTimeoutBeforeReady);\n    startup.readyTimeout = fromSecondsToMillis(startup.readyTimeout);\n    startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);\n    // ensure a valid SDK mode\n    // @ts-ignore, modify readonly prop\n    withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);\n    // ensure a valid Storage based on mode defined.\n    // @ts-ignore, modify readonly prop\n    if (storage)\n        withDefaults.storage = storage(withDefaults);\n    // Validate key and TT (for client-side)\n    var maybeKey = withDefaults.core.key;\n    if (validationParams.acceptKey) {\n        // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.\n        if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {\n            withDefaults.core.key = 'localhost_key';\n        }\n        else {\n            // Keeping same behaviour than JS SDK: if settings key or TT are invalid,\n            // `false` value is used as binded key/TT of the default client, which leads to some issues.\n            // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?\n            withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');\n        }\n        if (validationParams.acceptTT) {\n            var maybeTT = withDefaults.core.trafficType;\n            if (maybeTT !== undefined) { // @ts-ignore\n                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');\n            }\n        }\n    }\n    else {\n        // On server-side, key is undefined and used to distinguish from client-side\n        if (maybeKey !== undefined)\n            log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore\n        withDefaults.core.key = undefined;\n    }\n    // Current ip/hostname information\n    // @ts-ignore, modify readonly prop\n    withDefaults.runtime = runtime(withDefaults);\n    // ensure a valid list of integrations.\n    // `integrations` returns an array of valid integration items.\n    // @ts-ignore, modify readonly prop\n    if (integrations)\n        withDefaults.integrations = integrations(withDefaults);\n    if (localhost)\n        withDefaults.sync.localhostMode = localhost(withDefaults);\n    // validate push options\n    if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop\n        withDefaults.streamingEnabled = true;\n        // Backoff bases.\n        // We are not checking if bases are positive numbers. Thus, we might be reauthenticating immediately (`setTimeout` with NaN or negative number)\n        scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);\n    }\n    // validate sync enabled\n    if (withDefaults.sync.enabled !== false) { // @ts-ignore, modify readonly prop\n        withDefaults.sync.enabled = true;\n    }\n    // validate the `splitFilters` settings and parse splits query\n    var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);\n    withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;\n    withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;\n    // ensure a valid user consent value\n    // @ts-ignore, modify readonly prop\n    withDefaults.userConsent = consent(withDefaults);\n    return withDefaults;\n}\n","import { ERROR_NULL, ERROR_EMPTY, ERROR_INVALID, WARN_API_KEY, LOG_PREFIX_INSTANTIATION } from '../../logger/constants';\nimport { isString } from '../lang';\nvar item = 'api_key';\n/** validates the given api key */\nexport function validateApiKey(log, maybeApiKey) {\n    var apiKey = false;\n    if (maybeApiKey == undefined) { // eslint-disable-line eqeqeq\n        log.error(ERROR_NULL, [LOG_PREFIX_INSTANTIATION, item]);\n    }\n    else if (isString(maybeApiKey)) {\n        if (maybeApiKey.length > 0)\n            apiKey = maybeApiKey;\n        else\n            log.error(ERROR_EMPTY, [LOG_PREFIX_INSTANTIATION, item]);\n    }\n    else {\n        log.error(ERROR_INVALID, [LOG_PREFIX_INSTANTIATION, item]);\n    }\n    return apiKey;\n}\n// Exported for telemetry\nexport var usedKeysMap = {};\n/** validates the given api key and also warns if it is in use */\nexport function validateAndTrackApiKey(log, maybeApiKey) {\n    var apiKey = validateApiKey(log, maybeApiKey);\n    // If the apiKey is correct, we'll save it as the instance creation should work.\n    if (apiKey) {\n        if (!usedKeysMap[apiKey]) {\n            // If this key is not present, only warning scenarios is that we have factories for other keys.\n            usedKeysMap[apiKey] = 1;\n            if (Object.keys(usedKeysMap).length > 1) {\n                log.warn(WARN_API_KEY, ['an instance of the Split factory']);\n            }\n        }\n        else {\n            log.warn(WARN_API_KEY, [usedKeysMap[apiKey] + \" factory/ies with this API Key\"]);\n            usedKeysMap[apiKey]++;\n        }\n    }\n    return apiKey;\n}\nexport function releaseApiKey(apiKey) {\n    if (usedKeysMap[apiKey])\n        usedKeysMap[apiKey]--;\n    if (usedKeysMap[apiKey] === 0)\n        delete usedKeysMap[apiKey];\n}\n","export function timer(now) {\n    var st = now();\n    return function stop() {\n        return Math.round(now() - st);\n    };\n}\n","var _a, _b, _c;\nimport { submitterFactory, firstPushWindowDecorator } from './submitter';\nimport { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';\nimport { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';\nimport { base } from '../../utils/settingsValidation';\nimport { usedKeysMap } from '../../utils/inputValidation/apiKey';\nimport { timer } from '../../utils/timeTracker/timer';\nimport { objectAssign } from '../../utils/lang/objectAssign';\nvar OPERATION_MODE_MAP = (_a = {},\n    _a[STANDALONE_MODE] = STANDALONE_ENUM,\n    _a[CONSUMER_MODE] = CONSUMER_ENUM,\n    _a[CONSUMER_PARTIAL_MODE] = CONSUMER_PARTIAL_ENUM,\n    _a);\nvar IMPRESSIONS_MODE_MAP = (_b = {},\n    _b[OPTIMIZED] = OPTIMIZED_ENUM,\n    _b[DEBUG] = DEBUG_ENUM,\n    _b[NONE] = NONE_ENUM,\n    _b);\nvar USER_CONSENT_MAP = (_c = {},\n    _c[CONSENT_UNKNOWN] = 1,\n    _c[CONSENT_GRANTED] = 2,\n    _c[CONSENT_DECLINED] = 3,\n    _c);\nfunction getActiveFactories() {\n    return Object.keys(usedKeysMap).length;\n}\nfunction getRedundantActiveFactories() {\n    return Object.keys(usedKeysMap).reduce(function (acum, apiKey) {\n        return acum + usedKeysMap[apiKey] - 1;\n    }, 0);\n}\nexport function getTelemetryConfigStats(mode, storageType) {\n    return {\n        oM: OPERATION_MODE_MAP[mode],\n        st: storageType.toLowerCase(),\n        aF: getActiveFactories(),\n        rF: getRedundantActiveFactories(),\n    };\n}\n/**\n * Converts data from telemetry cache and settings into /metrics/config request payload.\n */\nexport function telemetryCacheConfigAdapter(telemetry, settings) {\n    return {\n        isEmpty: function () { return false; },\n        clear: function () { },\n        pop: function () {\n            var urls = settings.urls, scheduler = settings.scheduler;\n            var isClientSide = settings.core.key !== undefined;\n            return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {\n                sE: settings.streamingEnabled,\n                rR: {\n                    sp: scheduler.featuresRefreshRate / 1000,\n                    se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,\n                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,\n                    im: scheduler.impressionsRefreshRate / 1000,\n                    ev: scheduler.eventsPushRate / 1000,\n                    te: scheduler.telemetryRefreshRate / 1000,\n                },\n                uO: {\n                    s: urls.sdk !== base.urls.sdk,\n                    e: urls.events !== base.urls.events,\n                    a: urls.auth !== base.urls.auth,\n                    st: urls.streaming !== base.urls.streaming,\n                    t: urls.telemetry !== base.urls.telemetry,\n                },\n                iQ: scheduler.impressionsQueueSize,\n                eQ: scheduler.eventsQueueSize,\n                iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],\n                iL: settings.impressionListener ? true : false,\n                hP: false,\n                tR: telemetry.getTimeUntilReady(),\n                tC: telemetry.getTimeUntilReadyFromCache(),\n                nR: telemetry.getNonReadyUsage(),\n                t: telemetry.popTags(),\n                i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),\n                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0\n            });\n        }\n    };\n}\n/**\n * Submitter that periodically posts telemetry data\n */\nexport function telemetrySubmitterFactory(params) {\n    var telemetry = params.storage.telemetry, now = params.platform.now;\n    if (!telemetry || !now)\n        return; // No submitter created if telemetry cache is not defined\n    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;\n    var startTime = timer(now);\n    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);\n    readiness.gate.once(SDK_READY_FROM_CACHE, function () {\n        telemetry.recordTimeUntilReadyFromCache(startTime());\n    });\n    sdkReadinessManager.incInternalReadyCbCount();\n    readiness.gate.once(SDK_READY, function () {\n        telemetry.recordTimeUntilReady(startTime());\n        // Post config data when the SDK is ready and if the telemetry submitter was started\n        if (submitter.isRunning()) {\n            var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, 'telemetry config', undefined, 0, true);\n            postMetricsConfigTask.execute();\n        }\n    });\n    return submitter;\n}\n","import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';\nimport { submitterFactory } from './submitter';\nvar DATA_NAME = 'unique keys';\nvar UNIQUE_KEYS_RATE = 900000; // 15 minutes\n/**\n * Submitter that periodically posts impression counts\n */\nexport function uniqueKeysSubmitterFactory(params) {\n    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;\n    var isClientSide = key !== undefined;\n    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;\n    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);\n    // register unique keys submitter to be executed when uniqueKeys cache is full\n    uniqueKeys.setOnFullQueueCb(function () {\n        if (syncTask.isRunning()) {\n            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);\n            syncTask.execute();\n        }\n        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.\n        // Data will be sent when submitter is resumed.\n    });\n    return syncTask;\n}\n","import { eventsSubmitterFactory } from './eventsSubmitter';\nimport { impressionsSubmitterFactory } from './impressionsSubmitter';\nimport { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';\nimport { telemetrySubmitterFactory } from './telemetrySubmitter';\nimport { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';\nexport function submitterManagerFactory(params) {\n    var submitters = [\n        impressionsSubmitterFactory(params),\n        eventsSubmitterFactory(params)\n    ];\n    var impressionCountsSubmitter = impressionCountsSubmitterFactory(params);\n    if (impressionCountsSubmitter)\n        submitters.push(impressionCountsSubmitter);\n    var telemetrySubmitter = telemetrySubmitterFactory(params);\n    if (params.storage.uniqueKeys)\n        submitters.push(uniqueKeysSubmitterFactory(params));\n    return {\n        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED\n        start: function (onlyTelemetry) {\n            if (!onlyTelemetry)\n                submitters.forEach(function (submitter) { return submitter.start(); });\n            if (telemetrySubmitter)\n                telemetrySubmitter.start();\n        },\n        // `allExceptTelemetry` true if userConsent is changed to DECLINED\n        stop: function (allExceptTelemetry) {\n            submitters.forEach(function (submitter) { return submitter.stop(); });\n            if (!allExceptTelemetry && telemetrySubmitter)\n                telemetrySubmitter.stop();\n        },\n        isRunning: function () {\n            return submitters.some(function (submitter) { return submitter.isRunning(); });\n        },\n        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED\n        execute: function (onlyTelemetry) {\n            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });\n            if (telemetrySubmitter)\n                promises.push(telemetrySubmitter.execute());\n            return Promise.all(promises);\n        },\n        isExecuting: function () {\n            return submitters.some(function (submitter) { return submitter.isExecuting(); });\n        }\n    };\n}\n","// time for refresh token\nexport var SECONDS_BEFORE_EXPIRATION = 600;\n// Internal SDK events, subscribed by SyncManager and PushManager\n/**\n * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false\n * triggers `handleNonRetryableError` call\n */\nexport var PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';\n/**\n * emitted on SSE and Authenticate recoverable errors\n * triggers `handleRetryableError` call\n */\nexport var PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';\n/**\n * emitted on STREAMING_RESUMED control notification, OCCUPANCY different than 0, and SSE onopen event\n * triggers `stopPollingAndSyncAll` call\n */\nexport var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';\n/**\n * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.\n * triggers `startPolling` and `stopWorkers` calls\n */\nexport var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';\n// Update-type push notifications, handled by NotificationProcessor\nexport var MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';\nexport var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';\nexport var SEGMENT_UPDATE = 'SEGMENT_UPDATE';\nexport var SPLIT_KILL = 'SPLIT_KILL';\nexport var SPLIT_UPDATE = 'SPLIT_UPDATE';\n// Control-type push notifications, handled by NotificationKeeper\nexport var CONTROL = 'CONTROL';\nexport var OCCUPANCY = 'OCCUPANCY';\nexport var ControlType;\n(function (ControlType) {\n    ControlType[\"STREAMING_DISABLED\"] = \"STREAMING_DISABLED\";\n    ControlType[\"STREAMING_PAUSED\"] = \"STREAMING_PAUSED\";\n    ControlType[\"STREAMING_RESUMED\"] = \"STREAMING_RESUMED\";\n    ControlType[\"STREAMING_RESET\"] = \"STREAMING_RESET\";\n})(ControlType || (ControlType = {}));\n","import { CONSENT_GRANTED } from '../utils/constants';\nexport function isConsentGranted(settings) {\n    var userConsent = settings.userConsent;\n    // undefined userConsent is handled as granted (default)\n    return !userConsent || userConsent === CONSENT_GRANTED;\n}\n","import { submitterManagerFactory } from './submitters/submitterManager';\nimport { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';\nimport { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';\nimport { isConsentGranted } from '../consent';\nimport { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';\n/**\n * Online SyncManager factory.\n * Can be used for server-side API, and client-side API with or without multiple clients.\n *\n * @param pollingManagerFactory allows to specialize the SyncManager for server-side or client-side API by passing\n * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.\n * @param pushManagerFactory optional to build a SyncManager with or without streaming support\n */\nexport function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {\n    /**\n     * SyncManager factory for modular SDK\n     */\n    return function (params) {\n        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker;\n        /** Polling Manager */\n        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);\n        /** Push Manager */\n        var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?\n            pushManagerFactory(params, pollingManager) :\n            undefined;\n        /** Submitter Manager */\n        // It is not inyected as push and polling managers, because at the moment it is required\n        var submitterManager = submitterManagerFactory(params);\n        /** Sync Manager logic */\n        function startPolling() {\n            if (pollingManager.isRunning()) {\n                log.info(SYNC_CONTINUE_POLLING);\n            }\n            else {\n                log.info(SYNC_START_POLLING);\n                pollingManager.start();\n                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, POLLING);\n            }\n        }\n        function stopPollingAndSyncAll() {\n            log.info(SYNC_STOP_POLLING);\n            // if polling, stop\n            if (pollingManager.isRunning()) {\n                pollingManager.stop();\n                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, STREAMING);\n            }\n            // fetch splits and segments. There is no need to catch this promise (it is always resolved)\n            pollingManager.syncAll();\n        }\n        if (pushManager) {\n            pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);\n            pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);\n        }\n        var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)\n        var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization\n        return {\n            // Exposed for fine-grained control of synchronization.\n            // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).\n            pollingManager: pollingManager,\n            pushManager: pushManager,\n            submitterManager: submitterManager,\n            /**\n             * Method used to start the syncManager for the first time, or resume it after being stopped.\n             */\n            start: function () {\n                running = true;\n                // start syncing splits and segments\n                if (pollingManager) {\n                    // If synchronization is disabled pushManager and pollingManager should not start\n                    if (syncEnabled) {\n                        if (pushManager) {\n                            // Doesn't call `syncAll` when the syncManager is resuming\n                            if (startFirstTime) {\n                                pollingManager.syncAll();\n                                startFirstTime = false;\n                            }\n                            pushManager.start();\n                        }\n                        else {\n                            pollingManager.start();\n                        }\n                    }\n                    else {\n                        if (startFirstTime) {\n                            pollingManager.syncAll();\n                            startFirstTime = false;\n                        }\n                    }\n                }\n                // start periodic data recording (events, impressions, telemetry).\n                submitterManager.start(!isConsentGranted(settings));\n            },\n            /**\n             * Method used to stop/pause the syncManager.\n             */\n            stop: function () {\n                running = false;\n                // stop syncing\n                if (pushManager)\n                    pushManager.stop();\n                if (pollingManager && pollingManager.isRunning())\n                    pollingManager.stop();\n                // stop periodic data recording (events, impressions, telemetry).\n                submitterManager.stop();\n            },\n            isRunning: function () {\n                return running;\n            },\n            flush: function () {\n                return submitterManager.execute(!isConsentGranted(settings));\n            },\n            // [Only used for client-side]\n            // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side\n            shared: function (matchingKey, readinessManager, storage) {\n                if (!pollingManager)\n                    return;\n                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);\n                return {\n                    isRunning: mySegmentsSyncTask.isRunning,\n                    start: function () {\n                        if (syncEnabled) {\n                            if (pushManager) {\n                                if (pollingManager.isRunning()) {\n                                    // if doing polling, we must start the periodic fetch of data\n                                    if (storage.splits.usesSegments())\n                                        mySegmentsSyncTask.start();\n                                }\n                                else {\n                                    // if not polling, we must execute the sync task for the initial fetch\n                                    // of segments since `syncAll` was already executed when starting the main client\n                                    mySegmentsSyncTask.execute();\n                                }\n                                pushManager.add(matchingKey, mySegmentsSyncTask);\n                            }\n                            else {\n                                if (storage.splits.usesSegments())\n                                    mySegmentsSyncTask.start();\n                            }\n                        }\n                        else {\n                            if (!readinessManager.isReady())\n                                mySegmentsSyncTask.execute();\n                        }\n                    },\n                    stop: function () {\n                        // check in case `client.destroy()` has been invoked more than once for the same client\n                        var mySegmentsSyncTask = pollingManager.get(matchingKey);\n                        if (mySegmentsSyncTask) {\n                            // stop syncing\n                            if (pushManager)\n                                pushManager.remove(matchingKey);\n                            if (mySegmentsSyncTask.isRunning())\n                                mySegmentsSyncTask.stop();\n                            pollingManager.remove(matchingKey);\n                        }\n                    },\n                    flush: function () { return Promise.resolve(); }\n                };\n            }\n        };\n    };\n}\n","var Backoff = /** @class */ (function () {\n    /**\n     * Schedule function calls with exponential backoff\n     *\n     * @param {function} cb\n     * @param {number} baseMillis\n     * @param {number} maxMillis\n     */\n    function Backoff(cb, baseMillis, maxMillis) {\n        this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;\n        this.maxMillis = Backoff.__TEST__MAX_MILLIS || maxMillis || Backoff.DEFAULT_MAX_MILLIS;\n        this.attempts = 0;\n        this.cb = cb;\n    }\n    /**\n     * Schedule a next call to `cb`\n     * @returns scheduled delay in milliseconds\n     */\n    Backoff.prototype.scheduleCall = function () {\n        var _this = this;\n        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);\n        if (this.timeoutID)\n            clearTimeout(this.timeoutID);\n        this.timeoutID = setTimeout(function () {\n            _this.timeoutID = undefined;\n            _this.cb();\n        }, delayInMillis);\n        this.attempts++;\n        return delayInMillis;\n    };\n    Backoff.prototype.reset = function () {\n        this.attempts = 0;\n        if (this.timeoutID) {\n            clearTimeout(this.timeoutID);\n            this.timeoutID = undefined;\n        }\n    };\n    Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second\n    Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes\n    return Backoff;\n}());\nexport { Backoff };\n","import { OCCUPANCY } from '../constants';\nimport { isString } from '../../../utils/lang';\n/**\n * Parses the `data` JSON string, if exists, of a given SSE error notifications.\n * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.\n * Other network and HTTP errors do not have this property.\n *\n * @param {Object} error\n * @throws {SyntaxError} if `error.data` is an invalid JSON string\n */\nexport function errorParser(error) {\n    // @ts-ignore\n    if (isString(error.data))\n        error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'\n    return error;\n}\n/**\n * Parses the `data` JSON string of a given SSE message notifications.\n * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.\n *\n * @param message\n * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).\n * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.\n * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings\n */\nexport function messageParser(message) {\n    if (!message.data)\n        return;\n    var messageData = JSON.parse(message.data);\n    messageData.parsedData = JSON.parse(messageData.data);\n    // set the event type to OCCUPANCY, to handle all events uniformely\n    if (messageData.name && messageData.name === '[meta]occupancy')\n        messageData.parsedData.type = OCCUPANCY;\n    return messageData;\n}\n","import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';\nimport { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';\nvar CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];\nvar STREAMING_EVENT_TYPES = [OCCUPANCY_PRI, OCCUPANCY_SEC];\n/**\n * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.\n *\n * @param pushEmitter emitter for events related to streaming support\n */\n// @TODO update logic to handle OCCUPANCY for any region and rename according to new spec (e.g.: PUSH_SUBSYSTEM_UP --> PUSH_SUBSYSTEM_UP)\nexport function notificationKeeperFactory(pushEmitter, telemetryTracker) {\n    var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) { return ({\n        regex: regex,\n        hasPublishers: true,\n        oTime: -1,\n        cTime: -1 // keep track of most recent control notification timestamp per channel\n    }); });\n    // false if the number of publishers is equal to 0 in all regions\n    var hasPublishers = true;\n    // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED\n    var hasResumed = true;\n    function getHasPublishers() {\n        return channels.some(function (c) { return c.hasPublishers; });\n    }\n    return {\n        handleOpen: function () {\n            telemetryTracker.streamingEvent(CONNECTION_ESTABLISHED);\n            pushEmitter.emit(PUSH_SUBSYSTEM_UP);\n        },\n        isStreamingUp: function () {\n            return hasResumed && hasPublishers;\n        },\n        handleOccupancyEvent: function (publishers, channel, timestamp) {\n            for (var i = 0; i < channels.length; i++) {\n                var c = channels[i];\n                if (c.regex.test(channel)) {\n                    telemetryTracker.streamingEvent(STREAMING_EVENT_TYPES[i], publishers);\n                    if (timestamp > c.oTime) {\n                        c.oTime = timestamp;\n                        c.hasPublishers = publishers !== 0;\n                        var hasPublishersNow = getHasPublishers();\n                        if (hasResumed) {\n                            if (!hasPublishersNow && hasPublishers) {\n                                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);\n                            }\n                            else if (hasPublishersNow && !hasPublishers) {\n                                pushEmitter.emit(PUSH_SUBSYSTEM_UP);\n                            }\n                            // nothing to do when hasResumed === false:\n                            // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`\n                        }\n                        hasPublishers = hasPublishersNow;\n                    }\n                    return;\n                }\n            }\n        },\n        handleControlEvent: function (controlType, channel, timestamp) {\n            /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require\n             * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous\n             * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */\n            if (controlType === ControlType.STREAMING_RESET) {\n                pushEmitter.emit(controlType);\n                return;\n            }\n            for (var i = 0; i < channels.length; i++) {\n                var c = channels[i];\n                if (c.regex.test(channel)) {\n                    if (timestamp > c.cTime) {\n                        c.cTime = timestamp;\n                        if (controlType === ControlType.STREAMING_DISABLED) {\n                            telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);\n                            pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);\n                        }\n                        else if (hasPublishers) {\n                            if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {\n                                telemetryTracker.streamingEvent(STREAMING_STATUS, PAUSED);\n                                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);\n                            }\n                            else if (controlType === ControlType.STREAMING_RESUMED && !hasResumed) {\n                                telemetryTracker.streamingEvent(STREAMING_STATUS, ENABLED);\n                                pushEmitter.emit(PUSH_SUBSYSTEM_UP);\n                            }\n                            // nothing to do when hasPublishers === false:\n                            // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`\n                        }\n                        hasResumed = controlType === ControlType.STREAMING_RESUMED;\n                    }\n                    return;\n                }\n            }\n        },\n    };\n}\n","import { errorParser, messageParser } from './NotificationParser';\nimport { notificationKeeperFactory } from './NotificationKeeper';\nimport { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';\nimport { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';\nimport { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';\n/**\n * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.\n *\n * @param log factory logger\n * @param pushEmitter emitter for events related to streaming support\n */\nexport function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {\n    var notificationKeeper = notificationKeeperFactory(pushEmitter, telemetryTracker);\n    function isRetryableError(error) {\n        if (error.parsedData && error.parsedData.code) {\n            // Ably error\n            var code = error.parsedData.code;\n            telemetryTracker.streamingEvent(ABLY_ERROR, code);\n            // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)\n            if (40140 <= code && code <= 40149)\n                return true;\n            // Others 4XX errors (e.g., bad request from the SDK)\n            if (40000 <= code && code <= 49999)\n                return false;\n        }\n        else {\n            // network errors or 5XX HTTP errors\n            telemetryTracker.streamingEvent(SSE_CONNECTION_ERROR, NON_REQUESTED);\n        }\n        return true;\n    }\n    return {\n        handleOpen: function () {\n            notificationKeeper.handleOpen();\n        },\n        /* HTTP & Network errors */\n        handleError: function (error) {\n            var errorWithParsedData = error;\n            try {\n                errorWithParsedData = errorParser(error);\n            }\n            catch (err) {\n                log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);\n            }\n            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;\n            log.error(ERROR_STREAMING_SSE, [errorMessage]);\n            if (isRetryableError(errorWithParsedData)) {\n                pushEmitter.emit(PUSH_RETRYABLE_ERROR);\n            }\n            else {\n                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);\n            }\n        },\n        /* NotificationProcessor */\n        handleMessage: function (message) {\n            var messageWithParsedData;\n            try {\n                messageWithParsedData = messageParser(message);\n                if (!messageWithParsedData)\n                    return; // Messages with empty data are ignored\n            }\n            catch (err) {\n                log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);\n                return;\n            }\n            var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;\n            log.debug(STREAMING_NEW_MESSAGE, [data]);\n            // we only handle update events if streaming is up.\n            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)\n                return;\n            switch (parsedData.type) {\n                /* update events */\n                case SPLIT_UPDATE:\n                case SEGMENT_UPDATE:\n                case MY_SEGMENTS_UPDATE_V2:\n                case SPLIT_KILL:\n                    pushEmitter.emit(parsedData.type, parsedData);\n                    break;\n                case MY_SEGMENTS_UPDATE:\n                    pushEmitter.emit(parsedData.type, parsedData, channel);\n                    break;\n                /* occupancy & control events, handled by NotificationManagerKeeper */\n                case OCCUPANCY:\n                    notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);\n                    break;\n                case CONTROL:\n                    notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);\n                    break;\n                default:\n                    break;\n            }\n        },\n    };\n}\n","import { Backoff } from '../../../utils/Backoff';\n/**\n * MySegmentsUpdateWorker factory\n */\nexport function MySegmentsUpdateWorker(mySegmentsSyncTask) {\n    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events\n    var currentChangeNumber = -1;\n    var handleNewEvent = false;\n    var isHandlingEvent;\n    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber\n    var backoff = new Backoff(__handleMySegmentsUpdateCall);\n    function __handleMySegmentsUpdateCall() {\n        isHandlingEvent = true;\n        if (maxChangeNumber > currentChangeNumber) {\n            handleNewEvent = false;\n            var currentMaxChangeNumber_1 = maxChangeNumber;\n            // fetch mySegments revalidating data if cached\n            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {\n                if (!isHandlingEvent)\n                    return; // halt if `stop` has been called\n                if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.\n                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.\n                if (handleNewEvent) {\n                    __handleMySegmentsUpdateCall();\n                }\n                else {\n                    backoff.scheduleCall();\n                }\n            });\n        }\n        else {\n            isHandlingEvent = false;\n        }\n    }\n    return {\n        /**\n         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event\n         *\n         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification\n         * @param {SegmentsData | undefined} segmentsData might be undefined\n         */\n        put: function (changeNumber, segmentsData) {\n            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)\n                return;\n            maxChangeNumber = changeNumber;\n            handleNewEvent = true;\n            _segmentsData = segmentsData;\n            if (backoff.timeoutID || !isHandlingEvent)\n                __handleMySegmentsUpdateCall();\n            backoff.reset();\n        },\n        stop: function () {\n            isHandlingEvent = false;\n            backoff.reset();\n        }\n    };\n}\n","export var FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds\nexport var FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute\nexport var FETCH_BACKOFF_MAX_RETRIES = 10; // max retries\n","import { Backoff } from '../../../utils/Backoff';\nimport { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './constants';\n/**\n * SegmentsUpdateWorker factory\n */\nexport function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {\n    // Handles retries with CDN bypass per segment name\n    function SegmentUpdateWorker(segment) {\n        var maxChangeNumber = 0;\n        var handleNewEvent = false;\n        var isHandlingEvent;\n        var cdnBypass;\n        var backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);\n        function __handleSegmentUpdateCall() {\n            isHandlingEvent = true;\n            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {\n                handleNewEvent = false;\n                // fetch segments revalidating data if cached\n                segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {\n                    if (!isHandlingEvent)\n                        return; // halt if `stop` has been called\n                    if (handleNewEvent) {\n                        __handleSegmentUpdateCall();\n                    }\n                    else {\n                        var attempts = backoff.attempts + 1;\n                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {\n                            log.debug(\"Refresh completed\" + (cdnBypass ? ' bypassing the CDN' : '') + \" in \" + attempts + \" attempts.\");\n                            isHandlingEvent = false;\n                            return;\n                        }\n                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {\n                            backoff.scheduleCall();\n                            return;\n                        }\n                        if (cdnBypass) {\n                            log.debug(\"No changes fetched after \" + attempts + \" attempts with CDN bypassed.\");\n                            isHandlingEvent = false;\n                        }\n                        else {\n                            backoff.reset();\n                            cdnBypass = true;\n                            __handleSegmentUpdateCall();\n                        }\n                    }\n                });\n            }\n            else {\n                isHandlingEvent = false;\n            }\n        }\n        return {\n            put: function (changeNumber) {\n                var currentChangeNumber = segmentsCache.getChangeNumber(segment);\n                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)\n                    return;\n                maxChangeNumber = changeNumber;\n                handleNewEvent = true;\n                cdnBypass = false;\n                if (backoff.timeoutID || !isHandlingEvent)\n                    __handleSegmentUpdateCall();\n                backoff.reset();\n            },\n            stop: function () {\n                isHandlingEvent = false;\n                backoff.reset();\n            }\n        };\n    }\n    var segments = {};\n    return {\n        /**\n         * Invoked by NotificationProcessor on SEGMENT_UPDATE event\n         *\n         * @param {number} changeNumber change number of the SEGMENT_UPDATE notification\n         * @param {string} segmentName segment name of the SEGMENT_UPDATE notification\n         */\n        put: function (_a) {\n            var changeNumber = _a.changeNumber, segmentName = _a.segmentName;\n            if (!segments[segmentName])\n                segments[segmentName] = SegmentUpdateWorker(segmentName);\n            segments[segmentName].put(changeNumber);\n        },\n        stop: function () {\n            Object.keys(segments).forEach(function (segmentName) { return segments[segmentName].stop(); });\n        }\n    };\n}\n","import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';\nimport { Backoff } from '../../../utils/Backoff';\nimport { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';\n/**\n * SplitsUpdateWorker factory\n */\nexport function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {\n    var maxChangeNumber = 0;\n    var handleNewEvent = false;\n    var isHandlingEvent;\n    var cdnBypass;\n    var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);\n    function __handleSplitUpdateCall() {\n        isHandlingEvent = true;\n        if (maxChangeNumber > splitsCache.getChangeNumber()) {\n            handleNewEvent = false;\n            // fetch splits revalidating data if cached\n            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {\n                if (!isHandlingEvent)\n                    return; // halt if `stop` has been called\n                if (handleNewEvent) {\n                    __handleSplitUpdateCall();\n                }\n                else {\n                    // fetch new registered segments for server-side API. Not retrying on error\n                    if (segmentsSyncTask)\n                        segmentsSyncTask.execute(true);\n                    var attempts = backoff.attempts + 1;\n                    if (maxChangeNumber <= splitsCache.getChangeNumber()) {\n                        log.debug(\"Refresh completed\" + (cdnBypass ? ' bypassing the CDN' : '') + \" in \" + attempts + \" attempts.\");\n                        isHandlingEvent = false;\n                        return;\n                    }\n                    if (attempts < FETCH_BACKOFF_MAX_RETRIES) {\n                        backoff.scheduleCall();\n                        return;\n                    }\n                    if (cdnBypass) {\n                        log.debug(\"No changes fetched after \" + attempts + \" attempts with CDN bypassed.\");\n                        isHandlingEvent = false;\n                    }\n                    else {\n                        backoff.reset();\n                        cdnBypass = true;\n                        __handleSplitUpdateCall();\n                    }\n                }\n            });\n        }\n        else {\n            isHandlingEvent = false;\n        }\n    }\n    /**\n     * Invoked by NotificationProcessor on SPLIT_UPDATE event\n     *\n     * @param {number} changeNumber change number of the SPLIT_UPDATE notification\n     */\n    function put(_a) {\n        var changeNumber = _a.changeNumber;\n        var currentChangeNumber = splitsCache.getChangeNumber();\n        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)\n            return;\n        maxChangeNumber = changeNumber;\n        handleNewEvent = true;\n        cdnBypass = false;\n        if (backoff.timeoutID || !isHandlingEvent)\n            __handleSplitUpdateCall();\n        backoff.reset();\n    }\n    return {\n        put: put,\n        /**\n         * Invoked by NotificationProcessor on SPLIT_KILL event\n         *\n         * @param {number} changeNumber change number of the SPLIT_UPDATE notification\n         * @param {string} splitName name of split to kill\n         * @param {string} defaultTreatment default treatment value\n         */\n        killSplit: function (_a) {\n            var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;\n            if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {\n                // trigger an SDK_UPDATE if Split was killed locally\n                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);\n            }\n            // queues the SplitChanges fetch (only if changeNumber is newer)\n            put({ changeNumber: changeNumber });\n        },\n        stop: function () {\n            isHandlingEvent = false;\n            backoff.reset();\n        }\n    };\n}\n","/**\n * Base64 utils in pure JS, for browser, node and others which don't provide globals `btoa` and `atob`.\n * Implementation based on davidchambers/Base64 (https://github.com/davidchambers/Base64.js).\n\n   Copyright 2019 David Chambers\n\n   Licensed under the Apache License, Version 2.0 (the \"License\");\n   you may not use this file except in compliance with the License.\n   You may obtain a copy of the License at\n\n       http://www.apache.org/licenses/LICENSE-2.0\n\n   Unless required by applicable law or agreed to in writing, software\n   distributed under the License is distributed on an \"AS IS\" BASIS,\n   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n   See the License for the specific language governing permissions and\n   limitations under the License.\n */\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n/**\n * Decode a given string value in Base64 format\n *\n * @param {string} input value to decode\n */\nexport function decodeFromBase64(input) {\n    var str = (String(input)).replace(/[=]+$/, ''); // #31: ExtendScript bad parse of /=\n    if (str.length % 4 === 1) {\n        throw new Error(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n    }\n    var output = '';\n    for (\n    // initialize result and counters\n    var bc = 0, bs = void 0, buffer = void 0, idx = 0; \n    // get next character\n    buffer = str.charAt(idx++); // eslint-disable-line no-cond-assign\n     \n    // character found in table? initialize bit storage and add its ascii value;\n    // @ts-ignore\n    ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {\n        // try to find character in table (0-63, not found => -1)\n        buffer = chars.indexOf(buffer);\n    }\n    return output;\n}\n/**\n * Encode a given string value to Base64 format.\n *\n * @param {string} input value to encode\n */\nexport function encodeToBase64(input) {\n    var str = String(input);\n    var output = '';\n    for (\n    // initialize result and counter\n    var block = void 0, charCode = void 0, idx = 0, map = chars; \n    // if the next str index does not exist:\n    //   change the mapping table to \"=\"\n    //   check if d has no fractional digits\n    str.charAt(idx | 0) || (map = '=', idx % 1); \n    // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n    output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {\n        charCode = str.charCodeAt(idx += 3 / 4);\n        if (charCode > 0xFF) {\n            throw new Error(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n        }\n        // @ts-ignore\n        block = block << 8 | charCode;\n    }\n    return output;\n}\n","import { decodeFromBase64 } from '../base64';\n/**\n * Decode a JWT token.\n */\nexport function decodeJWTtoken(token) {\n    var base64Url = token.split('.')[1];\n    var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');\n    // no need to check availability of `encodeURIComponent`, since it is a function highly supported in browsers, node and other platforms.\n    var jsonPayload = decodeURIComponent(decodeFromBase64(base64).split('').map(function (c) {\n        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);\n    }).join(''));\n    return JSON.parse(jsonPayload);\n}\n","/*\n Trimmed version of \"utfx\" library (https://www.npmjs.com/package/utfx/v/1.0.1) used to encode,\n decode and convert UTF8 / UTF16 in JavaScript, with the minimal methods used by the SDK.\n\n utfx (c) 2014 Daniel Wirtz <dcode@dcode.io>\n Released under the Apache License, Version 2.0\n see: https://github.com/dcodeIO/utfx for details\n*/\n/**\n * Encodes UTF8 code points to UTF8 bytes.\n * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\n *  respectively `null` if there are no more code points left or a single numeric code point.\n * @param {!function(number)} dst Bytes destination as a function successively called with the next byte\n * @expose\n */\nfunction encodeUTF8(src, dst) {\n    var cp = null;\n    if (typeof src === 'number')\n        cp = src, src = function () { return null; };\n    while (cp !== null || (cp = src()) !== null) {\n        if (cp < 0x80)\n            dst(cp & 0x7F);\n        else if (cp < 0x800)\n            dst(((cp >> 6) & 0x1F) | 0xC0), dst((cp & 0x3F) | 0x80);\n        else if (cp < 0x10000)\n            dst(((cp >> 12) & 0x0F) | 0xE0), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);\n        else\n            dst(((cp >> 18) & 0x07) | 0xF0), dst(((cp >> 12) & 0x3F) | 0x80), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);\n        cp = null;\n    }\n}\n/**\n * Converts UTF16 characters to UTF8 code points.\n * @param {!function():number|null} src Characters source as a function returning the next char code respectively\n *  `null` if there are no more characters left.\n * @param {!function(number)} dst Code points destination as a function successively called with each converted code\n *  point.\n * @expose\n */\nfunction UTF16toUTF8(src, dst) {\n    var c1, c2 = null;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        if ((c1 = c2 !== null ? c2 : src()) === null)\n            break;\n        if (c1 >= 0xD800 && c1 <= 0xDFFF) {\n            if ((c2 = src()) !== null) {\n                if (c2 >= 0xDC00 && c2 <= 0xDFFF) {\n                    dst((c1 - 0xD800) * 0x400 + c2 - 0xDC00 + 0x10000);\n                    c2 = null;\n                    continue;\n                }\n            }\n        }\n        dst(c1);\n    }\n    if (c2 !== null)\n        dst(c2);\n}\n/**\n * Converts and encodes UTF16 characters to UTF8 bytes.\n * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`\n *  if there are no more characters left.\n * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\n * @expose\n */\nexport function encodeUTF16toUTF8(src, dst) {\n    UTF16toUTF8(src, function (cp) {\n        encodeUTF8(cp, dst);\n    });\n}\n/**\n * String.fromCharCode reference for compile time renaming.\n * @type {!function(...[number]):string}\n * @inner\n */\nvar stringFromCharCode = String.fromCharCode;\n/**\n * Creates a source function for a string.\n * @param {string} s String to read from\n * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are\n *  no more characters left.\n * @throws {TypeError} If the argument is invalid\n * @expose\n */\nexport function stringSource(s) {\n    if (typeof s !== 'string')\n        throw TypeError('Illegal argument: ' + (typeof s));\n    var i = 0;\n    return function () {\n        return i >= s.length ? null : s.charCodeAt(i++);\n    };\n}\n/**\n * Creates a destination function for a string.\n * @returns {function(number=):undefined|string} Destination function successively called with the next char code.\n *  Returns the final string when called without arguments.\n * @expose\n */\nexport function stringDestination() {\n    var cs = [], ps = [];\n    return function () {\n        if (arguments.length === 0)\n            return ps.join('') + stringFromCharCode.apply(String, cs);\n        if (cs.length + arguments.length > 1024)\n            ps.push(stringFromCharCode.apply(String, cs)), cs.length = 0; // @ts-ignore\n        Array.prototype.push.apply(cs, arguments);\n    };\n}\n","import { stringSource, stringDestination, encodeUTF16toUTF8 } from './utfx';\nexport function UTF16ToUTF8(key) {\n    var sd;\n    encodeUTF16toUTF8(stringSource(key), sd = stringDestination());\n    return sd();\n}\n/*!\n * +----------------------------------------------------------------------------------+\n * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |\n * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |\n * |----------------------------------------------------------------------------------|\n * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |\n * +----------------------------------------------------------------------------------+\n */\nexport function x86Multiply(m, n) {\n    //\n    // Given two 32bit ints, returns the two multiplied together as a\n    // 32bit int.\n    //\n    return ((m & 0xffff) * n) + ((((m >>> 16) * n) & 0xffff) << 16);\n}\nexport function x86Rotl(m, n) {\n    //\n    // Given a 32bit int and an int representing a number of bit positions,\n    // returns the 32bit int rotated left by that number of positions.\n    //\n    return (m << n) | (m >>> (32 - n));\n}\nexport function x86Fmix(h) {\n    //\n    // Given a block, returns murmurHash3's final x86 mix of that block.\n    //\n    h ^= h >>> 16;\n    h = x86Multiply(h, 0x85ebca6b);\n    h ^= h >>> 13;\n    h = x86Multiply(h, 0xc2b2ae35);\n    h ^= h >>> 16;\n    return h;\n}\n","/* eslint-disable no-fallthrough */\nimport { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';\n/*\n * +----------------------------------------------------------------------------------+\n * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |\n * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |\n * |----------------------------------------------------------------------------------|\n * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |\n * +----------------------------------------------------------------------------------+\n */\n// PUBLIC FUNCTIONS\n// ----------------\nfunction hash32(key, seed) {\n    //\n    // Given a string and an optional seed as an int, returns a 32 bit hash\n    // using the x86 flavor of MurmurHash3, as an unsigned int.\n    //\n    key = key || '';\n    seed = seed || 0;\n    var remainder = key.length % 4;\n    var bytes = key.length - remainder;\n    var h1 = seed;\n    var k1 = 0;\n    var c1 = 0xcc9e2d51;\n    var c2 = 0x1b873593;\n    for (var i = 0; i < bytes; i = i + 4) {\n        k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);\n        k1 = x86Multiply(k1, c1);\n        k1 = x86Rotl(k1, 15);\n        k1 = x86Multiply(k1, c2);\n        h1 ^= k1;\n        h1 = x86Rotl(h1, 13);\n        h1 = x86Multiply(h1, 5) + 0xe6546b64;\n    }\n    k1 = 0;\n    switch (remainder) {\n        case 3:\n            k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;\n        case 2:\n            k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;\n        case 1:\n            k1 ^= (key.charCodeAt(i) & 0xff);\n            k1 = x86Multiply(k1, c1);\n            k1 = x86Rotl(k1, 15);\n            k1 = x86Multiply(k1, c2);\n            h1 ^= k1;\n    }\n    h1 ^= key.length;\n    h1 = x86Fmix(h1);\n    return h1 >>> 0;\n}\nexport function hash(str, seed) {\n    return hash32(UTF16ToUTF8(str), seed >>> 0);\n}\nexport function bucket(str, seed) {\n    return Math.abs(hash(str, seed) % 100) + 1;\n}\n","import { objectAssign } from '../../../utils/lang/objectAssign';\nimport { encodeToBase64 } from '../../../utils/base64';\nimport { decodeJWTtoken } from '../../../utils/jwt';\nimport { hash } from '../../../utils/murmur3/murmur3';\n/**\n * Factory of authentication function.\n *\n * @param fetchAuth `SplitAPI.fetchAuth` endpoint\n */\nexport function authenticateFactory(fetchAuth) {\n    /**\n     * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.\n     * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.\n     */\n    return function authenticate(userKeys) {\n        return fetchAuth(userKeys)\n            .then(function (resp) { return resp.json(); })\n            .then(function (json) {\n            if (json.token) { // empty token when `\"pushEnabled\": false`\n                var decodedToken = decodeJWTtoken(json.token);\n                if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number')\n                    throw new Error('token properties \"issuedAt\" (iat) or \"expiration\" (exp) are missing or invalid');\n                var channels = JSON.parse(decodedToken['x-ably-capability']);\n                return objectAssign({\n                    decodedToken: decodedToken,\n                    channels: channels\n                }, json);\n            }\n            return json;\n        });\n    };\n}\n/**\n * Returns the hash of a given user key\n */\nexport function hashUserKey(userKey) {\n    return encodeToBase64(hash(userKey, 0).toString());\n}\n","import { isString } from '../../../utils/lang';\nvar VERSION = '1.1';\nvar CONTROL_CHANNEL_REGEX = /^control_/;\n/**\n * Build metadata headers for SSE connection.\n *\n * @param {ISettings} settings Validated settings.\n * @returns {Record<string, string>} Headers object\n */\nfunction buildSSEHeaders(settings) {\n    var headers = {\n        SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',\n        SplitSDKVersion: settings.version,\n    };\n    // ip and hostname are false if IPAddressesEnabled is false\n    var _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;\n    if (ip)\n        headers['SplitSDKMachineIP'] = ip;\n    if (hostname)\n        headers['SplitSDKMachineName'] = hostname;\n    return headers;\n}\n/**\n * Handles streaming connections with EventSource API\n */\nvar SSEClient = /** @class */ (function () {\n    /**\n     * SSEClient constructor.\n     *\n     * @param settings Validated settings.\n     * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.\n     * @param getEventSource Function to get the EventSource constructor.\n     * @throws 'EventSource API is not available. ' if EventSource is not available.\n     */\n    function SSEClient(settings, useHeaders, getEventSource) {\n        this.eventSource = getEventSource && getEventSource();\n        // if eventSource is not available, throw an exception\n        if (!this.eventSource)\n            throw new Error('EventSource API is not available. ');\n        this.streamingUrl = settings.urls.streaming + '/sse';\n        // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.\n        this.useHeaders = useHeaders;\n        this.headers = buildSSEHeaders(settings);\n    }\n    SSEClient.prototype.setEventHandler = function (handler) {\n        this.handler = handler;\n    };\n    /**\n     * Open the connection with a given authToken\n     *\n     * @param {IAuthTokenPushEnabled} authToken\n     * @throws {TypeError} Will throw an error if `authToken` is undefined\n     */\n    SSEClient.prototype.open = function (authToken) {\n        this.close(); // it closes connection if previously opened\n        var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {\n            var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';\n            return encodeURIComponent(params + channel);\n        }).join(',');\n        var url = this.streamingUrl + \"?channels=\" + channelsQueryParam + \"&accessToken=\" + authToken.token + \"&v=\" + VERSION + \"&heartbeats=true\"; // same results using `&heartbeats=false`\n        this.connection = new this.eventSource(\n        // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is passed as query params,\n        // because native EventSource implementations for browser doesn't support headers.\n        this.useHeaders ? url : url + (\"&SplitSDKVersion=\" + this.headers.SplitSDKVersion + \"&SplitSDKClientKey=\" + this.headers.SplitSDKClientKey), \n        // @ts-ignore. For server-side SDKs, metadata is passed via headers. EventSource must support headers, like 'eventsource' package for Node.\n        this.useHeaders ? { headers: this.headers } : undefined);\n        if (this.handler) { // no need to check if SSEClient is used only by PushManager\n            this.connection.addEventListener('open', this.handler.handleOpen);\n            this.connection.addEventListener('message', this.handler.handleMessage);\n            this.connection.addEventListener('error', this.handler.handleError);\n        }\n    };\n    /** Close connection  */\n    SSEClient.prototype.close = function () {\n        if (this.connection)\n            this.connection.close();\n    };\n    return SSEClient;\n}());\nexport { SSEClient };\n","import { isObject } from '../lang';\n// function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {\n//   return key !== undefined && key !== null && typeof key.matchingKey === 'string';\n// }\n// returns the matchingKey if the Key is defined as an object or the key itself if it is a string\nexport function getMatching(key) {\n    return isObject(key) ? key.matchingKey : key;\n}\n// if the key is a string, there's no bucketingKey (undefined)\nexport function getBucketing(key) {\n    return isObject(key) ? key.bucketingKey : undefined;\n}\n/**\n * Verify type of key and return a valid object key used for get treatment for a\n * specific split.\n */\nexport function keyParser(key) {\n    if (isObject(key)) {\n        return {\n            matchingKey: key.matchingKey,\n            bucketingKey: key.bucketingKey\n        };\n    }\n    else {\n        return {\n            matchingKey: key,\n            bucketingKey: key\n        };\n    }\n}\n","export var Compression;\n(function (Compression) {\n    Compression[Compression[\"None\"] = 0] = \"None\";\n    Compression[Compression[\"Gzip\"] = 1] = \"Gzip\";\n    Compression[Compression[\"Zlib\"] = 2] = \"Zlib\";\n})(Compression || (Compression = {}));\nexport var UpdateStrategy;\n(function (UpdateStrategy) {\n    UpdateStrategy[UpdateStrategy[\"UnboundedFetchRequest\"] = 0] = \"UnboundedFetchRequest\";\n    UpdateStrategy[UpdateStrategy[\"BoundedFetchRequest\"] = 1] = \"BoundedFetchRequest\";\n    UpdateStrategy[UpdateStrategy[\"KeyList\"] = 2] = \"KeyList\";\n    UpdateStrategy[UpdateStrategy[\"SegmentRemoval\"] = 3] = \"SegmentRemoval\";\n})(UpdateStrategy || (UpdateStrategy = {}));\n","/*\nTrimmed version of \"fflate\" library (https://www.npmjs.com/package/fflate/v/0.7.1)\nused for GZIP/Zlib decompression in JavaScript, with the minimal modules used by the SDK.\n\nMIT License\n\nCopyright (c) 2020 Arjun Barrett\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n*/\n/* eslint-disable */\n// @ts-nocheck\nexport var algorithms = (function iifeDecompress() {\n    // Handle runtimes without typed arrays\n    if ([typeof Uint8Array, typeof Uint16Array, typeof Uint32Array].some(function (v) { return v != 'function'; })) {\n        return 'global Uint8Array object is not available for gzip/zlib decompression';\n    }\n    // DEFLATE is a complex format; to read this code, you should probably check the RFC first:\n    // aliases for shorter compressed code (most minifers don't do this)\n    var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;\n    // fixed length extra bits\n    var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);\n    // fixed distance extra bits\n    // see fleb note\n    var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);\n    // code length index map\n    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n    // get base, reverse index map from extra bits\n    var freb = function (eb, start) {\n        var b = new u16(31);\n        for (var i = 0; i < 31; ++i) {\n            b[i] = start += 1 << eb[i - 1];\n        }\n        // numbers here are at max 18 bits\n        var r = new u32(b[30]);\n        for (var i = 1; i < 30; ++i) {\n            for (var j = b[i]; j < b[i + 1]; ++j) {\n                r[j] = ((j - b[i]) << 5) | i;\n            }\n        }\n        return [b, r];\n    };\n    var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];\n    // we can ignore the fact that the other numbers are wrong; they never happen anyway\n    fl[28] = 258, revfl[258] = 28;\n    var _b = freb(fdeb, 0), fd = _b[0];\n    // map of value to reverse (assuming 16 bits)\n    var rev = new u16(32768);\n    for (var i = 0; i < 32768; ++i) {\n        // reverse table algorithm from SO\n        var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);\n        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);\n        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);\n        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;\n    }\n    // create huffman tree from u8 \"map\": index -> code length for code index\n    // mb (max bits) must be at most 15\n    // TODO: optimize/split up?\n    var hMap = (function (cd, mb, r) {\n        var s = cd.length;\n        // index\n        var i = 0;\n        // u16 \"map\": index -> # of codes with bit length = index\n        var l = new u16(mb);\n        // length of cd must be 288 (total # of codes)\n        for (; i < s; ++i)\n            ++l[cd[i] - 1];\n        // u16 \"map\": index -> minimum code for bit length = index\n        var le = new u16(mb);\n        for (i = 0; i < mb; ++i) {\n            le[i] = (le[i - 1] + l[i - 1]) << 1;\n        }\n        var co;\n        if (r) {\n            // u16 \"map\": index -> number of actual bits, symbol for code\n            co = new u16(1 << mb);\n            // bits to remove for reverser\n            var rvb = 15 - mb;\n            for (i = 0; i < s; ++i) {\n                // ignore 0 lengths\n                if (cd[i]) {\n                    // num encoding both symbol and bits read\n                    var sv = (i << 4) | cd[i];\n                    // free bits\n                    var r_1 = mb - cd[i];\n                    // start value\n                    var v = le[cd[i] - 1]++ << r_1;\n                    // m is end value\n                    for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {\n                        // every 16 bit value starting with the code yields the same result\n                        co[rev[v] >>> rvb] = sv;\n                    }\n                }\n            }\n        }\n        else {\n            co = new u16(s);\n            for (i = 0; i < s; ++i) {\n                if (cd[i]) {\n                    co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);\n                }\n            }\n        }\n        return co;\n    });\n    // fixed length tree\n    var flt = new u8(288);\n    for (var i = 0; i < 144; ++i)\n        flt[i] = 8;\n    for (var i = 144; i < 256; ++i)\n        flt[i] = 9;\n    for (var i = 256; i < 280; ++i)\n        flt[i] = 7;\n    for (var i = 280; i < 288; ++i)\n        flt[i] = 8;\n    // fixed distance tree\n    var fdt = new u8(32);\n    for (var i = 0; i < 32; ++i)\n        fdt[i] = 5;\n    // fixed length map\n    var flrm = /*#__PURE__*/ hMap(flt, 9, 1);\n    // fixed distance map\n    var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);\n    // find max of array\n    var max = function (a) {\n        var m = a[0];\n        for (var i = 1; i < a.length; ++i) {\n            if (a[i] > m)\n                m = a[i];\n        }\n        return m;\n    };\n    // read d, starting at bit p and mask with m\n    var bits = function (d, p, m) {\n        var o = (p / 8) | 0;\n        return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;\n    };\n    // read d, starting at bit p continuing for at least 16 bits\n    var bits16 = function (d, p) {\n        var o = (p / 8) | 0;\n        return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));\n    };\n    // get end of byte\n    var shft = function (p) { return ((p + 7) / 8) | 0; };\n    // typed array slice - allows garbage collector to free original reference,\n    // while being more compatible than .slice\n    var slc = function (v, s, e) {\n        if (s == null || s < 0)\n            s = 0;\n        if (e == null || e > v.length)\n            e = v.length;\n        // can't use .constructor in case user-supplied\n        var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);\n        n.set(v.subarray(s, e));\n        return n;\n    };\n    // error codes\n    var ec = [\n        'unexpected EOF',\n        'invalid block type',\n        'invalid length/literal',\n        'invalid distance',\n        'stream finished',\n        'no stream handler',\n        ,\n        'no callback',\n        'invalid UTF-8 data',\n        'extra field too long',\n        'date not in range 1980-2099',\n        'filename too long',\n        'stream finishing',\n        'invalid zip data'\n        // determined by unknown compression method\n    ];\n    var err = function (ind, msg, nt) {\n        var e = new Error(msg || ec[ind]);\n        e.code = ind;\n        if (Error.captureStackTrace)\n            Error.captureStackTrace(e, err);\n        if (!nt)\n            throw e;\n        return e;\n    };\n    // expands raw DEFLATE data\n    var inflt = function (dat, buf, st) {\n        // source length\n        var sl = dat.length;\n        if (!sl || (st && st.f && !st.l))\n            return buf || new u8(0);\n        // have to estimate size\n        var noBuf = !buf || st;\n        // no state\n        var noSt = !st || st.i;\n        if (!st)\n            st = {};\n        // Assumes roughly 33% compression ratio average\n        if (!buf)\n            buf = new u8(sl * 3);\n        // ensure buffer can fit at least l elements\n        var cbuf = function (l) {\n            var bl = buf.length;\n            // need to increase size to fit\n            if (l > bl) {\n                // Double or set to necessary, whichever is greater\n                var nbuf = new u8(Math.max(bl * 2, l));\n                nbuf.set(buf);\n                buf = nbuf;\n            }\n        };\n        //  last chunk         bitpos           bytes\n        var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;\n        // total bits\n        var tbts = sl * 8;\n        do {\n            if (!lm) {\n                // BFINAL - this is only 1 when last chunk is next\n                final = bits(dat, pos, 1);\n                // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman\n                var type = bits(dat, pos + 1, 3);\n                pos += 3;\n                if (!type) {\n                    // go to end of byte boundary\n                    var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;\n                    if (t > sl) {\n                        if (noSt)\n                            err(0);\n                        break;\n                    }\n                    // ensure size\n                    if (noBuf)\n                        cbuf(bt + l);\n                    // Copy over uncompressed data\n                    buf.set(dat.subarray(s, t), bt);\n                    // Get new bitpos, update byte count\n                    st.b = bt += l, st.p = pos = t * 8, st.f = final;\n                    continue;\n                }\n                else if (type == 1)\n                    lm = flrm, dm = fdrm, lbt = 9, dbt = 5;\n                else if (type == 2) {\n                    //  literal                            lengths\n                    var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;\n                    var tl = hLit + bits(dat, pos + 5, 31) + 1;\n                    pos += 14;\n                    // length+distance tree\n                    var ldt = new u8(tl);\n                    // code length tree\n                    var clt = new u8(19);\n                    for (var i = 0; i < hcLen; ++i) {\n                        // use index map to get real code\n                        clt[clim[i]] = bits(dat, pos + i * 3, 7);\n                    }\n                    pos += hcLen * 3;\n                    // code lengths bits\n                    var clb = max(clt), clbmsk = (1 << clb) - 1;\n                    // code lengths map\n                    var clm = hMap(clt, clb, 1);\n                    for (var i = 0; i < tl;) {\n                        var r = clm[bits(dat, pos, clbmsk)];\n                        // bits read\n                        pos += r & 15;\n                        // symbol\n                        var s = r >>> 4;\n                        // code length to copy\n                        if (s < 16) {\n                            ldt[i++] = s;\n                        }\n                        else {\n                            //  copy   count\n                            var c = 0, n = 0;\n                            if (s == 16)\n                                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];\n                            else if (s == 17)\n                                n = 3 + bits(dat, pos, 7), pos += 3;\n                            else if (s == 18)\n                                n = 11 + bits(dat, pos, 127), pos += 7;\n                            while (n--)\n                                ldt[i++] = c;\n                        }\n                    }\n                    //    length tree                 distance tree\n                    var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);\n                    // max length bits\n                    lbt = max(lt);\n                    // max dist bits\n                    dbt = max(dt);\n                    lm = hMap(lt, lbt, 1);\n                    dm = hMap(dt, dbt, 1);\n                }\n                else\n                    err(1);\n                if (pos > tbts) {\n                    if (noSt)\n                        err(0);\n                    break;\n                }\n            }\n            // Make sure the buffer can hold this + the largest possible addition\n            // Maximum chunk size (practically, theoretically infinite) is 2^17;\n            if (noBuf)\n                cbuf(bt + 131072);\n            var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;\n            var lpos = pos;\n            for (;; lpos = pos) {\n                // bits read, code\n                var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;\n                pos += c & 15;\n                if (pos > tbts) {\n                    if (noSt)\n                        err(0);\n                    break;\n                }\n                if (!c)\n                    err(2);\n                if (sym < 256)\n                    buf[bt++] = sym;\n                else if (sym == 256) {\n                    lpos = pos, lm = null;\n                    break;\n                }\n                else {\n                    var add = sym - 254;\n                    // no extra bits needed if less\n                    if (sym > 264) {\n                        // index\n                        var i = sym - 257, b = fleb[i];\n                        add = bits(dat, pos, (1 << b) - 1) + fl[i];\n                        pos += b;\n                    }\n                    // dist\n                    var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;\n                    if (!d)\n                        err(3);\n                    pos += d & 15;\n                    var dt = fd[dsym];\n                    if (dsym > 3) {\n                        var b = fdeb[dsym];\n                        dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;\n                    }\n                    if (pos > tbts) {\n                        if (noSt)\n                            err(0);\n                        break;\n                    }\n                    if (noBuf)\n                        cbuf(bt + 131072);\n                    var end = bt + add;\n                    for (; bt < end; bt += 4) {\n                        buf[bt] = buf[bt - dt];\n                        buf[bt + 1] = buf[bt + 1 - dt];\n                        buf[bt + 2] = buf[bt + 2 - dt];\n                        buf[bt + 3] = buf[bt + 3 - dt];\n                    }\n                    bt = end;\n                }\n            }\n            st.l = lm, st.p = lpos, st.b = bt, st.f = final;\n            if (lm)\n                final = 1, st.m = lbt, st.d = dm, st.n = dbt;\n        } while (!final);\n        return bt == buf.length ? buf : slc(buf, 0, bt);\n    };\n    // gzip footer: -8 to -4 = CRC, -4 to -0 is length\n    // gzip start\n    var gzs = function (d) {\n        if (d[0] != 31 || d[1] != 139 || d[2] != 8)\n            err(6, 'invalid gzip data');\n        var flg = d[3];\n        var st = 10;\n        if (flg & 4)\n            st += d[10] | (d[11] << 8) + 2;\n        for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])\n            ;\n        return st + (flg & 2);\n    };\n    // gzip length\n    var gzl = function (d) {\n        var l = d.length;\n        return ((d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16) | (d[l - 1] << 24)) >>> 0;\n    };\n    // zlib valid\n    var zlv = function (d) {\n        if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))\n            err(6, 'invalid zlib data');\n        if (d[1] & 32)\n            err(6, 'invalid zlib data: preset dictionaries not supported');\n    };\n    return {\n        /**\n         * Expands GZIP data\n         * @param data The data to decompress\n         * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.\n         * @returns The decompressed version of the data\n         */\n        gunzipSync: function (data, out) {\n            return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));\n        },\n        /**\n         * Expands Zlib data\n         * @param data The data to decompress\n         * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n         * @returns The decompressed version of the data\n         */\n        unzlibSync: function (data, out) {\n            return inflt((zlv(data), data.subarray(2, -4)), out);\n        }\n    };\n})();\n","import { algorithms } from '../../utils/decompress';\nimport { decodeFromBase64 } from '../../utils/base64';\nvar GZIP = 1;\nvar ZLIB = 2;\nfunction Uint8ArrayToString(myUint8Arr) {\n    return String.fromCharCode.apply(null, myUint8Arr);\n}\nfunction StringToUint8Array(myString) {\n    var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });\n    return new Uint8Array(charCodes);\n}\n/**\n * Decode and decompress 'data' with 'compression' algorithm\n *\n * @param {string} data\n * @param {number} compression 1 GZIP, 2 ZLIB\n * @returns {Uint8Array}\n * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)\n */\nfunction decompress(data, compression) {\n    var compressData = decodeFromBase64(data);\n    var binData = StringToUint8Array(compressData);\n    if (typeof algorithms === 'string')\n        throw new Error(algorithms);\n    if (compression === GZIP)\n        return algorithms.gunzipSync(binData);\n    if (compression === ZLIB)\n        return algorithms.unzlibSync(binData);\n    throw new Error(\"Invalid compression algorithm #\" + compression);\n}\n/**\n * Decode, decompress and parse the provided 'data' into a KeyList object\n *\n * @param {string} data\n * @param {number} compression\n * @returns {{a?: string[], r?: string[] }}\n * @throws if data string cannot be decoded, decompressed or parsed\n */\nexport function parseKeyList(data, compression) {\n    var binKeyList = decompress(data, compression);\n    var strKeyList = Uint8ArrayToString(binKeyList);\n    // replace numbers to strings, to avoid losing precision\n    return JSON.parse(strKeyList.replace(/\\d+/g, '\"$&\"'));\n}\n/**\n * Decode, decompress and parse the provided 'data' into a Bitmap object\n *\n * @param {string} data\n * @param {number} compression\n * @returns {Uint8Array}\n * @throws if data string cannot be decoded or decompressed\n */\nexport function parseBitmap(data, compression) {\n    return decompress(data, compression);\n}\n/**\n * Check if the 'bitmap' bit at 'hash64hex' position is 1\n *\n * @param {Uint8Array} bitmap\n * @param {string} hash64hex 16-chars string, representing a number in hexa\n * @returns {boolean}\n */\nexport function isInBitmap(bitmap, hash64hex) {\n    // using the lowest 32 bits as index, to avoid losing precision when converting to number\n    var index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);\n    var internal = Math.floor(index / 8);\n    var offset = index % 8;\n    return (bitmap[internal] & 1 << offset) > 0;\n}\n","/**\n * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),\n * with the minimal features used by the SDK.\n\nCopyright (C) 2013 Mariusz Nowak (www.medikoo.com)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n**/\nvar SetPoly = /** @class */ (function () {\n    // unlike ES6 `Set`, it only accepts an array as first argument iterable\n    function SetPoly(values) {\n        var _this = this;\n        this.__setData__ = [];\n        if (Array.isArray(values))\n            values.forEach(function (value) { _this.add(value); });\n    }\n    SetPoly.prototype.clear = function () {\n        if (!this.__setData__.length)\n            return;\n        this.__setData__.length = 0;\n    };\n    SetPoly.prototype.add = function (value) {\n        if (this.has(value))\n            return this;\n        this.__setData__.push(value);\n        return this;\n    };\n    SetPoly.prototype.delete = function (value) {\n        var index = this.__setData__.indexOf(value);\n        if (index === -1)\n            return false;\n        this.__setData__.splice(index, 1);\n        return true;\n    };\n    SetPoly.prototype.has = function (value) {\n        return this.__setData__.indexOf(value) !== -1;\n    };\n    SetPoly.prototype.forEach = function (callbackfn, thisArg) {\n        if (typeof callbackfn !== 'function')\n            throw new TypeError(callbackfn + ' is not a function');\n        for (var i = 0; i < this.__setData__.length; i++) {\n            var value = this.__setData__[i];\n            callbackfn.call(thisArg, value, value, this);\n        }\n    };\n    Object.defineProperty(SetPoly.prototype, \"size\", {\n        get: function () {\n            return this.__setData__.length;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return SetPoly;\n}());\nexport { SetPoly };\n/**\n * return an array containing the items of the given set.\n * @param set Set or SetPoly instance\n */\nexport function setToArray(set) {\n    if (set instanceof SetPoly) {\n        return set.__setData__.slice();\n    }\n    // if not using SetPoly as set, it means Array.from is supported\n    // eslint-disable-next-line compat/compat\n    return Array.from(set);\n}\n/**\n * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,\n * a ponyfill with minimal features is returned instead.\n *\n * Exported for testing purposes only.\n */\nexport function __getSetConstructor() {\n    // eslint-disable-next-line compat/compat\n    if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {\n        return Set;\n    }\n    return SetPoly;\n}\nexport var _Set = __getSetConstructor();\n","/* eslint-disable no-fallthrough */\nimport { UTF16ToUTF8 } from './common';\n/*\n * +----------------------------------------------------------------------------------+\n * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |\n * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |\n * |----------------------------------------------------------------------------------|\n * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |\n * +----------------------------------------------------------------------------------+\n */\n// PRIVATE FUNCTIONS\n// -----------------\nfunction _x64Add(m, n) {\n    //\n    // Given two 64bit ints (as an array of two 32bit ints) returns the two\n    // added together as a 64bit int (as an array of two 32bit ints).\n    //\n    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];\n    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];\n    var o = [0, 0, 0, 0];\n    o[3] += m[3] + n[3];\n    o[2] += o[3] >>> 16;\n    o[3] &= 0xffff;\n    o[2] += m[2] + n[2];\n    o[1] += o[2] >>> 16;\n    o[2] &= 0xffff;\n    o[1] += m[1] + n[1];\n    o[0] += o[1] >>> 16;\n    o[1] &= 0xffff;\n    o[0] += m[0] + n[0];\n    o[0] &= 0xffff;\n    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];\n}\nfunction _x64Multiply(m, n) {\n    //\n    // Given two 64bit ints (as an array of two 32bit ints) returns the two\n    // multiplied together as a 64bit int (as an array of two 32bit ints).\n    //\n    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];\n    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];\n    var o = [0, 0, 0, 0];\n    o[3] += m[3] * n[3];\n    o[2] += o[3] >>> 16;\n    o[3] &= 0xffff;\n    o[2] += m[2] * n[3];\n    o[1] += o[2] >>> 16;\n    o[2] &= 0xffff;\n    o[2] += m[3] * n[2];\n    o[1] += o[2] >>> 16;\n    o[2] &= 0xffff;\n    o[1] += m[1] * n[3];\n    o[0] += o[1] >>> 16;\n    o[1] &= 0xffff;\n    o[1] += m[2] * n[2];\n    o[0] += o[1] >>> 16;\n    o[1] &= 0xffff;\n    o[1] += m[3] * n[1];\n    o[0] += o[1] >>> 16;\n    o[1] &= 0xffff;\n    o[0] += (m[0] * n[3]) + (m[1] * n[2]) + (m[2] * n[1]) + (m[3] * n[0]);\n    o[0] &= 0xffff;\n    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];\n}\nfunction _x64Rotl(m, n) {\n    //\n    // Given a 64bit int (as an array of two 32bit ints) and an int\n    // representing a number of bit positions, returns the 64bit int (as an\n    // array of two 32bit ints) rotated left by that number of positions.\n    //\n    n %= 64;\n    if (n === 32) {\n        return [m[1], m[0]];\n    }\n    else if (n < 32) {\n        return [(m[0] << n) | (m[1] >>> (32 - n)), (m[1] << n) | (m[0] >>> (32 - n))];\n    }\n    else {\n        n -= 32;\n        return [(m[1] << n) | (m[0] >>> (32 - n)), (m[0] << n) | (m[1] >>> (32 - n))];\n    }\n}\nfunction _x64LeftShift(m, n) {\n    //\n    // Given a 64bit int (as an array of two 32bit ints) and an int\n    // representing a number of bit positions, returns the 64bit int (as an\n    // array of two 32bit ints) shifted left by that number of positions.\n    //\n    n %= 64;\n    if (n === 0) {\n        return m;\n    }\n    else if (n < 32) {\n        return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];\n    }\n    else {\n        return [m[1] << (n - 32), 0];\n    }\n}\nfunction _x64Xor(m, n) {\n    //\n    // Given two 64bit ints (as an array of two 32bit ints) returns the two\n    // xored together as a 64bit int (as an array of two 32bit ints).\n    //\n    return [m[0] ^ n[0], m[1] ^ n[1]];\n}\nfunction _x64Fmix(h) {\n    //\n    // Given a block, returns murmurHash3's final x64 mix of that block.\n    // (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the\n    // only place where we need to right shift 64bit ints.)\n    //\n    h = _x64Xor(h, [0, h[0] >>> 1]);\n    h = _x64Multiply(h, [0xff51afd7, 0xed558ccd]);\n    h = _x64Xor(h, [0, h[0] >>> 1]);\n    h = _x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);\n    h = _x64Xor(h, [0, h[0] >>> 1]);\n    return h;\n}\n// PUBLIC FUNCTIONS\n// ----------------\nfunction hash128x64(key, seed) {\n    //\n    // Given a string and an optional seed as an int, returns a 128 bit\n    // hash using the x64 flavor of MurmurHash3, as an unsigned hex.\n    //\n    key = key || '';\n    seed = seed || 0;\n    var remainder = key.length % 16;\n    var bytes = key.length - remainder;\n    var h1 = [0, seed];\n    var h2 = [0, seed];\n    var k1 = [0, 0];\n    var k2 = [0, 0];\n    var c1 = [0x87c37b91, 0x114253d5];\n    var c2 = [0x4cf5ad43, 0x2745937f];\n    for (var i = 0; i < bytes; i = i + 16) {\n        k1 = [((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24), ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) &\n                0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24)];\n        k2 = [((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24), ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i +\n                9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24)];\n        k1 = _x64Multiply(k1, c1);\n        k1 = _x64Rotl(k1, 31);\n        k1 = _x64Multiply(k1, c2);\n        h1 = _x64Xor(h1, k1);\n        h1 = _x64Rotl(h1, 27);\n        h1 = _x64Add(h1, h2);\n        h1 = _x64Add(_x64Multiply(h1, [0, 5]), [0, 0x52dce729]);\n        k2 = _x64Multiply(k2, c2);\n        k2 = _x64Rotl(k2, 33);\n        k2 = _x64Multiply(k2, c1);\n        h2 = _x64Xor(h2, k2);\n        h2 = _x64Rotl(h2, 31);\n        h2 = _x64Add(h2, h1);\n        h2 = _x64Add(_x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);\n    }\n    k1 = [0, 0];\n    k2 = [0, 0];\n    switch (remainder) {\n        case 15:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 14)], 48));\n        case 14:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 13)], 40));\n        case 13:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 12)], 32));\n        case 12:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 11)], 24));\n        case 11:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 10)], 16));\n        case 10:\n            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 9)], 8));\n        case 9:\n            k2 = _x64Xor(k2, [0, key.charCodeAt(i + 8)]);\n            k2 = _x64Multiply(k2, c2);\n            k2 = _x64Rotl(k2, 33);\n            k2 = _x64Multiply(k2, c1);\n            h2 = _x64Xor(h2, k2);\n        case 8:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 7)], 56));\n        case 7:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 6)], 48));\n        case 6:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 5)], 40));\n        case 5:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 4)], 32));\n        case 4:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 3)], 24));\n        case 3:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 2)], 16));\n        case 2:\n            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 1)], 8));\n        case 1:\n            k1 = _x64Xor(k1, [0, key.charCodeAt(i)]);\n            k1 = _x64Multiply(k1, c1);\n            k1 = _x64Rotl(k1, 31);\n            k1 = _x64Multiply(k1, c2);\n            h1 = _x64Xor(h1, k1);\n    }\n    h1 = _x64Xor(h1, [0, key.length]);\n    h2 = _x64Xor(h2, [0, key.length]);\n    h1 = _x64Add(h1, h2);\n    h2 = _x64Add(h2, h1);\n    h1 = _x64Fmix(h1);\n    h2 = _x64Fmix(h2);\n    h1 = _x64Add(h1, h2);\n    h2 = _x64Add(h2, h1);\n    return ('00000000' + (h1[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h1[1] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[1] >>> 0).toString(16)).slice(-8);\n}\n/**\n * x64 version of Murmur3 for 128bits.\n *\n * @param {string} str\n */\nexport function hash128(str, seed) {\n    return hash128x64(UTF16ToUTF8(str), seed >>> 0);\n}\n","import { hash128 } from './murmur3_128';\n/**\n * Use instead of parseInt, to not lose precision when converting big integers (greater than 2^53 - 1)\n */\nfunction hex2dec(s) {\n    var i, j, digits = [0], carry;\n    for (i = 0; i < s.length; i += 1) {\n        carry = parseInt(s.charAt(i), 16);\n        for (j = digits.length - 1; j >= 0; j -= 1) {\n            digits[j] = digits[j] * 16 + carry;\n            carry = digits[j] / 10 | 0;\n            digits[j] %= 10;\n        }\n        while (carry > 0) {\n            digits.unshift(carry % 10);\n            carry = carry / 10 | 0;\n        }\n    }\n    return digits.join('');\n}\n/**\n * Gets the higher 64 bits of the x64 version of Murmur3 for 128bits, as decimal and hexadecimal number strings.\n * Used for MySegments channel V2 notifications.\n * @param {string} str\n */\nexport function hash64(str) {\n    var hex = hash128(str).slice(0, 16);\n    return {\n        hex: hex,\n        dec: hex2dec(hex) // KeyList notification\n    };\n}\n","import { objectAssign } from '../../utils/lang/objectAssign';\nimport { Backoff } from '../../utils/Backoff';\nimport { SSEHandlerFactory } from './SSEHandler';\nimport { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';\nimport { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';\nimport { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';\nimport { authenticateFactory, hashUserKey } from './AuthClient';\nimport { forOwn } from '../../utils/lang';\nimport { SSEClient } from './SSEClient';\nimport { getMatching } from '../../utils/key';\nimport { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';\nimport { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';\nimport { UpdateStrategy } from './SSEHandler/types';\nimport { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';\nimport { _Set } from '../../utils/lang/sets';\nimport { hash64 } from '../../utils/murmur3/murmur3_64';\nimport { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';\n/**\n * PushManager factory:\n * - for server-side if key is not provided in settings.\n * - for client-side, with support for multiple clients, if key is provided in settings\n */\nexport function pushManagerFactory(params, pollingManager) {\n    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;\n    // `userKey` is the matching key of main client in client-side SDK.\n    // It can be used to check if running on client-side or server-side SDK.\n    var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;\n    var log = settings.log;\n    var sseClient;\n    try {\n        // `useHeaders` false for client-side, even if the platform EventSource supports headers (e.g., React Native).\n        sseClient = new SSEClient(settings, userKey ? false : true, platform.getEventSource);\n    }\n    catch (e) {\n        log.warn(STREAMING_FALLBACK, [e]);\n        return;\n    }\n    var authenticate = authenticateFactory(splitApi.fetchAuth);\n    // init feedback loop\n    var pushEmitter = new platform.EventEmitter();\n    var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);\n    sseClient.setEventHandler(sseHandler);\n    // init workers\n    // MySegmentsUpdateWorker (client-side) are initiated in `add` method\n    var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);\n    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments\n    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);\n    // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker\n    var userKeyHashes = {};\n    // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.\n    // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.\n    var clients = {};\n    // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.\n    var connectForNewClient = false;\n    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.\n    // It is used to halt the `connectPush` process if it was in progress.\n    var disconnected;\n    // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.\n    // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.\n    var disabled; // `disabled` implies `disconnected === true`\n    /** PushManager functions related to initialization */\n    var connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);\n    var timeoutIdTokenRefresh;\n    var timeoutIdSseOpen;\n    function scheduleTokenRefreshAndSse(authData) {\n        // clear scheduled tasks if exist\n        if (timeoutIdTokenRefresh)\n            clearTimeout(timeoutIdTokenRefresh);\n        if (timeoutIdSseOpen)\n            clearTimeout(timeoutIdSseOpen);\n        // Set token refresh 10 minutes before `expirationTime - issuedAt`\n        var decodedToken = authData.decodedToken;\n        var refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION;\n        // Default connDelay of 60 secs\n        var connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;\n        log.info(STREAMING_REFRESH_TOKEN, [refreshTokenDelay, connDelay]);\n        timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);\n        timeoutIdSseOpen = setTimeout(function () {\n            // halt if disconnected\n            if (disconnected)\n                return;\n            sseClient.open(authData);\n        }, connDelay * 1000);\n        telemetryTracker.streamingEvent(TOKEN_REFRESH, decodedToken.exp);\n    }\n    function connectPush() {\n        // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)\n        if (disconnected)\n            return;\n        // @TODO distinguish log for 'Connecting' (1st time) and 'Re-connecting'\n        log.info(STREAMING_CONNECTING);\n        disconnected = false;\n        var userKeys = userKey ? Object.keys(clients) : undefined;\n        authenticate(userKeys).then(function (authData) {\n            if (disconnected)\n                return;\n            // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to\n            // close the sseClient in case the org has been bloqued while the instance was connected to streaming\n            if (!authData.pushEnabled) {\n                log.info(STREAMING_DISABLED);\n                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);\n                return;\n            }\n            // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place\n            if (userKeys && userKeys.length < Object.keys(clients).length)\n                return;\n            // Schedule SSE connection and refresh token\n            scheduleTokenRefreshAndSse(authData);\n        }).catch(function (error) {\n            if (disconnected)\n                return;\n            log.error(ERROR_STREAMING_AUTH, [error.message]);\n            // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side)\n            if (error.statusCode >= 400 && error.statusCode < 500) {\n                telemetryTracker.streamingEvent(AUTH_REJECTION);\n                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);\n                return;\n            }\n            // Handle other HTTP and network errors as recoverable errors\n            pushEmitter.emit(PUSH_RETRYABLE_ERROR);\n        });\n    }\n    // close SSE connection and cancel scheduled tasks\n    function disconnectPush() {\n        // Halt disconnecting, just to avoid redundant logs if called multiple times\n        if (disconnected)\n            return;\n        disconnected = true;\n        sseClient.close();\n        log.info(STREAMING_DISCONNECTING);\n        if (timeoutIdTokenRefresh)\n            clearTimeout(timeoutIdTokenRefresh);\n        if (timeoutIdSseOpen)\n            clearTimeout(timeoutIdSseOpen);\n        connectPushRetryBackoff.reset();\n        stopWorkers();\n    }\n    // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers\n    function stopWorkers() {\n        splitsUpdateWorker.stop();\n        if (userKey)\n            forOwn(clients, function (_a) {\n                var worker = _a.worker;\n                return worker.stop();\n            });\n        else\n            segmentsUpdateWorker.stop();\n    }\n    pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);\n    // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.\n    // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).\n    pushEmitter.on(PUSH_SUBSYSTEM_UP, function () {\n        connectPushRetryBackoff.reset();\n    });\n    /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */\n    pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {\n        disabled = true;\n        // Note: `stopWorkers` is been called twice, but it is not harmful\n        disconnectPush();\n        pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already\n    });\n    /** Fallback to polling with retry due to recoverable SSE and Authentication errors */\n    pushEmitter.on(PUSH_RETRYABLE_ERROR, function handleRetryableError() {\n        // SSE connection is closed to avoid repeated errors due to retries\n        sseClient.close();\n        // retry streaming reconnect with backoff algorithm\n        var delayInMillis = connectPushRetryBackoff.scheduleCall();\n        log.info(STREAMING_RECONNECT, [delayInMillis / 1000]);\n        pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already\n    });\n    /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */\n    pushEmitter.on(ControlType.STREAMING_RESET, function handleStreamingReset() {\n        if (disconnected)\n            return; // should never happen\n        // Minimum required clean-up.\n        // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute\n        if (timeoutIdTokenRefresh)\n            clearTimeout(timeoutIdTokenRefresh);\n        connectPush();\n    });\n    /** Functions related to synchronization (Queues and Workers in the spec) */\n    pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);\n    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);\n    if (userKey) {\n        pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {\n            var userKeyHash = channel.split('_')[2];\n            var userKey = userKeyHashes[userKeyHash];\n            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed\n                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);\n            }\n        });\n        pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {\n            switch (parsedData.u) {\n                case UpdateStrategy.BoundedFetchRequest: {\n                    var bitmap_1;\n                    try {\n                        bitmap_1 = parseBitmap(parsedData.d, parsedData.c);\n                    }\n                    catch (e) {\n                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);\n                        break;\n                    }\n                    forOwn(clients, function (_a) {\n                        var hash64 = _a.hash64, worker = _a.worker;\n                        if (isInBitmap(bitmap_1, hash64.hex)) {\n                            worker.put(parsedData.changeNumber); // fetch mySegments\n                        }\n                    });\n                    return;\n                }\n                case UpdateStrategy.KeyList: {\n                    var keyList = void 0, added_1, removed_1;\n                    try {\n                        keyList = parseKeyList(parsedData.d, parsedData.c);\n                        added_1 = new _Set(keyList.a);\n                        removed_1 = new _Set(keyList.r);\n                    }\n                    catch (e) {\n                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);\n                        break;\n                    }\n                    forOwn(clients, function (_a) {\n                        var hash64 = _a.hash64, worker = _a.worker;\n                        var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;\n                        if (add !== undefined) {\n                            worker.put(parsedData.changeNumber, {\n                                name: parsedData.segmentName,\n                                add: add\n                            });\n                        }\n                    });\n                    return;\n                }\n                case UpdateStrategy.SegmentRemoval:\n                    if (!parsedData.segmentName) {\n                        log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);\n                        break;\n                    }\n                    forOwn(clients, function (_a) {\n                        var worker = _a.worker;\n                        return worker.put(parsedData.changeNumber, {\n                            name: parsedData.segmentName,\n                            add: false\n                        });\n                    });\n                    return;\n            }\n            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases\n            forOwn(clients, function (_a) {\n                var worker = _a.worker;\n                worker.put(parsedData.changeNumber);\n            });\n        });\n    }\n    else {\n        pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);\n    }\n    return objectAssign(\n    // Expose Event Emitter functionality and Event constants\n    Object.create(pushEmitter), {\n        // Stop/pause push mode.\n        // It doesn't emit events. Neither PUSH_SUBSYSTEM_DOWN to start polling.\n        stop: function () {\n            disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.\n            if (userKey)\n                this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).\n        },\n        // Start/resume push mode.\n        // It eventually emits PUSH_SUBSYSTEM_DOWN, that starts polling, or PUSH_SUBSYSTEM_UP, that executes a syncAll\n        start: function () {\n            // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.\n            if (disabled || disconnected === false)\n                return;\n            disconnected = false;\n            if (userKey)\n                this.add(userKey, pollingManager.segmentsSyncTask); // client-side\n            else\n                setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side\n        },\n        // true/false if start or stop was called last respectively\n        isRunning: function () {\n            return disconnected === false;\n        },\n        // [Only for client-side]\n        add: function (userKey, mySegmentsSyncTask) {\n            var hash = hashUserKey(userKey);\n            if (!userKeyHashes[hash]) {\n                userKeyHashes[hash] = userKey;\n                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask) };\n                connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key\n                // Reconnects in case of a new client.\n                // Run in next event-loop cycle to save authentication calls\n                // in case multiple clients are created in the current cycle.\n                setTimeout(function checkForReconnect() {\n                    if (connectForNewClient) {\n                        connectForNewClient = false;\n                        connectPush();\n                    }\n                }, 0);\n            }\n        },\n        // [Only for client-side]\n        remove: function (userKey) {\n            var hash = hashUserKey(userKey);\n            delete userKeyHashes[hash];\n            delete clients[userKey];\n        }\n    });\n}\n","/**\n * Factory of MySegments fetcher.\n * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.\n */\nexport function mySegmentsFetcherFactory(fetchMySegments) {\n    return function mySegmentsFetcher(userMatchingKey, noCache, \n    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker\n    decorator) {\n        var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);\n        if (decorator)\n            mySegmentsPromise = decorator(mySegmentsPromise);\n        // Extract segment names\n        return mySegmentsPromise\n            .then(function (resp) { return resp.json(); })\n            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });\n    };\n}\n","export function timeout(ms, promise) {\n    if (ms < 1)\n        return promise;\n    return new Promise(function (resolve, reject) {\n        var tid = setTimeout(function () {\n            reject(new Error(\"Operation timed out because it exceeded the configured time limit of \" + ms + \" ms.\"));\n        }, ms);\n        promise.then(function (res) {\n            clearTimeout(tid);\n            resolve(res);\n        }, function (err) {\n            clearTimeout(tid);\n            reject(err);\n        });\n    });\n}\n","import { timeout } from '../../../utils/promise/timeout';\nimport { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';\nimport { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';\n/**\n * factory of MySegments updater, a task that:\n *  - fetches mySegments using `mySegmentsFetcher`\n *  - updates `mySegmentsCache`\n *  - uses `segmentsEventEmitter` to emit events related to segments data updates\n */\nexport function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {\n    var readyOnAlreadyExistentState = true;\n    var startingUp = true;\n    /** timeout and telemetry decorator for `splitChangesFetcher` promise  */\n    function _promiseDecorator(promise) {\n        if (startingUp)\n            promise = timeout(requestTimeoutBeforeReady, promise);\n        return promise;\n    }\n    // @TODO if allowing pluggable storages, handle async execution\n    function updateSegments(segmentsData) {\n        var shouldNotifyUpdate;\n        if (Array.isArray(segmentsData)) {\n            // Update the list of segment names available\n            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);\n        }\n        else {\n            // Add/Delete the segment\n            var name_1 = segmentsData.name, add = segmentsData.add;\n            if (mySegmentsCache.isInSegment(name_1) !== add) {\n                shouldNotifyUpdate = true;\n                if (add)\n                    mySegmentsCache.addToSegment(name_1);\n                else\n                    mySegmentsCache.removeFromSegment(name_1);\n            }\n            else {\n                shouldNotifyUpdate = false;\n            }\n        }\n        // Notify update if required\n        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {\n            readyOnAlreadyExistentState = false;\n            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);\n        }\n    }\n    function _mySegmentsUpdater(retry, segmentsData, noCache) {\n        var updaterPromise = segmentsData ?\n            // If segmentsData is provided, there is no need to fetch mySegments\n            new Promise(function (res) { updateSegments(segmentsData); res(true); }) :\n            // If not provided, fetch mySegments\n            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {\n                // Only when we have downloaded segments completely, we should not keep retrying anymore\n                startingUp = false;\n                updateSegments(segments);\n                return true;\n            });\n        return updaterPromise.catch(function (error) {\n            if (startingUp && retriesOnFailureBeforeReady > retry) {\n                retry += 1;\n                log.warn(SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);\n                return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params\n            }\n            else {\n                startingUp = false;\n            }\n            return false;\n        });\n    }\n    /**\n     * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.\n     * Returned promise will not be rejected.\n     *\n     * @param {SegmentsData | undefined} segmentsData it can be:\n     *  (1) the list of mySegments names to sync in the storage,\n     *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,\n     *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.\n     * @param {boolean | undefined} noCache true to revalidate data to fetch\n     */\n    return function mySegmentsUpdater(segmentsData, noCache) {\n        return _mySegmentsUpdater(0, segmentsData, noCache);\n    };\n}\n","import { syncTaskFactory } from '../../syncTask';\nimport { mySegmentsFetcherFactory } from '../fetchers/mySegmentsFetcher';\nimport { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';\n/**\n * Creates a sync task that periodically executes a `mySegmentsUpdater` task\n */\nexport function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {\n    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');\n}\n","/**\n * Factory of SplitChanges fetcher.\n * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.\n */\nexport function splitChangesFetcherFactory(fetchSplitChanges) {\n    return function splitChangesFetcher(since, noCache, till, \n    // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker\n    decorator) {\n        var splitsPromise = fetchSplitChanges(since, noCache, till);\n        if (decorator)\n            splitsPromise = decorator(splitsPromise);\n        return splitsPromise.then(function (resp) { return resp.json(); });\n    };\n}\n","import { _Set, setToArray } from '../../../utils/lang/sets';\nimport { timeout } from '../../../utils/promise/timeout';\nimport { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';\nimport { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';\n// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).\n// Returns a promise that could be rejected.\n// @TODO review together with Segments and MySegments storage APIs\nfunction checkAllSegmentsExist(segments) {\n    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());\n    return registeredSegments.then(function (segmentNames) {\n        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))\n            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== -1; }); });\n    });\n}\n/**\n * Collect segments from a raw split definition.\n * Exported for testing purposes.\n */\nexport function parseSegments(_a) {\n    var conditions = _a.conditions;\n    var segments = new _Set();\n    for (var i = 0; i < conditions.length; i++) {\n        var matchers = conditions[i].matcherGroup.matchers;\n        matchers.forEach(function (matcher) {\n            if (matcher.matcherType === 'IN_SEGMENT')\n                segments.add(matcher.userDefinedSegmentMatcherData.segmentName);\n        });\n    }\n    return segments;\n}\n/**\n * Given the list of splits from /splitChanges endpoint, it returns the mutations,\n * i.e., an object with added splits, removed splits and used segments.\n * Exported for testing purposes.\n */\nexport function computeSplitsMutation(entries) {\n    var segments = new _Set();\n    var computed = entries.reduce(function (accum, split) {\n        if (split.status === 'ACTIVE') {\n            accum.added.push([split.name, split]);\n            parseSegments(split).forEach(function (segmentName) {\n                segments.add(segmentName);\n            });\n        }\n        else {\n            accum.removed.push(split.name);\n        }\n        return accum;\n    }, { added: [], removed: [], segments: [] });\n    computed.segments = setToArray(segments);\n    return computed;\n}\n/**\n * factory of SplitChanges updater, a task that:\n *  - fetches split changes using `splitChangesFetcher`\n *  - updates `splitsCache`\n *  - uses `splitsEventEmitter` to emit events related to split data updates\n *\n * @param log  Logger instance\n * @param splitChangesFetcher  Fetcher of `/splitChanges`\n * @param splits  Splits storage, with sync or async methods\n * @param segments  Segments storage, with sync or async methods\n * @param splitsEventEmitter  Optional readiness manager. Not required for synchronizer or producer mode.\n * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.\n * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.\n */\nexport function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {\n    if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }\n    if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }\n    var startingUp = true;\n    /** timeout decorator for `splitChangesFetcher` promise  */\n    function _promiseDecorator(promise) {\n        if (startingUp && requestTimeoutBeforeReady)\n            promise = timeout(requestTimeoutBeforeReady, promise);\n        return promise;\n    }\n    /**\n     * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.\n     * Returned promise will not be rejected.\n     *\n     * @param {boolean | undefined} noCache true to revalidate data to fetch\n     * @param {boolean | undefined} till query param to bypass CDN requests\n     */\n    return function splitChangesUpdater(noCache, till) {\n        /**\n         * @param {number} since current changeNumber at splitsCache\n         * @param {number} retry current number of retry attempts\n         */\n        function _splitChangesUpdater(since, retry) {\n            if (retry === void 0) { retry = 0; }\n            log.debug(SYNC_SPLITS_FETCH, [since]);\n            var fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)\n                .then(function (splitChanges) {\n                startingUp = false;\n                var mutation = computeSplitsMutation(splitChanges.splits);\n                log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);\n                log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);\n                log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);\n                // Write into storage\n                // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency\n                return Promise.all([\n                    // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed\n                    splits.setChangeNumber(splitChanges.till),\n                    splits.addSplits(mutation.added),\n                    splits.removeSplits(mutation.removed),\n                    segments.registerSegments(mutation.segments)\n                ]).then(function () {\n                    if (splitsEventEmitter) {\n                        // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched\n                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && (isClientSide || checkAllSegmentsExist(segments))))\n                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)\n                            .then(function (emitSplitsArrivedEvent) {\n                            // emit SDK events\n                            if (emitSplitsArrivedEvent)\n                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED);\n                            return true;\n                        });\n                    }\n                    return true;\n                });\n            })\n                .catch(function (error) {\n                log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);\n                if (startingUp && retriesOnFailureBeforeReady > retry) {\n                    retry += 1;\n                    log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);\n                    return _splitChangesUpdater(since, retry);\n                }\n                else {\n                    startingUp = false;\n                }\n                return false;\n            });\n            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.\n            // Wrapping in a promise since checkCache can be async.\n            if (splitsEventEmitter && startingUp) {\n                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {\n                    if (isCacheReady)\n                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);\n                });\n            }\n            return fetcherPromise;\n        }\n        var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error\n        return sincePromise.then(_splitChangesUpdater);\n    };\n}\n","import { syncTaskFactory } from '../../syncTask';\nimport { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';\nimport { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';\n/**\n * Creates a sync task that periodically executes a `splitChangesUpdater` task\n */\nexport function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {\n    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');\n}\n","import { forOwn } from '../../utils/lang';\nimport { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';\nimport { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';\nimport { getMatching } from '../../utils/key';\nimport { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';\nimport { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';\n/**\n * Expose start / stop mechanism for polling data from services.\n * For client-side API with multiple clients.\n */\nexport function pollingManagerCSFactory(params) {\n    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;\n    var log = settings.log;\n    var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);\n    // Map of matching keys to their corresponding MySegmentsSyncTask.\n    var mySegmentsSyncTasks = {};\n    var matchingKey = getMatching(settings.core.key);\n    var mySegmentsSyncTask = add(matchingKey, readiness, storage);\n    function startMySegmentsSyncTasks() {\n        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {\n            mySegmentsSyncTask.start();\n        });\n    }\n    function stopMySegmentsSyncTasks() {\n        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {\n            if (mySegmentsSyncTask.isRunning())\n                mySegmentsSyncTask.stop();\n        });\n    }\n    // smart pausing\n    readiness.splits.on(SDK_SPLITS_ARRIVED, function () {\n        if (!splitsSyncTask.isRunning())\n            return; // noop if not doing polling\n        var splitsHaveSegments = storage.splits.usesSegments();\n        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {\n            log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);\n            if (splitsHaveSegments) {\n                startMySegmentsSyncTasks();\n            }\n            else {\n                stopMySegmentsSyncTasks();\n            }\n        }\n    });\n    function add(matchingKey, readiness, storage) {\n        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);\n        // smart ready\n        function smartReady() {\n            if (!readiness.isReady() && !storage.splits.usesSegments())\n                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);\n        }\n        if (!storage.splits.usesSegments())\n            setTimeout(smartReady, 0);\n        else\n            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);\n        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;\n        return mySegmentsSyncTask;\n    }\n    return {\n        splitsSyncTask: splitsSyncTask,\n        segmentsSyncTask: mySegmentsSyncTask,\n        // Start periodic fetching (polling)\n        start: function () {\n            log.info(POLLING_START);\n            splitsSyncTask.start();\n            if (storage.splits.usesSegments())\n                startMySegmentsSyncTasks();\n        },\n        // Stop periodic fetching (polling)\n        stop: function () {\n            log.info(POLLING_STOP);\n            if (splitsSyncTask.isRunning())\n                splitsSyncTask.stop();\n            stopMySegmentsSyncTasks();\n        },\n        // Used by SyncManager to know if running in polling mode.\n        isRunning: splitsSyncTask.isRunning,\n        // fetch splits and segments\n        syncAll: function () {\n            var promises = [splitsSyncTask.execute()];\n            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {\n                promises.push(mySegmentsSyncTask.execute());\n            });\n            return Promise.all(promises);\n        },\n        // Support for handling mySegments sync of multiple clients\n        add: add,\n        remove: function (matchingKey) {\n            delete mySegmentsSyncTasks[matchingKey];\n        },\n        get: function (matchingKey) {\n            return mySegmentsSyncTasks[matchingKey];\n        }\n    };\n}\n","var ImpressionsCacheInMemory = /** @class */ (function () {\n    /**\n     *\n     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.\n     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.\n     */\n    function ImpressionsCacheInMemory(impressionsQueueSize) {\n        if (impressionsQueueSize === void 0) { impressionsQueueSize = 0; }\n        this.maxQueue = impressionsQueueSize;\n        this.queue = [];\n    }\n    ImpressionsCacheInMemory.prototype.setOnFullQueueCb = function (cb) {\n        this.onFullQueue = cb;\n    };\n    /**\n     * Store impressions in sequential order\n     */\n    ImpressionsCacheInMemory.prototype.track = function (data) {\n        var _a;\n        (_a = this.queue).push.apply(_a, data);\n        // Check if the cache queue is full and we need to flush it.\n        if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {\n            this.onFullQueue();\n        }\n    };\n    /**\n     * Clear the data stored on the cache.\n     */\n    ImpressionsCacheInMemory.prototype.clear = function () {\n        this.queue = [];\n    };\n    /**\n     * Pop the collected data, used as payload for posting.\n     */\n    ImpressionsCacheInMemory.prototype.pop = function (toMerge) {\n        var data = this.queue;\n        this.clear();\n        return toMerge ? toMerge.concat(data) : data;\n    };\n    /**\n     * Check if the cache is empty.\n     */\n    ImpressionsCacheInMemory.prototype.isEmpty = function () {\n        return this.queue.length === 0;\n    };\n    return ImpressionsCacheInMemory;\n}());\nexport { ImpressionsCacheInMemory };\n","var DEDUP_WINDOW_SIZE_MS = 3600 * 1000;\n/**\n* Truncates de time frame received with the time window.\n*/\nexport function truncateTimeFrame(timestampInMs) {\n    return timestampInMs - (timestampInMs % DEDUP_WINDOW_SIZE_MS);\n}\n","export var LOG_PREFIX = 'storage:redis: ';\nexport var DEFAULT_CACHE_SIZE = 30000;\nexport var REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins\nexport var TTL_REFRESH = 3600; // 1hr\n","import { truncateTimeFrame } from '../../utils/time';\nimport { DEFAULT_CACHE_SIZE } from '../inRedis/constants';\nvar ImpressionCountsCacheInMemory = /** @class */ (function () {\n    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {\n        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = DEFAULT_CACHE_SIZE; }\n        this.cache = {};\n        this.cacheSize = 0;\n        this.maxStorage = impressionCountsCacheSize;\n    }\n    /**\n    * Builds key to be stored in the cache with the featureName and the timeFrame truncated.\n    */\n    ImpressionCountsCacheInMemory.prototype._makeKey = function (featureName, timeFrame) {\n        return featureName + \"::\" + truncateTimeFrame(timeFrame);\n    };\n    /**\n    * Increments the quantity of impressions with the passed featureName and timeFrame.\n    */\n    ImpressionCountsCacheInMemory.prototype.track = function (featureName, timeFrame, amount) {\n        var key = this._makeKey(featureName, timeFrame);\n        var currentAmount = this.cache[key];\n        this.cache[key] = currentAmount ? currentAmount + amount : amount;\n        if (this.onFullQueue) {\n            this.cacheSize = this.cacheSize + amount;\n            if (this.cacheSize >= this.maxStorage) {\n                this.onFullQueue();\n            }\n        }\n    };\n    /**\n     * Pop the collected data, used as payload for posting.\n     */\n    ImpressionCountsCacheInMemory.prototype.pop = function (toMerge) {\n        var data = this.cache;\n        this.clear();\n        if (toMerge) {\n            Object.keys(data).forEach(function (key) {\n                if (toMerge[key])\n                    toMerge[key] += data[key];\n                else\n                    toMerge[key] = data[key];\n            });\n            return toMerge;\n        }\n        return data;\n    };\n    /**\n     * Clear the data stored on the cache.\n     */\n    ImpressionCountsCacheInMemory.prototype.clear = function () {\n        this.cache = {};\n        this.cacheSize = 0;\n    };\n    /**\n     * Check if the cache is empty.\n     */\n    ImpressionCountsCacheInMemory.prototype.isEmpty = function () {\n        return Object.keys(this.cache).length === 0;\n    };\n    return ImpressionCountsCacheInMemory;\n}());\nexport { ImpressionCountsCacheInMemory };\n","var MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M\nvar EventsCacheInMemory = /** @class */ (function () {\n    /**\n     *\n     * @param eventsQueueSize number of queued events to call onFullQueueCb.\n     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.\n     */\n    function EventsCacheInMemory(eventsQueueSize) {\n        if (eventsQueueSize === void 0) { eventsQueueSize = 0; }\n        this.maxQueue = eventsQueueSize;\n        this.queue = [];\n        this.queueByteSize = 0;\n    }\n    EventsCacheInMemory.prototype.setOnFullQueueCb = function (cb) {\n        this.onFullQueue = cb;\n    };\n    /**\n     * Add a new event object at the end of the queue.\n     */\n    EventsCacheInMemory.prototype.track = function (data, size) {\n        if (size === void 0) { size = 0; }\n        this.queueByteSize += size;\n        this.queue.push(data);\n        this._checkForFlush();\n        return true;\n    };\n    /**\n     * Clear the data stored on the cache.\n     */\n    EventsCacheInMemory.prototype.clear = function () {\n        this.queue = [];\n        this.queueByteSize = 0;\n    };\n    /**\n     * Pop the collected data, used as payload for posting.\n     */\n    EventsCacheInMemory.prototype.pop = function (toMerge) {\n        var data = this.queue;\n        this.clear();\n        return toMerge ? toMerge.concat(data) : data;\n    };\n    /**\n     * Check if the cache is empty.\n     */\n    EventsCacheInMemory.prototype.isEmpty = function () {\n        return this.queue.length === 0;\n    };\n    /**\n     * Check if the cache queue is full and we need to flush it.\n     */\n    EventsCacheInMemory.prototype._checkForFlush = function () {\n        if ((this.queueByteSize > MAX_QUEUE_BYTE_SIZE) ||\n            // 0 means no maximum value, in case we want to avoid this being triggered. Size limit is not affected by it.\n            (this.maxQueue > 0 && this.queue.length >= this.maxQueue)) {\n            this.onFullQueue && this.onFullQueue();\n        }\n    };\n    return EventsCacheInMemory;\n}());\nexport { EventsCacheInMemory };\n","import { startsWith } from '../utils/lang';\nvar everythingAtTheEnd = /[^.]+$/;\nvar DEFAULT_PREFIX = 'SPLITIO';\nexport function validatePrefix(prefix) {\n    return prefix ? prefix + '.SPLITIO' : 'SPLITIO';\n}\nvar KeyBuilder = /** @class */ (function () {\n    function KeyBuilder(prefix) {\n        if (prefix === void 0) { prefix = DEFAULT_PREFIX; }\n        this.prefix = prefix;\n    }\n    KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {\n        return this.prefix + \".trafficType.\" + trafficType;\n    };\n    KeyBuilder.prototype.buildSplitKey = function (splitName) {\n        return this.prefix + \".split.\" + splitName;\n    };\n    KeyBuilder.prototype.buildSplitsTillKey = function () {\n        return this.prefix + \".splits.till\";\n    };\n    // NOT USED\n    // buildSplitsReady() {\n    //   return `${this.prefix}.splits.ready`;\n    // }\n    KeyBuilder.prototype.isSplitKey = function (key) {\n        return startsWith(key, this.prefix + \".split.\");\n    };\n    KeyBuilder.prototype.buildSplitKeyPrefix = function () {\n        return this.prefix + \".split.\";\n    };\n    // Only used by InLocalStorage.\n    KeyBuilder.prototype.buildSplitsWithSegmentCountKey = function () {\n        return this.prefix + \".splits.usingSegments\";\n    };\n    KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {\n        return this.prefix + \".segment.\" + segmentName;\n    };\n    KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {\n        return this.prefix + \".segment.\" + segmentName + \".till\";\n    };\n    // NOT USED\n    // buildSegmentsReady() {\n    //   return `${this.prefix}.segments.ready`;\n    // }\n    KeyBuilder.prototype.extractKey = function (builtKey) {\n        var s = builtKey.match(everythingAtTheEnd);\n        if (s && s.length) {\n            return s[0];\n        }\n        else {\n            throw new Error('Invalid latency key provided');\n        }\n    };\n    return KeyBuilder;\n}());\nexport { KeyBuilder };\n","import { __extends } from \"tslib\";\nimport { startsWith } from '../utils/lang';\nimport { KeyBuilder } from './KeyBuilder';\nvar KeyBuilderCS = /** @class */ (function (_super) {\n    __extends(KeyBuilderCS, _super);\n    function KeyBuilderCS(prefix, matchingKey) {\n        var _this = _super.call(this, prefix) || this;\n        _this.matchingKey = matchingKey;\n        _this.regexSplitsCacheKey = new RegExp(\"^\" + prefix + \"\\\\.(splits?|trafficType)\\\\.\");\n        return _this;\n    }\n    /**\n     * @override\n     */\n    KeyBuilderCS.prototype.buildSegmentNameKey = function (segmentName) {\n        return this.prefix + \".\" + this.matchingKey + \".segment.\" + segmentName;\n    };\n    KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {\n        var prefix = this.prefix + \".\" + this.matchingKey + \".segment.\";\n        if (startsWith(builtSegmentKeyName, prefix))\n            return builtSegmentKeyName.substr(prefix.length);\n    };\n    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3\n    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {\n        return this.matchingKey + \".\" + this.prefix + \".segment.\" + segmentName;\n    };\n    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3\n    KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {\n        var prefix = this.matchingKey + \".\" + this.prefix + \".segment.\";\n        if (startsWith(builtSegmentKeyName, prefix))\n            return builtSegmentKeyName.substr(prefix.length);\n    };\n    KeyBuilderCS.prototype.buildLastUpdatedKey = function () {\n        return this.prefix + \".splits.lastUpdated\";\n    };\n    KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {\n        return this.regexSplitsCacheKey.test(key);\n    };\n    KeyBuilderCS.prototype.buildSplitsFilterQueryKey = function () {\n        return this.prefix + \".splits.filterQuery\";\n    };\n    return KeyBuilderCS;\n}(KeyBuilder));\nexport { KeyBuilderCS };\n","/* eslint-disable no-undef */\nexport function isLocalStorageAvailable() {\n    var mod = '__SPLITSOFTWARE__';\n    try {\n        localStorage.setItem(mod, mod);\n        localStorage.removeItem(mod);\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\n/**\n * This class provides a skeletal implementation of the ISplitsCacheSync interface\n * to minimize the effort required to implement this interface.\n */\nvar AbstractSplitsCacheSync = /** @class */ (function () {\n    function AbstractSplitsCacheSync() {\n    }\n    AbstractSplitsCacheSync.prototype.addSplits = function (entries) {\n        var _this = this;\n        return entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); });\n    };\n    AbstractSplitsCacheSync.prototype.removeSplits = function (names) {\n        var _this = this;\n        return names.map(function (name) { return _this.removeSplit(name); });\n    };\n    AbstractSplitsCacheSync.prototype.getSplits = function (names) {\n        var _this = this;\n        var splits = {};\n        names.forEach(function (name) {\n            splits[name] = _this.getSplit(name);\n        });\n        return splits;\n    };\n    AbstractSplitsCacheSync.prototype.getAll = function () {\n        var _this = this;\n        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });\n    };\n    /**\n     * Check if the splits information is already stored in cache. This data can be preloaded.\n     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.\n     */\n    AbstractSplitsCacheSync.prototype.checkCache = function () {\n        return false;\n    };\n    /**\n     * Kill `name` split and set `defaultTreatment` and `changeNumber`.\n     * Used for SPLIT_KILL push notifications.\n     *\n     * @param {string} name\n     * @param {string} defaultTreatment\n     * @param {number} changeNumber\n     * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,\n     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.\n     */\n    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {\n        var split = this.getSplit(name);\n        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {\n            var newSplit = objectAssign({}, split);\n            newSplit.killed = true;\n            newSplit.defaultTreatment = defaultTreatment;\n            newSplit.changeNumber = changeNumber;\n            return this.addSplit(name, newSplit);\n        }\n        return false;\n    };\n    return AbstractSplitsCacheSync;\n}());\nexport { AbstractSplitsCacheSync };\n/**\n * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).\n * This util is intended to simplify the implementation of `splitsCache::usesSegments` method\n */\nexport function usesSegments(split) {\n    var conditions = split.conditions || [];\n    for (var i = 0; i < conditions.length; i++) {\n        var matchers = conditions[i].matcherGroup.matchers;\n        for (var j = 0; j < matchers.length; j++) {\n            if (matchers[j].matcherType === 'IN_SEGMENT')\n                return true;\n        }\n    }\n    return false;\n}\n","export var LOG_PREFIX = 'storage:localstorage: ';\nexport var DEFINED = '1';\n","import { __extends } from \"tslib\";\nimport { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';\nimport { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';\nimport { LOG_PREFIX } from './constants';\n/**\n * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.\n */\nvar SplitsCacheInLocal = /** @class */ (function (_super) {\n    __extends(SplitsCacheInLocal, _super);\n    /**\n     * @param {KeyBuilderCS} keys\n     * @param {number | undefined} expirationTimestamp\n     * @param {ISplitFiltersValidation} splitFiltersValidation\n     */\n    function SplitsCacheInLocal(log, keys, expirationTimestamp, splitFiltersValidation) {\n        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { byName: [], byPrefix: [] }, validFilters: [] }; }\n        var _this = _super.call(this) || this;\n        _this.log = log;\n        _this.cacheReadyButNeedsToFlush = false;\n        _this.keys = keys;\n        _this.splitFiltersValidation = splitFiltersValidation;\n        _this._checkExpiration(expirationTimestamp);\n        _this._checkFilterQuery();\n        return _this;\n    }\n    SplitsCacheInLocal.prototype._decrementCount = function (key) {\n        var count = toNumber(localStorage.getItem(key)) - 1;\n        // @ts-expect-error\n        if (count > 0)\n            localStorage.setItem(key, count);\n        else\n            localStorage.removeItem(key);\n    };\n    SplitsCacheInLocal.prototype._decrementCounts = function (split) {\n        try {\n            if (split) {\n                if (split.trafficTypeName) {\n                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);\n                    this._decrementCount(ttKey);\n                }\n                if (usesSegments(split)) {\n                    var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();\n                    this._decrementCount(segmentsCountKey);\n                }\n            }\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n        }\n    };\n    SplitsCacheInLocal.prototype._incrementCounts = function (split) {\n        try {\n            if (split) {\n                if (split.trafficTypeName) {\n                    var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);\n                    // @ts-expect-error\n                    localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);\n                }\n                if (usesSegments(split)) {\n                    var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();\n                    // @ts-expect-error\n                    localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);\n                }\n            }\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n        }\n    };\n    /**\n     * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).\n     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.\n     */\n    SplitsCacheInLocal.prototype.clear = function () {\n        this.log.info(LOG_PREFIX + 'Flushing Splits data from localStorage');\n        // collect item keys\n        var len = localStorage.length;\n        var accum = [];\n        for (var cur = 0; cur < len; cur++) {\n            var key = localStorage.key(cur);\n            if (key != null && this.keys.isSplitsCacheKey(key))\n                accum.push(key);\n        }\n        // remove items\n        accum.forEach(function (key) {\n            localStorage.removeItem(key);\n        });\n        this.hasSync = false;\n    };\n    SplitsCacheInLocal.prototype.addSplit = function (name, split) {\n        try {\n            var splitKey = this.keys.buildSplitKey(name);\n            var splitFromLocalStorage = localStorage.getItem(splitKey);\n            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;\n            this._decrementCounts(previousSplit);\n            localStorage.setItem(splitKey, JSON.stringify(split));\n            this._incrementCounts(split);\n            return true;\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n            return false;\n        }\n    };\n    SplitsCacheInLocal.prototype.removeSplit = function (name) {\n        try {\n            var split = this.getSplit(name);\n            localStorage.removeItem(this.keys.buildSplitKey(name));\n            this._decrementCounts(split);\n            return true;\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n            return false;\n        }\n    };\n    SplitsCacheInLocal.prototype.getSplit = function (name) {\n        var item = localStorage.getItem(this.keys.buildSplitKey(name));\n        return item && JSON.parse(item);\n    };\n    SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {\n        // when cache is ready but using a new split query, we must clear all split data\n        if (this.cacheReadyButNeedsToFlush) {\n            this.clear();\n            this.cacheReadyButNeedsToFlush = false;\n        }\n        // when using a new split query, we must update it at the store\n        if (this.updateNewFilter) {\n            this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');\n            var queryKey = this.keys.buildSplitsFilterQueryKey();\n            var queryString = this.splitFiltersValidation.queryString;\n            try {\n                if (queryString)\n                    localStorage.setItem(queryKey, queryString);\n                else\n                    localStorage.removeItem(queryKey);\n            }\n            catch (e) {\n                this.log.error(LOG_PREFIX + e);\n            }\n            this.updateNewFilter = false;\n        }\n        try {\n            localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');\n            // update \"last updated\" timestamp with current time\n            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');\n            this.hasSync = true;\n            return true;\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n            return false;\n        }\n    };\n    SplitsCacheInLocal.prototype.getChangeNumber = function () {\n        var n = -1;\n        var value = localStorage.getItem(this.keys.buildSplitsTillKey());\n        if (value !== null) {\n            value = parseInt(value, 10);\n            return isNaNNumber(value) ? n : value;\n        }\n        return n;\n    };\n    SplitsCacheInLocal.prototype.getSplitNames = function () {\n        var len = localStorage.length;\n        var accum = [];\n        var cur = 0;\n        while (cur < len) {\n            var key = localStorage.key(cur);\n            if (key != null && this.keys.isSplitKey(key))\n                accum.push(this.keys.extractKey(key));\n            cur++;\n        }\n        return accum;\n    };\n    SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {\n        var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));\n        return isFiniteNumber(ttCount) && ttCount > 0;\n    };\n    SplitsCacheInLocal.prototype.usesSegments = function () {\n        // If cache hasn't been synchronized with the cloud, assume we need them.\n        if (!this.hasSync)\n            return true;\n        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());\n        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);\n        if (isFiniteNumber(splitsWithSegmentsCount)) {\n            return splitsWithSegmentsCount > 0;\n        }\n        else {\n            return true;\n        }\n    };\n    /**\n     * Check if the splits information is already stored in browser LocalStorage.\n     * In this function we could add more code to check if the data is valid.\n     * @override\n     */\n    SplitsCacheInLocal.prototype.checkCache = function () {\n        return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;\n    };\n    /**\n     * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,\n     *\n     * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned\n     */\n    SplitsCacheInLocal.prototype._checkExpiration = function (expirationTimestamp) {\n        var value = localStorage.getItem(this.keys.buildLastUpdatedKey());\n        if (value !== null) {\n            value = parseInt(value, 10);\n            if (!isNaNNumber(value) && expirationTimestamp && value < expirationTimestamp)\n                this.clear();\n        }\n    };\n    SplitsCacheInLocal.prototype._checkFilterQuery = function () {\n        var _this = this;\n        var _a = this.splitFiltersValidation, queryString = _a.queryString, groupedFilters = _a.groupedFilters;\n        var queryKey = this.keys.buildSplitsFilterQueryKey();\n        var currentQueryString = localStorage.getItem(queryKey);\n        if (currentQueryString !== queryString) {\n            try {\n                // mark cache to update the new query filter on first successful splits fetch\n                this.updateNewFilter = true;\n                // if cache is ready:\n                if (this.checkCache()) {\n                    // * set change number to -1, to fetch splits with -1 `since` value.\n                    localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');\n                    // * remove from cache splits that doesn't match with the new filters\n                    this.getSplitNames().forEach(function (splitName) {\n                        if (queryString && (\n                        // @TODO consider redefining `groupedFilters` to expose a method like `groupedFilters::filter(splitName): boolean`\n                        groupedFilters.byName.indexOf(splitName) > -1 ||\n                            groupedFilters.byPrefix.some(function (prefix) { return splitName.startsWith(prefix + '__'); }))) {\n                            // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is cleared before updating on first successful splits fetch\n                            _this.cacheReadyButNeedsToFlush = true;\n                            return;\n                        }\n                        _this.removeSplit(splitName);\n                    });\n                }\n            }\n            catch (e) {\n                this.log.error(LOG_PREFIX + e);\n            }\n        }\n        // if the filter didn't change, nothing is done\n    };\n    return SplitsCacheInLocal;\n}(AbstractSplitsCacheSync));\nexport { SplitsCacheInLocal };\n","/**\n * This class provides a skeletal implementation of the ISegmentsCacheSync interface\n * to minimize the effort required to implement this interface.\n */\nvar AbstractSegmentsCacheSync = /** @class */ (function () {\n    function AbstractSegmentsCacheSync() {\n    }\n    /**\n     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.\n     * For client-side synchronizer: the method is not used.\n     */\n    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };\n    /**\n     * For server-side synchronizer: set the change number of `name` segment.\n     * For client-side synchronizer: the method is not used.\n     */\n    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };\n    /**\n     * For server-side synchronizer: get the change number of `name` segment.\n     * For client-side synchronizer: the method is not used.\n     */\n    AbstractSegmentsCacheSync.prototype.getChangeNumber = function (name) { return -1; };\n    /**\n     * For server-side synchronizer: the method is not used.\n     * For client-side synchronizer: reset the cache with the given list of segments.\n     */\n    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };\n    return AbstractSegmentsCacheSync;\n}());\nexport { AbstractSegmentsCacheSync };\n","import { __extends } from \"tslib\";\nimport { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';\nimport { LOG_PREFIX, DEFINED } from './constants';\nvar MySegmentsCacheInLocal = /** @class */ (function (_super) {\n    __extends(MySegmentsCacheInLocal, _super);\n    function MySegmentsCacheInLocal(log, keys) {\n        var _this = _super.call(this) || this;\n        _this.log = log;\n        _this.keys = keys;\n        return _this;\n        // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments\n    }\n    /**\n     * Removes list of segments from localStorage\n     * @NOTE this method is not being used at the moment.\n     */\n    MySegmentsCacheInLocal.prototype.clear = function () {\n        this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');\n        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage\n        // We could optimize next sentence, since it implies iterating over all localStorage items\n        this.resetSegments([]);\n    };\n    MySegmentsCacheInLocal.prototype.addToSegment = function (name) {\n        var segmentKey = this.keys.buildSegmentNameKey(name);\n        try {\n            localStorage.setItem(segmentKey, DEFINED);\n            return true;\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n            return false;\n        }\n    };\n    MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {\n        var segmentKey = this.keys.buildSegmentNameKey(name);\n        try {\n            localStorage.removeItem(segmentKey);\n            return true;\n        }\n        catch (e) {\n            this.log.error(LOG_PREFIX + e);\n            return false;\n        }\n    };\n    MySegmentsCacheInLocal.prototype.isInSegment = function (name) {\n        return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;\n    };\n    /**\n     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.\n     *\n     * @param {string[]} segmentNames list of segment names\n     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)\n     */\n    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {\n        var _this = this;\n        var isDiff = false;\n        var index;\n        // Scan current values from localStorage\n        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {\n            var segmentName = _this.keys.extractSegmentName(key);\n            if (segmentName) {\n                accum.push(segmentName);\n            }\n            else {\n                // @TODO @BREAKING: This is only to clean up \"old\" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.\n                segmentName = _this.keys.extractOldSegmentKey(key);\n                if (segmentName) { // this was an old segment key, let's clean up.\n                    var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);\n                    try {\n                        // If the new format key is not there, create it.\n                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {\n                            localStorage.setItem(newSegmentKey, DEFINED);\n                            // we are migrating a segment, let's track it.\n                            accum.push(segmentName);\n                        }\n                        localStorage.removeItem(key); // we migrated the current key, let's delete it.\n                    }\n                    catch (e) {\n                        _this.log.error(e);\n                    }\n                }\n            }\n            return accum;\n        }, []);\n        // Extreme fast => everything is empty\n        if (names.length === 0 && storedSegmentNames.length === names.length)\n            return isDiff;\n        // Quick path\n        if (storedSegmentNames.length !== names.length) {\n            isDiff = true;\n            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });\n            names.forEach(function (name) { return _this.addToSegment(name); });\n        }\n        else {\n            // Slowest path => we need to find at least 1 difference because\n            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {\n                // TODO: why empty statement?\n            }\n            if (index < names.length) {\n                isDiff = true;\n                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });\n                names.forEach(function (name) { return _this.addToSegment(name); });\n            }\n        }\n        return isDiff;\n    };\n    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {\n        var _this = this;\n        return Object.keys(localStorage).reduce(function (accum, key) {\n            var segmentName = _this.keys.extractSegmentName(key);\n            if (segmentName)\n                accum.push(segmentName);\n            return accum;\n        }, []);\n    };\n    MySegmentsCacheInLocal.prototype.getKeysCount = function () {\n        return 1;\n    };\n    return MySegmentsCacheInLocal;\n}(AbstractSegmentsCacheSync));\nexport { MySegmentsCacheInLocal };\n","import { __extends } from \"tslib\";\nimport { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';\n/**\n * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.\n * Supported by all JS runtimes.\n */\nvar MySegmentsCacheInMemory = /** @class */ (function (_super) {\n    __extends(MySegmentsCacheInMemory, _super);\n    function MySegmentsCacheInMemory() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.segmentCache = {};\n        return _this;\n    }\n    MySegmentsCacheInMemory.prototype.clear = function () {\n        this.segmentCache = {};\n    };\n    MySegmentsCacheInMemory.prototype.addToSegment = function (name) {\n        this.segmentCache[name] = true;\n        return true;\n    };\n    MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {\n        delete this.segmentCache[name];\n        return true;\n    };\n    MySegmentsCacheInMemory.prototype.isInSegment = function (name) {\n        return this.segmentCache[name] === true;\n    };\n    /**\n     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.\n     * @NOTE based on the way we use segments in the browser, this way is the best option\n     *\n     * @param {string[]} names list of segment names\n     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)\n     */\n    MySegmentsCacheInMemory.prototype.resetSegments = function (names) {\n        var _this = this;\n        var isDiff = false;\n        var index;\n        var storedSegmentKeys = Object.keys(this.segmentCache);\n        // Extreme fast => everything is empty\n        if (names.length === 0 && storedSegmentKeys.length === names.length)\n            return isDiff;\n        // Quick path\n        if (storedSegmentKeys.length !== names.length) {\n            isDiff = true;\n            this.segmentCache = {};\n            names.forEach(function (s) {\n                _this.addToSegment(s);\n            });\n        }\n        else {\n            // Slowest path => we need to find at least 1 difference because\n            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {\n                // TODO: why empty statement?\n            }\n            if (index < names.length) {\n                isDiff = true;\n                this.segmentCache = {};\n                names.forEach(function (s) {\n                    _this.addToSegment(s);\n                });\n            }\n        }\n        return isDiff;\n    };\n    MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {\n        return Object.keys(this.segmentCache);\n    };\n    MySegmentsCacheInMemory.prototype.getKeysCount = function () {\n        return 1;\n    };\n    return MySegmentsCacheInMemory;\n}(AbstractSegmentsCacheSync));\nexport { MySegmentsCacheInMemory };\n","import { __extends } from \"tslib\";\nimport { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';\nimport { isFiniteNumber } from '../../utils/lang';\n/**\n * Default ISplitsCacheSync implementation that stores split definitions in memory.\n * Supported by all JS runtimes.\n */\nvar SplitsCacheInMemory = /** @class */ (function (_super) {\n    __extends(SplitsCacheInMemory, _super);\n    function SplitsCacheInMemory() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.splitsCache = {};\n        _this.ttCache = {};\n        _this.changeNumber = -1;\n        _this.splitsWithSegmentsCount = 0;\n        return _this;\n    }\n    SplitsCacheInMemory.prototype.clear = function () {\n        this.splitsCache = {};\n        this.ttCache = {};\n        this.changeNumber = -1;\n        this.splitsWithSegmentsCount = 0;\n    };\n    SplitsCacheInMemory.prototype.addSplit = function (name, split) {\n        var previousSplit = this.getSplit(name);\n        if (previousSplit) { // We had this Split already\n            if (previousSplit.trafficTypeName) {\n                var previousTtName = previousSplit.trafficTypeName;\n                this.ttCache[previousTtName]--;\n                if (!this.ttCache[previousTtName])\n                    delete this.ttCache[previousTtName];\n            }\n            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.\n                this.splitsWithSegmentsCount--;\n            }\n        }\n        if (split) {\n            // Store the Split.\n            this.splitsCache[name] = split;\n            // Update TT cache\n            var ttName = split.trafficTypeName;\n            if (ttName) { // safeguard\n                if (!this.ttCache[ttName])\n                    this.ttCache[ttName] = 0;\n                this.ttCache[ttName]++;\n            }\n            // Add to segments count for the new version of the Split\n            if (usesSegments(split))\n                this.splitsWithSegmentsCount++;\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    SplitsCacheInMemory.prototype.removeSplit = function (name) {\n        var split = this.getSplit(name);\n        if (split) {\n            // Delete the Split\n            delete this.splitsCache[name];\n            var ttName = split.trafficTypeName;\n            if (ttName) { // safeguard\n                this.ttCache[ttName]--; // Update tt cache\n                if (!this.ttCache[ttName])\n                    delete this.ttCache[ttName];\n            }\n            // Update the segments count.\n            if (usesSegments(split))\n                this.splitsWithSegmentsCount--;\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    SplitsCacheInMemory.prototype.getSplit = function (name) {\n        return this.splitsCache[name] || null;\n    };\n    SplitsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {\n        this.changeNumber = changeNumber;\n        return true;\n    };\n    SplitsCacheInMemory.prototype.getChangeNumber = function () {\n        return this.changeNumber;\n    };\n    SplitsCacheInMemory.prototype.getSplitNames = function () {\n        return Object.keys(this.splitsCache);\n    };\n    SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {\n        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;\n    };\n    SplitsCacheInMemory.prototype.usesSegments = function () {\n        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;\n    };\n    return SplitsCacheInMemory;\n}(AbstractSplitsCacheSync));\nexport { SplitsCacheInMemory };\n","// Integration types\nexport var GOOGLE_ANALYTICS_TO_SPLIT = 'GOOGLE_ANALYTICS_TO_SPLIT';\nexport var SPLIT_TO_GOOGLE_ANALYTICS = 'SPLIT_TO_GOOGLE_ANALYTICS';\n// This value might be eventually set via a config parameter\nexport var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days\n","import { isNaNNumber } from '../utils/lang';\nvar MIN = 0;\nvar MAX = 22;\nvar BASE = 1.5;\n/**\n * Calculates buckets from latency in milliseconds\n *\n * @param latencyInMs\n * @returns a bucket index from 0 to 22 inclusive\n */\nexport function findLatencyIndex(latencyInMs) {\n    var index = Math.min(MAX, Math.max(MIN, Math.ceil(Math.log(latencyInMs) / Math.log(BASE))));\n    return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number\n}\n","import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';\nimport { findLatencyIndex } from '../findLatencyIndex';\nvar MAX_STREAMING_EVENTS = 20;\nvar MAX_TAGS = 10;\nexport var MAX_LATENCY_BUCKET_COUNT = 23;\nexport function newBuckets() {\n    // MAX_LATENCY_BUCKET_COUNT (length) is 23\n    // Not using Array.fill for old browsers compatibility\n    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n}\nvar ACCEPTANCE_RANGE = 0.001;\n/**\n * Record telemetry if mode is not localhost.\n * All factory instances track telemetry on server-side, and 0.1% on client-side.\n */\nexport function shouldRecordTelemetry(_a) {\n    var settings = _a.settings;\n    return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);\n}\nvar TelemetryCacheInMemory = /** @class */ (function () {\n    function TelemetryCacheInMemory(splits, segments) {\n        this.splits = splits;\n        this.segments = segments;\n        // isEmpty flag\n        this.e = true;\n        this.notReadyUsage = 0;\n        /** Usage stats */\n        this.impressionStats = [0, 0, 0];\n        this.eventStats = [0, 0];\n        this.lastSync = {};\n        this.httpErrors = {};\n        this.httpLatencies = {};\n        this.authRejections = 0;\n        this.tokenRefreshes = 0;\n        this.streamingEvents = [];\n        this.tags = [];\n        this.exceptions = {};\n        this.latencies = {};\n    }\n    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };\n    TelemetryCacheInMemory.prototype.clear = function () { };\n    TelemetryCacheInMemory.prototype.pop = function () {\n        this.e = true;\n        return {\n            lS: this.getLastSynchronization(),\n            mL: this.popLatencies(),\n            mE: this.popExceptions(),\n            hE: this.popHttpErrors(),\n            hL: this.popHttpLatencies(),\n            tR: this.popTokenRefreshes(),\n            aR: this.popAuthRejections(),\n            iQ: this.getImpressionStats(QUEUED),\n            iDe: this.getImpressionStats(DEDUPED),\n            iDr: this.getImpressionStats(DROPPED),\n            spC: this.splits && this.splits.getSplitNames().length,\n            seC: this.segments && this.segments.getRegisteredSegments().length,\n            skC: this.segments && this.segments.getKeysCount(),\n            sL: this.getSessionLength(),\n            eQ: this.getEventStats(QUEUED),\n            eD: this.getEventStats(DROPPED),\n            sE: this.popStreamingEvents(),\n            t: this.popTags(),\n        };\n    };\n    TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {\n        return this.timeUntilReady;\n    };\n    TelemetryCacheInMemory.prototype.recordTimeUntilReady = function (ms) {\n        this.timeUntilReady = ms;\n    };\n    TelemetryCacheInMemory.prototype.getTimeUntilReadyFromCache = function () {\n        return this.timeUntilReadyFromCache;\n    };\n    TelemetryCacheInMemory.prototype.recordTimeUntilReadyFromCache = function (ms) {\n        this.timeUntilReadyFromCache = ms;\n    };\n    TelemetryCacheInMemory.prototype.getNonReadyUsage = function () {\n        return this.notReadyUsage;\n    };\n    TelemetryCacheInMemory.prototype.recordNonReadyUsage = function () {\n        this.notReadyUsage++;\n    };\n    TelemetryCacheInMemory.prototype.getImpressionStats = function (type) {\n        return this.impressionStats[type];\n    };\n    TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {\n        this.impressionStats[type] += count;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.getEventStats = function (type) {\n        return this.eventStats[type];\n    };\n    TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {\n        this.eventStats[type] += count;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.getLastSynchronization = function () {\n        return this.lastSync;\n    };\n    TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {\n        this.lastSync[resource] = timeMs;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popHttpErrors = function () {\n        var result = this.httpErrors;\n        this.httpErrors = {};\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {\n        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});\n        statusErrors[status] = (statusErrors[status] || 0) + 1;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popHttpLatencies = function () {\n        var result = this.httpLatencies;\n        this.httpLatencies = {};\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {\n        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());\n        latencyBuckets[findLatencyIndex(latencyMs)]++;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popAuthRejections = function () {\n        var result = this.authRejections;\n        this.authRejections = 0;\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordAuthRejections = function () {\n        this.authRejections++;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {\n        var result = this.tokenRefreshes;\n        this.tokenRefreshes = 0;\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {\n        this.tokenRefreshes++;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popStreamingEvents = function () {\n        return this.streamingEvents.splice(0);\n    };\n    TelemetryCacheInMemory.prototype.recordStreamingEvents = function (streamingEvent) {\n        if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {\n            this.streamingEvents.push(streamingEvent);\n        }\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popTags = function () {\n        return this.tags.splice(0);\n    };\n    TelemetryCacheInMemory.prototype.addTag = function (tag) {\n        if (this.tags.length < MAX_TAGS) {\n            this.tags.push(tag);\n        }\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.getSessionLength = function () {\n        return this.sessionLength;\n    };\n    TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {\n        this.sessionLength = ms;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popExceptions = function () {\n        var result = this.exceptions;\n        this.exceptions = {};\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordException = function (method) {\n        this.exceptions[method] = (this.exceptions[method] || 0) + 1;\n        this.e = false;\n    };\n    TelemetryCacheInMemory.prototype.popLatencies = function () {\n        var result = this.latencies;\n        this.latencies = {};\n        return result;\n    };\n    TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {\n        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());\n        latencyBuckets[findLatencyIndex(latencyMs)]++;\n        this.e = false;\n    };\n    return TelemetryCacheInMemory;\n}());\nexport { TelemetryCacheInMemory };\n","import { setToArray, _Set } from '../../utils/lang/sets';\nimport { DEFAULT_CACHE_SIZE } from '../inRedis/constants';\nvar UniqueKeysCacheInMemoryCS = /** @class */ (function () {\n    /**\n     *\n     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.\n     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.\n     */\n    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {\n        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }\n        this.uniqueTrackerSize = 0;\n        this.uniqueKeysTracker = {};\n        this.maxStorage = uniqueKeysQueueSize;\n    }\n    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {\n        this.onFullQueue = cb;\n    };\n    /**\n     * Store unique keys per feature.\n     */\n    UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {\n        if (!this.uniqueKeysTracker[userKey])\n            this.uniqueKeysTracker[userKey] = new _Set();\n        var tracker = this.uniqueKeysTracker[userKey];\n        if (!tracker.has(featureName)) {\n            tracker.add(featureName);\n            this.uniqueTrackerSize++;\n        }\n        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {\n            this.onFullQueue();\n        }\n    };\n    /**\n     * Clear the data stored on the cache.\n     */\n    UniqueKeysCacheInMemoryCS.prototype.clear = function () {\n        this.uniqueTrackerSize = 0;\n        this.uniqueKeysTracker = {};\n    };\n    /**\n     * Pop the collected data, used as payload for posting.\n     */\n    UniqueKeysCacheInMemoryCS.prototype.pop = function () {\n        var data = this.uniqueKeysTracker;\n        this.clear();\n        return this.fromUniqueKeysCollector(data);\n    };\n    /**\n     * Check if the cache is empty.\n     */\n    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {\n        return Object.keys(this.uniqueKeysTracker).length === 0;\n    };\n    /**\n     * Converts `uniqueKeys` data from cache into request payload.\n     */\n    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {\n        var payload = [];\n        var userKeys = Object.keys(uniqueKeys);\n        for (var k = 0; k < userKeys.length; k++) {\n            var userKey = userKeys[k];\n            var featureNames = setToArray(uniqueKeys[userKey]);\n            var uniqueKeysPayload = {\n                k: userKey,\n                fs: featureNames\n            };\n            payload.push(uniqueKeysPayload);\n        }\n        return { keys: payload };\n    };\n    return UniqueKeysCacheInMemoryCS;\n}());\nexport { UniqueKeysCacheInMemoryCS };\n","import { SplitsCacheInMemory } from './SplitsCacheInMemory';\nimport { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';\nimport { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';\nimport { EventsCacheInMemory } from './EventsCacheInMemory';\nimport { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';\nimport { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';\nimport { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';\nimport { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';\n/**\n * InMemory storage factory for standalone client-side SplitFactory\n *\n * @param params parameters required by EventsCacheSync\n */\nexport function InMemoryStorageCSFactory(params) {\n    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;\n    var splits = new SplitsCacheInMemory();\n    var segments = new MySegmentsCacheInMemory();\n    var storage = {\n        splits: splits,\n        segments: segments,\n        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),\n        impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,\n        events: new EventsCacheInMemory(eventsQueueSize),\n        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,\n        uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,\n        // When using MEMORY we should clean all the caches to leave them empty\n        destroy: function () {\n            this.splits.clear();\n            this.segments.clear();\n            this.impressions.clear();\n            this.impressionCounts && this.impressionCounts.clear();\n            this.events.clear();\n            this.uniqueKeys && this.uniqueKeys.clear();\n        },\n        // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)\n        shared: function () {\n            return {\n                splits: this.splits,\n                segments: new MySegmentsCacheInMemory(),\n                impressions: this.impressions,\n                impressionCounts: this.impressionCounts,\n                events: this.events,\n                telemetry: this.telemetry,\n                // Set a new splits cache to clean it for the client without affecting other clients\n                destroy: function () {\n                    this.splits = new SplitsCacheInMemory();\n                    this.segments.clear();\n                }\n            };\n        },\n    };\n    // @TODO revisit storage logic in localhost mode\n    // No tracking data in localhost mode to avoid memory leaks\n    if (params.settings.mode === LOCALHOST_MODE) {\n        var noopTrack = function () { return true; };\n        storage.impressions.track = noopTrack;\n        storage.events.track = noopTrack;\n        if (storage.impressionCounts)\n            storage.impressionCounts.track = noopTrack;\n        if (storage.uniqueKeys)\n            storage.uniqueKeys.track = noopTrack;\n    }\n    return storage;\n}\nInMemoryStorageCSFactory.type = STORAGE_MEMORY;\n","import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';\nimport { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';\nimport { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';\nimport { validatePrefix } from '../KeyBuilder';\nimport { KeyBuilderCS } from '../KeyBuilderCS';\nimport { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';\nimport { SplitsCacheInLocal } from './SplitsCacheInLocal';\nimport { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';\nimport { MySegmentsCacheInMemory } from '../inMemory/MySegmentsCacheInMemory';\nimport { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';\nimport { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';\nimport { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';\nimport { LOG_PREFIX } from './constants';\nimport { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';\nimport { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';\nimport { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';\nimport { getMatching } from '../../utils/key';\n/**\n * InLocal storage factory for standalone client-side SplitFactory\n */\nexport function InLocalStorage(options) {\n    if (options === void 0) { options = {}; }\n    var prefix = validatePrefix(options.prefix);\n    function InLocalStorageCSFactory(params) {\n        // Fallback to InMemoryStorage if LocalStorage API is not available\n        if (!isLocalStorageAvailable()) {\n            params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');\n            return InMemoryStorageCSFactory(params);\n        }\n        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;\n        var matchingKey = getMatching(settings.core.key);\n        var keys = new KeyBuilderCS(prefix, matchingKey);\n        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;\n        var splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);\n        var segments = new MySegmentsCacheInLocal(log, keys);\n        return {\n            splits: splits,\n            segments: segments,\n            impressions: new ImpressionsCacheInMemory(impressionsQueueSize),\n            impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,\n            events: new EventsCacheInMemory(eventsQueueSize),\n            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,\n            uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,\n            destroy: function () {\n                var _a;\n                this.splits = new SplitsCacheInMemory();\n                this.segments = new MySegmentsCacheInMemory();\n                this.impressions.clear();\n                this.impressionCounts && this.impressionCounts.clear();\n                this.events.clear();\n                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();\n            },\n            // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).\n            shared: function (matchingKey) {\n                var childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);\n                return {\n                    splits: this.splits,\n                    segments: new MySegmentsCacheInLocal(log, childKeysBuilder),\n                    impressions: this.impressions,\n                    impressionCounts: this.impressionCounts,\n                    events: this.events,\n                    telemetry: this.telemetry,\n                    destroy: function () {\n                        this.splits = new SplitsCacheInMemory();\n                        this.segments = new MySegmentsCacheInMemory();\n                    }\n                };\n            },\n        };\n    }\n    InLocalStorageCSFactory.type = STORAGE_LOCALSTORAGE;\n    return InLocalStorageCSFactory;\n}\n","// returns true if the given value is a thenable object\nexport function thenable(o) {\n    return o !== undefined && o !== null && typeof o.then === 'function';\n}\n","import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';\nexport function validateIfNotDestroyed(log, readinessManager, method) {\n    if (!readinessManager.isDestroyed())\n        return true;\n    log.error(ERROR_CLIENT_DESTROYED, [method]);\n    return false;\n}\nexport function validateIfOperational(log, readinessManager, method) {\n    if (readinessManager.isReady() || readinessManager.isReadyFromCache())\n        return true;\n    log.warn(CLIENT_NOT_READY, [method]);\n    return false;\n}\n","export var SPLIT_KILLED = 'killed';\nexport var NO_CONDITION_MATCH = 'default rule';\nexport var SPLIT_NOT_FOUND = 'definition not found';\nexport var SDK_NOT_READY = 'not ready';\nexport var EXCEPTION = 'exception';\nexport var SPLIT_ARCHIVED = 'archived';\nexport var NOT_IN_SPLIT = 'not in split';\n","import { SPLIT_NOT_FOUND } from '../labels';\nimport { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';\n/**\n * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.\n * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.\n */\nexport function validateSplitExistance(log, readinessManager, splitName, labelOrSplitObj, method) {\n    if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.\n        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {\n            log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);\n            return false;\n        }\n    }\n    return true;\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { thenable } from '../utils/promise/thenable';\nimport { find } from '../utils/lang';\nimport { validateSplit, validateSplitExistance, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';\nfunction collectTreatments(splitObject) {\n    var conditions = splitObject.conditions;\n    // Rollout conditions are supposed to have the entire partitions list, so we find the first one.\n    var allTreatmentsCondition = find(conditions, function (cond) { return cond.conditionType === 'ROLLOUT'; });\n    // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.\n    if (!allTreatmentsCondition)\n        allTreatmentsCondition = conditions[0];\n    // Then extract the treatments from the partitions\n    return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) { return v.treatment; }) : [];\n}\nfunction objectToView(splitObject) {\n    if (!splitObject)\n        return null;\n    return {\n        name: splitObject.name,\n        trafficType: splitObject.trafficTypeName,\n        killed: splitObject.killed,\n        changeNumber: splitObject.changeNumber || 0,\n        treatments: collectTreatments(splitObject),\n        configs: splitObject.configurations || {}\n    };\n}\nfunction objectsToViews(splitObjects) {\n    var views = [];\n    splitObjects.forEach(function (split) {\n        var view = objectToView(split);\n        if (view)\n            views.push(view);\n    });\n    return views;\n}\nexport function sdkManagerFactory(log, splits, _a) {\n    var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;\n    var SPLIT_FN_LABEL = 'split';\n    return objectAssign(\n    // Proto-linkage of the readiness Event Emitter\n    Object.create(sdkStatus), {\n        /**\n         * Get the Split object corresponding to the given split name if valid\n         */\n        split: function (maybeSplitName) {\n            var splitName = validateSplit(log, maybeSplitName, SPLIT_FN_LABEL);\n            if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {\n                return null;\n            }\n            var split = splits.getSplit(splitName);\n            if (thenable(split)) {\n                return split.catch(function () { return null; }).then(function (result) {\n                    validateSplitExistance(log, readinessManager, splitName, result, SPLIT_FN_LABEL);\n                    return objectToView(result);\n                });\n            }\n            validateSplitExistance(log, readinessManager, splitName, split, SPLIT_FN_LABEL);\n            return objectToView(split);\n        },\n        /**\n         * Get the Split objects present on the factory storage\n         */\n        splits: function () {\n            if (!validateIfNotDestroyed(log, readinessManager, 'splits') || !validateIfOperational(log, readinessManager, 'splits')) {\n                return [];\n            }\n            var currentSplits = splits.getAll();\n            return thenable(currentSplits) ?\n                currentSplits.catch(function () { return []; }).then(objectsToViews) : // handle possible rejections when using pluggable storage\n                objectsToViews(currentSplits);\n        },\n        /**\n         * Get the Split names present on the factory storage\n         */\n        names: function () {\n            if (!validateIfNotDestroyed(log, readinessManager, 'names') || !validateIfOperational(log, readinessManager, 'names')) {\n                return [];\n            }\n            var splitNames = splits.getSplitNames();\n            return thenable(splitNames) ?\n                splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage\n                splitNames;\n        }\n    });\n}\n","import { objectAssign } from '../../utils/lang/objectAssign';\nvar AttributesCacheInMemory = /** @class */ (function () {\n    function AttributesCacheInMemory() {\n        this.attributesCache = {};\n    }\n    /**\n     * Create or update the value for the given attribute\n     *\n     * @param {string} attributeName attribute name\n     * @param {Object} attributeValue attribute value\n     * @returns {boolean} the attribute was stored\n     */\n    AttributesCacheInMemory.prototype.setAttribute = function (attributeName, attributeValue) {\n        this.attributesCache[attributeName] = attributeValue;\n        return true;\n    };\n    /**\n     * Retrieves the value of a given attribute\n     *\n     * @param {string} attributeName attribute name\n     * @returns {Object?} stored attribute value\n     */\n    AttributesCacheInMemory.prototype.getAttribute = function (attributeName) {\n        return this.attributesCache[attributeName];\n    };\n    /**\n     * Create or update all the given attributes\n     *\n     * @param {[string, Object]} attributes attributes to create or update\n     * @returns {boolean} attributes were stored\n     */\n    AttributesCacheInMemory.prototype.setAttributes = function (attributes) {\n        this.attributesCache = objectAssign(this.attributesCache, attributes);\n        return true;\n    };\n    /**\n     * Retrieve the full attributes map\n     *\n     * @returns {Map<string, Object>} stored attributes\n     */\n    AttributesCacheInMemory.prototype.getAll = function () {\n        return this.attributesCache;\n    };\n    /**\n     * Removes a given attribute from the map\n     *\n     * @param {string} attributeName attribute to remove\n     * @returns {boolean} attribute removed\n     */\n    AttributesCacheInMemory.prototype.removeAttribute = function (attributeName) {\n        if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {\n            delete this.attributesCache[attributeName];\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Clears all attributes stored in the SDK\n     *\n     */\n    AttributesCacheInMemory.prototype.clear = function () {\n        this.attributesCache = {};\n        return true;\n    };\n    return AttributesCacheInMemory;\n}());\nexport { AttributesCacheInMemory };\n","import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';\nexport function validateAttribute(log, attributeKey, attributeValue, method) {\n    if (!isString(attributeKey) || attributeKey.length === 0) {\n        log.warn(method + \": you passed an invalid attribute name, attribute name must be a non-empty string.\");\n        return false;\n    }\n    var isStringVal = isString(attributeValue);\n    var isFiniteVal = isFiniteNumber(attributeValue);\n    var isBoolVal = isBoolean(attributeValue);\n    var isArrayVal = Array.isArray(attributeValue);\n    if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.\n        log.warn(method + \": you passed an invalid attribute value for \" + attributeKey + \". Acceptable types are: string, number, boolean and array of strings.\");\n        return false;\n    }\n    return true;\n}\n","import { isObject } from '../lang';\nimport { validateAttribute } from './attribute';\nimport { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';\nexport function validateAttributes(log, maybeAttrs, method) {\n    // Attributes are optional\n    if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq\n        return maybeAttrs;\n    log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);\n    return false;\n}\nexport function validateAttributesDeep(log, maybeAttributes, method) {\n    if (!validateAttributes(log, maybeAttributes, method))\n        return false;\n    var result = true;\n    Object.keys(maybeAttributes).forEach(function (attributeKey) {\n        if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))\n            result = false;\n    });\n    return result;\n}\n","import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';\nimport { validateAttributesDeep } from '../utils/inputValidation/attributes';\nimport { objectAssign } from '../utils/lang/objectAssign';\n/**\n * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call\n */\nexport function clientAttributesDecoration(log, client) {\n    var attributeStorage = new AttributesCacheInMemory();\n    // Keep a reference to the original methods\n    var clientGetTreatment = client.getTreatment;\n    var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;\n    var clientGetTreatments = client.getTreatments;\n    var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;\n    var clientTrack = client.track;\n    function getTreatment(maybeKey, maybeSplit, maybeAttributes) {\n        return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));\n    }\n    function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {\n        return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));\n    }\n    function getTreatments(maybeKey, maybeSplits, maybeAttributes) {\n        return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));\n    }\n    function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {\n        return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));\n    }\n    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {\n        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);\n    }\n    function combineAttributes(maybeAttributes) {\n        var storedAttributes = attributeStorage.getAll();\n        if (Object.keys(storedAttributes).length > 0) {\n            return objectAssign({}, storedAttributes, maybeAttributes);\n        }\n        return maybeAttributes;\n    }\n    return objectAssign(client, {\n        getTreatment: getTreatment,\n        getTreatmentWithConfig: getTreatmentWithConfig,\n        getTreatments: getTreatments,\n        getTreatmentsWithConfig: getTreatmentsWithConfig,\n        track: track,\n        /**\n         * Add an attribute to client's in memory attributes storage\n         *\n         * @param {string} attributeName Attrinute name\n         * @param {string, number, boolean, list} attributeValue Attribute value\n         * @returns {boolean} true if the attribute was stored and false otherways\n         */\n        setAttribute: function (attributeName, attributeValue) {\n            var attribute = {};\n            attribute[attributeName] = attributeValue;\n            if (!validateAttributesDeep(log, attribute, 'setAttribute'))\n                return false;\n            log.debug(\"stored \" + attributeValue + \" for attribute \" + attributeName);\n            return attributeStorage.setAttribute(attributeName, attributeValue);\n        },\n        /**\n         * Returns the attribute with the given key\n         *\n         * @param {string} attributeName Attribute name\n         * @returns {Object} Attribute with the given key\n         */\n        getAttribute: function (attributeName) {\n            log.debug(\"retrieved attribute \" + attributeName);\n            return attributeStorage.getAttribute(attributeName + '');\n        },\n        /**\n         * Add to client's in memory attributes storage the attributes in 'attributes'\n         *\n         * @param {Object} attributes Object with attributes to store\n         * @returns true if attributes were stored an false otherways\n         */\n        setAttributes: function (attributes) {\n            if (!validateAttributesDeep(log, attributes, 'setAttributes'))\n                return false;\n            return attributeStorage.setAttributes(attributes);\n        },\n        /**\n         * Return all the attributes stored in client's in memory attributes storage\n         *\n         * @returns {Object} returns all the stored attributes\n         */\n        getAttributes: function () {\n            return attributeStorage.getAll();\n        },\n        /**\n         * Removes from client's in memory attributes storage the attribute with the given key\n         *\n         * @param {string} attributeName\n         * @returns {boolean} true if attribute was removed and false otherways\n         */\n        removeAttribute: function (attributeName) {\n            log.debug(\"removed attribute \" + attributeName);\n            return attributeStorage.removeAttribute(attributeName + '');\n        },\n        /**\n         * Remove all the stored attributes in the client's in memory attribute storage\n         */\n        clearAttributes: function () {\n            return attributeStorage.clear();\n        }\n    });\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { clientAttributesDecoration } from './clientAttributesDecoration';\n/**\n * Decorator that binds a key and (optionally) a traffic type to client methods\n *\n * @param client sync client instance\n * @param key validated split key\n * @param trafficType validated traffic type\n */\nexport function clientCSDecorator(log, client, key, trafficType) {\n    var clientCS = clientAttributesDecoration(log, client);\n    return objectAssign(clientCS, {\n        // In the client-side API, we bind a key to the client `getTreatment*` methods\n        getTreatment: clientCS.getTreatment.bind(clientCS, key),\n        getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),\n        getTreatments: clientCS.getTreatments.bind(clientCS, key),\n        getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),\n        // Key is bound to the `track` method. Same thing happens with trafficType but only if provided\n        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),\n        isClientSide: true\n    });\n}\n","export var matcherTypes = {\n    UNDEFINED: 0,\n    ALL_KEYS: 1,\n    IN_SEGMENT: 2,\n    WHITELIST: 3,\n    EQUAL_TO: 4,\n    GREATER_THAN_OR_EQUAL_TO: 5,\n    LESS_THAN_OR_EQUAL_TO: 6,\n    BETWEEN: 7,\n    EQUAL_TO_SET: 8,\n    CONTAINS_ANY_OF_SET: 9,\n    CONTAINS_ALL_OF_SET: 10,\n    PART_OF_SET: 11,\n    ENDS_WITH: 12,\n    STARTS_WITH: 13,\n    CONTAINS_STRING: 14,\n    IN_SPLIT_TREATMENT: 15,\n    EQUAL_TO_BOOLEAN: 16,\n    MATCHES_STRING: 17\n};\nexport var matcherDataTypes = {\n    BOOLEAN: 'BOOLEAN',\n    STRING: 'STRING',\n    NUMBER: 'NUMBER',\n    SET: 'SET',\n    DATETIME: 'DATETIME',\n    NOT_SPECIFIED: 'NOT_SPECIFIED'\n};\nexport function matcherTypesMapper(matcherType) {\n    var type = matcherTypes[matcherType];\n    if (type)\n        return type;\n    else\n        return matcherTypes.UNDEFINED;\n}\n","/**\n * Extract segment name as a plain string.\n */\nexport function segmentTransform(segment) {\n    return segment ? segment.segmentName : undefined;\n}\n","import { _Set } from '../../utils/lang/sets';\n/**\n * Extract whitelist as a set. Used by 'WHITELIST' matcher.\n */\nexport function whitelistTransform(whitelistObject) {\n    return new _Set(whitelistObject.whitelist);\n}\n","/**\n * Extract whitelist array. Used by set and string matchers\n */\nexport function setTransform(whitelistObject) {\n    return whitelistObject.whitelist;\n}\n","/**\n * Extract value from unary matcher data.\n */\nexport function numericTransform(unaryNumericObject) {\n    return unaryNumericObject.value;\n}\n","export function zeroSinceHH(millisSinceEpoch) {\n    return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);\n}\nexport function zeroSinceSS(millisSinceEpoch) {\n    return new Date(millisSinceEpoch).setUTCSeconds(0, 0);\n}\n","import { findIndex } from '../../utils/lang';\nimport { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';\nimport { segmentTransform } from './segment';\nimport { whitelistTransform } from './whitelist';\nimport { setTransform } from './set';\nimport { numericTransform } from './unaryNumeric';\nimport { zeroSinceHH, zeroSinceSS } from '../convertions';\n/**\n * Flat the complex matcherGroup structure into something handy.\n */\nexport function matchersTransform(matchers) {\n    var parsedMatchers = matchers.map(function (matcher) {\n        var matcherType = matcher.matcherType /* string */, negate = matcher.negate /* boolean */, keySelector = matcher.keySelector /* keySelectorObject */, segmentObject = matcher.userDefinedSegmentMatcherData /* segmentObject */, whitelistObject = matcher.whitelistMatcherData /* whiteListObject, provided by 'WHITELIST', set and string matchers */, unaryNumericObject = matcher.unaryNumericMatcherData /* unaryNumericObject */, betweenObject = matcher.betweenMatcherData /* betweenObject */, dependencyObject = matcher.dependencyMatcherData /* dependencyObject */, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData;\n        var attribute = keySelector && keySelector.attribute;\n        var type = matcherTypesMapper(matcherType);\n        // As default input data type we use string (even for ALL_KEYS)\n        var dataType = matcherDataTypes.STRING;\n        var value = undefined;\n        if (type === matcherTypes.IN_SEGMENT) {\n            value = segmentTransform(segmentObject);\n        }\n        else if (type === matcherTypes.WHITELIST) {\n            value = whitelistTransform(whitelistObject);\n        }\n        else if (type === matcherTypes.EQUAL_TO) {\n            value = numericTransform(unaryNumericObject);\n            dataType = matcherDataTypes.NUMBER;\n            if (unaryNumericObject.dataType === 'DATETIME') {\n                value = zeroSinceHH(value);\n                dataType = matcherDataTypes.DATETIME;\n            }\n        }\n        else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||\n            type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {\n            value = numericTransform(unaryNumericObject);\n            dataType = matcherDataTypes.NUMBER;\n            if (unaryNumericObject.dataType === 'DATETIME') {\n                value = zeroSinceSS(value);\n                dataType = matcherDataTypes.DATETIME;\n            }\n        }\n        else if (type === matcherTypes.BETWEEN) {\n            value = betweenObject;\n            dataType = matcherDataTypes.NUMBER;\n            if (value.dataType === 'DATETIME') {\n                value.start = zeroSinceSS(value.start);\n                value.end = zeroSinceSS(value.end);\n                dataType = matcherDataTypes.DATETIME;\n            }\n        }\n        else if (type === matcherTypes.EQUAL_TO_SET ||\n            type === matcherTypes.CONTAINS_ANY_OF_SET ||\n            type === matcherTypes.CONTAINS_ALL_OF_SET ||\n            type === matcherTypes.PART_OF_SET) {\n            value = setTransform(whitelistObject);\n            dataType = matcherDataTypes.SET;\n        }\n        else if (type === matcherTypes.STARTS_WITH ||\n            type === matcherTypes.ENDS_WITH ||\n            type === matcherTypes.CONTAINS_STRING) {\n            value = setTransform(whitelistObject);\n        }\n        else if (type === matcherTypes.IN_SPLIT_TREATMENT) {\n            value = dependencyObject;\n            dataType = matcherDataTypes.NOT_SPECIFIED;\n        }\n        else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {\n            dataType = matcherDataTypes.BOOLEAN;\n            value = booleanMatcherData;\n        }\n        else if (type === matcherTypes.MATCHES_STRING) {\n            value = stringMatcherData;\n        }\n        return {\n            attribute: attribute,\n            negate: negate,\n            type: type,\n            value: value,\n            dataType: dataType // runtime input data type\n        };\n    });\n    if (findIndex(parsedMatchers, function (m) { return m.type === matcherTypes.UNDEFINED; }) === -1) {\n        return parsedMatchers;\n    }\n    else {\n        return [];\n    }\n}\n","import { findIndex } from '../../utils/lang';\nvar Treatments = /** @class */ (function () {\n    function Treatments(ranges, treatments) {\n        if (ranges[ranges.length - 1] !== 100) {\n            throw new RangeError('Provided invalid dataset as input');\n        }\n        this._ranges = ranges;\n        this._treatments = treatments;\n    }\n    Treatments.parse = function (data) {\n        var _a = data.reduce(function (accum, value) {\n            var size = value.size, treatment = value.treatment;\n            accum.ranges.push(accum.inc += size);\n            accum.treatments.push(treatment);\n            return accum;\n        }, {\n            inc: 0,\n            ranges: [],\n            treatments: []\n        }), ranges = _a.ranges, treatments = _a.treatments;\n        return new Treatments(ranges, treatments);\n    };\n    Treatments.prototype.getTreatmentFor = function (x) {\n        if (x < 0 || x > 100) {\n            throw new RangeError('Please provide a value between 0 and 100');\n        }\n        // Readme [1]\n        // We need to manually add any dependency which escape of dummy resolution\n        // I'll deal with this in a future release\n        // for (let [k, r] of this._ranges.entries()) {\n        //   if (x <= r) return this._treatments[k];\n        // }\n        var index = findIndex(this._ranges, function (range) { return x <= range; });\n        var treatment = this._treatments[index];\n        return treatment;\n    };\n    return Treatments;\n}());\nexport { Treatments };\n","import { ENGINE_MATCHER_ALL } from '../../logger/constants';\nexport function allMatcherContext(log) {\n    return function allMatcher(runtimeAttr) {\n        log.debug(ENGINE_MATCHER_ALL);\n        return runtimeAttr != null;\n    };\n}\n","import { thenable } from '../../utils/promise/thenable';\nimport { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';\nexport function segmentMatcherContext(log, segmentName, storage) {\n    return function segmentMatcher(key) {\n        var isInSegment = storage.segments.isInSegment(segmentName, key);\n        if (thenable(isInSegment)) {\n            isInSegment.then(function (result) {\n                log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);\n                return result;\n            });\n        }\n        else {\n            log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);\n        }\n        return isInSegment;\n    };\n}\n","import { setToArray } from '../../utils/lang/sets';\nimport { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';\nexport function whitelistMatcherContext(log, ruleAttr) {\n    return function whitelistMatcher(runtimeAttr) {\n        var isInWhitelist = ruleAttr.has(runtimeAttr);\n        log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]);\n        return isInWhitelist;\n    };\n}\n","import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';\nexport function equalToMatcherContext(log, ruleAttr) {\n    return function equalToMatcher(runtimeAttr) {\n        var isEqual = runtimeAttr === ruleAttr;\n        log.debug(ENGINE_MATCHER_EQUAL, [runtimeAttr, ruleAttr, isEqual]);\n        return isEqual;\n    };\n}\n","import { ENGINE_MATCHER_GREATER } from '../../logger/constants';\nexport function greaterThanEqualMatcherContext(log, ruleAttr) {\n    return function greaterThanEqualMatcher(runtimeAttr) {\n        var isGreaterEqualThan = runtimeAttr >= ruleAttr;\n        log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterEqualThan]);\n        return isGreaterEqualThan;\n    };\n}\n","import { ENGINE_MATCHER_LESS } from '../../logger/constants';\nexport function lessThanEqualMatcherContext(log, ruleAttr) {\n    return function lessThanEqualMatcher(runtimeAttr) {\n        var isLessEqualThan = runtimeAttr <= ruleAttr;\n        log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]);\n        return isLessEqualThan;\n    };\n}\n","import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';\nexport function betweenMatcherContext(log, ruleVO) {\n    return function betweenMatcher(runtimeAttr) {\n        var isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;\n        log.debug(ENGINE_MATCHER_BETWEEN, [runtimeAttr, ruleVO.start, ruleVO.end, isBetween]);\n        return isBetween;\n    };\n}\n","import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';\nimport { findIndex } from '../../utils/lang';\nexport function equalToSetMatcherContext(log, ruleAttr) {\n    return function equalToSetMatcher(runtimeAttr) {\n        // Length being the same is the first condition.\n        var isEqual = runtimeAttr.length === ruleAttr.length;\n        var _loop_1 = function (i) {\n            // if length is the same we check that all elements are present in the other collection.\n            if (findIndex(ruleAttr, function (e) { return e === runtimeAttr[i]; }) < 0)\n                isEqual = false;\n        };\n        for (var i = 0; i < runtimeAttr.length && isEqual; i++) {\n            _loop_1(i);\n        }\n        log.debug(ENGINE_MATCHER_EQUAL_TO_SET, [runtimeAttr, ruleAttr, isEqual]);\n        return isEqual;\n    };\n}\n","import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';\nimport { findIndex } from '../../utils/lang';\nexport function containsAnySetMatcherContext(log, ruleAttr) {\n    return function containsAnyMatcher(runtimeAttr) {\n        var containsAny = false;\n        var _loop_1 = function (i) {\n            if (findIndex(runtimeAttr, function (e) { return e === ruleAttr[i]; }) >= 0)\n                containsAny = true;\n        };\n        for (var i = 0; i < ruleAttr.length && !containsAny; i++) {\n            _loop_1(i);\n        }\n        log.debug(ENGINE_MATCHER_CONTAINS_ANY, [runtimeAttr, ruleAttr, containsAny]);\n        return containsAny;\n    };\n}\n","import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';\nimport { findIndex } from '../../utils/lang';\nexport function containsAllSetMatcherContext(log, ruleAttr) {\n    return function containsAllMatcher(runtimeAttr) {\n        var containsAll = true;\n        if (runtimeAttr.length < ruleAttr.length) {\n            containsAll = false;\n        }\n        else {\n            var _loop_1 = function (i) {\n                if (findIndex(runtimeAttr, function (e) { return e === ruleAttr[i]; }) < 0)\n                    containsAll = false;\n            };\n            for (var i = 0; i < ruleAttr.length && containsAll; i++) {\n                _loop_1(i);\n            }\n        }\n        log.debug(ENGINE_MATCHER_CONTAINS_ALL, [runtimeAttr, ruleAttr, containsAll]);\n        return containsAll;\n    };\n}\n","import { findIndex } from '../../utils/lang';\nimport { ENGINE_MATCHER_PART_OF } from '../../logger/constants';\nexport function partOfSetMatcherContext(log, ruleAttr) {\n    return function partOfMatcher(runtimeAttr) {\n        // To be part of the length should be minor or equal.\n        var isPartOf = runtimeAttr.length <= ruleAttr.length;\n        var _loop_1 = function (i) {\n            // If the length says is possible, we iterate until we prove otherwise or we check all elements.\n            if (findIndex(ruleAttr, function (e) { return e === runtimeAttr[i]; }) < 0)\n                isPartOf = false;\n        };\n        for (var i = 0; i < runtimeAttr.length && isPartOf; i++) {\n            _loop_1(i);\n        }\n        log.debug(ENGINE_MATCHER_PART_OF, [runtimeAttr, ruleAttr, isPartOf]);\n        return isPartOf;\n    };\n}\n","import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';\nimport { endsWith } from '../../utils/lang';\nexport function endsWithMatcherContext(log, ruleAttr) {\n    return function endsWithMatcher(runtimeAttr) {\n        var strEndsWith = ruleAttr.some(function (e) { return endsWith(runtimeAttr, e); });\n        log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);\n        return strEndsWith;\n    };\n}\n","import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';\nimport { startsWith } from '../../utils/lang';\nexport function startsWithMatcherContext(log, ruleAttr) {\n    return function startsWithMatcher(runtimeAttr) {\n        var matches = ruleAttr.some(function (e) { return startsWith(runtimeAttr, e); });\n        log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]);\n        return matches;\n    };\n}\n","import { isString } from '../../utils/lang';\nimport { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';\nexport function containsStringMatcherContext(log, ruleAttr) {\n    return function containsStringMatcher(runtimeAttr) {\n        var contains = ruleAttr.some(function (e) { return isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1; });\n        log.debug(ENGINE_MATCHER_CONTAINS_STRING, [runtimeAttr, ruleAttr, contains]);\n        return contains;\n    };\n}\n","import { thenable } from '../../utils/promise/thenable';\nimport { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';\nexport function dependencyMatcherContext(log, _a, storage) {\n    var split = _a.split, treatments = _a.treatments;\n    function checkTreatment(evaluation, acceptableTreatments, parentName) {\n        var matches = false;\n        if (Array.isArray(acceptableTreatments)) {\n            matches = acceptableTreatments.indexOf(evaluation.treatment) !== -1;\n        }\n        log.debug(ENGINE_MATCHER_DEPENDENCY, [parentName, evaluation.treatment, evaluation.label, parentName, acceptableTreatments, matches]);\n        return matches;\n    }\n    return function dependencyMatcher(_a, splitEvaluator) {\n        var key = _a.key, attributes = _a.attributes;\n        log.debug(ENGINE_MATCHER_DEPENDENCY_PRE, [split, JSON.stringify(key), attributes ? '\\n attributes: ' + JSON.stringify(attributes) : '']);\n        var evaluation = splitEvaluator(log, key, split, attributes, storage);\n        if (thenable(evaluation)) {\n            return evaluation.then(function (ev) { return checkTreatment(ev, treatments, split); });\n        }\n        else {\n            return checkTreatment(evaluation, treatments, split);\n        }\n    };\n}\n","import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';\nexport function booleanMatcherContext(log, ruleAttr) {\n    return function booleanMatcher(runtimeAttr) {\n        var booleanMatches = ruleAttr === runtimeAttr;\n        log.debug(ENGINE_MATCHER_BOOLEAN, [ruleAttr, runtimeAttr]);\n        return booleanMatches;\n    };\n}\n","import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';\nexport function stringMatcherContext(log, ruleAttr) {\n    return function stringMatcher(runtimeAttr) {\n        var re;\n        try {\n            re = new RegExp(ruleAttr);\n        }\n        catch (e) {\n            log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]);\n            return false;\n        }\n        var regexMatches = re.test(runtimeAttr);\n        log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);\n        return regexMatches;\n    };\n}\n","import { allMatcherContext } from './all';\nimport { segmentMatcherContext } from './segment';\nimport { whitelistMatcherContext } from './whitelist';\nimport { equalToMatcherContext } from './eq';\nimport { greaterThanEqualMatcherContext } from './gte';\nimport { lessThanEqualMatcherContext } from './lte';\nimport { betweenMatcherContext } from './between';\nimport { equalToSetMatcherContext } from './eq_set';\nimport { containsAnySetMatcherContext } from './cont_any';\nimport { containsAllSetMatcherContext } from './cont_all';\nimport { partOfSetMatcherContext } from './part_of';\nimport { endsWithMatcherContext } from './ew';\nimport { startsWithMatcherContext } from './sw';\nimport { containsStringMatcherContext } from './cont_str';\nimport { dependencyMatcherContext } from './dependency';\nimport { booleanMatcherContext } from './boolean';\nimport { stringMatcherContext } from './string';\nvar matchers = [\n    undefined,\n    allMatcherContext,\n    segmentMatcherContext,\n    whitelistMatcherContext,\n    equalToMatcherContext,\n    greaterThanEqualMatcherContext,\n    lessThanEqualMatcherContext,\n    betweenMatcherContext,\n    equalToSetMatcherContext,\n    containsAnySetMatcherContext,\n    containsAllSetMatcherContext,\n    partOfSetMatcherContext,\n    endsWithMatcherContext,\n    startsWithMatcherContext,\n    containsStringMatcherContext,\n    dependencyMatcherContext,\n    booleanMatcherContext,\n    stringMatcherContext // MATCHES_STRING: 17\n];\n/**\n * Matcher factory.\n */\nexport function matcherFactory(log, matcherDto, storage) {\n    var type = matcherDto.type, value = matcherDto.value;\n    var matcherFn;\n    // @ts-ignore\n    if (matchers[type])\n        matcherFn = matchers[type](log, value, storage); // There is no index-out-of-bound exception in JavaScript\n    return matcherFn;\n}\n","import { isObject, uniq, toString, toNumber } from '../../utils/lang';\nimport { zeroSinceHH, zeroSinceSS } from '../convertions';\nimport { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';\nimport { ENGINE_SANITIZE } from '../../logger/constants';\nfunction sanitizeNumber(val) {\n    var num = toNumber(val);\n    return isNaN(num) ? undefined : num;\n}\nfunction sanitizeString(val) {\n    var valueToSanitize = val;\n    if (isObject(val)) {\n        // If the value is an object and is not a key, discard it.\n        valueToSanitize = val.matchingKey ? val.matchingKey : undefined;\n    }\n    var str = toString(valueToSanitize);\n    return str ? str : undefined;\n}\nfunction sanitizeArray(val) {\n    var arr = Array.isArray(val) ? uniq(val.map(function (e) { return e + ''; })) : [];\n    return arr.length ? arr : undefined;\n}\nfunction sanitizeBoolean(val) {\n    if (val === true || val === false)\n        return val;\n    if (typeof val === 'string') {\n        var lowerCaseValue = val.toLocaleLowerCase();\n        if (lowerCaseValue === 'true')\n            return true;\n        if (lowerCaseValue === 'false')\n            return false;\n    }\n    return undefined;\n}\nfunction dependencyProcessor(sanitizedValue, attributes) {\n    return {\n        key: sanitizedValue,\n        attributes: attributes\n    };\n}\n/**\n * We can define a pre-processing for the value, to be executed prior to matcher evaluation.\n */\nfunction getProcessingFunction(matcherTypeID, dataType) {\n    switch (matcherTypeID) {\n        case matcherTypes.EQUAL_TO:\n            return dataType === 'DATETIME' ? zeroSinceHH : undefined;\n        case matcherTypes.GREATER_THAN_OR_EQUAL_TO:\n        case matcherTypes.LESS_THAN_OR_EQUAL_TO:\n        case matcherTypes.BETWEEN:\n            return dataType === 'DATETIME' ? zeroSinceSS : undefined;\n        case matcherTypes.IN_SPLIT_TREATMENT:\n            return dependencyProcessor;\n        default:\n            return undefined;\n    }\n}\n/**\n * Sanitize matcher value\n */\nexport function sanitize(log, matcherTypeID, value, dataType, attributes) {\n    var processor = getProcessingFunction(matcherTypeID, dataType);\n    var sanitizedValue;\n    switch (dataType) {\n        case matcherDataTypes.NUMBER:\n        case matcherDataTypes.DATETIME:\n            sanitizedValue = sanitizeNumber(value);\n            break;\n        case matcherDataTypes.STRING:\n            sanitizedValue = sanitizeString(value);\n            break;\n        case matcherDataTypes.SET:\n            sanitizedValue = sanitizeArray(value);\n            break;\n        case matcherDataTypes.BOOLEAN:\n            sanitizedValue = sanitizeBoolean(value);\n            break;\n        case matcherDataTypes.NOT_SPECIFIED:\n            sanitizedValue = value;\n            break;\n        default:\n            sanitizedValue = undefined;\n    }\n    if (processor) {\n        // @ts-ignore\n        sanitizedValue = processor(sanitizedValue, attributes);\n    }\n    log.debug(ENGINE_SANITIZE, [value, dataType, sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue]);\n    return sanitizedValue;\n}\n","import { sanitize } from './sanitize';\nimport { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';\nfunction parseValue(log, key, attributeName, attributes) {\n    var value = undefined;\n    if (attributeName) {\n        if (attributes) {\n            value = attributes[attributeName];\n            log.debug(ENGINE_VALUE, [attributeName, value]);\n        }\n        else {\n            log.warn(ENGINE_VALUE_NO_ATTRIBUTES, [attributeName]);\n        }\n    }\n    else {\n        value = key;\n    }\n    return value;\n}\n/**\n * Defines value to be matched (key / attribute).\n */\nexport function sanitizeValue(log, key, matcherDto, attributes) {\n    var attributeName = matcherDto.attribute;\n    var valueToMatch = parseValue(log, key, attributeName, attributes);\n    var sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);\n    if (sanitizedValue !== undefined) {\n        return sanitizedValue;\n    }\n    else {\n        log.warn(ENGINE_VALUE_INVALID, [valueToMatch + (attributeName ? ' for attribute ' + attributeName : '')]);\n        return;\n    }\n}\n","import { ENGINE_BUCKET } from '../../logger/constants';\nimport { bucket } from '../../utils/murmur3/murmur3';\n/**\n * Get the treatment name given a key, a seed, and the percentage of each treatment.\n */\nexport function getTreatment(log, key, seed, treatments) {\n    var _bucket = bucket(key, seed);\n    var treatment = treatments.getTreatmentFor(_bucket);\n    log.debug(ENGINE_BUCKET, [_bucket, key, seed, treatment]);\n    return treatment;\n}\n/**\n * Evaluates the traffic allocation to see if we should apply rollout conditions or not.\n */\nexport function shouldApplyRollout(trafficAllocation, key, trafficAllocationSeed) {\n    // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.\n    if (trafficAllocation < 100) {\n        var _bucket = bucket(key, trafficAllocationSeed);\n        if (_bucket > trafficAllocation) {\n            return false;\n        }\n    }\n    return true;\n}\n","import { getTreatment, shouldApplyRollout } from './engineUtils';\nimport { thenable } from '../../utils/promise/thenable';\nimport * as LabelsConstants from '../../utils/labels';\n// Build Evaluation object if and only if matchingResult is true\nfunction match(log, matchingResult, bucketingKey, seed, treatments, label) {\n    if (matchingResult) {\n        var treatment = getTreatment(log, bucketingKey, seed, treatments);\n        return {\n            treatment: treatment,\n            label: label\n        };\n    }\n    // else we should notify the engine to continue evaluating\n    return undefined;\n}\n// Condition factory\nexport function conditionContext(log, matcherEvaluator, treatments, label, conditionType) {\n    return function conditionEvaluator(key, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) {\n        // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.\n        if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation, key.bucketingKey, trafficAllocationSeed)) {\n            return {\n                treatment: undefined,\n                label: LabelsConstants.NOT_IN_SPLIT\n            };\n        }\n        // matcherEvaluator could be Async, this relays on matchers return value, so we need\n        // to verify for thenable before play with the result.\n        // Also, we pass splitEvaluator function in case we have a matcher that needs to evaluate another split,\n        // as well as the entire key object for the same reason.\n        var matches = matcherEvaluator(key, attributes, splitEvaluator);\n        if (thenable(matches)) {\n            return matches.then(function (result) { return match(log, result, key.bucketingKey, seed, treatments, label); });\n        }\n        return match(log, matches, key.bucketingKey, seed, treatments, label);\n    };\n}\n","import { findIndex } from '../../utils/lang';\nimport { thenable } from '../../utils/promise/thenable';\nimport * as LabelsConstants from '../../utils/labels';\nimport { CONTROL } from '../../utils/constants';\nimport { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';\nexport function ifElseIfCombinerContext(log, predicates) {\n    function unexpectedInputHandler() {\n        log.error(ERROR_ENGINE_COMBINER_IFELSEIF);\n        return {\n            treatment: CONTROL,\n            label: LabelsConstants.EXCEPTION\n        };\n    }\n    function computeTreatment(predicateResults) {\n        var len = predicateResults.length;\n        for (var i = 0; i < len; i++) {\n            var evaluation = predicateResults[i];\n            if (evaluation !== undefined) {\n                log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);\n                return evaluation;\n            }\n        }\n        log.debug(ENGINE_COMBINER_IFELSEIF_NO_TREATMENT);\n        return undefined;\n    }\n    function ifElseIfCombiner(key, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) {\n        // In Async environments we are going to have async predicates. There is none way to know\n        // before hand so we need to evaluate all the predicates, verify for thenables, and finally,\n        // define how to return the treatment (wrap result into a Promise or not).\n        var predicateResults = predicates.map(function (evaluator) { return evaluator(key, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator); });\n        // if we find a thenable\n        if (findIndex(predicateResults, thenable) !== -1) {\n            return Promise.all(predicateResults).then(function (results) { return computeTreatment(results); });\n        }\n        return computeTreatment(predicateResults);\n    }\n    // if there is none predicates, then there was an error in parsing phase\n    if (!Array.isArray(predicates) || Array.isArray(predicates) && predicates.length === 0) {\n        return unexpectedInputHandler;\n    }\n    else {\n        return ifElseIfCombiner;\n    }\n}\n","import { findIndex } from '../../utils/lang';\nimport { thenable } from '../../utils/promise/thenable';\nimport { ENGINE_COMBINER_AND } from '../../logger/constants';\nexport function andCombinerContext(log, matchers) {\n    function andResults(results) {\n        // Array.prototype.every is supported by target environments\n        var hasMatchedAll = results.every(function (value) { return value; });\n        log.debug(ENGINE_COMBINER_AND, [hasMatchedAll]);\n        return hasMatchedAll;\n    }\n    return function andCombiner() {\n        var params = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            params[_i] = arguments[_i];\n        }\n        var matcherResults = matchers.map(function (matcher) { return matcher.apply(void 0, params); });\n        // If any matching result is a thenable we should use Promise.all\n        if (findIndex(matcherResults, thenable) !== -1) {\n            return Promise.all(matcherResults).then(andResults);\n        }\n        else {\n            return andResults(matcherResults);\n        }\n    };\n}\n","import { matchersTransform } from '../matchersTransform';\nimport { Treatments } from '../treatments';\nimport { matcherFactory } from '../matchers';\nimport { sanitizeValue } from '../value';\nimport { conditionContext } from '../condition';\nimport { ifElseIfCombinerContext } from '../combiners/ifelseif';\nimport { andCombinerContext } from '../combiners/and';\nimport { thenable } from '../../utils/promise/thenable';\nexport function parser(log, conditions, storage) {\n    var predicates = [];\n    for (var i = 0; i < conditions.length; i++) {\n        var _a = conditions[i], matcherGroup = _a.matcherGroup, partitions = _a.partitions, label = _a.label, conditionType = _a.conditionType;\n        // transform data structure\n        var matchers = matchersTransform(matcherGroup.matchers);\n        // create a set of pure functions from the matcher's dto\n        var expressions = matchers.map(function (matcherDto) {\n            var matcher = matcherFactory(log, matcherDto, storage);\n            // Evaluator function.\n            return function (key, attributes, splitEvaluator) {\n                var value = sanitizeValue(log, key, matcherDto, attributes);\n                var result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;\n                if (thenable(result)) {\n                    // @ts-ignore\n                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });\n                }\n                // @ts-ignore\n                return Boolean(result ^ matcherDto.negate);\n            };\n        });\n        // if matcher's factory can't instanciate the matchers, the expressions array\n        // will be empty\n        if (expressions.length === 0) {\n            // reset any data collected during parsing\n            predicates = [];\n            // and break the loop\n            break;\n        }\n        predicates.push(conditionContext(log, andCombinerContext(log, expressions), Treatments.parse(partitions), label, conditionType));\n    }\n    // Instanciate evaluator given the set of conditions using if else if logic\n    return ifElseIfCombinerContext(log, predicates);\n}\n","import { get } from '../utils/lang';\nimport { parser } from './parser';\nimport { keyParser } from '../utils/key';\nimport { thenable } from '../utils/promise/thenable';\nimport * as LabelsConstants from '../utils/labels';\nimport { CONTROL } from '../utils/constants';\nfunction evaluationResult(result, defaultTreatment) {\n    return {\n        treatment: get(result, 'treatment', defaultTreatment),\n        label: get(result, 'label', LabelsConstants.NO_CONDITION_MATCH)\n    };\n}\nvar Engine = /** @class */ (function () {\n    function Engine(baseInfo, evaluator) {\n        this.baseInfo = baseInfo;\n        this.evaluator = evaluator;\n        // in case we don't have a default treatment in the instanciation, use 'control'\n        if (typeof this.baseInfo.defaultTreatment !== 'string') {\n            this.baseInfo.defaultTreatment = CONTROL;\n        }\n    }\n    Engine.parse = function (log, splitFlatStructure, storage) {\n        var conditions = splitFlatStructure.conditions;\n        var evaluator = parser(log, conditions, storage);\n        return new Engine(splitFlatStructure, evaluator);\n    };\n    Engine.prototype.getKey = function () {\n        return this.baseInfo.name;\n    };\n    Engine.prototype.getTreatment = function (key, attributes, splitEvaluator) {\n        var _a = this.baseInfo, killed = _a.killed, seed = _a.seed, defaultTreatment = _a.defaultTreatment, trafficAllocation = _a.trafficAllocation, trafficAllocationSeed = _a.trafficAllocationSeed;\n        var parsedKey;\n        var treatment;\n        var label;\n        try {\n            parsedKey = keyParser(key);\n        }\n        catch (err) {\n            return {\n                treatment: CONTROL,\n                label: LabelsConstants.EXCEPTION\n            };\n        }\n        if (this.isGarbage()) {\n            treatment = CONTROL;\n            label = LabelsConstants.SPLIT_ARCHIVED;\n        }\n        else if (killed) {\n            treatment = defaultTreatment;\n            label = LabelsConstants.SPLIT_KILLED;\n        }\n        else {\n            var evaluation = this.evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator);\n            // Evaluation could be async, so we should handle that case checking for a\n            // thenable object\n            if (thenable(evaluation)) {\n                return evaluation.then(function (result) { return evaluationResult(result, defaultTreatment); });\n            }\n            else {\n                return evaluationResult(evaluation, defaultTreatment);\n            }\n        }\n        return {\n            treatment: treatment,\n            label: label\n        };\n    };\n    Engine.prototype.isGarbage = function () {\n        return this.baseInfo.status === 'ARCHIVED';\n    };\n    Engine.prototype.getChangeNumber = function () {\n        return this.baseInfo.changeNumber;\n    };\n    return Engine;\n}());\nexport { Engine };\n","import { Engine } from './Engine';\nimport { thenable } from '../utils/promise/thenable';\nimport * as LabelsConstants from '../utils/labels';\nimport { CONTROL } from '../utils/constants';\nvar treatmentException = {\n    treatment: CONTROL,\n    label: LabelsConstants.EXCEPTION,\n    config: null\n};\nfunction treatmentsException(splitNames) {\n    var evaluations = {};\n    splitNames.forEach(function (splitName) {\n        evaluations[splitName] = treatmentException;\n    });\n    return evaluations;\n}\nexport function evaluateFeature(log, key, splitName, attributes, storage) {\n    var parsedSplit;\n    try {\n        parsedSplit = storage.splits.getSplit(splitName);\n    }\n    catch (e) {\n        // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.\n        return treatmentException;\n    }\n    if (thenable(parsedSplit)) {\n        return parsedSplit.then(function (split) { return getEvaluation(log, split, key, attributes, storage); }).catch(\n        // Exception on async `getSplit` storage. For example, when the storage is redis or\n        // pluggable and there is a connection issue and we can't retrieve the split to be evaluated\n        function () { return treatmentException; });\n    }\n    return getEvaluation(log, parsedSplit, key, attributes, storage);\n}\nexport function evaluateFeatures(log, key, splitNames, attributes, storage) {\n    var parsedSplits;\n    try {\n        parsedSplits = storage.splits.getSplits(splitNames);\n    }\n    catch (e) {\n        // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.\n        return treatmentsException(splitNames);\n    }\n    return thenable(parsedSplits) ?\n        parsedSplits.then(function (splits) { return getEvaluations(log, splitNames, splits, key, attributes, storage); })\n            .catch(function () {\n            // Exception on async `getSplits` storage. For example, when the storage is redis or\n            // pluggable and there is a connection issue and we can't retrieve the split to be evaluated\n            return treatmentsException(splitNames);\n        }) :\n        getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);\n}\nfunction getEvaluation(log, splitJSON, key, attributes, storage) {\n    var evaluation = {\n        treatment: CONTROL,\n        label: LabelsConstants.SPLIT_NOT_FOUND,\n        config: null\n    };\n    if (splitJSON) {\n        var split_1 = Engine.parse(log, splitJSON, storage);\n        evaluation = split_1.getTreatment(key, attributes, evaluateFeature);\n        // If the storage is async and the evaluated split uses segment, evaluation is thenable\n        if (thenable(evaluation)) {\n            return evaluation.then(function (result) {\n                result.changeNumber = split_1.getChangeNumber();\n                result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;\n                return result;\n            });\n        }\n        else {\n            evaluation.changeNumber = split_1.getChangeNumber(); // Always sync and optional\n            evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;\n        }\n    }\n    return evaluation;\n}\nfunction getEvaluations(log, splitNames, splits, key, attributes, storage) {\n    var result = {};\n    var thenables = [];\n    splitNames.forEach(function (splitName) {\n        var evaluation = getEvaluation(log, splits[splitName], key, attributes, storage);\n        if (thenable(evaluation)) {\n            thenables.push(evaluation.then(function (res) {\n                result[splitName] = res;\n            }));\n        }\n        else {\n            result[splitName] = evaluation;\n        }\n    });\n    return thenables.length > 0 ? Promise.all(thenables).then(function () { return result; }) : result;\n}\n","import { thenable } from '../promise/thenable';\nimport { LOCALHOST_MODE } from '../constants';\nimport { WARN_NOT_EXISTENT_TT } from '../../logger/constants';\nfunction logTTExistanceWarning(log, maybeTT, method) {\n    log.warn(WARN_NOT_EXISTENT_TT, [method, maybeTT]);\n}\n/**\n * Separated from the previous method since on some cases it'll be async.\n */\nexport function validateTrafficTypeExistance(log, readinessManager, splitsCache, mode, maybeTT, method) {\n    // If not ready or in localhost mode, we won't run the validation\n    if (!readinessManager.isReady() || mode === LOCALHOST_MODE)\n        return true;\n    var res = splitsCache.trafficTypeExists(maybeTT); // never rejects or throws error\n    if (thenable(res)) {\n        return res.then(function (isValid) {\n            if (!isValid)\n                logTTExistanceWarning(log, maybeTT, method);\n            return isValid; // propagate result\n        });\n    }\n    else {\n        if (!res)\n            logTTExistanceWarning(log, maybeTT, method);\n        return res;\n    }\n}\n","import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';\n/**\n * Storage is async if mode is consumer or partial consumer\n */\nexport function isStorageSync(settings) {\n    return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;\n}\n","import { evaluateFeature, evaluateFeatures } from '../evaluator';\nimport { thenable } from '../utils/promise/thenable';\nimport { getMatching, getBucketing } from '../utils/key';\nimport { validateSplitExistance } from '../utils/inputValidation/splitExistance';\nimport { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';\nimport { SDK_NOT_READY } from '../utils/labels';\nimport { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';\nimport { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';\nimport { isStorageSync } from '../trackers/impressionObserver/utils';\nvar treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };\nfunction treatmentsNotReady(splitNames) {\n    var evaluations = {};\n    splitNames.forEach(function (splitName) {\n        evaluations[splitName] = treatmentNotReady;\n    });\n    return evaluations;\n}\n/**\n * Creator of base client with getTreatments and track methods.\n */\nexport function clientFactory(params) {\n    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;\n    var log = settings.log, mode = settings.mode;\n    function getTreatment(key, splitName, attributes, withConfig) {\n        if (withConfig === void 0) { withConfig = false; }\n        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);\n        var wrapUp = function (evaluationResult) {\n            var queue = [];\n            var treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, \"getTreatment\" + (withConfig ? 'withConfig' : ''), queue);\n            impressionsTracker.track(queue, attributes);\n            stopTelemetryTracker(queue[0] && queue[0].label);\n            return treatment;\n        };\n        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?\n            evaluateFeature(log, key, splitName, attributes, storage) :\n            isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected\n                treatmentNotReady :\n                Promise.resolve(treatmentNotReady); // Promisify if async\n        return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);\n    }\n    function getTreatmentWithConfig(key, splitName, attributes) {\n        return getTreatment(key, splitName, attributes, true);\n    }\n    function getTreatments(key, splitNames, attributes, withConfig) {\n        if (withConfig === void 0) { withConfig = false; }\n        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);\n        var wrapUp = function (evaluationResults) {\n            var queue = [];\n            var treatments = {};\n            Object.keys(evaluationResults).forEach(function (splitName) {\n                treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, \"getTreatments\" + (withConfig ? 'withConfig' : ''), queue);\n            });\n            impressionsTracker.track(queue, attributes);\n            stopTelemetryTracker(queue[0] && queue[0].label);\n            return treatments;\n        };\n        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?\n            evaluateFeatures(log, key, splitNames, attributes, storage) :\n            isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected\n                treatmentsNotReady(splitNames) :\n                Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async\n        return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);\n    }\n    function getTreatmentsWithConfig(key, splitNames, attributes) {\n        return getTreatments(key, splitNames, attributes, true);\n    }\n    // Internal function\n    function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName, queue) {\n        var matchingKey = getMatching(key);\n        var bucketingKey = getBucketing(key);\n        var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;\n        log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);\n        if (validateSplitExistance(log, readinessManager, splitName, label, invokingMethodName)) {\n            log.info(IMPRESSION_QUEUEING);\n            queue.push({\n                feature: splitName,\n                keyName: matchingKey,\n                treatment: treatment,\n                time: Date.now(),\n                bucketingKey: bucketingKey,\n                label: label,\n                changeNumber: changeNumber\n            });\n        }\n        if (withConfig) {\n            return {\n                treatment: treatment,\n                config: config\n            };\n        }\n        return treatment;\n    }\n    function track(key, trafficTypeName, eventTypeId, value, properties, size) {\n        if (size === void 0) { size = 1024; }\n        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);\n        var matchingKey = getMatching(key);\n        var timestamp = Date.now();\n        var eventData = {\n            eventTypeId: eventTypeId,\n            trafficTypeName: trafficTypeName,\n            value: value,\n            timestamp: timestamp,\n            key: matchingKey,\n            properties: properties\n        };\n        // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.\n        validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');\n        var result = eventTracker.track(eventData, size);\n        if (thenable(result)) {\n            return result.then(function (result) {\n                stopTelemetryTracker();\n                return result;\n            });\n        }\n        else {\n            stopTelemetryTracker();\n            return result;\n        }\n    }\n    return {\n        getTreatment: getTreatment,\n        getTreatmentWithConfig: getTreatmentWithConfig,\n        getTreatments: getTreatments,\n        getTreatmentsWithConfig: getTreatmentsWithConfig,\n        track: track,\n        isClientSide: false\n    };\n}\n","import { ERROR_EVENT_TYPE_FORMAT, ERROR_NULL, ERROR_INVALID, ERROR_EMPTY } from '../../logger/constants';\nimport { isString } from '../lang';\nvar EVENT_TYPE_REGEX = /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/;\nvar item = 'event_type';\nexport function validateEvent(log, maybeEvent, method) {\n    if (maybeEvent == undefined) { // eslint-disable-line eqeqeq\n        log.error(ERROR_NULL, [method, item]);\n    }\n    else if (!isString(maybeEvent)) {\n        log.error(ERROR_INVALID, [method, item]);\n    }\n    else { // It is a string.\n        if (maybeEvent.length === 0) {\n            log.error(ERROR_EMPTY, [method, item]);\n        }\n        else if (!EVENT_TYPE_REGEX.test(maybeEvent)) {\n            log.error(ERROR_EVENT_TYPE_FORMAT, [method, maybeEvent]);\n        }\n        else {\n            return maybeEvent;\n        }\n    }\n    return false;\n}\n","import { ERROR_NOT_FINITE } from '../../logger/constants';\nimport { isFiniteNumber } from '../lang';\nexport function validateEventValue(log, maybeValue, method) {\n    if (isFiniteNumber(maybeValue) || maybeValue == undefined) // eslint-disable-line eqeqeq\n        return maybeValue;\n    log.error(ERROR_NOT_FINITE, [method]);\n    return false;\n}\n","import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';\nimport { objectAssign } from '../lang/objectAssign';\nimport { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';\nvar ECMA_SIZES = {\n    NULL: 0,\n    STRING: 2,\n    BOOLEAN: 4,\n    NUMBER: 8\n};\nvar MAX_PROPERTIES_AMOUNT = 300;\nvar MAX_EVENT_SIZE = 1024 * 32;\nvar BASE_EVENT_SIZE = 1024; // We assume 1kb events without properties (avg measured)\nexport function validateEventProperties(log, maybeProperties, method) {\n    if (maybeProperties == undefined)\n        return { properties: null, size: BASE_EVENT_SIZE }; // eslint-disable-line eqeqeq\n    if (!isObject(maybeProperties)) {\n        log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'properties']);\n        return { properties: false, size: BASE_EVENT_SIZE };\n    }\n    var keys = Object.keys(maybeProperties);\n    // Shallow clone\n    var clone = objectAssign({}, maybeProperties);\n    // To avoid calculating the size twice we'll return it from here.\n    var output = {\n        properties: clone,\n        size: BASE_EVENT_SIZE // We assume 1kb events without properties (avg measured)\n    };\n    if (keys.length > MAX_PROPERTIES_AMOUNT) {\n        log.warn(WARN_TRIMMING_PROPERTIES, [method]);\n    }\n    for (var i = 0; i < keys.length; i++) {\n        output.size += keys[i].length * ECMA_SIZES.STRING; // Count the size of the key which is always a string.\n        var val = clone[keys[i]];\n        var isStringVal = isString(val);\n        var isFiniteVal = isFiniteNumber(val);\n        var isBoolVal = isBoolean(val);\n        var isNullVal = val === null;\n        if (!(isStringVal || isFiniteVal || isBoolVal || isNullVal)) { // If it's not of valid type.\n            clone[keys[i]] = null;\n            val = null;\n            isNullVal = true;\n            log.warn(WARN_SETTING_NULL, [method, keys[i]]);\n        }\n        if (isNullVal)\n            output.size += ECMA_SIZES.NULL;\n        else if (isFiniteVal)\n            output.size += ECMA_SIZES.NUMBER;\n        else if (isBoolVal)\n            output.size += ECMA_SIZES.BOOLEAN;\n        else if (isStringVal)\n            output.size += val.length * ECMA_SIZES.STRING;\n        if (output.size > MAX_EVENT_SIZE) {\n            log.error(ERROR_SIZE_EXCEEDED, [method]);\n            output.properties = false;\n            break;\n        }\n    }\n    return output;\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';\nimport { startsWith } from '../utils/lang';\nimport { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';\nimport { isStorageSync } from '../trackers/impressionObserver/utils';\n/**\n * Decorator that validates the input before actually executing the client methods.\n * We should \"guard\" the client here, while not polluting the \"real\" implementation of those methods.\n */\nexport function clientInputValidationDecorator(settings, client, readinessManager) {\n    var log = settings.log;\n    var isSync = isStorageSync(settings);\n    /**\n     * Avoid repeating this validations code\n     */\n    function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {\n        var multi = startsWith(methodName, 'getTreatments');\n        var key = validateKey(log, maybeKey, methodName);\n        var splitOrSplits = multi ? validateSplits(log, maybeSplitOrSplits, methodName) : validateSplit(log, maybeSplitOrSplits, methodName);\n        var attributes = validateAttributes(log, maybeAttributes, methodName);\n        var isOperational = validateIfNotDestroyed(log, readinessManager, methodName);\n        validateIfOperational(log, readinessManager, methodName);\n        var valid = isOperational && key && splitOrSplits && attributes !== false;\n        return {\n            valid: valid,\n            key: key,\n            splitOrSplits: splitOrSplits,\n            attributes: attributes\n        };\n    }\n    function wrapResult(value) {\n        return isSync ? value : Promise.resolve(value);\n    }\n    function getTreatment(maybeKey, maybeSplit, maybeAttributes) {\n        var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');\n        if (params.valid) {\n            return client.getTreatment(params.key, params.splitOrSplits, params.attributes);\n        }\n        else {\n            return wrapResult(CONTROL);\n        }\n    }\n    function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {\n        var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');\n        if (params.valid) {\n            return client.getTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);\n        }\n        else {\n            return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));\n        }\n    }\n    function getTreatments(maybeKey, maybeSplits, maybeAttributes) {\n        var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');\n        if (params.valid) {\n            return client.getTreatments(params.key, params.splitOrSplits, params.attributes);\n        }\n        else {\n            var res_1 = {};\n            if (params.splitOrSplits)\n                params.splitOrSplits.forEach(function (split) { return res_1[split] = CONTROL; });\n            return wrapResult(res_1);\n        }\n    }\n    function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {\n        var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');\n        if (params.valid) {\n            return client.getTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);\n        }\n        else {\n            var res_2 = {};\n            if (params.splitOrSplits)\n                params.splitOrSplits.forEach(function (split) { return res_2[split] = objectAssign({}, CONTROL_WITH_CONFIG); });\n            return wrapResult(res_2);\n        }\n    }\n    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {\n        var key = validateKey(log, maybeKey, 'track');\n        var tt = validateTrafficType(log, maybeTT, 'track');\n        var event = validateEvent(log, maybeEvent, 'track');\n        var eventValue = validateEventValue(log, maybeEventValue, 'track');\n        var _a = validateEventProperties(log, maybeProperties, 'track'), properties = _a.properties, size = _a.size;\n        var isOperational = validateIfNotDestroyed(log, readinessManager, 'track');\n        if (isOperational && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error\n            return client.track(key, tt, event, eventValue, properties, size);\n        }\n        else {\n            return isSync ? false : Promise.resolve(false);\n        }\n    }\n    return {\n        getTreatment: getTreatment,\n        getTreatmentWithConfig: getTreatmentWithConfig,\n        getTreatments: getTreatments,\n        getTreatmentsWithConfig: getTreatmentsWithConfig,\n        track: track\n    };\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { releaseApiKey } from '../utils/inputValidation/apiKey';\nimport { clientFactory } from './client';\nimport { clientInputValidationDecorator } from './clientInputValidation';\nvar COOLDOWN_TIME_IN_MILLIS = 1000;\n/**\n * Creates an Sdk client, i.e., a base client with status and destroy interface\n */\nexport function sdkClientFactory(params, isSharedClient) {\n    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;\n    var lastActionTime = 0;\n    function __cooldown(func, time) {\n        var now = Date.now();\n        //get the actual time elapsed in ms\n        var timeElapsed = now - lastActionTime;\n        //check if the time elapsed is less than desired cooldown\n        if (timeElapsed < time) {\n            //if yes, return message with remaining time in seconds\n            settings.log.warn(\"Flush cooldown, remaining time \" + (time - timeElapsed) / 1000 + \" seconds\");\n            return Promise.resolve();\n        }\n        else {\n            //Do the requested action and re-assign the lastActionTime\n            lastActionTime = now;\n            return func();\n        }\n    }\n    function __flush() {\n        return syncManager ? syncManager.flush() : Promise.resolve();\n    }\n    return objectAssign(\n    // Proto-linkage of the readiness Event Emitter\n    Object.create(sdkReadinessManager.sdkStatus), \n    // Client API (getTreatment* & track methods)\n    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), \n    // Sdk destroy\n    {\n        flush: function () {\n            // @TODO define cooldown time\n            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);\n        },\n        destroy: function () {\n            // record stat before flushing data\n            if (!isSharedClient)\n                telemetryTracker.sessionLength();\n            // Stop background jobs\n            syncManager && syncManager.stop();\n            return __flush().then(function () {\n                // Cleanup event listeners\n                sdkReadinessManager.readinessManager.destroy();\n                signalListener && signalListener.stop();\n                // Release the API Key if it is the main client\n                if (!isSharedClient)\n                    releaseApiKey(settings.core.authorizationKey);\n                if (uniqueKeysTracker)\n                    uniqueKeysTracker.stop();\n                // Cleanup storage\n                return storage.destroy();\n            });\n        }\n    });\n}\n","import { clientCSDecorator } from './clientCS';\nimport { validateKey } from '../utils/inputValidation/key';\nimport { validateTrafficType } from '../utils/inputValidation/trafficType';\nimport { getMatching, keyParser } from '../utils/key';\nimport { sdkClientFactory } from './sdkClient';\nimport { objectAssign } from '../utils/lang/objectAssign';\nimport { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';\nimport { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';\nfunction buildInstanceId(key, trafficType) {\n    // @ts-ignore\n    return (key.matchingKey ? key.matchingKey : key) + \"-\" + (key.bucketingKey ? key.bucketingKey : key) + \"-\" + (trafficType !== undefined ? trafficType : '');\n}\nvar method = 'Client instantiation';\n/**\n * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,\n * where clients can have a binded TT for the track method, which is provided via the settings\n * (default client) or the client method (shared clients).\n */\nexport function sdkClientMethodCSFactory(params) {\n    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, readyTimeout = _a.startup.readyTimeout, log = _a.log;\n    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);\n    var parsedDefaultKey = keyParser(key);\n    var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);\n    // Cache instances created per factory.\n    var clientInstances = {};\n    clientInstances[defaultInstanceId] = mainClientInstance;\n    return function client(key, trafficType) {\n        if (key === undefined) {\n            log.debug(RETRIEVE_CLIENT_DEFAULT);\n            return mainClientInstance;\n        }\n        // Validate the key value\n        var validKey = validateKey(log, key, \"Shared \" + method);\n        if (validKey === false) {\n            throw new Error('Shared Client needs a valid key.');\n        }\n        var validTrafficType;\n        if (trafficType !== undefined) {\n            validTrafficType = validateTrafficType(log, trafficType, \"Shared \" + method);\n            if (validTrafficType === false) {\n                throw new Error('Shared Client needs a valid traffic type or no traffic type at all.');\n            }\n        }\n        var instanceId = buildInstanceId(validKey, validTrafficType);\n        if (!clientInstances[instanceId]) {\n            var matchingKey = getMatching(validKey);\n            var sharedSdkReadiness_1 = sdkReadinessManager.shared(readyTimeout);\n            var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {\n                if (err)\n                    return;\n                // Emit SDK_READY in consumer mode for shared clients\n                sharedSdkReadiness_1.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);\n            });\n            // 3 possibilities:\n            // - Standalone mode: both syncManager and sharedSyncManager are defined\n            // - Consumer mode: both syncManager and sharedSyncManager are undefined\n            // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined\n            // @ts-ignore\n            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);\n            // As shared clients reuse all the storage information, we don't need to check here if we\n            // will use offline or online mode. We should stick with the original decision.\n            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {\n                sdkReadinessManager: sharedSdkReadiness_1,\n                storage: sharedStorage || storage,\n                syncManager: sharedSyncManager,\n                signalListener: undefined, // only the main client \"destroy\" method stops the signal listener\n            }), true), validKey, validTrafficType);\n            sharedSyncManager && sharedSyncManager.start();\n            log.info(NEW_SHARED_CLIENT);\n        }\n        else {\n            log.debug(RETRIEVE_CLIENT_EXISTING);\n        }\n        return clientInstances[instanceId];\n    };\n}\n","/**\n * Map implementation based on es6-map polyfill (https://github.com/medikoo/es6-map/blob/master/polyfill.js),\n * with the minimal features used by the SDK.\n\nCopyright (C) 2013 Mariusz Nowak (www.medikoo.com)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n**/\nvar MapPoly = /** @class */ (function () {\n    // unlike ES6 `Map`, it only accepts an array as first argument iterable\n    function MapPoly(entries) {\n        var _this = this;\n        this.__mapKeysData__ = [];\n        this.__mapValuesData__ = [];\n        if (Array.isArray(entries))\n            entries.forEach(function (entry) { _this.set(entry[0], entry[1]); });\n    }\n    MapPoly.prototype.clear = function () {\n        if (!this.__mapKeysData__.length)\n            return;\n        this.__mapKeysData__.length = 0;\n        this.__mapValuesData__.length = 0;\n    };\n    MapPoly.prototype.delete = function (key) {\n        var index = this.__mapKeysData__.indexOf(key);\n        if (index === -1)\n            return false;\n        this.__mapKeysData__.splice(index, 1);\n        this.__mapValuesData__.splice(index, 1);\n        return true;\n    };\n    MapPoly.prototype.forEach = function (callbackfn, thisArg) {\n        for (var i = 0; i < this.__mapKeysData__.length; i++) {\n            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);\n        }\n    };\n    MapPoly.prototype.get = function (key) {\n        var index = this.__mapKeysData__.indexOf(key);\n        if (index === -1)\n            return;\n        return this.__mapValuesData__[index];\n    };\n    MapPoly.prototype.has = function (key) {\n        return this.__mapKeysData__.indexOf(key) !== -1;\n    };\n    MapPoly.prototype.set = function (key, value) {\n        var index = this.__mapKeysData__.indexOf(key);\n        if (index === -1)\n            index = this.__mapKeysData__.push(key) - 1;\n        this.__mapValuesData__[index] = value;\n        return this;\n    };\n    Object.defineProperty(MapPoly.prototype, \"size\", {\n        get: function () {\n            return this.__mapKeysData__.length;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return MapPoly;\n}());\nexport { MapPoly };\n/**\n * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),\n * a ponyfill with minimal features is returned instead.\n *\n * Exported for testing purposes only.\n */\nexport function __getMapConstructor() {\n    // eslint-disable-next-line compat/compat\n    if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {\n        return Map;\n    }\n    return MapPoly;\n}\nexport var _Map = __getMapConstructor();\n","/* eslint-disable no-use-before-define */\n/**\n * yallist implementation based on isaacs/yallist (https://github.com/isaacs/yallist/yallist.js),\n * with the minimal features used by the SDK.\n\nCopyright (c) Isaac Z. Schlueter and Contributors\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted, provided that the above\ncopyright notice and this permission notice appear in all copies.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\nWITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\nANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR\nIN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n**/\nvar Node = /** @class */ (function () {\n    function Node(value, prev, next, list) {\n        this.list = list;\n        this.value = value;\n        if (prev) {\n            prev.next = this;\n            this.prev = prev;\n        }\n        else {\n            this.prev = null;\n        }\n        if (next) {\n            next.prev = this;\n            this.next = next;\n        }\n        else {\n            this.next = null;\n        }\n    }\n    return Node;\n}());\nexport { Node };\nvar LinkedList = /** @class */ (function () {\n    function LinkedList() {\n        this.tail = null;\n        this.head = null;\n        this.length = 0;\n    }\n    // removes the given node of `this` list and returns the next node.\n    LinkedList.prototype.removeNode = function (node) {\n        if (!node || !(node instanceof Node))\n            return;\n        if (node.list !== this) {\n            throw new Error('removing node which does not belong to this list');\n        }\n        var next = node.next;\n        var prev = node.prev;\n        if (next) {\n            next.prev = prev;\n        }\n        if (prev) {\n            prev.next = next;\n        }\n        if (node === this.head) {\n            this.head = next;\n        }\n        if (node === this.tail) {\n            this.tail = prev;\n        }\n        node.list.length--;\n        node.next = null;\n        node.prev = null;\n        node.list = null;\n        return next;\n    };\n    // Move a Node object to the front of the list. (That is, pull it out of wherever it lives, and make it the new head.)\n    // If the node belongs to a different list, then that list will remove it first.\n    LinkedList.prototype.unshiftNode = function (node) {\n        if (!node || !(node instanceof Node))\n            return;\n        if (node === this.head) {\n            return;\n        }\n        if (node.list) {\n            node.list.removeNode(node);\n        }\n        var head = this.head;\n        node.list = this;\n        node.next = head;\n        if (head) {\n            head.prev = node;\n        }\n        this.head = node;\n        if (!this.tail) {\n            this.tail = node;\n        }\n        this.length++;\n    };\n    // similar to Array.prototype.unshift, it adds one or more elements to the head of the list and returns the new length of the list.\n    LinkedList.prototype.unshift = function () {\n        for (var i = 0, l = arguments.length; i < l; i++) {\n            this.head = new Node(arguments[i], null, this.head, this);\n            if (!this.tail) {\n                this.tail = this.head;\n            }\n            this.length++;\n        }\n        return this.length;\n    };\n    return LinkedList;\n}());\nexport { LinkedList };\n","import { _Map } from '../lang/maps';\nimport { LinkedList, Node } from './LinkedList';\nvar LRUCache = /** @class */ (function () {\n    function LRUCache(maxSize) {\n        this.maxLen = maxSize || 1;\n        this.items = new _Map();\n        this.lru = new LinkedList();\n    }\n    LRUCache.prototype.get = function (key) {\n        var node = this.items.get(key);\n        if (!node || !(node instanceof Node))\n            return;\n        this.lru.unshiftNode(node); // Move to front\n        return node.value.value;\n    };\n    LRUCache.prototype.set = function (key, value) {\n        var node = this.items.get(key);\n        if (node) {\n            if (!(node instanceof Node))\n                return false;\n            this.lru.unshiftNode(node); // Move to front\n            this.lru.head.value.value = value; // Update value\n        }\n        else {\n            if (this.lru.length === this.maxLen) { // Remove last\n                var last = this.lru.tail;\n                if (!last)\n                    return false;\n                this.items.delete(last.value.key);\n                this.lru.removeNode(this.lru.tail); // Remove node\n            }\n            // @ts-ignore\n            this.lru.unshift({ key: key, value: value }); // Push front\n            this.items.set(key, this.lru.head);\n        }\n        return true;\n    };\n    return LRUCache;\n}());\nexport { LRUCache };\n","import { LRUCache } from '../../utils/LRUCache';\nvar ImpressionObserver = /** @class */ (function () {\n    function ImpressionObserver(size, hasher) {\n        this.cache = new LRUCache(size);\n        this.hasher = hasher;\n    }\n    ImpressionObserver.prototype.testAndSet = function (impression) {\n        var hash = this.hasher(impression);\n        var previous = this.cache.get(hash);\n        this.cache.set(hash, impression.time);\n        return previous;\n    };\n    return ImpressionObserver;\n}());\nexport { ImpressionObserver };\n","export function buildKey(impression) {\n    return impression.keyName + \":\" + impression.feature + \":\" + impression.treatment + \":\" + impression.label + \":\" + impression.changeNumber;\n}\n","import { ImpressionObserver } from './ImpressionObserver';\nimport { hash } from '../../utils/murmur3/murmur3';\nimport { buildKey } from './buildKey';\nexport function hashImpression32(impression) {\n    return hash(buildKey(impression));\n}\nvar LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes\nexport function impressionObserverCSFactory() {\n    return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression32);\n}\n","import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';\n/**\n * Factory function for IntegrationsManager with pluggable integrations.\n * The integrations manager instantiates integration, and bypass tracked events and impressions to them.\n *\n * @param integrations validated list of integration factories\n * @param params information of the Sdk factory instance that integrations can access to\n *\n * @returns integration manager or undefined if `integrations` are not present in settings.\n */\nexport function pluggableIntegrationsManagerFactory(integrations, params) {\n    var listeners = [];\n    // No need to check if `settings.integrations` is an array of functions. It was already validated\n    integrations.forEach(function (integrationFactory) {\n        var integration = integrationFactory(params);\n        if (integration && integration.queue)\n            listeners.push(integration);\n    });\n    // If `listeners` is empty, not return a integration manager\n    if (listeners.length === 0)\n        return;\n    // Exception safe methods: each integration module is responsable for handling errors\n    return {\n        handleImpression: function (impressionData) {\n            listeners.forEach(function (listener) { return listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }); });\n        },\n        handleEvent: function (eventData) {\n            listeners.forEach(function (listener) { return listener.queue({ type: SPLIT_EVENT, payload: eventData }); });\n        }\n    };\n}\n","/* eslint-disable no-undef */\nimport { objectAssign } from '../../utils/lang/objectAssign';\nimport { isString, isFiniteNumber, uniqAsStrings } from '../../utils/lang';\nimport { validateEvent, validateEventValue, validateEventProperties, validateKey, validateTrafficType } from '../../utils/inputValidation';\nvar logPrefix = 'ga-to-split: ';\nvar logNameMapper = 'ga-to-split:mapper';\n/**\n * Provides a plugin to use with analytics.js, accounting for the possibility\n * that the global command queue has been renamed or not yet defined.\n * @param window Reference to global object.\n * @param pluginName The plugin name identifier.\n * @param pluginConstructor The plugin constructor function.\n * @param log Logger instance.\n * @param autoRequire If true, log error when auto-require script is not detected\n */\nfunction providePlugin(window, pluginName, pluginConstructor, log, autoRequire, telemetryTracker) {\n    // get reference to global command queue. Init it if not defined yet.\n    var gaAlias = window.GoogleAnalyticsObject || 'ga';\n    window[gaAlias] = window[gaAlias] || function () {\n        (window[gaAlias].q = window[gaAlias].q || []).push(arguments);\n    };\n    // provides the plugin for use with analytics.js.\n    window[gaAlias]('provide', pluginName, pluginConstructor);\n    var hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;\n    if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found\n        log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');\n    }\n    if (telemetryTracker && hasAutoRequire) {\n        telemetryTracker.addTag('integration:ga-autorequire');\n    }\n}\n// Default mapping: object used for building the default mapper from hits to Split events\nvar defaultMapping = {\n    eventTypeId: {\n        event: 'eventAction',\n        social: 'socialAction',\n    },\n    eventValue: {\n        event: 'eventValue',\n        timing: 'timingValue',\n    },\n    eventProperties: {\n        pageview: ['page'],\n        screenview: ['screenName'],\n        event: ['eventCategory', 'eventLabel'],\n        social: ['socialNetwork', 'socialTarget'],\n        timing: ['timingCategory', 'timingVar', 'timingLabel'],\n        exception: ['exDescription', 'exFatal'],\n    }\n};\n/**\n * Build a mapper function based on a mapping object\n *\n * @param {object} mapping\n */\nfunction mapperBuilder(mapping) {\n    return function (model) {\n        var hitType = model.get('hitType');\n        // @ts-expect-error\n        var eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');\n        // @ts-expect-error\n        var value = model.get(mapping.eventValue[hitType]);\n        var properties = {}; // @ts-expect-error\n        var fields = mapping.eventProperties[hitType];\n        if (fields) {\n            for (var i = 0; i < fields.length; i++) {\n                var fieldValue = model.get(fields[i]);\n                if (fieldValue !== undefined)\n                    properties[fields[i]] = fieldValue;\n            }\n        }\n        return {\n            eventTypeId: eventTypeId,\n            value: value,\n            properties: properties,\n            timestamp: Date.now(),\n        };\n    };\n}\n// exposed for unit testing purposses.\nexport var defaultMapper = mapperBuilder(defaultMapping);\nexport var defaultPrefix = 'ga';\n/**\n * Return a new list of identities removing invalid and duplicated ones.\n *\n * @param {Array} identities list of identities\n * @returns list of valid and unique identities. The list might be empty if `identities` is not an array or all its elements are invalid.\n */\nexport function validateIdentities(identities) {\n    if (!Array.isArray(identities))\n        return [];\n    // Remove duplicated identities\n    var uniqueIdentities = uniqAsStrings(identities);\n    // Filter based on rum-agent identities validator\n    return uniqueIdentities.filter(function (identity) {\n        if (!identity)\n            return false;\n        var maybeKey = identity.key;\n        var maybeTT = identity.trafficType;\n        if (!isString(maybeKey) && !isFiniteNumber(maybeKey))\n            return false;\n        if (!isString(maybeTT))\n            return false;\n        return true;\n    });\n}\n/**\n * Checks if EventData fields (except EventTypeId) are valid, and logs corresponding warnings.\n * EventTypeId is validated separately.\n *\n * @param {EventData} data event data instance to validate. Precondition: data != undefined\n * @returns {boolean} Whether the data instance is a valid EventData or not.\n */\nexport function validateEventData(log, eventData) {\n    if (!validateEvent(log, eventData.eventTypeId, logNameMapper))\n        return false;\n    if (validateEventValue(log, eventData.value, logNameMapper) === false)\n        return false;\n    var properties = validateEventProperties(log, eventData.properties, logNameMapper).properties;\n    if (properties === false)\n        return false;\n    if (eventData.timestamp && !isFiniteNumber(eventData.timestamp))\n        return false;\n    if (eventData.key && validateKey(log, eventData.key, logNameMapper) === false)\n        return false;\n    if (eventData.trafficTypeName && validateTrafficType(log, eventData.trafficTypeName, logNameMapper) === false)\n        return false;\n    return true;\n}\nvar INVALID_PREFIX_REGEX = /^[^a-zA-Z0-9]+/;\nvar INVALID_SUBSTRING_REGEX = /[^-_.:a-zA-Z0-9]+/g;\n/**\n * Fixes the passed string value to comply with EventTypeId format, by removing invalid characters and truncating if necessary.\n *\n * @param {object} log factory logger\n * @param {string} eventTypeId string value to fix.\n * @returns {string} Fixed version of `eventTypeId`.\n */\nexport function fixEventTypeId(log, eventTypeId) {\n    // return the input eventTypeId if it cannot be fixed\n    if (!isString(eventTypeId) || eventTypeId.length === 0) {\n        return eventTypeId;\n    }\n    // replace invalid substrings and truncate\n    var fixed = eventTypeId\n        .replace(INVALID_PREFIX_REGEX, '')\n        .replace(INVALID_SUBSTRING_REGEX, '_');\n    var truncated = fixed.slice(0, 80);\n    if (truncated.length < fixed.length)\n        log.warn(logPrefix + 'EventTypeId was truncated because it cannot be more than 80 characters long.');\n    return truncated;\n}\n/**\n * GaToSplit integration.\n * This function provides the SplitTracker plugin to ga command queue.\n *\n * @param {object} sdkOptions options passed at the SDK integrations settings (isomorphic SDK) or the GoogleAnalyticsToSplit plugin (pluggable browser SDK)\n * @param {object} storage SDK storage passed to track events\n * @param {object} coreSettings core settings used to define an identity if no one provided as SDK or plugin options\n * @param {object} log factory logger\n */\nexport function GaToSplit(sdkOptions, params) {\n    var storage = params.storage, _a = params.settings, coreSettings = _a.core, log = _a.log, telemetryTracker = params.telemetryTracker;\n    var defaultOptions = {\n        prefix: defaultPrefix,\n        // We set default identities if key and TT are present in settings.core\n        identities: (coreSettings.key && coreSettings.trafficType) ?\n            [{ key: coreSettings.key, trafficType: coreSettings.trafficType }] :\n            undefined\n    };\n    var SplitTracker = /** @class */ (function () {\n        // Constructor for the SplitTracker plugin.\n        function SplitTracker(tracker, pluginOptions) {\n            // precedence of options: SDK options (config.integrations) overwrite pluginOptions (`ga('require', 'splitTracker', pluginOptions)`)\n            var opts = objectAssign({}, defaultOptions, sdkOptions, pluginOptions);\n            this.tracker = tracker;\n            // Validate identities\n            var validIdentities = validateIdentities(opts.identities);\n            if (validIdentities.length === 0) {\n                log.warn(logPrefix + 'No valid identities were provided. Please check that you are passing a valid list of identities or providing a traffic type at the SDK configuration.');\n                return;\n            }\n            var invalids = validIdentities.length - opts.identities.length;\n            if (invalids) {\n                log.warn(logPrefix + (invalids + \" identities were discarded because they are invalid or duplicated. Identities must be an array of objects with key and trafficType.\"));\n            }\n            opts.identities = validIdentities;\n            // Validate prefix\n            if (!isString(opts.prefix)) {\n                log.warn(logPrefix + 'The provided `prefix` was ignored since it is invalid. Please check that you are passing a string object as `prefix`.');\n                opts.prefix = undefined;\n            }\n            // Overwrite sendHitTask to perform plugin tasks:\n            // 1) filter hits\n            // 2) map hits to Split events\n            // 3) handle events, i.e., validate and send them to Split BE\n            var originalSendHitTask = tracker.get('sendHitTask');\n            tracker.set('sendHitTask', function (model) {\n                originalSendHitTask(model);\n                // filter hit if `hits` flag is false or if it comes from Split-to-GA integration\n                if (opts.hits === false || model.get('splitHit'))\n                    return;\n                try {\n                    if (opts.filter && !opts.filter(model))\n                        return;\n                }\n                catch (err) {\n                    log.warn(logPrefix + (\"custom filter threw: \" + err));\n                    return;\n                }\n                // map hit into an EventData instance\n                var eventData = defaultMapper(model);\n                if (opts.mapper) {\n                    try {\n                        eventData = opts.mapper(model, eventData);\n                    }\n                    catch (err) {\n                        log.warn(logPrefix + (\"custom mapper threw: \" + err));\n                        return;\n                    }\n                    if (!eventData)\n                        return;\n                }\n                // Add prefix. Nothing is appended if the prefix is falsy, e.g. undefined or ''.\n                if (opts.prefix)\n                    eventData.eventTypeId = opts.prefix + \".\" + eventData.eventTypeId;\n                eventData.eventTypeId = fixEventTypeId(log, eventData.eventTypeId);\n                if (!validateEventData(log, eventData))\n                    return;\n                // Store the event\n                if (eventData.key && eventData.trafficTypeName) {\n                    storage.events.track(eventData);\n                }\n                else { // Store the event for each Key-TT pair (identities), if key and TT is not present in eventData\n                    opts.identities.forEach(function (identity) {\n                        var event = objectAssign({\n                            key: identity.key,\n                            trafficTypeName: identity.trafficType,\n                        }, eventData);\n                        storage.events.track(event);\n                    });\n                }\n            });\n            log.info(logPrefix + 'integration started');\n        }\n        return SplitTracker;\n    }());\n    // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.\n    providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);\n}\n","import { GaToSplit } from './GaToSplit';\nexport function GoogleAnalyticsToSplit(options) {\n    if (options === void 0) { options = {}; }\n    // GaToSplit integration factory\n    function GoogleAnalyticsToSplitFactory(params) {\n        return GaToSplit(options, params);\n    }\n    GoogleAnalyticsToSplitFactory.type = 'GOOGLE_ANALYTICS_TO_SPLIT';\n    return GoogleAnalyticsToSplitFactory;\n}\n","/* eslint-disable no-undef */\nimport { uniq } from '../../utils/lang';\nimport { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';\nvar logPrefix = 'split-to-ga: ';\nvar noGaWarning = '`ga` command queue not found.';\nvar noHit = 'No hit was sent.';\nvar SplitToGa = /** @class */ (function () {\n    /**\n     * constructor description\n     * @param {object} options options passed at the SDK integrations settings (isomorphic SDK) or the SplitToGoogleAnalytics plugin (pluggable browser SDK)\n     */\n    function SplitToGa(log, options) {\n        this.trackerNames = SplitToGa.defaultTrackerNames;\n        this.log = log;\n        if (options) {\n            if (typeof options.filter === 'function')\n                this.filter = options.filter;\n            if (typeof options.mapper === 'function')\n                this.mapper = options.mapper;\n            // We strip off duplicated values if we received a `trackerNames` param.\n            // We don't warn if a tracker does not exist, since the user might create it after the SDK is initialized.\n            // Note: GA allows to create and get trackers using a string or number as tracker name, and does nothing if other types are used.\n            if (Array.isArray(options.trackerNames))\n                this.trackerNames = uniq(options.trackerNames);\n            // No need to validate `impressions` and `events` flags. Any other value than `false` is ignored (considered true by default).\n            this.impressions = options.impressions;\n            this.events = options.events;\n        }\n        log.info(logPrefix + 'integration started');\n        if (typeof SplitToGa.getGa() !== 'function')\n            log.warn(logPrefix + (noGaWarning + \" No hits will be sent until it is available.\"));\n    }\n    // Default mapper function.\n    SplitToGa.defaultMapper = function (_a) {\n        var type = _a.type, payload = _a.payload;\n        switch (type) {\n            case SPLIT_IMPRESSION:\n                return {\n                    hitType: 'event',\n                    eventCategory: 'split-impression',\n                    eventAction: 'Evaluate ' + payload.impression.feature,\n                    eventLabel: 'Treatment: ' + payload.impression.treatment + '. Targeting rule: ' + payload.impression.label + '.',\n                    nonInteraction: true,\n                };\n            case SPLIT_EVENT:\n                return {\n                    hitType: 'event',\n                    eventCategory: 'split-event',\n                    eventAction: payload.eventTypeId,\n                    eventValue: payload.value,\n                    nonInteraction: true,\n                };\n        }\n    };\n    // Util to access ga command queue, accounting for the possibility that it has been renamed.\n    SplitToGa.getGa = function () {\n        return typeof window !== 'undefined' ? window[window['GoogleAnalyticsObject'] || 'ga'] : undefined;\n    };\n    /**\n     * Validates if a given object is a UniversalAnalytics.FieldsObject instance, and logs a warning if not.\n     * It checks that the object contains a `hitType`, since it is the minimal field required to send the hit\n     * and avoid the GA error `No hit type specified. Aborting hit.`.\n     * Other validations (e.g., an `event` hitType must have a `eventCategory` and `eventAction`) are handled\n     * and logged (as warnings or errors depending the case) by GA debugger, but the hit is sent anyway.\n     *\n     * @param {object} log factory logger\n     * @param {UniversalAnalytics.FieldsObject} fieldsObject object to validate.\n     * @returns {boolean} Whether the data instance is a valid FieldsObject or not.\n     */\n    SplitToGa.validateFieldsObject = function (log, fieldsObject) {\n        if (fieldsObject && fieldsObject.hitType)\n            return true;\n        log.warn(logPrefix + 'your custom mapper returned an invalid FieldsObject instance. It must be an object with at least a `hitType` field.');\n        return false;\n    };\n    SplitToGa.prototype.queue = function (data) {\n        // access ga command queue via `getGa` method, accounting for the possibility that\n        // the global `ga` reference was not yet mutated by analytics.js.\n        var ga = SplitToGa.getGa();\n        if (ga) {\n            if (this.impressions === false && data.type === SPLIT_IMPRESSION)\n                return;\n            if (this.events === false && data.type === SPLIT_EVENT)\n                return;\n            var fieldsObject_1;\n            try { // only try/catch filter and mapper, which might be defined by the user\n                // filter\n                if (this.filter && !this.filter(data))\n                    return;\n                // map data into a FieldsObject instance\n                fieldsObject_1 = SplitToGa.defaultMapper(data);\n                if (this.mapper) {\n                    fieldsObject_1 = this.mapper(data, fieldsObject_1);\n                    // don't send the hit if it is falsy or invalid\n                    if (!fieldsObject_1 || !SplitToGa.validateFieldsObject(this.log, fieldsObject_1))\n                        return;\n                }\n            }\n            catch (err) {\n                this.log.warn(logPrefix + (\"queue method threw: \" + err + \". \" + noHit));\n                return;\n            }\n            // send the hit\n            this.trackerNames.forEach(function (trackerName) {\n                var sendCommand = trackerName ? trackerName + \".send\" : 'send';\n                // mark the hit as a Split one to avoid the loop.\n                fieldsObject_1.splitHit = true;\n                // Send to GA using our reference to the GA object.\n                ga(sendCommand, fieldsObject_1);\n            });\n        }\n        else {\n            this.log.warn(logPrefix + (noGaWarning + \" \" + noHit));\n        }\n    };\n    // A falsy object represents the default tracker\n    SplitToGa.defaultTrackerNames = [''];\n    return SplitToGa;\n}());\nexport { SplitToGa };\n","import { SplitToGa } from './SplitToGa';\nexport function SplitToGoogleAnalytics(options) {\n    if (options === void 0) { options = {}; }\n    // SplitToGa integration factory\n    function SplitToGoogleAnalyticsFactory(params) {\n        return new SplitToGa(params.settings.log, options);\n    }\n    SplitToGoogleAnalyticsFactory.type = 'SPLIT_TO_GOOGLE_ANALYTICS';\n    return SplitToGoogleAnalyticsFactory;\n}\n","import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '../utils/constants/browser';\nimport { pluggableIntegrationsManagerFactory } from './pluggable';\nimport { GoogleAnalyticsToSplit } from './ga/GoogleAnalyticsToSplit';\nimport { SplitToGoogleAnalytics } from './ga/SplitToGoogleAnalytics';\n/**\n * IntegrationsManager factory for the browser variant of the isomorphic JS SDK.\n * The integrations manager instantiates integration modules, and bypass tracked events and impressions to them.\n *\n * @param integrations valid integration settings object for browser sdk\n * @param params information of the Sdk factory instance that integrations can access to\n *\n * @returns integration manager or undefined if `integrations` are not present in settings.\n */\nexport function integrationsManagerFactory(integrations, params) {\n    // maps integration config items into integration factories to reuse the pluggable integration manager\n    var integrationFactories = integrations\n        .map(function (integrationOptions) {\n        switch (integrationOptions.type) {\n            case GOOGLE_ANALYTICS_TO_SPLIT: return GoogleAnalyticsToSplit(integrationOptions);\n            case SPLIT_TO_GOOGLE_ANALYTICS: return SplitToGoogleAnalytics(integrationOptions);\n        }\n    })\n        .filter(function (integrationFactory) {\n        return integrationFactory && typeof integrationFactory === 'function';\n    });\n    return pluggableIntegrationsManagerFactory(integrationFactories, params);\n}\n","import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';\nimport { ERROR_STORAGE_INVALID } from '../../../logger/constants';\nimport { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';\nexport function __InLocalStorageMockFactory(params) {\n    var result = InMemoryStorageCSFactory(params);\n    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE\n    return result;\n}\n__InLocalStorageMockFactory.type = STORAGE_MEMORY;\n/**\n * This function validates `settings.storage` object\n *\n * @param {any} settings config object provided by the user to initialize the sdk\n *\n * @returns {Object} valid storage factory. Default to `InMemoryStorageCSFactory` if the provided storage is invalid or not compatible with the sdk mode if mode is standalone or localhost\n *\n * @throws error if mode is consumer and the provided storage is not compatible\n */\nexport function validateStorageCS(settings) {\n    var _a = settings.storage, storage = _a === void 0 ? InMemoryStorageCSFactory : _a, log = settings.log, mode = settings.mode;\n    // If an invalid storage is provided, fallback into MEMORY\n    if (typeof storage !== 'function' || [STORAGE_MEMORY, STORAGE_LOCALSTORAGE, STORAGE_PLUGGABLE].indexOf(storage.type) === -1) {\n        storage = InMemoryStorageCSFactory;\n        log.error(ERROR_STORAGE_INVALID);\n    }\n    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE\n    if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {\n        return __InLocalStorageMockFactory;\n    }\n    if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {\n        // Consumer modes require an async storage\n        if (storage.type !== STORAGE_PLUGGABLE)\n            throw new Error('A PluggableStorage instance is required on consumer mode');\n    }\n    else {\n        // Standalone and localhost modes require a sync storage\n        if (storage.type === STORAGE_PLUGGABLE) {\n            storage = InMemoryStorageCSFactory;\n            log.error(ERROR_STORAGE_INVALID, [' It requires consumer mode.']);\n        }\n    }\n    // return default InMemory storage if provided one is not valid\n    return storage;\n}\n","/**\n * wraps a given promise in a new one with a default onRejected function,\n * that handles the promise rejection if not other onRejected handler is provided.\n *\n * Caveats:\n *  - There are some cases where the `defaultOnRejected` handler is not invoked\n * and the promise rejection must be handled by the user (same as the Promise spec):\n *    - using async/await syntax with a transpiler to Promises\n *    - setting an `onFinally` handler as the first handler (e.g. `promiseWrapper(Promise.reject()).finally(...)`)\n *    - setting more than one handler with at least one of them being an onRejected handler\n *  - If the wrapped promise is rejected when using native async/await syntax, the `defaultOnRejected` handler is invoked\n * and neither the catch block nor the remaining try block are executed.\n *\n * @param customPromise promise to wrap\n * @param defaultOnRejected default onRejected function\n * @returns a promise that doesn't need to be handled for rejection (except when using async/await syntax) and\n * includes a method named `hasOnFulfilled` that returns true if the promise has attached an onFulfilled handler.\n */\nexport function promiseWrapper(customPromise, defaultOnRejected) {\n    var hasOnFulfilled = false;\n    var hasOnRejected = false;\n    function chain(promise) {\n        var newPromise = new Promise(function (res, rej) {\n            return promise.then(res, function (value) {\n                if (hasOnRejected) {\n                    rej(value);\n                }\n                else {\n                    defaultOnRejected(value);\n                }\n            });\n        });\n        var originalThen = newPromise.then;\n        // Using `defineProperty` in case Promise.prototype.then property is not writable\n        Object.defineProperty(newPromise, 'then', {\n            value: function (onfulfilled, onrejected) {\n                var result = originalThen.call(newPromise, onfulfilled, onrejected);\n                if (typeof onfulfilled === 'function')\n                    hasOnFulfilled = true;\n                if (typeof onrejected === 'function') {\n                    hasOnRejected = true;\n                    return result;\n                }\n                else {\n                    return chain(result);\n                }\n            }\n        });\n        return newPromise;\n    }\n    var result = chain(customPromise);\n    result.hasOnFulfilled = function () { return hasOnFulfilled; };\n    return result;\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';\nfunction splitsEventEmitterFactory(EventEmitter) {\n    var splitsEventEmitter = objectAssign(new EventEmitter(), {\n        splitsArrived: false,\n        splitsCacheLoaded: false,\n    });\n    // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:\n    // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and\n    // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)\n    splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (isSplitKill) { if (!isSplitKill)\n        splitsEventEmitter.splitsArrived = true; });\n    splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });\n    return splitsEventEmitter;\n}\nfunction segmentsEventEmitterFactory(EventEmitter) {\n    var segmentsEventEmitter = objectAssign(new EventEmitter(), {\n        segmentsArrived: false\n    });\n    segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, function () { segmentsEventEmitter.segmentsArrived = true; });\n    return segmentsEventEmitter;\n}\n/**\n * Factory of readiness manager, which handles the ready / update event propagation.\n */\nexport function readinessManagerFactory(EventEmitter, readyTimeout, splits) {\n    if (readyTimeout === void 0) { readyTimeout = 0; }\n    if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }\n    var segments = segmentsEventEmitterFactory(EventEmitter);\n    var gate = new EventEmitter();\n    // emit SDK_READY_FROM_CACHE\n    var isReadyFromCache = false;\n    if (splits.splitsCacheLoaded)\n        isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE\n    else\n        splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);\n    // emit SDK_READY_TIMED_OUT\n    var hasTimedout = false;\n    var readyTimeoutId;\n    if (readyTimeout > 0) {\n        readyTimeoutId = setTimeout(function () {\n            hasTimedout = true;\n            gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');\n        }, readyTimeout);\n    }\n    // emit SDK_READY and SDK_UPDATE\n    var isReady = false;\n    splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);\n    segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);\n    var isDestroyed = false;\n    function checkIsReadyFromCache() {\n        isReadyFromCache = true;\n        // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted\n        if (!isReady) {\n            try {\n                gate.emit(SDK_READY_FROM_CACHE);\n            }\n            catch (e) {\n                // throws user callback exceptions in next tick\n                setTimeout(function () { throw e; }, 0);\n            }\n        }\n    }\n    function checkIsReadyOrUpdate(diff) {\n        if (isReady) {\n            try {\n                gate.emit(SDK_UPDATE, diff);\n            }\n            catch (e) {\n                // throws user callback exceptions in next tick\n                setTimeout(function () { throw e; }, 0);\n            }\n        }\n        else {\n            if (splits.splitsArrived && segments.segmentsArrived) {\n                clearTimeout(readyTimeoutId);\n                isReady = true;\n                try {\n                    gate.emit(SDK_READY);\n                }\n                catch (e) {\n                    // throws user callback exceptions in next tick\n                    setTimeout(function () { throw e; }, 0);\n                }\n            }\n        }\n    }\n    var refCount = 1;\n    return {\n        splits: splits,\n        segments: segments,\n        gate: gate,\n        shared: function (readyTimeout) {\n            if (readyTimeout === void 0) { readyTimeout = 0; }\n            refCount++;\n            return readinessManagerFactory(EventEmitter, readyTimeout, splits);\n        },\n        destroy: function () {\n            isDestroyed = true;\n            segments.removeAllListeners();\n            gate.removeAllListeners();\n            clearTimeout(readyTimeoutId);\n            if (refCount > 0)\n                refCount--;\n            if (refCount === 0)\n                splits.removeAllListeners();\n        },\n        isReady: function () { return isReady; },\n        hasTimedout: function () { return hasTimedout; },\n        isReadyFromCache: function () { return isReadyFromCache; },\n        isDestroyed: function () { return isDestroyed; },\n        isOperational: function () { return (isReady || isReadyFromCache) && !isDestroyed; }\n    };\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { promiseWrapper } from '../utils/promise/wrapper';\nimport { readinessManagerFactory } from './readinessManager';\nimport { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';\nimport { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';\nvar NEW_LISTENER_EVENT = 'newListener';\nvar REMOVE_LISTENER_EVENT = 'removeListener';\n/**\n * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).\n * It also updates logs related warnings and errors.\n *\n * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event\n * @param readinessManager optional readinessManager to use. only used internally for `shared` method\n */\nexport function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager) {\n    if (readyTimeout === void 0) { readyTimeout = 0; }\n    if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, readyTimeout); }\n    /** Ready callback warning */\n    var internalReadyCbCount = 0;\n    var readyCbCount = 0;\n    readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {\n        if (event === SDK_READY)\n            readyCbCount--;\n    });\n    readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {\n        if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {\n            if (readinessManager.isReady()) {\n                log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);\n            }\n            else if (event === SDK_READY) {\n                readyCbCount++;\n            }\n        }\n    });\n    /** Ready promise */\n    var readyPromise = generateReadyPromise();\n    readinessManager.gate.once(SDK_READY_FROM_CACHE, function () {\n        log.info(CLIENT_READY_FROM_CACHE);\n    });\n    // default onRejected handler, that just logs the error, if ready promise doesn't have one.\n    function defaultOnRejected(err) {\n        log.error(err && err.message);\n    }\n    function generateReadyPromise() {\n        var promise = promiseWrapper(new Promise(function (resolve, reject) {\n            readinessManager.gate.once(SDK_READY, function () {\n                log.info(CLIENT_READY);\n                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())\n                    log.warn(CLIENT_NO_LISTENER);\n                resolve();\n            });\n            readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {\n                reject(new Error(message));\n            });\n        }), defaultOnRejected);\n        return promise;\n    }\n    return {\n        readinessManager: readinessManager,\n        shared: function (readyTimeout) {\n            if (readyTimeout === void 0) { readyTimeout = 0; }\n            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));\n        },\n        incInternalReadyCbCount: function () {\n            internalReadyCbCount++;\n        },\n        sdkStatus: objectAssign(\n        // Expose Event Emitter functionality\n        Object.create(readinessManager.gate), {\n            // Expose the event constants without changing the interface\n            Event: {\n                SDK_READY: SDK_READY,\n                SDK_READY_FROM_CACHE: SDK_READY_FROM_CACHE,\n                SDK_UPDATE: SDK_UPDATE,\n                SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT,\n            },\n            /**\n             * Returns a promise that will be resolved once the SDK has finished loading (SDK_READY event emitted) or rejected if the SDK has timedout (SDK_READY_TIMED_OUT event emitted).\n             * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, calling the `ready` method after the\n             * SDK had timed out will return a new promise that should eventually resolve if the SDK gets ready.\n             *\n             * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.\n             * However, when using async/await syntax, the rejection should be explicitly propagated like in the following example:\n             * ```\n             * try {\n             *   await client.ready().catch((e) => { throw e; });\n             *   // SDK is ready\n             * } catch(e) {\n             *   // SDK has timedout\n             * }\n             * ```\n             *\n             * @function ready\n             * @returns {Promise<void>}\n             */\n            ready: function () {\n                if (readinessManager.hasTimedout()) {\n                    if (!readinessManager.isReady()) {\n                        return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);\n                    }\n                    else {\n                        return Promise.resolve();\n                    }\n                }\n                return readyPromise;\n            },\n            // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.\n            __getStatus: function () {\n                return {\n                    isReady: readinessManager.isReady(),\n                    isReadyFromCache: readinessManager.isReadyFromCache(),\n                    isOperational: readinessManager.isOperational(),\n                    hasTimedout: readinessManager.hasTimedout(),\n                    isDestroyed: readinessManager.isDestroyed(),\n                };\n            },\n        })\n    };\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { thenable } from '../utils/promise/thenable';\nimport { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';\nimport { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';\n/**\n * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.\n *\n * @param impressionsCache cache to save impressions\n * @param metadata runtime metadata (ip, hostname and version)\n * @param impressionListener optional impression listener\n * @param integrationsManager optional integrations manager\n * @param strategy strategy for impressions tracking.\n */\nexport function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {\n    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;\n    return {\n        track: function (impressions, attributes) {\n            if (settings.userConsent === CONSENT_DECLINED)\n                return;\n            var impressionsCount = impressions.length;\n            var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;\n            var impressionsToListenerCount = impressionsToListener.length;\n            if (impressionsToStore.length > 0) {\n                var res = impressionsCache.track(impressionsToStore);\n                // If we're on an async storage, handle error and log it.\n                if (thenable(res)) {\n                    res.then(function () {\n                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);\n                    }).catch(function (err) {\n                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);\n                    });\n                }\n                else {\n                    // Record when impressionsCache is sync only (standalone mode)\n                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded\n                    if (telemetryCache) {\n                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);\n                        telemetryCache.recordImpressionStats(DEDUPED, deduped);\n                    }\n                }\n            }\n            // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor\n            if (impressionListener || integrationsManager) {\n                var _loop_1 = function (i) {\n                    var impressionData = {\n                        // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener\n                        impression: objectAssign({}, impressionsToListener[i]),\n                        attributes: attributes,\n                        ip: ip,\n                        hostname: hostname,\n                        sdkLanguageVersion: version\n                    };\n                    // Wrap in a timeout because we don't want it to be blocking.\n                    setTimeout(function () {\n                        // integrationsManager.handleImpression does not throw errors\n                        if (integrationsManager)\n                            integrationsManager.handleImpression(impressionData);\n                        try { // @ts-ignore. An exception on the listeners should not break the SDK.\n                            if (impressionListener)\n                                impressionListener.logImpression(impressionData);\n                        }\n                        catch (err) {\n                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);\n                        }\n                    }, 0);\n                };\n                for (var i = 0; i < impressionsToListenerCount; i++) {\n                    _loop_1(i);\n                }\n            }\n        }\n    };\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { thenable } from '../utils/promise/thenable';\nimport { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';\nimport { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';\nimport { isStorageSync } from './impressionObserver/utils';\n/**\n * Event tracker stores events in cache and pass them to the integrations manager if provided.\n *\n * @param eventsCache cache to save events\n * @param integrationsManager optional event handler used for integrations\n */\nexport function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {\n    var log = settings.log;\n    var isSync = isStorageSync(settings);\n    function queueEventsCallback(eventData, tracked) {\n        var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;\n        // Logging every prop would be too much.\n        var msg = \"event of type \\\"\" + eventTypeId + \"\\\" for traffic type \\\"\" + trafficTypeName + \"\\\". Key: \" + key + \". Value: \" + value + \". Timestamp: \" + timestamp + \". \" + (properties ? 'With properties.' : 'With no properties.');\n        if (tracked) {\n            log.info(EVENTS_TRACKER_SUCCESS, [msg]);\n            if (integrationsManager) {\n                // Wrap in a timeout because we don't want it to be blocking.\n                setTimeout(function () {\n                    // copy of event, to avoid unexpected behaviour if modified by integrations\n                    var eventDataCopy = objectAssign({}, eventData);\n                    if (eventData.properties)\n                        eventDataCopy.properties = objectAssign({}, eventData.properties);\n                    // integrationsManager does not throw errors (they are internally handled by each integration module)\n                    integrationsManager.handleEvent(eventDataCopy);\n                }, 0);\n            }\n        }\n        else {\n            log.error(ERROR_EVENTS_TRACKER, [msg]);\n        }\n        return tracked;\n    }\n    return {\n        track: function (eventData, size) {\n            if (settings.userConsent === CONSENT_DECLINED) {\n                return isSync ? false : Promise.resolve(false);\n            }\n            var tracked = eventsCache.track(eventData, size);\n            if (thenable(tracked)) {\n                return tracked.then(queueEventsCallback.bind(null, eventData));\n            }\n            else {\n                // Record when eventsCache is sync only (standalone mode)\n                // @TODO we are not dropping events on full queue yet, so `tracked` is always true ATM\n                if (telemetryCache)\n                    telemetryCache.recordEventStats(tracked ? QUEUED : DROPPED, 1);\n                return queueEventsCallback(eventData, tracked);\n            }\n        }\n    };\n}\n","import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';\nimport { timer } from '../utils/timeTracker/timer';\nimport { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';\nexport function telemetryTrackerFactory(telemetryCache, now) {\n    if (telemetryCache && now) {\n        var startTime_1 = timer(now);\n        return {\n            trackEval: function (method) {\n                var evalTime = timer(now);\n                return function (label) {\n                    switch (label) {\n                        case EXCEPTION:\n                            telemetryCache.recordException(method);\n                            return; // Don't track latency on exceptions\n                        case SDK_NOT_READY: // @ts-ignore ITelemetryCacheAsync doesn't implement the method\n                            if (telemetryCache.recordNonReadyUsage)\n                                telemetryCache.recordNonReadyUsage();\n                    }\n                    telemetryCache.recordLatency(method, evalTime());\n                };\n            },\n            trackHttp: function (operation) {\n                var httpTime = timer(now);\n                return function (error) {\n                    telemetryCache.recordHttpLatency(operation, httpTime());\n                    if (error && error.statusCode)\n                        telemetryCache.recordHttpError(operation, error.statusCode);\n                    else\n                        telemetryCache.recordSuccessfulSync(operation, Date.now());\n                };\n            },\n            sessionLength: function () {\n                if (telemetryCache.recordSessionLength)\n                    telemetryCache.recordSessionLength(startTime_1());\n            },\n            streamingEvent: function (e, d) {\n                if (e === AUTH_REJECTION) {\n                    telemetryCache.recordAuthRejections();\n                }\n                else {\n                    telemetryCache.recordStreamingEvents({\n                        e: e,\n                        d: d,\n                        t: Date.now()\n                    });\n                    if (e === TOKEN_REFRESH)\n                        telemetryCache.recordTokenRefreshes();\n                }\n            },\n            addTag: function (tag) {\n                // @ts-ignore\n                if (telemetryCache.addTag)\n                    telemetryCache.addTag(tag);\n            }\n        };\n    }\n    else { // If there is not `telemetryCache` or `now` time tracker, return a no-op telemetry tracker\n        var noopTrack = function () { return function () { }; };\n        return {\n            trackEval: noopTrack,\n            trackHttp: noopTrack,\n            sessionLength: function () { },\n            streamingEvent: function () { },\n            addTag: function () { }\n        };\n    }\n}\n","import { objectAssign } from '../utils/lang/objectAssign';\nimport { find } from '../utils/lang';\nimport { _Map } from '../utils/lang/maps';\nexport var LogLevels = {\n    DEBUG: 'DEBUG',\n    INFO: 'INFO',\n    WARN: 'WARN',\n    ERROR: 'ERROR',\n    NONE: 'NONE'\n};\nvar LogLevelIndexes = {\n    DEBUG: 1,\n    INFO: 2,\n    WARN: 3,\n    ERROR: 4,\n    NONE: 5\n};\nexport function isLogLevelString(str) {\n    return !!find(LogLevels, function (lvl) { return str === lvl; });\n}\n// exported for testing purposes only\nexport function _sprintf(format, args) {\n    if (format === void 0) { format = ''; }\n    if (args === void 0) { args = []; }\n    var i = 0;\n    return format.replace(/%s/g, function () {\n        return args[i++];\n    });\n}\nvar defaultOptions = {\n    prefix: 'splitio',\n    logLevel: LogLevels.NONE,\n    showLevel: true,\n};\nvar Logger = /** @class */ (function () {\n    function Logger(options, codes) {\n        this.options = objectAssign({}, defaultOptions, options);\n        this.codes = codes || new _Map();\n        this.logLevel = LogLevelIndexes[this.options.logLevel];\n    }\n    Logger.prototype.setLogLevel = function (logLevel) {\n        this.options.logLevel = logLevel;\n        this.logLevel = LogLevelIndexes[logLevel];\n    };\n    Logger.prototype.debug = function (msg, args) {\n        if (this._shouldLog(LogLevelIndexes.DEBUG))\n            this._log(LogLevels.DEBUG, msg, args);\n    };\n    Logger.prototype.info = function (msg, args) {\n        if (this._shouldLog(LogLevelIndexes.INFO))\n            this._log(LogLevels.INFO, msg, args);\n    };\n    Logger.prototype.warn = function (msg, args) {\n        if (this._shouldLog(LogLevelIndexes.WARN))\n            this._log(LogLevels.WARN, msg, args);\n    };\n    Logger.prototype.error = function (msg, args) {\n        if (this._shouldLog(LogLevelIndexes.ERROR))\n            this._log(LogLevels.ERROR, msg, args);\n    };\n    Logger.prototype._log = function (level, msg, args) {\n        if (typeof msg === 'number') {\n            var format = this.codes.get(msg);\n            msg = format ? _sprintf(format, args) : \"Message code \" + msg + (args ? ', with args: ' + args.toString() : '');\n        }\n        else {\n            if (args)\n                msg = _sprintf(msg, args);\n        }\n        var formattedText = this._generateLogMessage(level, msg);\n        console.log(formattedText);\n    };\n    Logger.prototype._generateLogMessage = function (level, text) {\n        var textPre = ' => ';\n        var result = '';\n        if (this.options.showLevel) {\n            result += '[' + level + ']' + (level === LogLevels.INFO || level === LogLevels.WARN ? ' ' : '') + ' ';\n        }\n        if (this.options.prefix) {\n            result += this.options.prefix + textPre;\n        }\n        return result += text;\n    };\n    Logger.prototype._shouldLog = function (level) {\n        return level >= this.logLevel;\n    };\n    return Logger;\n}());\nexport { Logger };\n","import { LogLevels, isLogLevelString } from './index';\nimport { ERROR_LOGLEVEL_INVALID } from './constants';\n/**\n * The public Logger utility API exposed via SplitFactory, used to update the log level.\n *\n * @param log the factory logger instance to handle\n */\nexport function createLoggerAPI(log) {\n    function setLogLevel(logLevel) {\n        if (isLogLevelString(logLevel)) {\n            log.setLogLevel(logLevel);\n        }\n        else {\n            log.error(ERROR_LOGLEVEL_INVALID);\n        }\n    }\n    return {\n        /**\n         * Enables all the logs.\n         */\n        enable: function () {\n            setLogLevel(LogLevels.DEBUG);\n        },\n        /**\n         * Sets a custom log Level for the SDK.\n         * @param {string} logLevel - Custom LogLevel value.\n         */\n        setLogLevel: setLogLevel,\n        /**\n         * Disables all the log levels.\n         */\n        disable: function () {\n            // Disabling is equal logLevel none\n            setLogLevel(LogLevels.NONE);\n        },\n        /**\n         * Exposed for usage with setLogLevel\n         */\n        LogLevel: LogLevels\n    };\n}\n","/**\n * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds\n *\n * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances\n * @returns IStrategyResult\n */\nexport function strategyDebugFactory(impressionsObserver) {\n    return {\n        process: function (impressions) {\n            impressions.forEach(function (impression) {\n                // Adds previous time if it is enabled\n                impression.pt = impressionsObserver.testAndSet(impression);\n            });\n            return {\n                impressionsToStore: impressions,\n                impressionsToListener: impressions,\n                deduped: 0\n            };\n        }\n    };\n}\n","import { truncateTimeFrame } from '../../utils/time';\n/**\n * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds\n *\n * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances\n * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)\n * @returns IStrategyResult\n */\nexport function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {\n    return {\n        process: function (impressions) {\n            var impressionsToStore = [];\n            impressions.forEach(function (impression) {\n                impression.pt = impressionsObserver.testAndSet(impression);\n                var now = Date.now();\n                // Increments impression counter per featureName\n                if (impression.pt)\n                    impressionsCounter.track(impression.feature, now, 1);\n                // Checks if the impression should be added in queue to be sent\n                if (!impression.pt || impression.pt < truncateTimeFrame(now)) {\n                    impressionsToStore.push(impression);\n                }\n            });\n            return {\n                impressionsToStore: impressionsToStore,\n                impressionsToListener: impressions,\n                deduped: impressions.length - impressionsToStore.length\n            };\n        }\n    };\n}\n","/**\n * None strategy for impressions tracker.\n *\n * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)\n * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.\n * @returns IStrategyResult\n */\nexport function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {\n    return {\n        process: function (impressions) {\n            impressions.forEach(function (impression) {\n                var now = Date.now();\n                // Increments impression counter per featureName\n                impressionsCounter.track(impression.feature, now, 1);\n                // Keep track by unique key\n                uniqueKeysTracker.track(impression.keyName, impression.feature);\n            });\n            return {\n                impressionsToStore: [],\n                impressionsToListener: impressions,\n                deduped: 0\n            };\n        }\n    };\n}\n","import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';\nvar noopFilterAdapter = {\n    add: function () { return true; },\n    contains: function () { return true; },\n    clear: function () { }\n};\n/**\n * Trackes uniques keys\n * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period\n * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.\n *\n * @param log Logger instance\n * @param uniqueKeysCache cache to save unique keys\n * @param filterAdapter filter adapter\n */\nexport function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {\n    if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }\n    var intervalId;\n    if (filterAdapter.refreshRate) {\n        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);\n    }\n    return {\n        track: function (key, featureName) {\n            if (!filterAdapter.add(key, featureName)) {\n                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + \"The feature \" + featureName + \" and key \" + key + \" exist in the filter\");\n                return;\n            }\n            uniqueKeysCache.track(key, featureName);\n        },\n        stop: function () {\n            clearInterval(intervalId);\n        }\n    };\n}\n","import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';\nimport { impressionsTrackerFactory } from '../trackers/impressionsTracker';\nimport { eventTrackerFactory } from '../trackers/eventTracker';\nimport { telemetryTrackerFactory } from '../trackers/telemetryTracker';\nimport { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';\nimport { createLoggerAPI } from '../logger/sdkLogger';\nimport { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';\nimport { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';\nimport { objectAssign } from '../utils/lang/objectAssign';\nimport { strategyDebugFactory } from '../trackers/strategy/strategyDebug';\nimport { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';\nimport { strategyNoneFactory } from '../trackers/strategy/strategyNone';\nimport { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';\nimport { NONE, OPTIMIZED } from '../utils/constants';\n/**\n * Modular SDK factory\n */\nexport function sdkFactory(params) {\n    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;\n    var log = settings.log, impressionsMode = settings.sync.impressionsMode;\n    // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.\n    // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.\n    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.\n    validateAndTrackApiKey(log, settings.core.authorizationKey);\n    var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);\n    var readiness = sdkReadinessManager.readinessManager;\n    var storage = storageFactory({\n        settings: settings,\n        onReadyCb: function (error) {\n            if (error)\n                return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter\n            readiness.splits.emit(SDK_SPLITS_ARRIVED);\n            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);\n        },\n    });\n    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`\n    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);\n    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });\n    var observer = impressionsObserverFactory();\n    var uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;\n    var strategy;\n    switch (impressionsMode) {\n        case OPTIMIZED:\n            strategy = strategyOptimizedFactory(observer, storage.impressionCounts);\n            break;\n        case NONE:\n            strategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);\n            break;\n        default:\n            strategy = strategyDebugFactory(observer);\n    }\n    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);\n    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);\n    // splitApi is used by SyncManager and Browser signal listener\n    var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);\n    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };\n    var syncManager = syncManagerFactory && syncManagerFactory(ctx);\n    ctx.syncManager = syncManager;\n    var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);\n    ctx.signalListener = signalListener;\n    // SDK client and manager\n    var clientMethod = sdkClientMethodFactory(ctx);\n    var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);\n    syncManager && syncManager.start();\n    signalListener && signalListener.start();\n    log.info(NEW_FACTORY);\n    // @ts-ignore\n    return objectAssign({\n        // Split evaluation and event tracking engine\n        client: clientMethod,\n        // Manager API to explore available information\n        manager: function () {\n            log.debug(RETRIEVE_MANAGER);\n            return managerInstance;\n        },\n        // Logger wrapper API\n        Logger: createLoggerAPI(log),\n        settings: settings,\n    }, extraProps && extraProps(ctx));\n}\n","import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED, USER_CONSENT_INITIAL } from '../logger/constants';\nimport { isConsentGranted } from './index';\nimport { CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../utils/constants';\nimport { isBoolean } from '../utils/lang';\n// User consent enum\nvar ConsentStatus = {\n    GRANTED: CONSENT_GRANTED,\n    DECLINED: CONSENT_DECLINED,\n    UNKNOWN: CONSENT_UNKNOWN,\n};\n/**\n * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.\n */\nexport function createUserConsentAPI(params) {\n    var settings = params.settings, log = params.settings.log, syncManager = params.syncManager, _a = params.storage, events = _a.events, impressions = _a.impressions, impressionCounts = _a.impressionCounts;\n    if (!isConsentGranted(settings))\n        log.info(USER_CONSENT_INITIAL, [settings.userConsent]);\n    return {\n        setStatus: function (consent) {\n            var _a, _b;\n            // validate input param\n            if (!isBoolean(consent)) {\n                log.warn(ERROR_NOT_BOOLEAN, ['UserConsent.setStatus']);\n                return false;\n            }\n            var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;\n            if (settings.userConsent !== newConsentStatus) {\n                log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop\n                settings.userConsent = newConsentStatus;\n                if (consent) { // resumes submitters if transitioning to GRANTED\n                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _a === void 0 ? void 0 : _a.start();\n                }\n                else { // pauses submitters (except telemetry), and drops tracked data if transitioning to DECLINED\n                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _b === void 0 ? void 0 : _b.stop(true);\n                    // @ts-ignore, clear method is present in storage for standalone and partial consumer mode\n                    if (events.clear)\n                        events.clear(); // @ts-ignore\n                    if (impressions.clear)\n                        impressions.clear(); // @ts-ignore\n                    if (impressionCounts && impressionCounts.clear)\n                        impressionCounts.clear();\n                }\n            }\n            else {\n                log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);\n            }\n            return true;\n        },\n        getStatus: function () {\n            return settings.userConsent;\n        },\n        Status: ConsentStatus\n    };\n}\n","// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.\nexport function validateRuntime() {\n    return {\n        ip: false,\n        hostname: false\n    };\n}\n","/**\n * 'true' if running in Node.js, or 'false' otherwise.\n * We check for version truthiness since most shims will have that as empty string.\n */\n// eslint-disable-next-line no-undef\nexport var isNode = typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version ? true : false;\n","import * as c from '../constants';\nexport var codesError = [\n    // evaluator\n    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid Split, no valid rules found'],\n    // SDK\n    [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],\n    [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],\n    [c.ERROR_IMPRESSIONS_TRACKER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Could not store impressions bulk with %s impression(s). Error: %s'],\n    [c.ERROR_IMPRESSIONS_LISTENER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Impression listener logImpression method threw: %s.'],\n    [c.ERROR_EVENTS_TRACKER, c.LOG_PREFIX_EVENTS_TRACKER + 'Failed to queue %s'],\n    // synchronizer\n    [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'],\n    [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],\n    [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],\n    [c.ERROR_HTTP, 'Response status is not OK. Status: %s. URL: %s. Message: %s'],\n    // client status\n    [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\\'t be emitted again. The callback won\\'t be executed.'],\n    [c.ERROR_CLIENT_DESTROYED, '%s: Client has already been destroyed - no calls possible.'],\n    // input validation\n    [c.ERROR_EVENT_TYPE_FORMAT, '%s: you passed \"%s\", event_type must adhere to the regular expression /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/g. This means an event_type must be alphanumeric, cannot be more than 80 characters long, and can only include a dash, underscore, period, or colon as separators of alphanumeric characters.'],\n    [c.ERROR_NOT_PLAIN_OBJECT, '%s: %s must be a plain object.'],\n    [c.ERROR_SIZE_EXCEEDED, '%s: the maximum size allowed for the properties is 32768 bytes, which was exceeded. Event not queued.'],\n    [c.ERROR_NOT_FINITE, '%s: value must be a finite number.'],\n    [c.ERROR_NULL, '%s: you passed a null or undefined %s. It must be a non-empty string.'],\n    [c.ERROR_TOO_LONG, '%s: %s too long. It must have 250 characters or less.'],\n    [c.ERROR_INVALID_KEY_OBJECT, '%s: Key must be an object with bucketingKey and matchingKey with valid string properties.'],\n    [c.ERROR_INVALID, '%s: you passed an invalid %s. It must be a non-empty string.'],\n    [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],\n    [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],\n    [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],\n    // initialization / settings validation\n    [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid \"%s\" config param. It should be one of the following values: %s. Defaulting to \"%s\".'],\n    [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for \"sync.localhostMode\" config. A valid entity should be provided for localhost mode.'],\n    [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],\n    [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided \"%s\" config param is lower than allowed. Setting to the minimum value %s seconds'],\n];\n","import * as c from '../constants';\nimport { codesError } from './error';\nexport var codesWarn = codesError.concat([\n    // evaluator\n    [c.ENGINE_VALUE_INVALID, c.LOG_PREFIX_ENGINE_VALUE + 'Value %s doesn\\'t match with expected type.'],\n    [c.ENGINE_VALUE_NO_ATTRIBUTES, c.LOG_PREFIX_ENGINE_VALUE + 'Defined attribute [%s], no attributes received.'],\n    // synchronizer\n    [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying download of segments #%s. Reason: %s'],\n    [c.SYNC_SPLITS_FETCH_FAILS, c.LOG_PREFIX_SYNC_SPLITS + 'Error while doing fetch of Splits. %s'],\n    [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],\n    [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],\n    [c.STREAMING_FALLBACK, c.LOG_PREFIX_SYNC_STREAMING + 'Falling back to polling mode. Reason: %s'],\n    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s.'],\n    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],\n    // client status\n    [c.CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.'],\n    [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],\n    // input validation\n    [c.WARN_SETTING_NULL, '%s: Property \"%s\" is of invalid type. Setting value to null.'],\n    [c.WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. Some of them will be trimmed when processed.'],\n    [c.WARN_CONVERTING, '%s: %s \"%s\" is not of type string, converting.'],\n    [c.WARN_TRIMMING, '%s: %s \"%s\" has extra whitespace, trimming.'],\n    [c.WARN_NOT_EXISTENT_SPLIT, '%s: split \"%s\" does not exist in this environment, please double check what splits exist in the Split web console.'],\n    [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],\n    [c.WARN_NOT_EXISTENT_TT, '%s: traffic type \"%s\" does not have any corresponding split in this environment, make sure you\\'re tracking your events to a valid traffic type defined in the Split web console.'],\n    // initialization / settings validation\n    [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],\n    [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS + ': split filters have been configured but will have no effect if mode is not \"%s\", since synchronization is being deferred to an external tool.'],\n    [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': split filter at position %s is invalid. It must be an object with a valid filter type (\"byName\" or \"byPrefix\") and a list of \"values\".'],\n    [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': splitFilters configuration must be a non-empty array of filter objects.'],\n    [c.WARN_API_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],\n    [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],\n]);\n","import * as c from '../constants';\nimport { codesWarn } from './warn';\nvar READY_MSG = 'Split SDK is ready';\nexport var codesInfo = codesWarn.concat([\n    // client status\n    [c.CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'],\n    [c.CLIENT_READY, READY_MSG],\n    // SDK\n    [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Split: %s. Key: %s. Evaluation: %s. Label: %s'],\n    [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing corresponding impression.'],\n    [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],\n    [c.NEW_FACTORY, 'New Split SDK instance created.'],\n    [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],\n    [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],\n    [c.USER_CONSENT_UPDATED, 'UserConsent: consent status changed from %s to %s.'],\n    [c.USER_CONSENT_NOT_UPDATED, 'UserConsent: call had no effect because it was the current consent status (%s).'],\n    [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],\n    // synchronizer\n    [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],\n    [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],\n    [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],\n    [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],\n    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],\n    [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],\n    [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],\n    [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],\n    [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting streaming.'],\n    [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given Api key. Switching to polling mode.'],\n    [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting streaming.'],\n    [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],\n    [c.SYNC_CONTINUE_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming couldn\\'t connect. Continue polling.'],\n    [c.SYNC_STOP_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming connected. Syncing and stopping polling.'],\n]);\n","import * as c from '../constants';\nimport { codesInfo } from './info';\nexport var codesDebug = codesInfo.concat([\n    // evaluator\n    [c.ENGINE_COMBINER_AND, c.LOG_PREFIX_ENGINE_COMBINER + '[andCombiner] evaluates to %s'],\n    [c.ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Treatment found: %s'],\n    [c.ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, c.LOG_PREFIX_ENGINE_COMBINER + 'All predicates evaluated, no treatment found.'],\n    [c.ENGINE_BUCKET, c.LOG_PREFIX_ENGINE + ': using algo \"murmur\" bucket %s for key %s using seed %s - treatment %s'],\n    [c.ENGINE_MATCHER_ALL, c.LOG_PREFIX_ENGINE_MATCHER + '[allMatcher] is always true'],\n    [c.ENGINE_MATCHER_BETWEEN, c.LOG_PREFIX_ENGINE_MATCHER + '[betweenMatcher] is %s between %s and %s? %s'],\n    [c.ENGINE_MATCHER_BOOLEAN, c.LOG_PREFIX_ENGINE_MATCHER + '[booleanMatcher] %s === %s'],\n    [c.ENGINE_MATCHER_CONTAINS_ALL, c.LOG_PREFIX_ENGINE_MATCHER + '[containsAllMatcher] %s contains all elements of %s? %s'],\n    [c.ENGINE_MATCHER_CONTAINS_ANY, c.LOG_PREFIX_ENGINE_MATCHER + '[containsAnyMatcher] %s contains at least an element of %s? %s'],\n    [c.ENGINE_MATCHER_CONTAINS_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[containsStringMatcher] %s contains %s? %s'],\n    [c.ENGINE_MATCHER_DEPENDENCY, c.LOG_PREFIX_ENGINE_MATCHER + '[dependencyMatcher] parent split \"%s\" evaluated to \"%s\" with label \"%s\". %s evaluated treatment is part of [%s] ? %s.'],\n    [c.ENGINE_MATCHER_DEPENDENCY_PRE, c.LOG_PREFIX_ENGINE_MATCHER + '[dependencyMatcher] will evaluate parent split: \"%s\" with key: %s %s'],\n    [c.ENGINE_MATCHER_EQUAL, c.LOG_PREFIX_ENGINE_MATCHER + '[equalToMatcher] is %s equal to %s? %s'],\n    [c.ENGINE_MATCHER_EQUAL_TO_SET, c.LOG_PREFIX_ENGINE_MATCHER + '[equalToSetMatcher] is %s equal to set %s? %s'],\n    [c.ENGINE_MATCHER_ENDS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[endsWithMatcher] %s ends with %s? %s'],\n    [c.ENGINE_MATCHER_GREATER, c.LOG_PREFIX_ENGINE_MATCHER + '[greaterThanEqualMatcher] is %s greater than %s? %s'],\n    [c.ENGINE_MATCHER_LESS, c.LOG_PREFIX_ENGINE_MATCHER + '[lessThanEqualMatcher] is %s less than %s? %s'],\n    [c.ENGINE_MATCHER_PART_OF, c.LOG_PREFIX_ENGINE_MATCHER + '[partOfMatcher] %s is part of %s? %s'],\n    [c.ENGINE_MATCHER_SEGMENT, c.LOG_PREFIX_ENGINE_MATCHER + '[segmentMatcher] evaluated %s / %s => %s'],\n    [c.ENGINE_MATCHER_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] does %s matches with %s? %s'],\n    [c.ENGINE_MATCHER_STRING_INVALID, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] %s is an invalid regex'],\n    [c.ENGINE_MATCHER_STARTS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[startsWithMatcher] %s starts with %s? %s'],\n    [c.ENGINE_MATCHER_WHITELIST, c.LOG_PREFIX_ENGINE_MATCHER + '[whitelistMatcher] evaluated %s in [%s] => %s'],\n    [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute [%s], [%s] will be used for matching.'],\n    [c.ENGINE_SANITIZE, c.LOG_PREFIX_ENGINE + ':sanitize: Attempted to sanitize [%s] which should be of type [%s]. Sanitized and processed value => [%s]'],\n    // SDK\n    [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],\n    [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],\n    [c.RETRIEVE_CLIENT_DEFAULT, 'Retrieving default SDK client.'],\n    [c.RETRIEVE_CLIENT_EXISTING, 'Retrieving existing SDK client.'],\n    [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],\n    // synchronizer\n    [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Splits data: \\n%s'],\n    [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up split update using since = %s'],\n    [c.SYNC_SPLITS_NEW, c.LOG_PREFIX_SYNC_SPLITS + 'New splits %s'],\n    [c.SYNC_SPLITS_REMOVED, c.LOG_PREFIX_SYNC_SPLITS + 'Removed splits %s'],\n    [c.SYNC_SPLITS_SEGMENTS, c.LOG_PREFIX_SYNC_SPLITS + 'Segment names collected %s'],\n    [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],\n    [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],\n    [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],\n    [c.SYNC_TASK_STOP, c.LOG_PREFIX_SYNC + ': Stopping %s'],\n    // initialization / settings validation\n    [c.SETTINGS_SPLITS_FILTER, c.LOG_PREFIX_SETTINGS + ': splits filtering criteria is \"%s\".']\n]);\n","import { LogLevels, isLogLevelString } from '../../../logger';\n/**\n * Returns the LogLevel for the given debugValue or undefined if it is invalid,\n * i.e., if the debugValue is not a boolean or LogLevel string.\n *\n * @param debugValue debug value at config\n * @returns LogLevel of the given debugValue or undefined if the provided value is invalid\n */\nexport function getLogLevel(debugValue) {\n    if (typeof debugValue === 'boolean') {\n        if (debugValue) {\n            return LogLevels.DEBUG;\n        }\n        else {\n            return LogLevels.NONE;\n        }\n    }\n    else if (typeof debugValue === 'string' && isLogLevelString(debugValue)) {\n        return debugValue;\n    }\n    else {\n        return undefined;\n    }\n}\n","import { isLogLevelString, Logger, LogLevels } from '../../../logger';\nimport { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';\nimport { isNode } from '../../env/isNode';\nimport { codesDebug } from '../../../logger/messages/debug';\nimport { _Map } from '../../lang/maps';\nimport { getLogLevel } from './commons';\nvar allCodes = new _Map(codesDebug);\n// @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages\nvar LS_KEY = 'splitio_debug';\nvar ENV_VAR_KEY = 'SPLITIO_DEBUG';\n/**\n * Logger initial debug level, that is disabled ('NONE') by default.\n * Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'.\n * Other acceptable values are 'on', 'enable' and 'enabled', which are equivalent to 'DEBUG'.\n * Any other string value is equivalent to disable.\n */\nvar initialState = String(\n// eslint-disable-next-line no-undef\nisNode ? process.env[ENV_VAR_KEY] : isLocalStorageAvailable() ? localStorage.getItem(LS_KEY) : '');\n// By default it starts disabled.\nvar initialLogLevel = LogLevels.NONE;\n// Kept to avoid a breaking change ('on', 'enable' and 'enabled' are equivalent)\nif (/^(enabled?|on)/i.test(initialState)) {\n    initialLogLevel = LogLevels.DEBUG;\n}\nelse if (isLogLevelString(initialState)) {\n    initialLogLevel = initialState;\n}\n/**\n * Validates the `debug` property at config and use it to set the log level.\n *\n * @param settings user config object, with an optional `debug` property of type boolean or string log level.\n * @returns a logger instance with the log level at `settings.debug`. If `settings.debug` is invalid or not provided, `initialLogLevel` is used.\n */\nexport function validateLogger(settings) {\n    var debug = settings.debug;\n    var logLevel = debug !== undefined ? getLogLevel(debug) : initialLogLevel;\n    var log = new Logger({ logLevel: logLevel || initialLogLevel }, allCodes);\n    // @ts-ignore // if logLevel is undefined at this point, it means that settings `debug` value is invalid\n    if (!logLevel)\n        log._log(LogLevels.ERROR, 'Invalid Log Level - No changes to the logs will be applied.');\n    return log;\n}\n","import { isString } from '../../../utils/lang';\nexport function parseCondition(data) {\n    var treatment = data.treatment;\n    if (data.keys) {\n        return {\n            conditionType: 'WHITELIST',\n            matcherGroup: {\n                combiner: 'AND',\n                matchers: [\n                    {\n                        keySelector: null,\n                        matcherType: 'WHITELIST',\n                        negate: false,\n                        whitelistMatcherData: {\n                            whitelist: isString(data.keys) ? [data.keys] : data.keys\n                        }\n                    }\n                ]\n            },\n            partitions: [\n                {\n                    treatment: treatment,\n                    size: 100\n                }\n            ],\n            label: \"whitelisted \" + treatment\n        };\n    }\n    else {\n        return {\n            conditionType: 'ROLLOUT',\n            matcherGroup: {\n                combiner: 'AND',\n                matchers: [\n                    {\n                        keySelector: null,\n                        matcherType: 'ALL_KEYS',\n                        negate: false\n                    }\n                ]\n            },\n            partitions: [\n                {\n                    treatment: treatment,\n                    size: 100\n                }\n            ],\n            label: 'default rule'\n        };\n    }\n}\n","import { isObject, forOwn } from '../../../utils/lang';\nimport { parseCondition } from './parseCondition';\nfunction hasTreatmentChanged(prev, curr) {\n    if (typeof prev !== typeof curr)\n        return true;\n    if (typeof prev === 'string') { // strings treatments, just compare\n        return prev !== curr;\n    }\n    else { // has treatment and config, compare both\n        return prev.treatment !== curr.treatment || prev.config !== curr.config;\n    }\n}\nexport function splitsParserFromSettingsFactory() {\n    var previousMock = { 'emptyMock': '1' };\n    function mockUpdated(currentData) {\n        var names = Object.keys(currentData);\n        // Different amount of items\n        if (names.length !== Object.keys(previousMock).length) {\n            previousMock = currentData;\n            return true;\n        }\n        return names.some(function (name) {\n            var newSplit = !previousMock[name];\n            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);\n            var changed = newSplit || newTreatment;\n            if (changed)\n                previousMock = currentData;\n            return changed;\n        });\n    }\n    /**\n     *\n     * @param settings validated object with mocked features mapping.\n     */\n    return function splitsParserFromSettings(settings) {\n        var features = settings.features || {};\n        if (!mockUpdated(features))\n            return false;\n        var splitObjects = {};\n        forOwn(features, function (data, splitName) {\n            var treatment = data;\n            var config = null;\n            if (isObject(data)) {\n                treatment = data.treatment;\n                config = data.config || config;\n            }\n            var configurations = {};\n            if (config !== null)\n                configurations[treatment] = config;\n            splitObjects[splitName] = {\n                trafficTypeName: 'localhost',\n                conditions: [parseCondition({ treatment: treatment })],\n                configurations: configurations\n            };\n        });\n        return splitObjects;\n    };\n}\n","import { forOwn } from '../../../utils/lang';\nimport { syncTaskFactory } from '../../syncTask';\nimport { CONTROL } from '../../../utils/constants';\nimport { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';\nimport { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';\n/**\n * Offline equivalent of `splitChangesUpdaterFactory`\n */\nexport function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {\n    var log = settings.log, splitsCache = storage.splits;\n    var startingUp = true;\n    return function objectUpdater() {\n        var splits = [];\n        var loadError = null;\n        var splitsMock = {};\n        try {\n            splitsMock = splitsParser(settings);\n        }\n        catch (err) {\n            loadError = err;\n            log.error(ERROR_SYNC_OFFLINE_LOADING, [err]);\n        }\n        if (!loadError && splitsMock) {\n            log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);\n            forOwn(splitsMock, function (val, name) {\n                splits.push([\n                    name, {\n                        name: name,\n                        status: 'ACTIVE',\n                        killed: false,\n                        trafficAllocation: 100,\n                        defaultTreatment: CONTROL,\n                        conditions: val.conditions || [],\n                        configurations: val.configurations,\n                        trafficTypeName: val.trafficTypeName\n                    }\n                ]);\n            });\n            return Promise.all([\n                splitsCache.clear(),\n                splitsCache.addSplits(splits)\n            ]).then(function () {\n                readiness.splits.emit(SDK_SPLITS_ARRIVED);\n                if (startingUp) {\n                    startingUp = false;\n                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {\n                        // Emits SDK_READY_FROM_CACHE\n                        if (cacheReady)\n                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);\n                        // Emits SDK_READY\n                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);\n                    });\n                }\n                return true;\n            });\n        }\n        else {\n            return Promise.resolve(true);\n        }\n    };\n}\n/**\n * PollingManager in Offline mode\n */\nexport function fromObjectSyncTaskFactory(splitsParser, storage, readiness, settings) {\n    return syncTaskFactory(settings.log, fromObjectUpdaterFactory(splitsParser, storage, readiness, settings), settings.scheduler.offlineRefreshRate, 'offlineUpdater');\n}\n","import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';\nimport { objectAssign } from '../../utils/lang/objectAssign';\nimport { SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';\nfunction flush() {\n    return Promise.resolve();\n}\n/**\n * Offline SyncManager factory.\n * Can be used for server-side API, and client-side API with or without multiple clients.\n *\n * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.\n */\nexport function syncManagerOfflineFactory(splitsParserFactory) {\n    /**\n     * SyncManager factory for modular SDK\n     */\n    return function (_a) {\n        var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;\n        return objectAssign(fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings), {\n            // fake flush, that resolves immediately\n            flush: flush,\n            // [Only used for client-side]\n            shared: function (matchingKey, readinessManager) {\n                return {\n                    start: function () {\n                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created\n                        // SDK_READY cannot be emitted directly because this will not update the readiness status\n                        setTimeout(function () {\n                            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager\n                        }, 0);\n                    },\n                    stop: function () { },\n                    isRunning: function () {\n                        return true;\n                    },\n                    flush: flush,\n                };\n            }\n        });\n    };\n}\n","import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';\nimport { syncManagerOfflineFactory } from './syncManagerOffline';\n// Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)\n// SDK instances instantiate their SyncManagers with the same factory\nvar localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory);\nlocalhostFromObject.type = 'LocalhostFromObject';\nexport function LocalhostFromObject() {\n    return localhostFromObject;\n}\n","import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';\nimport { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';\nimport { stringToUpperCase } from '../lang';\nvar userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];\nexport function validateConsent(_a) {\n    var userConsent = _a.userConsent, log = _a.log;\n    userConsent = stringToUpperCase(userConsent);\n    if (userConsentValues.indexOf(userConsent) > -1)\n        return userConsent;\n    log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);\n    return CONSENT_GRANTED;\n}\n","export var packageVersion = '10.22.4';\n","import { packageVersion } from './version';\nimport { CONSENT_GRANTED } from '@splitsoftware/splitio-commons/esm/utils/constants';\nexport var defaults = {\n    startup: {\n        // Stress the request time used while starting up the SDK.\n        requestTimeoutBeforeReady: 5,\n        // How many quick retries we will do while starting up the SDK.\n        retriesOnFailureBeforeReady: 1,\n        // Maximum amount of time used before notifies me a timeout.\n        readyTimeout: 10,\n        // Amount of time we will wait before the first push of events.\n        eventsFirstPushWindow: 10\n    },\n    // Consent is considered granted by default\n    userConsent: CONSENT_GRANTED,\n    // Instance version.\n    version: \"javascript-\" + packageVersion,\n};\n","import { isLocalStorageAvailable } from '@splitsoftware/splitio-commons/esm/utils/env/isLocalStorageAvailable';\nimport { LOCALHOST_MODE, STORAGE_MEMORY } from '@splitsoftware/splitio-commons/esm/utils/constants';\nvar STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';\nexport function validateStorage(settings) {\n    var log = settings.log, mode = settings.mode, _a = settings.storage, _b = _a === void 0 ? { type: STORAGE_MEMORY } : _a, type = _b.type, _c = _b.options, options = _c === void 0 ? {} : _c, prefix = _b.prefix;\n    var __originalType;\n    var fallbackToMemory = function () {\n        __originalType = type;\n        type = STORAGE_MEMORY;\n    };\n    // In localhost mode, fallback to Memory storage and track original type to emit SDK_READY_FROM_CACHE if corresponds.\n    // ATM, other mode settings (e.g., 'consumer') are ignored in client-side API, and so treated as standalone.\n    if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {\n        fallbackToMemory();\n    }\n    // If an invalid storage type is provided OR we want to use LOCALSTORAGE and\n    // it's not available, fallback into MEMORY\n    if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||\n        type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {\n        fallbackToMemory();\n        log.error('Invalid or unavailable storage. Fallbacking into MEMORY storage');\n    }\n    return {\n        type: type,\n        options: options,\n        prefix: prefix,\n        __originalType: __originalType\n    };\n}\n","import { WARN_INTEGRATION_INVALID } from '../../../logger/constants';\n/**\n * This function validates `settings.integrations` object\n *\n * @param {any} settings config object provided by the user to initialize the sdk\n * @param {function} integrationValidator filter used to remove invalid integration items\n * @param {string} extraWarning optional string used to better describe why an item might be invalid\n *\n * @returns {Array} array of valid integration items. The array might be empty if `settings` object does not have valid integrations.\n */\nexport function validateIntegrations(settings, integrationValidator, extraWarning) {\n    var integrations = settings.integrations, log = settings.log;\n    // If integrations is not an array or an empty array, we return an empty array (no integrations).\n    if (!Array.isArray(integrations) || integrations.length === 0)\n        return [];\n    // We remove invalid integration items\n    var validIntegrations = integrations.filter(integrationValidator);\n    // Log a warning if at least one item is invalid\n    var invalids = integrations.length - validIntegrations.length;\n    if (invalids)\n        log.warn(WARN_INTEGRATION_INVALID, [invalids, extraWarning || '']);\n    return validIntegrations;\n}\n","import { validateIntegrations } from './common';\nimport { isString } from '../../lang';\n/**\n * This function validates `settings.integrations` object that consists of a list of configuration items, used by the isomorphic JS SDK.\n *\n * @param {any} settings config object provided by the user to initialize the sdk\n * @param {Array<string>} validIntegrationTypes list of integration types to filter from `settings.integrations`\n *\n * @returns {Array} array of valid integration items. The array might be empty if `settings` object does not have valid integrations.\n */\nexport function validateConfigurableIntegrations(settings, validIntegrationTypes) {\n    if (validIntegrationTypes === void 0) { validIntegrationTypes = []; }\n    return validateIntegrations(settings, function (integration) { return integration && isString(integration.type) && validIntegrationTypes.indexOf(integration.type) > -1; }, 'Integration items must have a valid \"type\" value');\n}\n","import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '@splitsoftware/splitio-commons/esm/utils/constants/browser';\nimport { validateConfigurableIntegrations } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/integrations/configurable';\nexport function validateIntegrations(settings) {\n    return validateConfigurableIntegrations(settings, [GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS]);\n}\n","import { settingsValidation } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation';\nimport { validateRuntime } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/runtime';\nimport { validateLogger } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger';\nimport { LocalhostFromObject } from '@splitsoftware/splitio-commons/esm/sync/offline/LocalhostFromObject';\nimport { validateConsent } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/consent';\nimport { defaults } from './defaults/browser';\nimport { validateStorage } from './storage/browser';\nimport { validateIntegrations } from './integrations/browser';\nvar params = {\n    defaults: defaults,\n    acceptKey: true, acceptTT: true,\n    runtime: validateRuntime,\n    storage: validateStorage,\n    integrations: validateIntegrations,\n    logger: validateLogger,\n    localhost: function () { return LocalhostFromObject(); },\n    consent: validateConsent,\n};\nexport function settingsFactory(config) {\n    return settingsValidation(config, params);\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// Adaptation of \"events\" library (https://www.npmjs.com/package/events)\n// exported as an ES module instead of CommonJS, to avoid extra configuration steps when using\n// the ESM build of the SDK with tools that doesn't support CommonJS by default (e.g. Rollup).\nvar R = typeof Reflect === 'object' ? Reflect : null;\nvar ReflectApply = R && typeof R.apply === 'function'\n    ? R.apply\n    : function ReflectApply(target, receiver, args) {\n        return Function.prototype.apply.call(target, receiver, args);\n    };\nvar ReflectOwnKeys;\nif (R && typeof R.ownKeys === 'function') {\n    ReflectOwnKeys = R.ownKeys;\n}\nelse if (Object.getOwnPropertySymbols) {\n    ReflectOwnKeys = function ReflectOwnKeys(target) {\n        return Object.getOwnPropertyNames(target)\n            .concat(Object.getOwnPropertySymbols(target));\n    };\n}\nelse {\n    ReflectOwnKeys = function ReflectOwnKeys(target) {\n        return Object.getOwnPropertyNames(target);\n    };\n}\nfunction ProcessEmitWarning(warning) {\n    if (console && console.warn)\n        console.warn(warning);\n}\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n    return value !== value;\n};\nexport function EventEmitter() {\n    EventEmitter.init.call(this);\n}\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\nfunction checkListener(listener) {\n    if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n    }\n}\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n    enumerable: true,\n    get: function () {\n        return defaultMaxListeners;\n    },\n    set: function (arg) {\n        if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n            throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n        }\n        defaultMaxListeners = arg;\n    }\n});\nEventEmitter.init = function () {\n    if (this._events === undefined ||\n        this._events === Object.getPrototypeOf(this)._events) {\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n    }\n    this._maxListeners = this._maxListeners || undefined;\n};\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n        throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n    }\n    this._maxListeners = n;\n    return this;\n};\nfunction _getMaxListeners(that) {\n    if (that._maxListeners === undefined)\n        return EventEmitter.defaultMaxListeners;\n    return that._maxListeners;\n}\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n    return _getMaxListeners(this);\n};\nEventEmitter.prototype.emit = function emit(type) {\n    var args = [];\n    for (var i = 1; i < arguments.length; i++)\n        args.push(arguments[i]);\n    var doError = (type === 'error');\n    var events = this._events;\n    if (events !== undefined)\n        doError = (doError && events.error === undefined);\n    else if (!doError)\n        return false;\n    // If there is no 'error' event listener then throw.\n    if (doError) {\n        var er;\n        if (args.length > 0)\n            er = args[0];\n        if (er instanceof Error) {\n            // Note: The comments on the `throw` lines are intentional, they show\n            // up in Node's output if this results in an unhandled exception.\n            throw er; // Unhandled 'error' event\n        }\n        // At least give some kind of context to the user\n        var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n        err.context = er;\n        throw err; // Unhandled 'error' event\n    }\n    var handler = events[type];\n    if (handler === undefined)\n        return false;\n    if (typeof handler === 'function') {\n        ReflectApply(handler, this, args);\n    }\n    else {\n        var len = handler.length;\n        var listeners = arrayClone(handler, len); // eslint-disable-next-line no-redeclare\n        for (var i = 0; i < len; ++i)\n            ReflectApply(listeners[i], this, args);\n    }\n    return true;\n};\nfunction _addListener(target, type, listener, prepend) {\n    var m;\n    var events;\n    var existing;\n    checkListener(listener);\n    events = target._events;\n    if (events === undefined) {\n        events = target._events = Object.create(null);\n        target._eventsCount = 0;\n    }\n    else {\n        // To avoid recursion in the case that type === \"newListener\"! Before\n        // adding it to the listeners, first emit \"newListener\".\n        if (events.newListener !== undefined) {\n            target.emit('newListener', type, listener.listener ? listener.listener : listener);\n            // Re-assign `events` because a newListener handler could have caused the\n            // this._events to be assigned to a new object\n            events = target._events;\n        }\n        existing = events[type];\n    }\n    if (existing === undefined) {\n        // Optimize the case of one listener. Don't need the extra array object.\n        existing = events[type] = listener;\n        ++target._eventsCount;\n    }\n    else {\n        if (typeof existing === 'function') {\n            // Adding the second element, need to change to array.\n            existing = events[type] =\n                prepend ? [listener, existing] : [existing, listener];\n            // If we've already got an array, just append.\n        }\n        else if (prepend) {\n            existing.unshift(listener);\n        }\n        else {\n            existing.push(listener);\n        }\n        // Check for listener leak\n        m = _getMaxListeners(target);\n        if (m > 0 && existing.length > m && !existing.warned) {\n            existing.warned = true;\n            // No error code for this since it is a Warning\n            // eslint-disable-next-line no-restricted-syntax\n            var w = new Error('Possible EventEmitter memory leak detected. ' +\n                existing.length + ' ' + String(type) + ' listeners ' +\n                'added. Use emitter.setMaxListeners() to ' +\n                'increase limit');\n            w.name = 'MaxListenersExceededWarning';\n            w.emitter = target;\n            w.type = type;\n            w.count = existing.length;\n            ProcessEmitWarning(w);\n        }\n    }\n    return target;\n}\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n    return _addListener(this, type, listener, false);\n};\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n        return _addListener(this, type, listener, true);\n    };\nfunction onceWrapper() {\n    if (!this.fired) {\n        this.target.removeListener(this.type, this.wrapFn);\n        this.fired = true;\n        if (arguments.length === 0)\n            return this.listener.call(this.target);\n        return this.listener.apply(this.target, arguments);\n    }\n}\nfunction _onceWrap(target, type, listener) {\n    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n    var wrapped = onceWrapper.bind(state);\n    wrapped.listener = listener;\n    state.wrapFn = wrapped;\n    return wrapped;\n}\nEventEmitter.prototype.once = function once(type, listener) {\n    checkListener(listener);\n    this.on(type, _onceWrap(this, type, listener));\n    return this;\n};\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n        checkListener(listener);\n        this.prependListener(type, _onceWrap(this, type, listener));\n        return this;\n    };\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n        var list, events, position, i, originalListener;\n        checkListener(listener);\n        events = this._events;\n        if (events === undefined)\n            return this;\n        list = events[type];\n        if (list === undefined)\n            return this;\n        if (list === listener || list.listener === listener) {\n            if (--this._eventsCount === 0)\n                this._events = Object.create(null);\n            else {\n                delete events[type];\n                if (events.removeListener)\n                    this.emit('removeListener', type, list.listener || listener);\n            }\n        }\n        else if (typeof list !== 'function') {\n            position = -1;\n            for (i = list.length - 1; i >= 0; i--) {\n                if (list[i] === listener || list[i].listener === listener) {\n                    originalListener = list[i].listener;\n                    position = i;\n                    break;\n                }\n            }\n            if (position < 0)\n                return this;\n            if (position === 0)\n                list.shift();\n            else {\n                spliceOne(list, position);\n            }\n            if (list.length === 1)\n                events[type] = list[0];\n            if (events.removeListener !== undefined)\n                this.emit('removeListener', type, originalListener || listener);\n        }\n        return this;\n    };\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n        var listeners, events, i;\n        events = this._events;\n        if (events === undefined)\n            return this;\n        // not listening for removeListener, no need to emit\n        if (events.removeListener === undefined) {\n            if (arguments.length === 0) {\n                this._events = Object.create(null);\n                this._eventsCount = 0;\n            }\n            else if (events[type] !== undefined) {\n                if (--this._eventsCount === 0)\n                    this._events = Object.create(null);\n                else\n                    delete events[type];\n            }\n            return this;\n        }\n        // emit removeListener for all listeners on all events\n        if (arguments.length === 0) {\n            var keys = Object.keys(events);\n            var key;\n            for (i = 0; i < keys.length; ++i) {\n                key = keys[i];\n                if (key === 'removeListener')\n                    continue;\n                this.removeAllListeners(key);\n            }\n            this.removeAllListeners('removeListener');\n            this._events = Object.create(null);\n            this._eventsCount = 0;\n            return this;\n        }\n        listeners = events[type];\n        if (typeof listeners === 'function') {\n            this.removeListener(type, listeners);\n        }\n        else if (listeners !== undefined) {\n            // LIFO order\n            for (i = listeners.length - 1; i >= 0; i--) {\n                this.removeListener(type, listeners[i]);\n            }\n        }\n        return this;\n    };\nfunction _listeners(target, type, unwrap) {\n    var events = target._events;\n    if (events === undefined)\n        return [];\n    var evlistener = events[type];\n    if (evlistener === undefined)\n        return [];\n    if (typeof evlistener === 'function')\n        return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n    return unwrap ?\n        unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\nEventEmitter.prototype.listeners = function listeners(type) {\n    return _listeners(this, type, true);\n};\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n    return _listeners(this, type, false);\n};\nEventEmitter.listenerCount = function (emitter, type) {\n    if (typeof emitter.listenerCount === 'function') {\n        return emitter.listenerCount(type);\n    }\n    else {\n        return listenerCount.call(emitter, type);\n    }\n};\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n    var events = this._events;\n    if (events !== undefined) {\n        var evlistener = events[type];\n        if (typeof evlistener === 'function') {\n            return 1;\n        }\n        else if (evlistener !== undefined) {\n            return evlistener.length;\n        }\n    }\n    return 0;\n}\nEventEmitter.prototype.eventNames = function eventNames() {\n    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\nfunction arrayClone(arr, n) {\n    var copy = new Array(n);\n    for (var i = 0; i < n; ++i)\n        copy[i] = arr[i];\n    return copy;\n}\nfunction spliceOne(list, index) {\n    for (; index + 1 < list.length; index++)\n        list[index] = list[index + 1];\n    list.pop();\n}\nfunction unwrapListeners(arr) {\n    var ret = new Array(arr.length);\n    for (var i = 0; i < ret.length; ++i) {\n        ret[i] = arr[i].listener || arr[i];\n    }\n    return ret;\n}\n","export default function(e,n){return n=n||{},new Promise(function(t,r){var s=new XMLHttpRequest,o=[],u=[],i={},a=function(){return{ok:2==(s.status/100|0),statusText:s.statusText,status:s.status,url:s.responseURL,text:function(){return Promise.resolve(s.responseText)},json:function(){return Promise.resolve(s.responseText).then(JSON.parse)},blob:function(){return Promise.resolve(new Blob([s.response]))},clone:a,headers:{keys:function(){return o},entries:function(){return u},get:function(e){return i[e.toLowerCase()]},has:function(e){return e.toLowerCase()in i}}}};for(var l in s.open(n.method||\"get\",e,!0),s.onload=function(){s.getAllResponseHeaders().replace(/^(.*?):[^\\S\\n]*([\\s\\S]*?)$/gm,function(e,n,t){o.push(n=n.toLowerCase()),u.push([n,t]),i[n]=i[n]?i[n]+\",\"+t:t}),t(a())},s.onerror=r,s.withCredentials=\"include\"==n.credentials,n.headers)s.setRequestHeader(l,n.headers[l]);s.send(n.body||null)})}\n//# sourceMappingURL=unfetch.module.js.map\n","import unfetch from 'unfetch';\nexport function getFetch() {\n    return typeof fetch === 'function' ? fetch : unfetch;\n}\n","export function getEventSource() {\n    return typeof EventSource === 'function' ? EventSource : undefined;\n}\n","import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';\nimport { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';\nimport { OPTIMIZED, DEBUG, NONE } from '../utils/constants';\nimport { objectAssign } from '../utils/lang/objectAssign';\nimport { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';\nimport { isConsentGranted } from '../consent';\nvar VISIBILITYCHANGE_EVENT = 'visibilitychange';\nvar PAGEHIDE_EVENT = 'pagehide';\nvar UNLOAD_EVENT = 'unload';\nvar EVENT_NAME = 'for unload page event.';\n/**\n * We'll listen for events over the window object.\n */\nvar BrowserSignalListener = /** @class */ (function () {\n    function BrowserSignalListener(syncManager, settings, storage, serviceApi) {\n        this.syncManager = syncManager;\n        this.settings = settings;\n        this.storage = storage;\n        this.serviceApi = serviceApi;\n        this.flushData = this.flushData.bind(this);\n        this.flushDataIfHidden = this.flushDataIfHidden.bind(this);\n        this.stopSync = this.stopSync.bind(this);\n        this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);\n    }\n    /**\n     * start method.\n     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.\n     */\n    BrowserSignalListener.prototype.start = function () {\n        this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);\n        if (typeof document !== 'undefined' && document.addEventListener) {\n            // Flush data whenever the page is hidden or unloaded.\n            document.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);\n        }\n        if (typeof window !== 'undefined' && window.addEventListener) {\n            // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.\n            // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.\n            window.addEventListener(PAGEHIDE_EVENT, this.flushData);\n            // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.\n            window.addEventListener(UNLOAD_EVENT, this.stopSync);\n        }\n    };\n    /**\n     * stop method.\n     * Called when client is destroyed, it removes event listeners.\n     */\n    BrowserSignalListener.prototype.stop = function () {\n        this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]);\n        if (typeof document !== 'undefined' && document.removeEventListener) {\n            document.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);\n        }\n        if (typeof window !== 'undefined' && window.removeEventListener) {\n            window.removeEventListener(PAGEHIDE_EVENT, this.flushData);\n            window.removeEventListener(UNLOAD_EVENT, this.stopSync);\n        }\n    };\n    BrowserSignalListener.prototype.stopSync = function () {\n        // Close streaming connection\n        if (this.syncManager && this.syncManager.pushManager)\n            this.syncManager.pushManager.stop();\n    };\n    /**\n     * flushData method.\n     * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,\n     * using beacon API if possible, or falling back to regular post transport.\n     */\n    BrowserSignalListener.prototype.flushData = function () {\n        if (!this.syncManager)\n            return; // In consumer mode there is not sync manager and data to flush\n        var _a = this.settings.urls, events = _a.events, telemetry = _a.telemetry;\n        // Flush impressions & events data if there is user consent\n        if (isConsentGranted(this.settings)) {\n            var sim = this.settings.sync.impressionsMode;\n            var extraMetadata = {\n                // sim stands for Sync/Split Impressions Mode\n                sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE\n            };\n            this._flushData(events + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);\n            this._flushData(events + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);\n            if (this.storage.impressionCounts)\n                this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);\n            // @ts-ignore\n            if (this.storage.uniqueKeys)\n                this._flushData(telemetry + '/v1/keys/cs/beacon', this.storage.uniqueKeys, this.serviceApi.postUniqueKeysBulkCs);\n        }\n        // Flush telemetry data\n        if (this.storage.telemetry)\n            this._flushData(telemetry + '/v1/metrics/usage/beacon', this.storage.telemetry, this.serviceApi.postMetricsUsage);\n    };\n    BrowserSignalListener.prototype.flushDataIfHidden = function () {\n        // Precondition: document defined\n        if (document.visibilityState === 'hidden')\n            this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden\n    };\n    BrowserSignalListener.prototype._flushData = function (url, cache, postService, fromCacheToPayload, extraMetadata) {\n        // if there is data in cache, send it to backend\n        if (!cache.isEmpty()) {\n            var dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.pop()) : cache.pop();\n            if (!this._sendBeacon(url, dataPayload, extraMetadata)) {\n                postService(JSON.stringify(dataPayload)).catch(function () { }); // no-op to handle possible promise rejection\n            }\n        }\n    };\n    /**\n     * _sendBeacon method.\n     * Util method that check if beacon API is available, build the payload and send it.\n     * Returns true if beacon API was used successfully, false otherwise.\n     */\n    BrowserSignalListener.prototype._sendBeacon = function (url, data, extraMetadata) {\n        // eslint-disable-next-line compat/compat\n        if (typeof navigator !== 'undefined' && navigator.sendBeacon) {\n            var json = {\n                entries: data,\n                token: this.settings.core.authorizationKey,\n                sdk: this.settings.version\n            };\n            // Extend with endpoint specific metadata where needed\n            if (extraMetadata)\n                objectAssign(json, extraMetadata);\n            // Stringify the payload\n            var payload = JSON.stringify(json);\n            // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n            try { // eslint-disable-next-line compat/compat\n                return navigator.sendBeacon(url, payload);\n            }\n            catch (e) {\n                return false;\n            }\n        }\n        return false;\n    };\n    return BrowserSignalListener;\n}());\nexport { BrowserSignalListener };\n","// Can be used on any runtime, since it fallbacks to `Date.now` if `performance.now` is not available\nfunction nowFactory() {\n    // eslint-disable-next-line\n    if (typeof performance === 'object' && typeof performance.now === 'function') {\n        // eslint-disable-next-line\n        return performance.now.bind(performance);\n    }\n    else {\n        return Date.now;\n    }\n}\nexport var now = nowFactory();\n","import { EventEmitter } from './EventEmitter';\nimport { getFetch } from '../platform/getFetch/browser';\nimport { getEventSource } from '../platform/getEventSource/browser';\nimport { BrowserSignalListener } from '@splitsoftware/splitio-commons/esm/listeners/browser';\nimport { now } from '@splitsoftware/splitio-commons/esm/utils/timeTracker/now/browser';\nexport var platform = {\n    getFetch: getFetch,\n    getEventSource: getEventSource,\n    EventEmitter: EventEmitter,\n    now: now\n};\nexport var SignalListener = BrowserSignalListener;\n","import { splitApiFactory } from '@splitsoftware/splitio-commons/esm/services/splitApi';\nimport { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/esm/sync/syncManagerOnline';\nimport { pushManagerFactory } from '@splitsoftware/splitio-commons/esm/sync/streaming/pushManager';\nimport { pollingManagerCSFactory } from '@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerCS';\nimport { InLocalStorage } from '@splitsoftware/splitio-commons/esm/storages/inLocalStorage';\nimport { InMemoryStorageCSFactory } from '@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorageCS';\nimport { sdkManagerFactory } from '@splitsoftware/splitio-commons/esm/sdkManager';\nimport { sdkClientMethodCSFactory } from '@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethodCSWithTT';\nimport { impressionObserverCSFactory } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverCS';\nimport { integrationsManagerFactory } from '@splitsoftware/splitio-commons/esm/integrations/browser';\nimport { __InLocalStorageMockFactory } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/storage/storageCS';\nimport { sdkFactory } from '@splitsoftware/splitio-commons/esm/sdkFactory';\nimport { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '@splitsoftware/splitio-commons/esm/utils/constants';\nimport { createUserConsentAPI } from '@splitsoftware/splitio-commons/esm/consent/sdkUserConsent';\nimport { settingsFactory } from '../settings/browser';\nimport { platform, SignalListener } from '../platform';\nvar syncManagerOnlineCSFactory = syncManagerOnlineFactory(pollingManagerCSFactory, pushManagerFactory);\nfunction getStorage(settings) {\n    return settings.storage.type === STORAGE_LOCALSTORAGE ?\n        InLocalStorage(settings.storage)\n        : settings.storage.__originalType === STORAGE_LOCALSTORAGE ?\n            __InLocalStorageMockFactory\n            : InMemoryStorageCSFactory;\n}\n/**\n *\n * @param {import(\"@splitsoftware/splitio-commons/types/types\").ISettings} settings\n */\nfunction getModules(settings) {\n    var modules = {\n        settings: settings,\n        platform: platform,\n        storageFactory: getStorage(settings),\n        splitApiFactory: splitApiFactory,\n        syncManagerFactory: syncManagerOnlineCSFactory,\n        sdkManagerFactory: sdkManagerFactory,\n        sdkClientMethodFactory: sdkClientMethodCSFactory,\n        SignalListener: SignalListener,\n        integrationsManagerFactory: settings.integrations && settings.integrations.length > 0 ? integrationsManagerFactory.bind(null, settings.integrations) : undefined,\n        impressionsObserverFactory: impressionObserverCSFactory,\n        extraProps: function (params) {\n            return {\n                UserConsent: createUserConsentAPI(params)\n            };\n        }\n    };\n    switch (settings.mode) {\n        case LOCALHOST_MODE:\n            modules.splitApiFactory = undefined;\n            modules.syncManagerFactory = settings.sync.localhostMode;\n            modules.SignalListener = undefined;\n            break;\n    }\n    return modules;\n}\n/**\n * SplitFactory for client-side.\n *\n * @param {SplitIO.IBrowserSettings} config configuration object used to instantiate the SDK\n * @param {Function=} __updateModules optional function that lets redefine internal SDK modules. Use with\n * caution since, unlike `config`, this param is not validated neither considered part of the public API.\n * @throws Will throw an error if the provided config is invalid.\n */\nexport function SplitFactory(config, __updateModules) {\n    var settings = settingsFactory(config);\n    var modules = getModules(settings);\n    if (__updateModules)\n        __updateModules(modules);\n    return sdkFactory(modules);\n}\n"],"names":["getOwnPropertySymbols","propIsEnumerable","toObject","val","shouldUseNative","test1","test2","i","order2","n","test3","letter","objectAssign","target","source","from","to","symbols","key","ENGINE_COMBINER_AND","ENGINE_COMBINER_IFELSEIF","ENGINE_COMBINER_IFELSEIF_NO_TREATMENT","ENGINE_BUCKET","ENGINE_MATCHER_ALL","ENGINE_MATCHER_BETWEEN","ENGINE_MATCHER_BOOLEAN","ENGINE_MATCHER_CONTAINS_ALL","ENGINE_MATCHER_CONTAINS_ANY","ENGINE_MATCHER_CONTAINS_STRING","ENGINE_MATCHER_DEPENDENCY","ENGINE_MATCHER_DEPENDENCY_PRE","ENGINE_MATCHER_EQUAL","ENGINE_MATCHER_EQUAL_TO_SET","ENGINE_MATCHER_ENDS_WITH","ENGINE_MATCHER_GREATER","ENGINE_MATCHER_LESS","ENGINE_MATCHER_PART_OF","ENGINE_MATCHER_SEGMENT","ENGINE_MATCHER_STRING","ENGINE_MATCHER_STRING_INVALID","ENGINE_MATCHER_STARTS_WITH","ENGINE_MATCHER_WHITELIST","ENGINE_VALUE","ENGINE_SANITIZE","CLEANUP_REGISTERING","CLEANUP_DEREGISTERING","RETRIEVE_CLIENT_DEFAULT","RETRIEVE_CLIENT_EXISTING","RETRIEVE_MANAGER","SYNC_OFFLINE_DATA","SYNC_SPLITS_FETCH","SYNC_SPLITS_NEW","SYNC_SPLITS_REMOVED","SYNC_SPLITS_SEGMENTS","STREAMING_NEW_MESSAGE","SYNC_TASK_START","SYNC_TASK_EXECUTE","SYNC_TASK_STOP","SETTINGS_SPLITS_FILTER","CLIENT_READY_FROM_CACHE","CLIENT_READY","IMPRESSION","IMPRESSION_QUEUEING","NEW_SHARED_CLIENT","NEW_FACTORY","POLLING_SMART_PAUSING","POLLING_START","POLLING_STOP","SYNC_SPLITS_FETCH_RETRY","STREAMING_REFRESH_TOKEN","STREAMING_RECONNECT","STREAMING_CONNECTING","STREAMING_DISABLED","STREAMING_DISCONNECTING","SUBMITTERS_PUSH_FULL_QUEUE","SUBMITTERS_PUSH","SYNC_START_POLLING","SYNC_CONTINUE_POLLING","SYNC_STOP_POLLING","EVENTS_TRACKER_SUCCESS","IMPRESSIONS_TRACKER_SUCCESS","USER_CONSENT_UPDATED","USER_CONSENT_NOT_UPDATED","USER_CONSENT_INITIAL","ENGINE_VALUE_INVALID","ENGINE_VALUE_NO_ATTRIBUTES","CLIENT_NO_LISTENER","CLIENT_NOT_READY","SYNC_MYSEGMENTS_FETCH_RETRY","SYNC_SPLITS_FETCH_FAILS","STREAMING_PARSING_ERROR_FAILS","STREAMING_PARSING_MESSAGE_FAILS","STREAMING_FALLBACK","SUBMITTERS_PUSH_FAILS","SUBMITTERS_PUSH_RETRY","WARN_SETTING_NULL","WARN_TRIMMING_PROPERTIES","WARN_CONVERTING","WARN_TRIMMING","WARN_NOT_EXISTENT_SPLIT","WARN_LOWERCASE_TRAFFIC_TYPE","WARN_NOT_EXISTENT_TT","WARN_INTEGRATION_INVALID","WARN_SPLITS_FILTER_IGNORED","WARN_SPLITS_FILTER_INVALID","WARN_SPLITS_FILTER_EMPTY","WARN_API_KEY","STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2","ERROR_ENGINE_COMBINER_IFELSEIF","ERROR_LOGLEVEL_INVALID","ERROR_CLIENT_LISTENER","ERROR_CLIENT_CANNOT_GET_READY","ERROR_SYNC_OFFLINE_LOADING","ERROR_STREAMING_SSE","ERROR_STREAMING_AUTH","ERROR_IMPRESSIONS_TRACKER","ERROR_IMPRESSIONS_LISTENER","ERROR_EVENTS_TRACKER","ERROR_EVENT_TYPE_FORMAT","ERROR_NOT_PLAIN_OBJECT","ERROR_SIZE_EXCEEDED","ERROR_NOT_FINITE","ERROR_CLIENT_DESTROYED","ERROR_NULL","ERROR_TOO_LONG","ERROR_INVALID_KEY_OBJECT","ERROR_INVALID","ERROR_EMPTY","ERROR_EMPTY_ARRAY","ERROR_INVALID_CONFIG_PARAM","ERROR_HTTP","ERROR_LOCALHOST_MODULE_REQUIRED","ERROR_NOT_BOOLEAN","ERROR_MIN_CONFIG_PARAM","LOG_PREFIX_SETTINGS","LOG_PREFIX_INSTANTIATION","LOG_PREFIX_ENGINE","LOG_PREFIX_ENGINE_COMBINER","LOG_PREFIX_ENGINE_MATCHER","LOG_PREFIX_ENGINE_VALUE","LOG_PREFIX_SYNC","LOG_PREFIX_SYNC_MANAGER","LOG_PREFIX_SYNC_OFFLINE","LOG_PREFIX_SYNC_STREAMING","LOG_PREFIX_SYNC_SPLITS","LOG_PREFIX_SYNC_SEGMENTS","LOG_PREFIX_SYNC_MYSEGMENTS","LOG_PREFIX_SYNC_POLLING","LOG_PREFIX_SYNC_SUBMITTERS","LOG_PREFIX_IMPRESSIONS_TRACKER","LOG_PREFIX_EVENTS_TRACKER","LOG_PREFIX_UNIQUE_KEYS_TRACKER","LOG_PREFIX_CLEANUP","messageNoFetch","splitHttpClientFactory","settings","getFetch","getOptions","log","authorizationKey","version","_a","ip","hostname","options","fetch","headers","url","reqOpts","latencyTracker","logErrorsAsInfo","request","response","message","error","resp","msg","networkError","CONTROL","CONTROL_WITH_CONFIG","UNKNOWN","NA","SPLIT_IMPRESSION","SPLIT_EVENT","DEBUG","OPTIMIZED","NONE","PRODUCER_MODE","CONSUMER_MODE","CONSUMER_PARTIAL_MODE","STORAGE_REDIS","CONSENT_GRANTED","CONSENT_DECLINED","CONSENT_UNKNOWN","QUEUED","DROPPED","DEDUPED","STANDALONE_ENUM","CONSUMER_ENUM","CONSUMER_PARTIAL_ENUM","OPTIMIZED_ENUM","DEBUG_ENUM","NONE_ENUM","SPLITS","IMPRESSIONS","IMPRESSIONS_COUNT","EVENTS","TELEMETRY","TOKEN","SEGMENT","MY_SEGMENT","TREATMENT","TREATMENTS","TREATMENT_WITH_CONFIG","TREATMENTS_WITH_CONFIG","TRACK","CONNECTION_ESTABLISHED","OCCUPANCY_PRI","OCCUPANCY_SEC","STREAMING_STATUS","SSE_CONNECTION_ERROR","TOKEN_REFRESH","ABLY_ERROR","SYNC_MODE_UPDATE","AUTH_REJECTION","STREAMING","POLLING","REQUESTED","NON_REQUESTED","DISABLED","ENABLED","PAUSED","noCacheHeaderOptions","userKeyToQueryParam","userKey","splitApiFactory","platform","telemetryTracker","urls","filterQueryString","SplitSDKImpressionsMode","splitHttpClient","userMatchingKeys","queryParams","since","noCache","till","segmentName","userMatchingKey","body","syncTaskFactory","task","period","taskName","executing","promiseChain","running","runningId","runningArgs","timeoutID","execute","args","_i","result","periodicExecute","currentRunningId","submitterFactory","postClient","sourceCache","postRate","dataName","fromCacheToPayload","maxRetries","debugLogs","retries","data","postData","dataCountMessage","jsonPayload","err","firstPushWindowDecorator","submitter","firstPushWindow","stopEventPublisherTimeout","originalStart","originalStop","DATA_NAME","eventsSubmitterFactory","params","eventsPushRate","eventsFirstPushWindow","postEventsBulk","events","endsWith","sub","caseInsensitive","isString","find","iteratee","res","isObject","keys","iterateeResult","findIndex","forOwn","obj","get","prop","pathPieces","partial_1","pathPiece","groupBy","map","isBoolean","isFiniteNumber","isIntegerNumber","isNaNNumber","stringToUpperCase","merge","rest","nextSource","startsWith","toNumber","valOf","uniq","arr","seen","item","uniqAsStrings","stringify","itemString","uniqueIdCounter","uniqueId","fromImpressionsCollector","sendLabels","groupedByFeature","dto","value","name","entry","keyImpression","impressionsSubmitterFactory","impressionsRefreshRate","labelsEnabled","postTestImpressionsBulk","impressions","syncTask","fromImpressionCountsCollector","impressionsCount","pf","splitted","featureName","timeFrame","impressionsInTimeframe","IMPRESSIONS_COUNT_RATE","impressionCountsSubmitterFactory","postTestImpressionsCount","impressionCounts","SDK_SPLITS_ARRIVED","SDK_SPLITS_CACHE_LOADED","SDK_SEGMENTS_ARRIVED","SDK_READY_TIMED_OUT","SDK_READY","SDK_READY_FROM_CACHE","SDK_UPDATE","mode","TRIMMABLE_SPACES_REGEX","validateSplit","maybeSplit","method","validateSplits","maybeSplits","listName","validatedArray_1","splitName","FILTERS_METADATA","validateFilterType","maybeFilterType","filterMetadata","validateSplitFilter","type","values","maxLength","queryStringBuilder","groupedFilters","queryParam","filter","validateSplitFilters","maybeSplitFilters","index","validImpressionsMode","impressionsMode","KEY_MAX_LENGTH","validateKeyValue","maybeKey","validateKey","matchingKey","bucketingKey","CAPITAL_LETTERS_REGEX","validateTrafficType","maybeTT","base","fromSecondsToMillis","settingsValidation","config","validationParams","defaults","runtime","storage","integrations","logger","localhost","consent","withDefaults","validateMinValue","paramName","actualValue","minValue","scheduler","startup","splitFiltersValidation","validateApiKey","maybeApiKey","apiKey","usedKeysMap","validateAndTrackApiKey","releaseApiKey","timer","now","st","_b","_c","OPERATION_MODE_MAP","IMPRESSIONS_MODE_MAP","USER_CONSENT_MAP","getActiveFactories","getRedundantActiveFactories","acum","getTelemetryConfigStats","storageType","telemetryCacheConfigAdapter","telemetry","isClientSide","int","telemetrySubmitterFactory","telemetryRefreshRate","splitApi","readiness","sdkReadinessManager","startTime","postMetricsConfigTask","UNIQUE_KEYS_RATE","uniqueKeysSubmitterFactory","postUniqueKeysBulkCs","postUniqueKeysBulkSs","uniqueKeys","postUniqueKeysBulk","submitterManagerFactory","submitters","impressionCountsSubmitter","telemetrySubmitter","onlyTelemetry","allExceptTelemetry","promises","SECONDS_BEFORE_EXPIRATION","PUSH_NONRETRYABLE_ERROR","PUSH_RETRYABLE_ERROR","PUSH_SUBSYSTEM_UP","PUSH_SUBSYSTEM_DOWN","MY_SEGMENTS_UPDATE","MY_SEGMENTS_UPDATE_V2","SEGMENT_UPDATE","SPLIT_KILL","SPLIT_UPDATE","OCCUPANCY","ControlType","isConsentGranted","userConsent","syncManagerOnlineFactory","pollingManagerFactory","pushManagerFactory","streamingEnabled","syncEnabled","pollingManager","pushManager","submitterManager","startPolling","stopPollingAndSyncAll","startFirstTime","readinessManager","mySegmentsSyncTask","Backoff","cb","baseMillis","maxMillis","_this","delayInMillis","errorParser","messageParser","messageData","CONTROL_CHANNEL_REGEXS","STREAMING_EVENT_TYPES","notificationKeeperFactory","pushEmitter","channels","regex","hasPublishers","hasResumed","getHasPublishers","c","publishers","channel","timestamp","hasPublishersNow","controlType","SSEHandlerFactory","notificationKeeper","isRetryableError","code","errorWithParsedData","errorMessage","messageWithParsedData","parsedData","MySegmentsUpdateWorker","maxChangeNumber","currentChangeNumber","handleNewEvent","isHandlingEvent","_segmentsData","backoff","__handleMySegmentsUpdateCall","currentMaxChangeNumber_1","changeNumber","segmentsData","FETCH_BACKOFF_BASE","FETCH_BACKOFF_MAX_WAIT","FETCH_BACKOFF_MAX_RETRIES","SegmentsUpdateWorker","segmentsSyncTask","segmentsCache","SegmentUpdateWorker","segment","cdnBypass","__handleSegmentUpdateCall","attempts","segments","SplitsUpdateWorker","splitsCache","splitsSyncTask","splitsEventEmitter","__handleSplitUpdateCall","put","defaultTreatment","chars","decodeFromBase64","input","str","output","bc","bs","buffer","idx","encodeToBase64","block","charCode","decodeJWTtoken","token","base64Url","base64","encodeUTF8","src","dst","cp","UTF16toUTF8","c1","c2","encodeUTF16toUTF8","stringFromCharCode","stringSource","s","stringDestination","cs","ps","UTF16ToUTF8","sd","x86Multiply","m","x86Rotl","x86Fmix","h","hash32","seed","remainder","bytes","h1","k1","hash","bucket","authenticateFactory","fetchAuth","userKeys","json","decodedToken","hashUserKey","VERSION","CONTROL_CHANNEL_REGEX","buildSSEHeaders","SSEClient","useHeaders","getEventSource","handler","authToken","channelsQueryParam","getMatching","getBucketing","keyParser","Compression","UpdateStrategy","algorithms","v","u8","u16","u32","fleb","fdeb","clim","freb","eb","start","b","r","j","fl","revfl","fd","rev","x","hMap","cd","mb","l","le","co","rvb","sv","r_1","flt","fdt","flrm","fdrm","max","a","bits","d","p","o","bits16","shft","slc","e","ec","ind","nt","inflt","dat","buf","sl","noBuf","noSt","cbuf","bl","nbuf","final","pos","bt","lm","dm","lbt","dbt","tbts","hLit","hcLen","tl","ldt","clt","clb","clbmsk","clm","lt","dt","t","lms","dms","lpos","sym","add","dsym","end","gzs","flg","zs","gzl","zlv","out","GZIP","ZLIB","Uint8ArrayToString","myUint8Arr","StringToUint8Array","myString","charCodes","decompress","compression","compressData","binData","parseKeyList","binKeyList","strKeyList","parseBitmap","isInBitmap","bitmap","hash64hex","internal","offset","SetPoly","callbackfn","thisArg","setToArray","set","__getSetConstructor","_Set","_x64Add","_x64Multiply","_x64Rotl","_x64LeftShift","_x64Xor","_x64Fmix","hash128x64","h2","k2","hash128","hex2dec","digits","carry","hash64","hex","sseClient","authenticate","sseHandler","segmentsUpdateWorker","splitsUpdateWorker","userKeyHashes","clients","connectForNewClient","disconnected","disabled","connectPushRetryBackoff","connectPush","timeoutIdTokenRefresh","timeoutIdSseOpen","scheduleTokenRefreshAndSse","authData","refreshTokenDelay","connDelay","disconnectPush","stopWorkers","worker","userKeyHash","bitmap_1","keyList","added_1","removed_1","mySegmentsFetcherFactory","fetchMySegments","decorator","mySegmentsPromise","timeout","ms","promise","resolve","reject","tid","mySegmentsUpdaterFactory","mySegmentsFetcher","mySegmentsCache","segmentsEventEmitter","requestTimeoutBeforeReady","retriesOnFailureBeforeReady","readyOnAlreadyExistentState","startingUp","_promiseDecorator","updateSegments","shouldNotifyUpdate","name_1","_mySegmentsUpdater","retry","updaterPromise","mySegmentsSyncTaskFactory","splitChangesFetcherFactory","fetchSplitChanges","splitsPromise","checkAllSegmentsExist","registeredSegments","segmentNames","changeNumbers","parseSegments","conditions","matchers","matcher","computeSplitsMutation","entries","computed","accum","split","splitChangesUpdaterFactory","splitChangesFetcher","splits","_splitChangesUpdater","fetcherPromise","splitChanges","mutation","emitSplitsArrivedEvent","isCacheReady","sincePromise","splitsSyncTaskFactory","pollingManagerCSFactory","mySegmentsSyncTasks","startMySegmentsSyncTasks","stopMySegmentsSyncTasks","splitsHaveSegments","smartReady","ImpressionsCacheInMemory","impressionsQueueSize","toMerge","DEDUP_WINDOW_SIZE_MS","truncateTimeFrame","timestampInMs","LOG_PREFIX","DEFAULT_CACHE_SIZE","REFRESH_RATE","TTL_REFRESH","ImpressionCountsCacheInMemory","impressionCountsCacheSize","amount","currentAmount","MAX_QUEUE_BYTE_SIZE","EventsCacheInMemory","eventsQueueSize","size","everythingAtTheEnd","DEFAULT_PREFIX","validatePrefix","prefix","KeyBuilder","trafficType","builtKey","KeyBuilderCS","_super","builtSegmentKeyName","isLocalStorageAvailable","mod","AbstractSplitsCacheSync","keyValuePair","names","newSplit","usesSegments","DEFINED","SplitsCacheInLocal","expirationTimestamp","count","ttKey","segmentsCountKey","len","cur","splitKey","splitFromLocalStorage","previousSplit","queryKey","queryString","ttCount","storedCount","splitsWithSegmentsCount","currentQueryString","AbstractSegmentsCacheSync","MySegmentsCacheInLocal","segmentKey","isDiff","storedSegmentNames","newSegmentKey","MySegmentsCacheInMemory","storedSegmentKeys","SplitsCacheInMemory","previousTtName","ttName","GOOGLE_ANALYTICS_TO_SPLIT","SPLIT_TO_GOOGLE_ANALYTICS","DEFAULT_CACHE_EXPIRATION_IN_MILLIS","MIN","MAX","BASE","findLatencyIndex","latencyInMs","MAX_STREAMING_EVENTS","MAX_TAGS","MAX_LATENCY_BUCKET_COUNT","newBuckets","ACCEPTANCE_RANGE","shouldRecordTelemetry","TelemetryCacheInMemory","resource","timeMs","status","statusErrors","latencyMs","latencyBuckets","streamingEvent","tag","UniqueKeysCacheInMemoryCS","uniqueKeysQueueSize","tracker","payload","k","featureNames","uniqueKeysPayload","noopTrack","InLocalStorage","InLocalStorageCSFactory","__splitFiltersValidation","childKeysBuilder","thenable","validateIfNotDestroyed","validateIfOperational","SPLIT_KILLED","NO_CONDITION_MATCH","SPLIT_NOT_FOUND","SDK_NOT_READY","EXCEPTION","SPLIT_ARCHIVED","NOT_IN_SPLIT","validateSplitExistance","labelOrSplitObj","collectTreatments","splitObject","allTreatmentsCondition","cond","objectToView","objectsToViews","splitObjects","views","view","sdkManagerFactory","sdkStatus","SPLIT_FN_LABEL","maybeSplitName","currentSplits","splitNames","AttributesCacheInMemory","attributeName","attributeValue","attributes","validateAttribute","attributeKey","isStringVal","isFiniteVal","isBoolVal","isArrayVal","validateAttributes","maybeAttrs","validateAttributesDeep","maybeAttributes","clientAttributesDecoration","client","attributeStorage","clientGetTreatment","clientGetTreatmentWithConfig","clientGetTreatments","clientGetTreatmentsWithConfig","clientTrack","getTreatment","combineAttributes","getTreatmentWithConfig","getTreatments","getTreatmentsWithConfig","track","maybeEvent","maybeEventValue","maybeProperties","storedAttributes","attribute","clientCSDecorator","clientCS","matcherTypes","matcherDataTypes","matcherTypesMapper","matcherType","segmentTransform","whitelistTransform","whitelistObject","setTransform","numericTransform","unaryNumericObject","zeroSinceHH","millisSinceEpoch","zeroSinceSS","matchersTransform","parsedMatchers","negate","keySelector","segmentObject","betweenObject","dependencyObject","booleanMatcherData","stringMatcherData","dataType","Treatments","ranges","treatments","treatment","range","allMatcherContext","runtimeAttr","segmentMatcherContext","isInSegment","whitelistMatcherContext","ruleAttr","isInWhitelist","equalToMatcherContext","isEqual","greaterThanEqualMatcherContext","isGreaterEqualThan","lessThanEqualMatcherContext","isLessEqualThan","betweenMatcherContext","ruleVO","isBetween","equalToSetMatcherContext","_loop_1","containsAnySetMatcherContext","containsAny","containsAllSetMatcherContext","containsAll","partOfSetMatcherContext","isPartOf","endsWithMatcherContext","strEndsWith","startsWithMatcherContext","matches","containsStringMatcherContext","contains","dependencyMatcherContext","checkTreatment","evaluation","acceptableTreatments","parentName","splitEvaluator","ev","booleanMatcherContext","booleanMatches","stringMatcherContext","re","regexMatches","matcherFactory","matcherDto","matcherFn","sanitizeNumber","num","sanitizeString","valueToSanitize","sanitizeArray","sanitizeBoolean","lowerCaseValue","dependencyProcessor","sanitizedValue","getProcessingFunction","matcherTypeID","sanitize","processor","parseValue","sanitizeValue","valueToMatch","_bucket","shouldApplyRollout","trafficAllocation","trafficAllocationSeed","match","matchingResult","label","conditionContext","matcherEvaluator","conditionType","ifElseIfCombinerContext","predicates","unexpectedInputHandler","computeTreatment","predicateResults","ifElseIfCombiner","evaluator","results","andCombinerContext","andResults","hasMatchedAll","matcherResults","parser","matcherGroup","partitions","expressions","evaluationResult","Engine","baseInfo","splitFlatStructure","killed","parsedKey","treatmentException","treatmentsException","evaluations","evaluateFeature","parsedSplit","getEvaluation","evaluateFeatures","parsedSplits","getEvaluations","splitJSON","split_1","thenables","logTTExistanceWarning","validateTrafficTypeExistance","isValid","isStorageSync","treatmentNotReady","treatmentsNotReady","clientFactory","impressionsTracker","eventTracker","withConfig","stopTelemetryTracker","wrapUp","queue","processEvaluation","evaluationResults","invokingMethodName","trafficTypeName","eventTypeId","properties","eventData","EVENT_TYPE_REGEX","validateEvent","validateEventValue","maybeValue","ECMA_SIZES","MAX_PROPERTIES_AMOUNT","MAX_EVENT_SIZE","BASE_EVENT_SIZE","validateEventProperties","clone","isNullVal","clientInputValidationDecorator","isSync","validateEvaluationParams","maybeSplitOrSplits","methodName","multi","splitOrSplits","isOperational","valid","wrapResult","res_1","res_2","tt","event","eventValue","COOLDOWN_TIME_IN_MILLIS","sdkClientFactory","isSharedClient","syncManager","signalListener","uniqueKeysTracker","lastActionTime","__cooldown","func","time","timeElapsed","__flush","buildInstanceId","sdkClientMethodCSFactory","readyTimeout","mainClientInstance","parsedDefaultKey","defaultInstanceId","clientInstances","validKey","validTrafficType","instanceId","sharedSdkReadiness_1","sharedStorage","sharedSyncManager","MapPoly","__getMapConstructor","_Map","Node","prev","next","list","LinkedList","node","head","LRUCache","maxSize","last","ImpressionObserver","hasher","impression","previous","buildKey","hashImpression32","LAST_SEEN_CACHE_SIZE","impressionObserverCSFactory","pluggableIntegrationsManagerFactory","listeners","integrationFactory","integration","impressionData","listener","logPrefix","logNameMapper","providePlugin","window","pluginName","pluginConstructor","autoRequire","gaAlias","hasAutoRequire","defaultMapping","mapperBuilder","mapping","model","hitType","fields","fieldValue","defaultMapper","defaultPrefix","validateIdentities","identities","uniqueIdentities","identity","validateEventData","INVALID_PREFIX_REGEX","INVALID_SUBSTRING_REGEX","fixEventTypeId","fixed","truncated","GaToSplit","sdkOptions","coreSettings","defaultOptions","SplitTracker","pluginOptions","opts","validIdentities","invalids","originalSendHitTask","GoogleAnalyticsToSplit","GoogleAnalyticsToSplitFactory","noGaWarning","noHit","SplitToGa","fieldsObject","ga","fieldsObject_1","trackerName","sendCommand","SplitToGoogleAnalytics","SplitToGoogleAnalyticsFactory","integrationsManagerFactory","integrationFactories","integrationOptions","__InLocalStorageMockFactory","validateStorageCS","promiseWrapper","customPromise","defaultOnRejected","hasOnFulfilled","hasOnRejected","chain","newPromise","rej","originalThen","onfulfilled","onrejected","splitsEventEmitterFactory","EventEmitter","isSplitKill","segmentsEventEmitterFactory","readinessManagerFactory","gate","isReadyFromCache","checkIsReadyFromCache","hasTimedout","readyTimeoutId","isReady","checkIsReadyOrUpdate","isDestroyed","diff","refCount","NEW_LISTENER_EVENT","REMOVE_LISTENER_EVENT","sdkReadinessManagerFactory","internalReadyCbCount","readyCbCount","readyPromise","generateReadyPromise","impressionsTrackerFactory","impressionsCache","strategy","integrationsManager","telemetryCache","impressionListener","impressionsToStore","impressionsToListener","deduped","impressionsToListenerCount","eventTrackerFactory","eventsCache","queueEventsCallback","tracked","eventDataCopy","telemetryTrackerFactory","startTime_1","evalTime","operation","httpTime","LogLevels","LogLevelIndexes","isLogLevelString","lvl","_sprintf","format","Logger","codes","logLevel","level","formattedText","text","textPre","createLoggerAPI","setLogLevel","strategyDebugFactory","impressionsObserver","strategyOptimizedFactory","impressionsCounter","strategyNoneFactory","noopFilterAdapter","uniqueKeysTrackerFactory","uniqueKeysCache","filterAdapter","intervalId","sdkFactory","storageFactory","extraProps","syncManagerFactory","SignalListener","impressionsObserverFactory","sdkClientMethodFactory","filterAdapterFactory","observer","ctx","clientMethod","managerInstance","ConsentStatus","createUserConsentAPI","newConsentStatus","validateRuntime","isNode","codesError","codesWarn","READY_MSG","codesInfo","codesDebug","getLogLevel","debugValue","allCodes","LS_KEY","ENV_VAR_KEY","initialState","initialLogLevel","validateLogger","debug","parseCondition","hasTreatmentChanged","curr","splitsParserFromSettingsFactory","previousMock","mockUpdated","currentData","newTreatment","changed","features","configurations","fromObjectUpdaterFactory","splitsParser","loadError","splitsMock","cacheReady","fromObjectSyncTaskFactory","flush","syncManagerOfflineFactory","splitsParserFactory","localhostFromObject","LocalhostFromObject","userConsentValues","validateConsent","packageVersion","validateStorage","__originalType","fallbackToMemory","validateIntegrations","integrationValidator","extraWarning","validIntegrations","validateConfigurableIntegrations","validIntegrationTypes","settingsFactory","R","ReflectApply","receiver","ReflectOwnKeys","ProcessEmitWarning","warning","NumberIsNaN","defaultMaxListeners","checkListener","arg","_getMaxListeners","that","doError","er","arrayClone","_addListener","prepend","existing","w","onceWrapper","_onceWrap","state","wrapped","position","originalListener","spliceOne","_listeners","unwrap","evlistener","unwrapListeners","emitter","listenerCount","copy","ret","u","VISIBILITYCHANGE_EVENT","PAGEHIDE_EVENT","UNLOAD_EVENT","EVENT_NAME","BrowserSignalListener","serviceApi","sim","extraMetadata","cache","postService","dataPayload","nowFactory","syncManagerOnlineCSFactory","getStorage","getModules","modules","SplitFactory","__updateModules"],"sourceRoot":""}