@contentful/optimization-core 0.1.0-alpha

package/dist/index.mjs

@@ -0,0 +1,1535 @@
+import * as __rspack_external__contentful_optimization_api_client_cba5a7ee from "@contentful/optimization-api-client";
+import { batch, computed, effect, signal } from "@preact/signals-core";
+import { get as compat_get } from "es-toolkit/compat";
+import { diary, enable } from "diary";
+import { compare } from "diary/utils";
+import { isEqual } from "es-toolkit";
+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;
+class Logger {
+    name = '@contentful/optimization';
+    PREFIX_PARTS = [
+        'Ctfl',
+        'O10n'
+    ];
+    DELIMITER = ':';
+    diary;
+    sinks = [];
+    constructor(){
+        this.diary = diary(this.name, this.onLogEvent.bind(this));
+        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 (compare(this.verbosity, event.level) > COMPARISON_EQUALITY) return;
+        consoleMap[event.level](...event.messages);
+    }
+}
+const MergeTagValueResolver_logger = createScopedLogger('Personalization');
+const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
+const MergeTagValueResolver = {
+    isMergeTagEntry (embeddedEntryNodeTarget) {
+        return __rspack_external__contentful_optimization_api_client_cba5a7ee.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)=>compat_get(profile, selector));
+        if (!matchingSelector) return;
+        const value = compat_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 MergeTagValueResolver_logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
+        const { fields: { nt_fallback: fallback } } = mergeTagEntry;
+        if (!__rspack_external__contentful_optimization_api_client_cba5a7ee.Profile.safeParse(profile).success) {
+            MergeTagValueResolver_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 = createScopedLogger('Personalization');
+const PersonalizedEntryResolver_RESOLUTION_WARNING_BASE = 'Could not resolve personalized entry variant:';
+const PersonalizedEntryResolver = {
+    getPersonalizationEntry ({ personalizedEntry, selectedPersonalizations }, skipValidation = false) {
+        if (!skipValidation && (!selectedPersonalizations.length || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizedEntry)(personalizedEntry))) return;
+        const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.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, __rspack_external__contentful_optimization_api_client_cba5a7ee.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, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizedEntry)(personalizedEntry) || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(personalizationEntry))) return;
+        const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.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, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(personalizationEntry) || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isEntryReplacementVariant)(selectedVariant))) return;
+        const selectedVariantEntry = personalizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
+        return (0, __rspack_external__contentful_optimization_api_client_cba5a7ee.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, __rspack_external__contentful_optimization_api_client_cba5a7ee.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;
+const signals_changes = signal();
+const consent = signal();
+const signals_event = signal();
+const flags = computed(()=>resolvers_FlagsResolver.resolve(signals_changes.value ?? []));
+const online = signal(true);
+const signals_personalizations = signal();
+const signals_profile = signal();
+function toObservable(s) {
+    return {
+        subscribe (next) {
+            const dispose = effect(()=>{
+                next(s.value);
+            });
+            return {
+                unsubscribe: dispose
+            };
+        }
+    };
+}
+const signals = {
+    changes: signals_changes,
+    consent: consent,
+    event: signals_event,
+    flags: flags,
+    online: online,
+    personalizations: signals_personalizations,
+    profile: signals_profile
+};
+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);
+        });
+    };
+}
+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 value_presence_ValuePresence = ValuePresence;
+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 value_presence_ValuePresence(config?.preventedComponentEvents);
+        this.interceptors = interceptors;
+    }
+}
+const src_ProductBase = ProductBase;
+class AnalyticsBase extends src_ProductBase {
+}
+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 AnalyticsStateful_logger = createScopedLogger('Analytics');
+const MAX_QUEUED_EVENTS = 25;
+_dec = guardedBy('isNotDuplicated', {
+    onBlocked: 'onBlockedByDuplication'
+}), _dec1 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+}), _dec2 = guardedBy('isNotDuplicated', {
+    onBlocked: 'onBlockedByDuplication'
+}), _dec3 = guardedBy('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: toObservable(signals_event),
+        profile: toObservable(signals_profile)
+    };
+    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_profile.value = defaultProfile;
+        }
+        effect(()=>{
+            const id = signals_profile.value?.id;
+            AnalyticsStateful_logger.info(`Analytics ${consent.value ? 'will' : 'will not'} be collected due to consent (${consent.value})`);
+            AnalyticsStateful_logger.debug(`Profile ${id && `with ID ${id}`} has been ${id ? 'set' : 'cleared'}`);
+        });
+        effect(()=>{
+            if (online.value) this.flush();
+        });
+    }
+    reset() {
+        batch(()=>{
+            signals_event.value = void 0;
+            signals_profile.value = void 0;
+        });
+    }
+    hasConsent(name) {
+        return !!consent.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
+    }
+    onBlockedByConsent(name, payload) {
+        AnalyticsStateful_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';
+        AnalyticsStateful_logger.debug(`Duplicate "${componentType} view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
+    }
+    async trackComponentView(payload, _duplicationScope = '') {
+        AnalyticsStateful_logger.info(`Processing "component view" event for ${payload.componentId}`);
+        await this.enqueueEvent(this.builder.buildComponentView(payload));
+    }
+    async trackFlagView(payload, _duplicationScope = '') {
+        AnalyticsStateful_logger.debug(`Processing "flag view" event for ${payload.componentId}`);
+        await this.enqueueEvent(this.builder.buildFlagView(payload));
+    }
+    async enqueueEvent(event) {
+        const { value: profile } = signals_profile;
+        if (!profile) return void AnalyticsStateful_logger.warn('Attempting to emit an event without an Optimization profile');
+        const intercepted = await this.interceptors.event.run(event);
+        const validEvent = __rspack_external__contentful_optimization_api_client_cba5a7ee.InsightsEvent.parse(intercepted);
+        AnalyticsStateful_logger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
+        const profileEventQueue = this.queue.get(profile);
+        signals_event.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() {
+        AnalyticsStateful_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 = createScopedLogger('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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.ComponentViewEvent.parse(intercepted);
+        await this.sendBatchEvent(parsed, profile);
+    }
+    async sendBatchEvent(event, profile) {
+        const batchEvent = __rspack_external__contentful_optimization_api_client_cba5a7ee.BatchInsightsEventArray.parse([
+            {
+                profile,
+                events: [
+                    event
+                ]
+            }
+        ]);
+        await this.api.insights.sendBatchEvents(batchEvent);
+    }
+}
+const analytics_AnalyticsStateless = AnalyticsStateless;
+const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha";
+const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
+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;
+    }
+}
+class CoreBase {
+    api;
+    eventBuilder;
+    config;
+    interceptors = {
+        event: new InterceptorManager(),
+        state: new InterceptorManager()
+    };
+    constructor(config){
+        this.config = config;
+        const { analytics, personalization, eventBuilder, logLevel, environment, clientId } = config;
+        logger.addSink(new ConsoleLogSink(logLevel));
+        const apiConfig = {
+            ...analytics,
+            ...personalization,
+            clientId,
+            environment
+        };
+        this.api = new __rspack_external__contentful_optimization_api_client_cba5a7ee.ApiClient(apiConfig);
+        this.eventBuilder = new __rspack_external__contentful_optimization_api_client_cba5a7ee.EventBuilder(eventBuilder ?? {
+            channel: 'server',
+            library: {
+                name: 'Optimization Core',
+                version: OPTIMIZATION_CORE_SDK_VERSION
+            }
+        });
+    }
+    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 src_CoreBase = CoreBase;
+class PersonalizationBase extends src_ProductBase {
+    flagsResolver = resolvers_FlagsResolver;
+    mergeTagValueResolver = resolvers_MergeTagValueResolver;
+    personalizedEntryResolver = resolvers_PersonalizedEntryResolver;
+    getCustomFlag(name, changes) {
+        return resolvers_FlagsResolver.resolve(changes)[name];
+    }
+    personalizeEntry(entry, personalizations) {
+        return resolvers_PersonalizedEntryResolver.resolve(entry, personalizations);
+    }
+    getMergeTagValue(embeddedEntryNodeTarget, profile) {
+        return resolvers_MergeTagValueResolver.resolve(embeddedEntryNodeTarget, profile);
+    }
+}
+const personalization_PersonalizationBase = PersonalizationBase;
+function PersonalizationStateful_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 PersonalizationStateful_apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (PersonalizationStateful_apply_decs_2203_r = PersonalizationStateful_applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var PersonalizationStateful_dec, PersonalizationStateful_dec1, PersonalizationStateful_dec2, PersonalizationStateful_dec3, _dec4, _dec5, PersonalizationStateful_initProto;
+const PersonalizationStateful_logger = createScopedLogger('Personalization');
+PersonalizationStateful_dec = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+}), PersonalizationStateful_dec1 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+}), PersonalizationStateful_dec2 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+}), PersonalizationStateful_dec3 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+}), _dec4 = guardedBy('isNotDuplicated', {
+    onBlocked: 'onBlockedByDuplication'
+}), _dec5 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
+});
+class PersonalizationStateful extends personalization_PersonalizationBase {
+    static{
+        ({ e: [PersonalizationStateful_initProto] } = PersonalizationStateful_apply_decs_2203_r(this, [
+            [
+                PersonalizationStateful_dec,
+                2,
+                "identify"
+            ],
+            [
+                PersonalizationStateful_dec1,
+                2,
+                "page"
+            ],
+            [
+                PersonalizationStateful_dec2,
+                2,
+                "screen"
+            ],
+            [
+                PersonalizationStateful_dec3,
+                2,
+                "track"
+            ],
+            [
+                [
+                    _dec4,
+                    _dec5
+                ],
+                2,
+                "trackComponentView"
+            ]
+        ], []));
+    }
+    offlineQueue = (PersonalizationStateful_initProto(this), new Set());
+    states = {
+        eventStream: toObservable(signals_event),
+        flags: toObservable(flags),
+        profile: toObservable(signals_profile),
+        personalizations: toObservable(signals_personalizations)
+    };
+    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;
+            batch(()=>{
+                signals_changes.value = defaultChanges;
+                signals_personalizations.value = defaultPersonalizations;
+                signals_profile.value = defaultProfile;
+            });
+        }
+        if (defaults?.consent !== void 0) {
+            const { consent: defaultConsent } = defaults;
+            consent.value = defaultConsent;
+        }
+        this.getAnonymousId = getAnonymousId ?? (()=>void 0);
+        effect(()=>{
+            PersonalizationStateful_logger.debug(`Profile ${signals_profile.value && `with ID ${signals_profile.value.id}`} has been ${signals_profile.value ? 'set' : 'cleared'}`);
+        });
+        effect(()=>{
+            PersonalizationStateful_logger.debug(`Variants have been ${signals_personalizations.value?.length ? 'populated' : 'cleared'}`);
+        });
+        effect(()=>{
+            PersonalizationStateful_logger.info(`Personalization ${consent.value ? 'will' : 'will not'} take effect due to consent (${consent.value})`);
+        });
+        effect(()=>{
+            if (online.value) this.flush();
+        });
+    }
+    reset() {
+        batch(()=>{
+            signals_changes.value = void 0;
+            signals_event.value = void 0;
+            signals_profile.value = void 0;
+            signals_personalizations.value = void 0;
+        });
+    }
+    getCustomFlag(name, changes = signals_changes.value) {
+        return super.getCustomFlag(name, changes);
+    }
+    personalizeEntry(entry, personalizations = signals_personalizations.value) {
+        return super.personalizeEntry(entry, personalizations);
+    }
+    getMergeTagValue(embeddedEntryNodeTarget, profile = signals_profile.value) {
+        return super.getMergeTagValue(embeddedEntryNodeTarget, profile);
+    }
+    hasConsent(name) {
+        return !!consent.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
+    }
+    onBlockedByConsent(name, payload) {
+        PersonalizationStateful_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) {
+        PersonalizationStateful_logger.debug(`Duplicate "component view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
+    }
+    async identify(payload) {
+        PersonalizationStateful_logger.info('Sending "identify" event');
+        const event = this.builder.buildIdentify(payload);
+        return await this.sendOrEnqueueEvent(event);
+    }
+    async page(payload) {
+        PersonalizationStateful_logger.info('Sending "page" event');
+        const event = this.builder.buildPageView(payload);
+        return await this.sendOrEnqueueEvent(event);
+    }
+    async screen(payload) {
+        PersonalizationStateful_logger.info(`Sending "screen" event for "${payload.name}"`);
+        const event = this.builder.buildScreenView(payload);
+        return await this.sendOrEnqueueEvent(event);
+    }
+    async track(payload) {
+        PersonalizationStateful_logger.info(`Sending "track" event "${payload.event}"`);
+        const event = this.builder.buildTrack(payload);
+        return await this.sendOrEnqueueEvent(event);
+    }
+    async trackComponentView(payload, _duplicationScope = '') {
+        PersonalizationStateful_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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.ExperienceEvent.parse(intercepted);
+        signals_event.value = validEvent;
+        if (online.value) return await this.upsertProfile([
+            validEvent
+        ]);
+        PersonalizationStateful_logger.debug(`Queueing ${validEvent.type} event`, validEvent);
+        this.offlineQueue.add(validEvent);
+    }
+    async flush() {
+        if (0 === this.offlineQueue.size) return;
+        PersonalizationStateful_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) PersonalizationStateful_logger.debug(`Anonymous ID found: ${anonymousId}`);
+        const data = await this.api.experience.upsertProfile({
+            profileId: anonymousId ?? signals_profile.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;
+        batch(()=>{
+            if (!isEqual(signals_changes.value, changes)) signals_changes.value = changes;
+            if (!isEqual(signals_profile.value, profile)) signals_profile.value = profile;
+            if (!isEqual(signals_personalizations.value, personalizations)) signals_personalizations.value = personalizations;
+        });
+    }
+}
+const personalization_PersonalizationStateful = PersonalizationStateful;
+const PersonalizationStateless_logger = createScopedLogger('Personalization');
+class PersonalizationStateless extends personalization_PersonalizationBase {
+    async identify(payload) {
+        PersonalizationStateless_logger.info('Sending "identify" event');
+        const { profile, ...builderArgs } = payload;
+        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.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;
+class CoreStateful extends src_CoreBase {
+    analytics;
+    personalization;
+    constructor(config){
+        super(config);
+        const { allowedEventTypes, defaults, getAnonymousId, preventedComponentEvents } = config;
+        if (defaults?.consent !== void 0) {
+            const { consent: defaultConsent } = defaults;
+            consent.value = defaultConsent;
+        }
+        this.analytics = new analytics_AnalyticsStateful({
+            api: this.api,
+            builder: this.eventBuilder,
+            config: {
+                allowedEventTypes,
+                preventedComponentEvents,
+                defaults: {
+                    consent: defaults?.consent,
+                    profile: defaults?.profile
+                }
+            },
+            interceptors: this.interceptors
+        });
+        this.personalization = new personalization_PersonalizationStateful({
+            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: toObservable(consent),
+            eventStream: toObservable(signals_event),
+            flags: toObservable(flags),
+            personalizations: toObservable(signals_personalizations),
+            profile: toObservable(signals_profile)
+        };
+    }
+    reset() {
+        batch(()=>{
+            signals_event.value = void 0;
+            signals_changes.value = void 0;
+            signals_profile.value = void 0;
+            signals_personalizations.value = void 0;
+        });
+    }
+    async flush() {
+        await this.analytics.flush();
+        await this.personalization.flush();
+    }
+    consent(accept) {
+        consent.value = accept;
+    }
+    online(isOnline) {
+        online.value = isOnline;
+    }
+    registerPreviewPanel(previewPanel) {
+        previewPanel.signals = signals;
+    }
+}
+const src_CoreStateful = CoreStateful;
+class CoreStateless extends src_CoreBase {
+    analytics;
+    personalization;
+    constructor(config){
+        super(config);
+        this.analytics = new analytics_AnalyticsStateless({
+            api: this.api,
+            builder: this.eventBuilder,
+            interceptors: this.interceptors
+        });
+        this.personalization = new personalization_PersonalizationStateless({
+            api: this.api,
+            builder: this.eventBuilder,
+            interceptors: this.interceptors
+        });
+    }
+}
+const src_CoreStateless = CoreStateless;
+export * from "@contentful/optimization-api-client";
+export { ANONYMOUS_ID_COOKIE, ConsoleLogSink, InterceptorManager, Logger, OPTIMIZATION_CORE_SDK_VERSION, analytics_AnalyticsStateful as AnalyticsStateful, analytics_AnalyticsStateless as AnalyticsStateless, batch, createScopedLogger, effect, guardedBy, logger, personalization_PersonalizationStateful as PersonalizationStateful, personalization_PersonalizationStateless as PersonalizationStateless, resolvers_FlagsResolver as FlagsResolver, resolvers_MergeTagValueResolver as MergeTagValueResolver, resolvers_PersonalizedEntryResolver as PersonalizedEntryResolver, signals, src_CoreStateful as CoreStateful, src_CoreStateless as CoreStateless, src_LogSink as LogSink, value_presence_ValuePresence as ValuePresence };
+
+//# sourceMappingURL=index.mjs.map