@contentful/optimization-core 0.1.0-alpha

package/dist/index.cjs

@@ -0,0 +1,1808 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/CoreBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__rspack_default_export
+        });
+        var _contentful_optimization_api_client__rspack_import_0 = __webpack_require__("@contentful/optimization-api-client");
+        var logger__rspack_import_1 = __webpack_require__("../../lib/logger/dist/index.mjs");
+        var _global_constants__rspack_import_3 = __webpack_require__("./src/global-constants.ts");
+        var _lib_interceptor__rspack_import_2 = __webpack_require__("./src/lib/interceptor/InterceptorManager.ts");
+        class CoreBase {
+            api;
+            eventBuilder;
+            config;
+            interceptors = {
+                event: new _lib_interceptor__rspack_import_2.v(),
+                state: new _lib_interceptor__rspack_import_2.v()
+            };
+            constructor(config){
+                this.config = config;
+                const { analytics, personalization, eventBuilder, logLevel, environment, clientId } = config;
+                logger__rspack_import_1.vF.addSink(new logger__rspack_import_1.vg(logLevel));
+                const apiConfig = {
+                    ...analytics,
+                    ...personalization,
+                    clientId,
+                    environment
+                };
+                this.api = new _contentful_optimization_api_client__rspack_import_0.ApiClient(apiConfig);
+                this.eventBuilder = new _contentful_optimization_api_client__rspack_import_0.EventBuilder(eventBuilder ?? {
+                    channel: 'server',
+                    library: {
+                        name: 'Optimization Core',
+                        version: _global_constants__rspack_import_3.E
+                    }
+                });
+            }
+            getCustomFlag(name, changes) {
+                return this.personalization.getCustomFlag(name, changes);
+            }
+            personalizeEntry(entry, personalizations) {
+                return this.personalization.personalizeEntry(entry, personalizations);
+            }
+            getMergeTagValue(embeddedEntryNodeTarget, profile) {
+                return this.personalization.getMergeTagValue(embeddedEntryNodeTarget, profile);
+            }
+            async identify(payload) {
+                return await this.personalization.identify(payload);
+            }
+            async page(payload) {
+                return await this.personalization.page(payload);
+            }
+            async screen(payload) {
+                return await this.personalization.screen(payload);
+            }
+            async track(payload) {
+                return await this.personalization.track(payload);
+            }
+            async trackComponentView(payload, duplicationScope) {
+                if (payload.sticky) return await this.personalization.trackComponentView(payload, duplicationScope);
+                await this.analytics.trackComponentView(payload, duplicationScope);
+            }
+            async trackFlagView(payload, duplicationScope) {
+                await this.analytics.trackFlagView(payload, duplicationScope);
+            }
+        }
+        const __rspack_default_export = CoreBase;
+    },
+    "./src/CoreStateful.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__rspack_default_export
+        });
+        var _analytics__rspack_import_0 = __webpack_require__("./src/analytics/index.ts");
+        var _CoreBase__rspack_import_1 = __webpack_require__("./src/CoreBase.ts");
+        var _personalization__rspack_import_2 = __webpack_require__("./src/personalization/index.ts");
+        var _signals__rspack_import_3 = __webpack_require__("./src/signals.ts");
+        class CoreStateful extends _CoreBase__rspack_import_1.A {
+            analytics;
+            personalization;
+            constructor(config){
+                super(config);
+                const { allowedEventTypes, defaults, getAnonymousId, preventedComponentEvents } = config;
+                if (defaults?.consent !== void 0) {
+                    const { consent: defaultConsent } = defaults;
+                    _signals__rspack_import_3.vJ.value = defaultConsent;
+                }
+                this.analytics = new _analytics__rspack_import_0.R({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    config: {
+                        allowedEventTypes,
+                        preventedComponentEvents,
+                        defaults: {
+                            consent: defaults?.consent,
+                            profile: defaults?.profile
+                        }
+                    },
+                    interceptors: this.interceptors
+                });
+                this.personalization = new _personalization__rspack_import_2.$C({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    config: {
+                        allowedEventTypes,
+                        getAnonymousId,
+                        preventedComponentEvents,
+                        defaults: {
+                            consent: defaults?.consent,
+                            changes: defaults?.changes,
+                            profile: defaults?.profile,
+                            personalizations: defaults?.personalizations
+                        }
+                    },
+                    interceptors: this.interceptors
+                });
+            }
+            get states() {
+                return {
+                    consent: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.vJ),
+                    eventStream: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.f0),
+                    flags: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.Mv),
+                    personalizations: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.wh),
+                    profile: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.ME)
+                };
+            }
+            reset() {
+                (0, _signals__rspack_import_3.vA)(()=>{
+                    _signals__rspack_import_3.f0.value = void 0;
+                    _signals__rspack_import_3.Ao.value = void 0;
+                    _signals__rspack_import_3.ME.value = void 0;
+                    _signals__rspack_import_3.wh.value = void 0;
+                });
+            }
+            async flush() {
+                await this.analytics.flush();
+                await this.personalization.flush();
+            }
+            consent(accept) {
+                _signals__rspack_import_3.vJ.value = accept;
+            }
+            online(isOnline) {
+                _signals__rspack_import_3.WD.value = isOnline;
+            }
+            registerPreviewPanel(previewPanel) {
+                previewPanel.signals = _signals__rspack_import_3.QO;
+            }
+        }
+        const __rspack_default_export = CoreStateful;
+    },
+    "./src/CoreStateless.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__rspack_default_export
+        });
+        var _analytics__rspack_import_0 = __webpack_require__("./src/analytics/index.ts");
+        var _CoreBase__rspack_import_1 = __webpack_require__("./src/CoreBase.ts");
+        var _personalization__rspack_import_2 = __webpack_require__("./src/personalization/index.ts");
+        class CoreStateless extends _CoreBase__rspack_import_1.A {
+            analytics;
+            personalization;
+            constructor(config){
+                super(config);
+                this.analytics = new _analytics__rspack_import_0.v({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    interceptors: this.interceptors
+                });
+                this.personalization = new _personalization__rspack_import_2.jL({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    interceptors: this.interceptors
+                });
+            }
+        }
+        const __rspack_default_export = CoreStateless;
+    },
+    "./src/ProductBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__rspack_default_export
+        });
+        var _lib_value_presence_ValuePresence__rspack_import_0 = __webpack_require__("./src/lib/value-presence/ValuePresence.ts");
+        const defaultAllowedEvents = [
+            'page',
+            'identify'
+        ];
+        class ProductBase {
+            allowedEventTypes;
+            builder;
+            api;
+            duplicationDetector;
+            interceptors;
+            constructor(options){
+                const { api, builder, config, interceptors } = options;
+                this.allowedEventTypes = config?.allowedEventTypes ?? defaultAllowedEvents;
+                this.api = api;
+                this.builder = builder;
+                this.duplicationDetector = new _lib_value_presence_ValuePresence__rspack_import_0.A(config?.preventedComponentEvents);
+                this.interceptors = interceptors;
+            }
+        }
+        const __rspack_default_export = ProductBase;
+    },
+    "./src/analytics/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            R: ()=>analytics_AnalyticsStateful,
+            v: ()=>analytics_AnalyticsStateless
+        });
+        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        var guardedBy = __webpack_require__("./src/lib/decorators/guardedBy.ts");
+        var signals = __webpack_require__("./src/signals.ts");
+        var ProductBase = __webpack_require__("./src/ProductBase.ts");
+        class AnalyticsBase extends ProductBase.A {
+        }
+        const analytics_AnalyticsBase = AnalyticsBase;
+        function applyDecs2203RFactory() {
+            function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+                return function(initializer) {
+                    assertNotFinished(decoratorFinishedRef, "addInitializer");
+                    assertCallable(initializer, "An initializer");
+                    initializers.push(initializer);
+                };
+            }
+            function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+                var kindStr;
+                switch(kind){
+                    case 1:
+                        kindStr = "accessor";
+                        break;
+                    case 2:
+                        kindStr = "method";
+                        break;
+                    case 3:
+                        kindStr = "getter";
+                        break;
+                    case 4:
+                        kindStr = "setter";
+                        break;
+                    default:
+                        kindStr = "field";
+                }
+                var ctx = {
+                    kind: kindStr,
+                    name: isPrivate ? "#" + name : name,
+                    static: isStatic,
+                    private: isPrivate,
+                    metadata: metadata
+                };
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+                var get, set;
+                if (0 === kind) if (isPrivate) {
+                    get = desc.get;
+                    set = desc.set;
+                } else {
+                    get = function() {
+                        return this[name];
+                    };
+                    set = function(v) {
+                        this[name] = v;
+                    };
+                }
+                else if (2 === kind) get = function() {
+                    return desc.value;
+                };
+                else {
+                    if (1 === kind || 3 === kind) get = function() {
+                        return desc.get.call(this);
+                    };
+                    if (1 === kind || 4 === kind) set = function(v) {
+                        desc.set.call(this, v);
+                    };
+                }
+                ctx.access = get && set ? {
+                    get: get,
+                    set: set
+                } : get ? {
+                    get: get
+                } : {
+                    set: set
+                };
+                try {
+                    return dec(value, ctx);
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+            }
+            function assertNotFinished(decoratorFinishedRef, fnName) {
+                if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+            }
+            function assertCallable(fn, hint) {
+                if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+            }
+            function assertValidReturnValue(kind, value) {
+                var type = typeof value;
+                if (1 === kind) {
+                    if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+                    if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+                    if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+                    if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+                } else if ("function" !== type) {
+                    var hint;
+                    hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+                    throw new TypeError(hint + " decorators must return a function or void 0");
+                }
+            }
+            function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+                var decs = decInfo[0];
+                var desc, init, value;
+                if (isPrivate) desc = 0 === kind || 1 === kind ? {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                } : 3 === kind ? {
+                    get: decInfo[3]
+                } : 4 === kind ? {
+                    set: decInfo[3]
+                } : {
+                    value: decInfo[3]
+                };
+                else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+                if (1 === kind) value = {
+                    get: desc.get,
+                    set: desc.set
+                };
+                else if (2 === kind) value = desc.value;
+                else if (3 === kind) value = desc.get;
+                else if (4 === kind) value = desc.set;
+                var newValue, get, set;
+                if ("function" == typeof decs) {
+                    newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                    if (void 0 !== newValue) {
+                        assertValidReturnValue(kind, newValue);
+                        if (0 === kind) init = newValue;
+                        else if (1 === kind) {
+                            init = newValue.init;
+                            get = newValue.get || value.get;
+                            set = newValue.set || value.set;
+                            value = {
+                                get: get,
+                                set: set
+                            };
+                        } else value = newValue;
+                    }
+                } else for(var i = decs.length - 1; i >= 0; i--){
+                    var dec = decs[i];
+                    newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                    if (void 0 !== newValue) {
+                        assertValidReturnValue(kind, newValue);
+                        var newInit;
+                        if (0 === kind) newInit = newValue;
+                        else if (1 === kind) {
+                            newInit = newValue.init;
+                            get = newValue.get || value.get;
+                            set = newValue.set || value.set;
+                            value = {
+                                get: get,
+                                set: set
+                            };
+                        } else value = newValue;
+                        if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                        else if ("function" == typeof init) init = [
+                            init,
+                            newInit
+                        ];
+                        else init.push(newInit);
+                    }
+                }
+                if (0 === kind || 1 === kind) {
+                    if (void 0 === init) init = function(instance, init) {
+                        return init;
+                    };
+                    else if ("function" != typeof init) {
+                        var ownInitializers = init;
+                        init = function(instance, init) {
+                            var value = init;
+                            for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                            return value;
+                        };
+                    } else {
+                        var originalInitializer = init;
+                        init = function(instance, init) {
+                            return originalInitializer.call(instance, init);
+                        };
+                    }
+                    ret.push(init);
+                }
+                if (0 !== kind) {
+                    if (1 === kind) {
+                        desc.get = value.get;
+                        desc.set = value.set;
+                    } else if (2 === kind) desc.value = value;
+                    else if (3 === kind) desc.get = value;
+                    else if (4 === kind) desc.set = value;
+                    if (isPrivate) if (1 === kind) {
+                        ret.push(function(instance, args) {
+                            return value.get.call(instance, args);
+                        });
+                        ret.push(function(instance, args) {
+                            return value.set.call(instance, args);
+                        });
+                    } else if (2 === kind) ret.push(value);
+                    else ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                    else Object.defineProperty(base, name, desc);
+                }
+            }
+            function applyMemberDecs(Class, decInfos, metadata) {
+                var ret = [];
+                var protoInitializers;
+                var staticInitializers;
+                var existingProtoNonFields = new Map();
+                var existingStaticNonFields = new Map();
+                for(var i = 0; i < decInfos.length; i++){
+                    var decInfo = decInfos[i];
+                    if (Array.isArray(decInfo)) {
+                        var kind = decInfo[1];
+                        var name = decInfo[2];
+                        var isPrivate = decInfo.length > 3;
+                        var isStatic = kind >= 5;
+                        var base;
+                        var initializers;
+                        if (isStatic) {
+                            base = Class;
+                            kind -= 5;
+                            staticInitializers = staticInitializers || [];
+                            initializers = staticInitializers;
+                        } else {
+                            base = Class.prototype;
+                            protoInitializers = protoInitializers || [];
+                            initializers = protoInitializers;
+                        }
+                        if (0 !== kind && !isPrivate) {
+                            var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                            var existingKind = existingNonFields.get(name) || 0;
+                            if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                            if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                            else existingNonFields.set(name, true);
+                        }
+                        applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+                    }
+                }
+                pushInitializers(ret, protoInitializers);
+                pushInitializers(ret, staticInitializers);
+                return ret;
+            }
+            function pushInitializers(ret, initializers) {
+                if (initializers) ret.push(function(instance) {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+                    return instance;
+                });
+            }
+            function applyClassDecs(targetClass, classDecs, metadata) {
+                if (classDecs.length > 0) {
+                    var initializers = [];
+                    var newClass = targetClass;
+                    var name = targetClass.name;
+                    for(var i = classDecs.length - 1; i >= 0; i--){
+                        var decoratorFinishedRef = {
+                            v: false
+                        };
+                        try {
+                            var nextNewClass = classDecs[i](newClass, {
+                                kind: "class",
+                                name: name,
+                                addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                                metadata
+                            });
+                        } finally{
+                            decoratorFinishedRef.v = true;
+                        }
+                        if (void 0 !== nextNewClass) {
+                            assertValidReturnValue(10, nextNewClass);
+                            newClass = nextNewClass;
+                        }
+                    }
+                    return [
+                        defineMetadata(newClass, metadata),
+                        function() {
+                            for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                        }
+                    ];
+                }
+            }
+            function defineMetadata(Class, metadata) {
+                return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+                    configurable: true,
+                    enumerable: true,
+                    value: metadata
+                });
+            }
+            return function(targetClass, memberDecs, classDecs, parentClass) {
+                if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+                var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+                var e = applyMemberDecs(targetClass, memberDecs, metadata);
+                if (!classDecs.length) defineMetadata(targetClass, metadata);
+                return {
+                    e: e,
+                    get c () {
+                        return applyClassDecs(targetClass, classDecs, metadata);
+                    }
+                };
+            };
+        }
+        function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+            return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+        }
+        var _dec, _dec1, _dec2, _dec3, _initProto;
+        const logger = (0, dist.zP)('Analytics');
+        const MAX_QUEUED_EVENTS = 25;
+        _dec = (0, guardedBy.i)('isNotDuplicated', {
+            onBlocked: 'onBlockedByDuplication'
+        }), _dec1 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        }), _dec2 = (0, guardedBy.i)('isNotDuplicated', {
+            onBlocked: 'onBlockedByDuplication'
+        }), _dec3 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        });
+        class AnalyticsStateful extends analytics_AnalyticsBase {
+            static{
+                ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+                    [
+                        [
+                            _dec,
+                            _dec1
+                        ],
+                        2,
+                        "trackComponentView"
+                    ],
+                    [
+                        [
+                            _dec2,
+                            _dec3
+                        ],
+                        2,
+                        "trackFlagView"
+                    ]
+                ], []));
+            }
+            queue = (_initProto(this), new Map());
+            states = {
+                eventStream: (0, signals.br)(signals.f0),
+                profile: (0, signals.br)(signals.ME)
+            };
+            constructor(options){
+                const { api, builder, config, interceptors } = options;
+                super({
+                    api,
+                    builder,
+                    config,
+                    interceptors
+                });
+                const { defaults } = config ?? {};
+                if (defaults?.profile !== void 0) {
+                    const { profile: defaultProfile } = defaults;
+                    signals.ME.value = defaultProfile;
+                }
+                (0, signals.QZ)(()=>{
+                    const id = signals.ME.value?.id;
+                    logger.info(`Analytics ${signals.vJ.value ? 'will' : 'will not'} be collected due to consent (${signals.vJ.value})`);
+                    logger.debug(`Profile ${id && `with ID ${id}`} has been ${id ? 'set' : 'cleared'}`);
+                });
+                (0, signals.QZ)(()=>{
+                    if (signals.WD.value) this.flush();
+                });
+            }
+            reset() {
+                (0, signals.vA)(()=>{
+                    signals.f0.value = void 0;
+                    signals.ME.value = void 0;
+                });
+            }
+            hasConsent(name) {
+                return !!signals.vJ.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
+            }
+            onBlockedByConsent(name, payload) {
+                logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
+            }
+            isNotDuplicated(_name, payload) {
+                const [{ componentId: value }, duplicationScope] = payload;
+                const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
+                if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
+                return !isDuplicated;
+            }
+            onBlockedByDuplication(name, payload) {
+                const componentType = 'trackFlagView' === name ? 'flag' : 'component';
+                logger.debug(`Duplicate "${componentType} view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
+            }
+            async trackComponentView(payload, _duplicationScope = '') {
+                logger.info(`Processing "component view" event for ${payload.componentId}`);
+                await this.enqueueEvent(this.builder.buildComponentView(payload));
+            }
+            async trackFlagView(payload, _duplicationScope = '') {
+                logger.debug(`Processing "flag view" event for ${payload.componentId}`);
+                await this.enqueueEvent(this.builder.buildFlagView(payload));
+            }
+            async enqueueEvent(event) {
+                const { value: profile } = signals.ME;
+                if (!profile) return void logger.warn('Attempting to emit an event without an Optimization profile');
+                const intercepted = await this.interceptors.event.run(event);
+                const validEvent = optimization_api_client_.InsightsEvent.parse(intercepted);
+                logger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
+                const profileEventQueue = this.queue.get(profile);
+                signals.f0.value = validEvent;
+                if (profileEventQueue) profileEventQueue.push(validEvent);
+                else this.queue.set(profile, [
+                    validEvent
+                ]);
+                await this.flushMaxEvents();
+            }
+            async flushMaxEvents() {
+                if (this.queue.values().toArray().flat().length >= MAX_QUEUED_EVENTS) await this.flush();
+            }
+            async flush() {
+                logger.debug('Flushing event queue');
+                const batches = [];
+                this.queue.forEach((events, profile)=>batches.push({
+                        profile,
+                        events
+                    }));
+                if (!batches.length) return;
+                const sendSuccess = await this.api.insights.sendBatchEvents(batches);
+                if (sendSuccess) this.queue.clear();
+            }
+        }
+        const analytics_AnalyticsStateful = AnalyticsStateful;
+        const AnalyticsStateless_logger = (0, dist.zP)('Analytics');
+        class AnalyticsStateless extends analytics_AnalyticsBase {
+            async trackComponentView(args) {
+                AnalyticsStateless_logger.info('Processing "component view" event');
+                const { profile, ...builderArgs } = args;
+                const event = this.builder.buildComponentView(builderArgs);
+                const intercepted = await this.interceptors.event.run(event);
+                const parsed = optimization_api_client_.ComponentViewEvent.parse(intercepted);
+                await this.sendBatchEvent(parsed, profile);
+            }
+            async trackFlagView(args) {
+                AnalyticsStateless_logger.debug('Processing "flag view" event');
+                const { profile, ...builderArgs } = args;
+                const event = this.builder.buildFlagView(builderArgs);
+                const intercepted = await this.interceptors.event.run(event);
+                const parsed = optimization_api_client_.ComponentViewEvent.parse(intercepted);
+                await this.sendBatchEvent(parsed, profile);
+            }
+            async sendBatchEvent(event, profile) {
+                const batchEvent = optimization_api_client_.BatchInsightsEventArray.parse([
+                    {
+                        profile,
+                        events: [
+                            event
+                        ]
+                    }
+                ]);
+                await this.api.insights.sendBatchEvents(batchEvent);
+            }
+        }
+        const analytics_AnalyticsStateless = AnalyticsStateless;
+    },
+    "./src/global-constants.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            E: ()=>OPTIMIZATION_CORE_SDK_VERSION,
+            T: ()=>ANONYMOUS_ID_COOKIE
+        });
+        const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha";
+        const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
+    },
+    "./src/lib/decorators/guardedBy.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            i: ()=>guardedBy
+        });
+        const isFunction = (v)=>'function' == typeof v;
+        const nameToString = (name)=>'string' == typeof name ? name : 'symbol' == typeof name ? name.description ?? String(name) : String(name);
+        const isOnBlockedKey = (v)=>'string' == typeof v || 'symbol' == typeof v;
+        const isAsyncFunction = (fn)=>'[object AsyncFunction]' === Object.prototype.toString.call(fn);
+        function guardedBy(predicateName, opts) {
+            return function(_value, context) {
+                const decoratedName = nameToString(context.name);
+                context.addInitializer(function() {
+                    const originalUnknown = Reflect.get(this, context.name);
+                    if (!isFunction(originalUnknown)) return;
+                    const original = originalUnknown;
+                    const originalIsAsync = isAsyncFunction(original);
+                    const resolvePredicate = (self)=>{
+                        const { [predicateName]: cand } = self;
+                        if (!isFunction(cand)) throw new TypeError(`@guardedBy expects predicate "${String(predicateName)}" to be a synchronous function.`);
+                        return cand;
+                    };
+                    const computeAllowed = (self, args)=>{
+                        const pred = resolvePredicate(self);
+                        const ok = Boolean(pred.call(self, decoratedName, args));
+                        return opts?.invert === true ? !ok : ok;
+                    };
+                    const runOnBlocked = (self, args)=>{
+                        const { onBlocked } = opts ?? {};
+                        if (void 0 === onBlocked) return;
+                        if (isFunction(onBlocked)) return void onBlocked.call(self, decoratedName, args);
+                        if (isOnBlockedKey(onBlocked)) {
+                            const { [onBlocked]: handlerCandidate } = self;
+                            if (isFunction(handlerCandidate)) handlerCandidate.call(self, decoratedName, args);
+                        }
+                    };
+                    const blockedReturn = ()=>originalIsAsync ? Promise.resolve(void 0) : void 0;
+                    const wrapped = function(...args) {
+                        if (!computeAllowed(this, args)) {
+                            runOnBlocked(this, args);
+                            return blockedReturn();
+                        }
+                        return original.call(this, ...args);
+                    };
+                    Reflect.set(this, context.name, wrapped);
+                });
+            };
+        }
+    },
+    "./src/lib/decorators/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            i: ()=>_guardedBy__rspack_import_0.i
+        });
+        var _guardedBy__rspack_import_0 = __webpack_require__("./src/lib/decorators/guardedBy.ts");
+    },
+    "./src/lib/interceptor/InterceptorManager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            v: ()=>InterceptorManager
+        });
+        class InterceptorManager {
+            interceptors = new Map();
+            nextId = 0;
+            add(interceptor) {
+                const { nextId: id } = this;
+                this.nextId += 1;
+                this.interceptors.set(id, interceptor);
+                return id;
+            }
+            remove(id) {
+                return this.interceptors.delete(id);
+            }
+            clear() {
+                this.interceptors.clear();
+            }
+            count() {
+                return this.interceptors.size;
+            }
+            async run(input) {
+                const fns = Array.from(this.interceptors.values());
+                let acc = input;
+                for (const fn of fns)acc = await fn(acc);
+                return acc;
+            }
+        }
+    },
+    "./src/lib/interceptor/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            v: ()=>_InterceptorManager__rspack_import_0.v
+        });
+        var _InterceptorManager__rspack_import_0 = __webpack_require__("./src/lib/interceptor/InterceptorManager.ts");
+    },
+    "./src/lib/value-presence/ValuePresence.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__rspack_default_export
+        });
+        class ValuePresence {
+            #map;
+            constructor(defaultMap){
+                const map = new Map();
+                if (defaultMap) Object.entries(defaultMap).map(([scope, values])=>map.set(scope.length ? scope : void 0, new Set(values)));
+                this.#map = map;
+            }
+            isPresent(scope, value) {
+                return this.#map.get(scope)?.has(value) ?? false;
+            }
+            addValue(scope, value) {
+                const values = this.#map.get(scope);
+                if (values) values.add(value);
+                else this.#map.set(scope, new Set([
+                    value
+                ]));
+            }
+            removeValue(scope, value) {
+                this.#map.get(scope)?.delete(value);
+            }
+            reset(scope) {
+                if (void 0 !== scope) this.#map.get(scope)?.clear();
+                else this.#map.clear();
+            }
+        }
+        const __rspack_default_export = ValuePresence;
+    },
+    "./src/lib/value-presence/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            n: ()=>_ValuePresence__rspack_import_0.A
+        });
+        var _ValuePresence__rspack_import_0 = __webpack_require__("./src/lib/value-presence/ValuePresence.ts");
+    },
+    "./src/personalization/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            OR: ()=>resolvers.OR,
+            $C: ()=>personalization_PersonalizationStateful,
+            jL: ()=>personalization_PersonalizationStateless,
+            cv: ()=>resolvers.cv,
+            z8: ()=>resolvers.z8
+        });
+        var resolvers = __webpack_require__("./src/personalization/resolvers/index.ts");
+        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
+        const external_es_toolkit_namespaceObject = require("es-toolkit");
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        var guardedBy = __webpack_require__("./src/lib/decorators/guardedBy.ts");
+        var signals = __webpack_require__("./src/signals.ts");
+        var ProductBase = __webpack_require__("./src/ProductBase.ts");
+        class PersonalizationBase extends ProductBase.A {
+            flagsResolver = resolvers.OR;
+            mergeTagValueResolver = resolvers.cv;
+            personalizedEntryResolver = resolvers.z8;
+            getCustomFlag(name, changes) {
+                return resolvers.OR.resolve(changes)[name];
+            }
+            personalizeEntry(entry, personalizations) {
+                return resolvers.z8.resolve(entry, personalizations);
+            }
+            getMergeTagValue(embeddedEntryNodeTarget, profile) {
+                return resolvers.cv.resolve(embeddedEntryNodeTarget, profile);
+            }
+        }
+        const personalization_PersonalizationBase = PersonalizationBase;
+        function applyDecs2203RFactory() {
+            function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+                return function(initializer) {
+                    assertNotFinished(decoratorFinishedRef, "addInitializer");
+                    assertCallable(initializer, "An initializer");
+                    initializers.push(initializer);
+                };
+            }
+            function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+                var kindStr;
+                switch(kind){
+                    case 1:
+                        kindStr = "accessor";
+                        break;
+                    case 2:
+                        kindStr = "method";
+                        break;
+                    case 3:
+                        kindStr = "getter";
+                        break;
+                    case 4:
+                        kindStr = "setter";
+                        break;
+                    default:
+                        kindStr = "field";
+                }
+                var ctx = {
+                    kind: kindStr,
+                    name: isPrivate ? "#" + name : name,
+                    static: isStatic,
+                    private: isPrivate,
+                    metadata: metadata
+                };
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+                var get, set;
+                if (0 === kind) if (isPrivate) {
+                    get = desc.get;
+                    set = desc.set;
+                } else {
+                    get = function() {
+                        return this[name];
+                    };
+                    set = function(v) {
+                        this[name] = v;
+                    };
+                }
+                else if (2 === kind) get = function() {
+                    return desc.value;
+                };
+                else {
+                    if (1 === kind || 3 === kind) get = function() {
+                        return desc.get.call(this);
+                    };
+                    if (1 === kind || 4 === kind) set = function(v) {
+                        desc.set.call(this, v);
+                    };
+                }
+                ctx.access = get && set ? {
+                    get: get,
+                    set: set
+                } : get ? {
+                    get: get
+                } : {
+                    set: set
+                };
+                try {
+                    return dec(value, ctx);
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+            }
+            function assertNotFinished(decoratorFinishedRef, fnName) {
+                if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+            }
+            function assertCallable(fn, hint) {
+                if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+            }
+            function assertValidReturnValue(kind, value) {
+                var type = typeof value;
+                if (1 === kind) {
+                    if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+                    if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+                    if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+                    if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+                } else if ("function" !== type) {
+                    var hint;
+                    hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+                    throw new TypeError(hint + " decorators must return a function or void 0");
+                }
+            }
+            function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+                var decs = decInfo[0];
+                var desc, init, value;
+                if (isPrivate) desc = 0 === kind || 1 === kind ? {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                } : 3 === kind ? {
+                    get: decInfo[3]
+                } : 4 === kind ? {
+                    set: decInfo[3]
+                } : {
+                    value: decInfo[3]
+                };
+                else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+                if (1 === kind) value = {
+                    get: desc.get,
+                    set: desc.set
+                };
+                else if (2 === kind) value = desc.value;
+                else if (3 === kind) value = desc.get;
+                else if (4 === kind) value = desc.set;
+                var newValue, get, set;
+                if ("function" == typeof decs) {
+                    newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                    if (void 0 !== newValue) {
+                        assertValidReturnValue(kind, newValue);
+                        if (0 === kind) init = newValue;
+                        else if (1 === kind) {
+                            init = newValue.init;
+                            get = newValue.get || value.get;
+                            set = newValue.set || value.set;
+                            value = {
+                                get: get,
+                                set: set
+                            };
+                        } else value = newValue;
+                    }
+                } else for(var i = decs.length - 1; i >= 0; i--){
+                    var dec = decs[i];
+                    newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                    if (void 0 !== newValue) {
+                        assertValidReturnValue(kind, newValue);
+                        var newInit;
+                        if (0 === kind) newInit = newValue;
+                        else if (1 === kind) {
+                            newInit = newValue.init;
+                            get = newValue.get || value.get;
+                            set = newValue.set || value.set;
+                            value = {
+                                get: get,
+                                set: set
+                            };
+                        } else value = newValue;
+                        if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                        else if ("function" == typeof init) init = [
+                            init,
+                            newInit
+                        ];
+                        else init.push(newInit);
+                    }
+                }
+                if (0 === kind || 1 === kind) {
+                    if (void 0 === init) init = function(instance, init) {
+                        return init;
+                    };
+                    else if ("function" != typeof init) {
+                        var ownInitializers = init;
+                        init = function(instance, init) {
+                            var value = init;
+                            for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                            return value;
+                        };
+                    } else {
+                        var originalInitializer = init;
+                        init = function(instance, init) {
+                            return originalInitializer.call(instance, init);
+                        };
+                    }
+                    ret.push(init);
+                }
+                if (0 !== kind) {
+                    if (1 === kind) {
+                        desc.get = value.get;
+                        desc.set = value.set;
+                    } else if (2 === kind) desc.value = value;
+                    else if (3 === kind) desc.get = value;
+                    else if (4 === kind) desc.set = value;
+                    if (isPrivate) if (1 === kind) {
+                        ret.push(function(instance, args) {
+                            return value.get.call(instance, args);
+                        });
+                        ret.push(function(instance, args) {
+                            return value.set.call(instance, args);
+                        });
+                    } else if (2 === kind) ret.push(value);
+                    else ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                    else Object.defineProperty(base, name, desc);
+                }
+            }
+            function applyMemberDecs(Class, decInfos, metadata) {
+                var ret = [];
+                var protoInitializers;
+                var staticInitializers;
+                var existingProtoNonFields = new Map();
+                var existingStaticNonFields = new Map();
+                for(var i = 0; i < decInfos.length; i++){
+                    var decInfo = decInfos[i];
+                    if (Array.isArray(decInfo)) {
+                        var kind = decInfo[1];
+                        var name = decInfo[2];
+                        var isPrivate = decInfo.length > 3;
+                        var isStatic = kind >= 5;
+                        var base;
+                        var initializers;
+                        if (isStatic) {
+                            base = Class;
+                            kind -= 5;
+                            staticInitializers = staticInitializers || [];
+                            initializers = staticInitializers;
+                        } else {
+                            base = Class.prototype;
+                            protoInitializers = protoInitializers || [];
+                            initializers = protoInitializers;
+                        }
+                        if (0 !== kind && !isPrivate) {
+                            var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                            var existingKind = existingNonFields.get(name) || 0;
+                            if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                            if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                            else existingNonFields.set(name, true);
+                        }
+                        applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+                    }
+                }
+                pushInitializers(ret, protoInitializers);
+                pushInitializers(ret, staticInitializers);
+                return ret;
+            }
+            function pushInitializers(ret, initializers) {
+                if (initializers) ret.push(function(instance) {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+                    return instance;
+                });
+            }
+            function applyClassDecs(targetClass, classDecs, metadata) {
+                if (classDecs.length > 0) {
+                    var initializers = [];
+                    var newClass = targetClass;
+                    var name = targetClass.name;
+                    for(var i = classDecs.length - 1; i >= 0; i--){
+                        var decoratorFinishedRef = {
+                            v: false
+                        };
+                        try {
+                            var nextNewClass = classDecs[i](newClass, {
+                                kind: "class",
+                                name: name,
+                                addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                                metadata
+                            });
+                        } finally{
+                            decoratorFinishedRef.v = true;
+                        }
+                        if (void 0 !== nextNewClass) {
+                            assertValidReturnValue(10, nextNewClass);
+                            newClass = nextNewClass;
+                        }
+                    }
+                    return [
+                        defineMetadata(newClass, metadata),
+                        function() {
+                            for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                        }
+                    ];
+                }
+            }
+            function defineMetadata(Class, metadata) {
+                return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+                    configurable: true,
+                    enumerable: true,
+                    value: metadata
+                });
+            }
+            return function(targetClass, memberDecs, classDecs, parentClass) {
+                if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+                var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+                var e = applyMemberDecs(targetClass, memberDecs, metadata);
+                if (!classDecs.length) defineMetadata(targetClass, metadata);
+                return {
+                    e: e,
+                    get c () {
+                        return applyClassDecs(targetClass, classDecs, metadata);
+                    }
+                };
+            };
+        }
+        function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+            return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+        }
+        var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _initProto;
+        const logger = (0, dist.zP)('Personalization');
+        _dec = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        }), _dec1 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        }), _dec2 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        }), _dec3 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        }), _dec4 = (0, guardedBy.i)('isNotDuplicated', {
+            onBlocked: 'onBlockedByDuplication'
+        }), _dec5 = (0, guardedBy.i)('hasConsent', {
+            onBlocked: 'onBlockedByConsent'
+        });
+        class PersonalizationStateful extends personalization_PersonalizationBase {
+            static{
+                ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+                    [
+                        _dec,
+                        2,
+                        "identify"
+                    ],
+                    [
+                        _dec1,
+                        2,
+                        "page"
+                    ],
+                    [
+                        _dec2,
+                        2,
+                        "screen"
+                    ],
+                    [
+                        _dec3,
+                        2,
+                        "track"
+                    ],
+                    [
+                        [
+                            _dec4,
+                            _dec5
+                        ],
+                        2,
+                        "trackComponentView"
+                    ]
+                ], []));
+            }
+            offlineQueue = (_initProto(this), new Set());
+            states = {
+                eventStream: (0, signals.br)(signals.f0),
+                flags: (0, signals.br)(signals.Mv),
+                profile: (0, signals.br)(signals.ME),
+                personalizations: (0, signals.br)(signals.wh)
+            };
+            getAnonymousId;
+            constructor(options){
+                const { api, builder, config, interceptors } = options;
+                super({
+                    api,
+                    builder,
+                    config,
+                    interceptors
+                });
+                const { defaults, getAnonymousId } = config ?? {};
+                if (defaults) {
+                    const { changes: defaultChanges, personalizations: defaultPersonalizations, profile: defaultProfile } = defaults;
+                    (0, signals.vA)(()=>{
+                        signals.Ao.value = defaultChanges;
+                        signals.wh.value = defaultPersonalizations;
+                        signals.ME.value = defaultProfile;
+                    });
+                }
+                if (defaults?.consent !== void 0) {
+                    const { consent: defaultConsent } = defaults;
+                    signals.vJ.value = defaultConsent;
+                }
+                this.getAnonymousId = getAnonymousId ?? (()=>void 0);
+                (0, signals.QZ)(()=>{
+                    logger.debug(`Profile ${signals.ME.value && `with ID ${signals.ME.value.id}`} has been ${signals.ME.value ? 'set' : 'cleared'}`);
+                });
+                (0, signals.QZ)(()=>{
+                    logger.debug(`Variants have been ${signals.wh.value?.length ? 'populated' : 'cleared'}`);
+                });
+                (0, signals.QZ)(()=>{
+                    logger.info(`Personalization ${signals.vJ.value ? 'will' : 'will not'} take effect due to consent (${signals.vJ.value})`);
+                });
+                (0, signals.QZ)(()=>{
+                    if (signals.WD.value) this.flush();
+                });
+            }
+            reset() {
+                (0, signals.vA)(()=>{
+                    signals.Ao.value = void 0;
+                    signals.f0.value = void 0;
+                    signals.ME.value = void 0;
+                    signals.wh.value = void 0;
+                });
+            }
+            getCustomFlag(name, changes = signals.Ao.value) {
+                return super.getCustomFlag(name, changes);
+            }
+            personalizeEntry(entry, personalizations = signals.wh.value) {
+                return super.personalizeEntry(entry, personalizations);
+            }
+            getMergeTagValue(embeddedEntryNodeTarget, profile = signals.ME.value) {
+                return super.getMergeTagValue(embeddedEntryNodeTarget, profile);
+            }
+            hasConsent(name) {
+                return !!signals.vJ.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
+            }
+            onBlockedByConsent(name, payload) {
+                logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
+            }
+            isNotDuplicated(_name, payload) {
+                const [{ componentId: value }, duplicationScope] = payload;
+                const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
+                if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
+                return !isDuplicated;
+            }
+            onBlockedByDuplication(_name, payload) {
+                logger.debug(`Duplicate "component view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
+            }
+            async identify(payload) {
+                logger.info('Sending "identify" event');
+                const event = this.builder.buildIdentify(payload);
+                return await this.sendOrEnqueueEvent(event);
+            }
+            async page(payload) {
+                logger.info('Sending "page" event');
+                const event = this.builder.buildPageView(payload);
+                return await this.sendOrEnqueueEvent(event);
+            }
+            async screen(payload) {
+                logger.info(`Sending "screen" event for "${payload.name}"`);
+                const event = this.builder.buildScreenView(payload);
+                return await this.sendOrEnqueueEvent(event);
+            }
+            async track(payload) {
+                logger.info(`Sending "track" event "${payload.event}"`);
+                const event = this.builder.buildTrack(payload);
+                return await this.sendOrEnqueueEvent(event);
+            }
+            async trackComponentView(payload, _duplicationScope = '') {
+                logger.info(`Sending "track personalization" event for ${payload.componentId}`);
+                const event = this.builder.buildComponentView(payload);
+                return await this.sendOrEnqueueEvent(event);
+            }
+            async sendOrEnqueueEvent(event) {
+                const intercepted = await this.interceptors.event.run(event);
+                const validEvent = optimization_api_client_.ExperienceEvent.parse(intercepted);
+                signals.f0.value = validEvent;
+                if (signals.WD.value) return await this.upsertProfile([
+                    validEvent
+                ]);
+                logger.debug(`Queueing ${validEvent.type} event`, validEvent);
+                this.offlineQueue.add(validEvent);
+            }
+            async flush() {
+                if (0 === this.offlineQueue.size) return;
+                logger.debug('Flushing offline event queue');
+                await this.upsertProfile(Array.from(this.offlineQueue));
+                this.offlineQueue.clear();
+            }
+            async upsertProfile(events) {
+                const anonymousId = this.getAnonymousId();
+                if (anonymousId) logger.debug(`Anonymous ID found: ${anonymousId}`);
+                const data = await this.api.experience.upsertProfile({
+                    profileId: anonymousId ?? signals.ME.value?.id,
+                    events
+                });
+                await this.updateOutputSignals(data);
+                return data;
+            }
+            async updateOutputSignals(data) {
+                const intercepted = await this.interceptors.state.run(data);
+                const { changes, personalizations, profile } = intercepted;
+                (0, signals.vA)(()=>{
+                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.Ao.value, changes)) signals.Ao.value = changes;
+                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.ME.value, profile)) signals.ME.value = profile;
+                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.wh.value, personalizations)) signals.wh.value = personalizations;
+                });
+            }
+        }
+        const personalization_PersonalizationStateful = PersonalizationStateful;
+        const PersonalizationStateless_logger = (0, dist.zP)('Personalization');
+        class PersonalizationStateless extends personalization_PersonalizationBase {
+            async identify(payload) {
+                PersonalizationStateless_logger.info('Sending "identify" event');
+                const { profile, ...builderArgs } = payload;
+                const event = optimization_api_client_.IdentifyEvent.parse(this.builder.buildIdentify(builderArgs));
+                return await this.upsertProfile(event, profile);
+            }
+            async page(payload) {
+                PersonalizationStateless_logger.info('Sending "page" event');
+                const { profile, ...builderArgs } = payload;
+                const event = optimization_api_client_.PageViewEvent.parse(this.builder.buildPageView(builderArgs));
+                return await this.upsertProfile(event, profile);
+            }
+            async screen(payload) {
+                PersonalizationStateless_logger.info(`Sending "screen" event for "${payload.name}"`);
+                const { profile, ...builderArgs } = payload;
+                const event = optimization_api_client_.ScreenViewEvent.parse(this.builder.buildScreenView(builderArgs));
+                return await this.upsertProfile(event, profile);
+            }
+            async track(payload) {
+                PersonalizationStateless_logger.info(`Sending "track" event "${payload.event}"`);
+                const { profile, ...builderArgs } = payload;
+                const event = optimization_api_client_.TrackEvent.parse(this.builder.buildTrack(builderArgs));
+                return await this.upsertProfile(event, profile);
+            }
+            async trackComponentView(payload) {
+                PersonalizationStateless_logger.info('Sending "track personalization" event');
+                const { profile, ...builderArgs } = payload;
+                const event = optimization_api_client_.ComponentViewEvent.parse(this.builder.buildComponentView(builderArgs));
+                return await this.upsertProfile(event, profile);
+            }
+            async upsertProfile(event, profile) {
+                const intercepted = await this.interceptors.event.run(event);
+                const data = await this.api.experience.upsertProfile({
+                    profileId: profile?.id,
+                    events: [
+                        intercepted
+                    ]
+                });
+                return data;
+            }
+        }
+        const personalization_PersonalizationStateless = PersonalizationStateless;
+    },
+    "./src/personalization/resolvers/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            OR: ()=>resolvers_FlagsResolver,
+            cv: ()=>resolvers_MergeTagValueResolver,
+            z8: ()=>resolvers_PersonalizedEntryResolver
+        });
+        const FlagsResolver = {
+            resolve (changes) {
+                if (!changes) return {};
+                return changes.reduce((acc, { key, value })=>{
+                    const actualValue = 'object' == typeof value && null !== value && 'value' in value && 'object' == typeof value.value ? value.value : value;
+                    acc[key] = actualValue;
+                    return acc;
+                }, {});
+            }
+        };
+        const resolvers_FlagsResolver = FlagsResolver;
+        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
+        const compat_namespaceObject = require("es-toolkit/compat");
+        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
+        const logger = (0, dist.zP)('Personalization');
+        const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
+        const MergeTagValueResolver = {
+            isMergeTagEntry (embeddedEntryNodeTarget) {
+                return optimization_api_client_.MergeTagEntry.safeParse(embeddedEntryNodeTarget).success;
+            },
+            normalizeSelectors (id) {
+                return id.split('_').map((_path, index, paths)=>{
+                    const dotPath = paths.slice(0, index).join('.');
+                    const underScorePath = paths.slice(index).join('_');
+                    return [
+                        dotPath,
+                        underScorePath
+                    ].filter((path)=>'' !== path).join('.');
+                });
+            },
+            getValueFromProfile (id, profile) {
+                const selectors = MergeTagValueResolver.normalizeSelectors(id);
+                const matchingSelector = selectors.find((selector)=>(0, compat_namespaceObject.get)(profile, selector));
+                if (!matchingSelector) return;
+                const value = (0, compat_namespaceObject.get)(profile, matchingSelector);
+                if (!value || 'string' != typeof value && 'number' != typeof value && 'boolean' != typeof value) return;
+                return `${value}`;
+            },
+            resolve (mergeTagEntry, profile) {
+                if (!MergeTagValueResolver.isMergeTagEntry(mergeTagEntry)) return void logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
+                const { fields: { nt_fallback: fallback } } = mergeTagEntry;
+                if (!optimization_api_client_.Profile.safeParse(profile).success) {
+                    logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
+                    return fallback;
+                }
+                return MergeTagValueResolver.getValueFromProfile(mergeTagEntry.fields.nt_mergetag_id, profile) ?? fallback;
+            }
+        };
+        const resolvers_MergeTagValueResolver = MergeTagValueResolver;
+        const PersonalizedEntryResolver_logger = (0, dist.zP)('Personalization');
+        const PersonalizedEntryResolver_RESOLUTION_WARNING_BASE = 'Could not resolve personalized entry variant:';
+        const PersonalizedEntryResolver = {
+            getPersonalizationEntry ({ personalizedEntry, selectedPersonalizations }, skipValidation = false) {
+                if (!skipValidation && (!selectedPersonalizations.length || !(0, optimization_api_client_.isPersonalizedEntry)(personalizedEntry))) return;
+                const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, optimization_api_client_.isPersonalizationEntry)(maybePersonalization)).find((personalizationEntry)=>selectedPersonalizations.some(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id));
+                return personalizationEntry;
+            },
+            getSelectedPersonalization ({ personalizationEntry, selectedPersonalizations }, skipValidation = false) {
+                if (!skipValidation && (!selectedPersonalizations.length || !(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry))) return;
+                const selectedPersonalization = selectedPersonalizations.find(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id);
+                return selectedPersonalization;
+            },
+            getSelectedVariant ({ personalizedEntry, personalizationEntry, selectedVariantIndex }, skipValidation = false) {
+                if (!skipValidation && (!(0, optimization_api_client_.isPersonalizedEntry)(personalizedEntry) || !(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry))) return;
+                const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, optimization_api_client_.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === personalizedEntry.sys.id)?.variants;
+                if (!relevantVariants?.length) return;
+                return relevantVariants.at(selectedVariantIndex - 1);
+            },
+            getSelectedVariantEntry ({ personalizationEntry, selectedVariant }, skipValidation = false) {
+                if (!skipValidation && (!(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry) || !(0, optimization_api_client_.isEntryReplacementVariant)(selectedVariant))) return;
+                const selectedVariantEntry = personalizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
+                return (0, optimization_api_client_.isEntry)(selectedVariantEntry) ? selectedVariantEntry : void 0;
+            },
+            resolve (entry, selectedPersonalizations) {
+                PersonalizedEntryResolver_logger.debug(`Resolving personalized entry for baseline entry ${entry.sys.id}`);
+                if (!selectedPersonalizations?.length) {
+                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} no selectedPersonalizations exist for the current profile`);
+                    return {
+                        entry
+                    };
+                }
+                if (!(0, optimization_api_client_.isPersonalizedEntry)(entry)) {
+                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} entry ${entry.sys.id} is not personalized`);
+                    return {
+                        entry
+                    };
+                }
+                const personalizationEntry = PersonalizedEntryResolver.getPersonalizationEntry({
+                    personalizedEntry: entry,
+                    selectedPersonalizations
+                }, true);
+                if (!personalizationEntry) {
+                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a personalization entry for ${entry.sys.id}`);
+                    return {
+                        entry
+                    };
+                }
+                const selectedPersonalization = PersonalizedEntryResolver.getSelectedPersonalization({
+                    personalizationEntry,
+                    selectedPersonalizations
+                }, true);
+                const selectedVariantIndex = selectedPersonalization?.variantIndex ?? 0;
+                if (0 === selectedVariantIndex) {
+                    PersonalizedEntryResolver_logger.debug(`Resolved personalization entry for entry ${entry.sys.id} is baseline`);
+                    return {
+                        entry
+                    };
+                }
+                const selectedVariant = PersonalizedEntryResolver.getSelectedVariant({
+                    personalizedEntry: entry,
+                    personalizationEntry,
+                    selectedVariantIndex
+                }, true);
+                if (!selectedVariant) {
+                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+                    return {
+                        entry
+                    };
+                }
+                const selectedVariantEntry = PersonalizedEntryResolver.getSelectedVariantEntry({
+                    personalizationEntry,
+                    selectedVariant
+                }, true);
+                if (selectedVariantEntry) PersonalizedEntryResolver_logger.debug(`Entry ${entry.sys.id} has been resolved to variant entry ${selectedVariantEntry.sys.id}`);
+                else {
+                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+                    return {
+                        entry
+                    };
+                }
+                return {
+                    entry: selectedVariantEntry,
+                    personalization: selectedPersonalization
+                };
+            }
+        };
+        const resolvers_PersonalizedEntryResolver = PersonalizedEntryResolver;
+    },
+    "./src/signals.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            WD: ()=>online,
+            vA: ()=>signals_core_namespaceObject.batch,
+            ME: ()=>profile,
+            f0: ()=>signals_event,
+            QO: ()=>signals,
+            Mv: ()=>flags,
+            br: ()=>toObservable,
+            vJ: ()=>consent,
+            Ao: ()=>changes,
+            QZ: ()=>signals_core_namespaceObject.effect,
+            wh: ()=>personalizations
+        });
+        const signals_core_namespaceObject = require("@preact/signals-core");
+        var resolvers = __webpack_require__("./src/personalization/resolvers/index.ts");
+        const changes = (0, signals_core_namespaceObject.signal)();
+        const consent = (0, signals_core_namespaceObject.signal)();
+        const signals_event = (0, signals_core_namespaceObject.signal)();
+        const flags = (0, signals_core_namespaceObject.computed)(()=>resolvers.OR.resolve(changes.value ?? []));
+        const online = (0, signals_core_namespaceObject.signal)(true);
+        const personalizations = (0, signals_core_namespaceObject.signal)();
+        const profile = (0, signals_core_namespaceObject.signal)();
+        function toObservable(s) {
+            return {
+                subscribe (next) {
+                    const dispose = (0, signals_core_namespaceObject.effect)(()=>{
+                        next(s.value);
+                    });
+                    return {
+                        unsubscribe: dispose
+                    };
+                }
+            };
+        }
+        const signals = {
+            changes,
+            consent,
+            event: signals_event,
+            flags,
+            online,
+            personalizations,
+            profile
+        };
+    },
+    "@contentful/optimization-api-client" (module) {
+        module.exports = require("@contentful/optimization-api-client");
+    },
+    "../../lib/logger/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Vy: ()=>Logger,
+            vF: ()=>logger,
+            zP: ()=>createScopedLogger,
+            vg: ()=>ConsoleLogSink,
+            y$: ()=>src_LogSink
+        });
+        const external_diary_namespaceObject = require("diary");
+        const utils_namespaceObject = require("diary/utils");
+        class Logger {
+            name = '@contentful/optimization';
+            PREFIX_PARTS = [
+                'Ctfl',
+                'O10n'
+            ];
+            DELIMITER = ':';
+            diary;
+            sinks = [];
+            constructor(){
+                this.diary = (0, external_diary_namespaceObject.diary)(this.name, this.onLogEvent.bind(this));
+                (0, external_diary_namespaceObject.enable)(this.name);
+            }
+            assembleLocationPrefix(logLocation) {
+                return `[${[
+                    ...this.PREFIX_PARTS,
+                    logLocation
+                ].join(this.DELIMITER)}]`;
+            }
+            addSink(sink) {
+                this.sinks = [
+                    ...this.sinks.filter((existingSink)=>existingSink.name !== sink.name),
+                    sink
+                ];
+            }
+            removeSink(name) {
+                this.sinks = this.sinks.filter((sink)=>sink.name !== name);
+            }
+            removeSinks() {
+                this.sinks = [];
+            }
+            debug(logLocation, message, ...args) {
+                this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            info(logLocation, message, ...args) {
+                this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            log(logLocation, message, ...args) {
+                this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            warn(logLocation, message, ...args) {
+                this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            error(logLocation, message, ...args) {
+                this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            fatal(logLocation, message, ...args) {
+                this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+            }
+            onLogEvent(event) {
+                this.sinks.forEach((sink)=>{
+                    sink.ingest(event);
+                });
+            }
+        }
+        const logger = new Logger();
+        function createScopedLogger(location) {
+            return {
+                debug: (message, ...args)=>{
+                    logger.debug(location, message, ...args);
+                },
+                info: (message, ...args)=>{
+                    logger.info(location, message, ...args);
+                },
+                log: (message, ...args)=>{
+                    logger.log(location, message, ...args);
+                },
+                warn: (message, ...args)=>{
+                    logger.warn(location, message, ...args);
+                },
+                error: (message, ...args)=>{
+                    logger.error(location, message, ...args);
+                },
+                fatal: (message, ...args)=>{
+                    logger.fatal(location, message, ...args);
+                }
+            };
+        }
+        class LogSink {
+        }
+        const src_LogSink = LogSink;
+        const consoleMap = {
+            debug: (...args)=>{
+                console.debug(...args);
+            },
+            info: (...args)=>{
+                console.info(...args);
+            },
+            log: (...args)=>{
+                console.log(...args);
+            },
+            warn: (...args)=>{
+                console.warn(...args);
+            },
+            error: (...args)=>{
+                console.error(...args);
+            },
+            fatal: (...args)=>{
+                console.error(...args);
+            }
+        };
+        const COMPARISON_EQUALITY = 0;
+        class ConsoleLogSink extends src_LogSink {
+            name = 'ConsoleLogSink';
+            verbosity;
+            constructor(verbosity){
+                super();
+                this.verbosity = verbosity ?? 'error';
+            }
+            ingest(event) {
+                if ((0, utils_namespaceObject.compare)(this.verbosity, event.level) > COMPARISON_EQUALITY) return;
+                consoleMap[event.level](...event.messages);
+            }
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        ANONYMOUS_ID_COOKIE: ()=>_global_constants__rspack_import_7.T,
+        AnalyticsStateful: ()=>_analytics__rspack_import_3.R,
+        AnalyticsStateless: ()=>_analytics__rspack_import_3.v,
+        ConsoleLogSink: ()=>logger__rspack_import_2.vg,
+        CoreStateful: ()=>_CoreStateful__rspack_import_5.A,
+        CoreStateless: ()=>_CoreStateless__rspack_import_6.A,
+        FlagsResolver: ()=>_personalization__rspack_import_11.OR,
+        InterceptorManager: ()=>_lib_interceptor__rspack_import_9.v,
+        LogSink: ()=>logger__rspack_import_2.y$,
+        Logger: ()=>logger__rspack_import_2.Vy,
+        MergeTagValueResolver: ()=>_personalization__rspack_import_11.cv,
+        OPTIMIZATION_CORE_SDK_VERSION: ()=>_global_constants__rspack_import_7.E,
+        PersonalizationStateful: ()=>_personalization__rspack_import_11.$C,
+        PersonalizationStateless: ()=>_personalization__rspack_import_11.jL,
+        PersonalizedEntryResolver: ()=>_personalization__rspack_import_11.z8,
+        ValuePresence: ()=>_lib_value_presence__rspack_import_10.n,
+        batch: ()=>_signals__rspack_import_0.vA,
+        createScopedLogger: ()=>logger__rspack_import_2.zP,
+        effect: ()=>_signals__rspack_import_0.QZ,
+        guardedBy: ()=>_lib_decorators__rspack_import_8.i,
+        logger: ()=>logger__rspack_import_2.vF,
+        signals: ()=>_signals__rspack_import_0.QO
+    });
+    var _signals__rspack_import_0 = __webpack_require__("./src/signals.ts");
+    var _contentful_optimization_api_client__rspack_import_1 = __webpack_require__("@contentful/optimization-api-client");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _contentful_optimization_api_client__rspack_import_1)if ([
+        "CoreStateless",
+        "signals",
+        "CoreStateful",
+        "default",
+        "batch",
+        "effect"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_contentful_optimization_api_client__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var logger__rspack_import_2 = __webpack_require__("../../lib/logger/dist/index.mjs");
+    var _analytics__rspack_import_3 = __webpack_require__("./src/analytics/index.ts");
+    __webpack_require__("./src/CoreBase.ts");
+    var _CoreStateful__rspack_import_5 = __webpack_require__("./src/CoreStateful.ts");
+    var _CoreStateless__rspack_import_6 = __webpack_require__("./src/CoreStateless.ts");
+    var _global_constants__rspack_import_7 = __webpack_require__("./src/global-constants.ts");
+    var _lib_decorators__rspack_import_8 = __webpack_require__("./src/lib/decorators/index.ts");
+    var _lib_interceptor__rspack_import_9 = __webpack_require__("./src/lib/interceptor/index.ts");
+    var _lib_value_presence__rspack_import_10 = __webpack_require__("./src/lib/value-presence/index.ts");
+    var _personalization__rspack_import_11 = __webpack_require__("./src/personalization/index.ts");
+})();
+exports.ANONYMOUS_ID_COOKIE = __webpack_exports__.ANONYMOUS_ID_COOKIE;
+exports.AnalyticsStateful = __webpack_exports__.AnalyticsStateful;
+exports.AnalyticsStateless = __webpack_exports__.AnalyticsStateless;
+exports.ConsoleLogSink = __webpack_exports__.ConsoleLogSink;
+exports.CoreStateful = __webpack_exports__.CoreStateful;
+exports.CoreStateless = __webpack_exports__.CoreStateless;
+exports.FlagsResolver = __webpack_exports__.FlagsResolver;
+exports.InterceptorManager = __webpack_exports__.InterceptorManager;
+exports.LogSink = __webpack_exports__.LogSink;
+exports.Logger = __webpack_exports__.Logger;
+exports.MergeTagValueResolver = __webpack_exports__.MergeTagValueResolver;
+exports.OPTIMIZATION_CORE_SDK_VERSION = __webpack_exports__.OPTIMIZATION_CORE_SDK_VERSION;
+exports.PersonalizationStateful = __webpack_exports__.PersonalizationStateful;
+exports.PersonalizationStateless = __webpack_exports__.PersonalizationStateless;
+exports.PersonalizedEntryResolver = __webpack_exports__.PersonalizedEntryResolver;
+exports.ValuePresence = __webpack_exports__.ValuePresence;
+exports.batch = __webpack_exports__.batch;
+exports.createScopedLogger = __webpack_exports__.createScopedLogger;
+exports.effect = __webpack_exports__.effect;
+exports.guardedBy = __webpack_exports__.guardedBy;
+exports.logger = __webpack_exports__.logger;
+exports.signals = __webpack_exports__.signals;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ANONYMOUS_ID_COOKIE",
+    "AnalyticsStateful",
+    "AnalyticsStateless",
+    "ConsoleLogSink",
+    "CoreStateful",
+    "CoreStateless",
+    "FlagsResolver",
+    "InterceptorManager",
+    "LogSink",
+    "Logger",
+    "MergeTagValueResolver",
+    "OPTIMIZATION_CORE_SDK_VERSION",
+    "PersonalizationStateful",
+    "PersonalizationStateless",
+    "PersonalizedEntryResolver",
+    "ValuePresence",
+    "batch",
+    "createScopedLogger",
+    "effect",
+    "guardedBy",
+    "logger",
+    "signals"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map