@athoscommerce/snap-preact 1.0.0

package/dist/esm/src/Templates/Stores/TemplateEditor/TemplateEditorStore.js

@@ -0,0 +1,328 @@
+import { StorageStore, StorageType } from '@athoscommerce/snap-store-mobx';
+import { observable, makeObservable } from 'mobx';
+import Color from 'color';
+import deepmerge from 'deepmerge';
+import { TEMPLATE_STORE_KEY } from '../TemplateStore';
+import { configUI, themeUI, searchControllerUI, autocompleteControllerUI, updateAutocompleteControllerState } from './uiAbstractions';
+const THEME_VARIABLE_DEFAULTS = {
+    breakpoints: {
+        mobile: 600,
+        tablet: 900,
+        desktop: 1200,
+    },
+    colors: {
+        text: '#333333',
+        primary: '#1D4990',
+        secondary: '#6187ae',
+        accent: '#00AEEF',
+    },
+};
+export class TemplateEditorStore {
+    constructor({ templatesStore }) {
+        this.state = {
+            hidden: false,
+            activeTab: 'configuration',
+        };
+        this.overrides = {
+            config: {},
+            controller: {},
+            theme: {},
+        };
+        this.initial = {
+            config: {
+                language: 'en',
+                currency: 'usd',
+            },
+            controller: {},
+            theme: {
+                extends: 'base',
+                variables: THEME_VARIABLE_DEFAULTS,
+            },
+        };
+        this.tabs = ['templates', 'configuration'];
+        this.uiAbstractions = {
+            templates: {
+                config: configUI(this),
+                theme: themeUI(this),
+            },
+            controllers: {
+                search: searchControllerUI(this),
+                autocomplete: autocompleteControllerUI(this),
+            },
+        };
+        this.setThemeOverride = (obj) => {
+            const { path, value } = obj;
+            // grab the initial config value using the path provided
+            const initialValue = path.reduce((acc, key) => {
+                return acc && acc[key];
+            }, this.initial.theme);
+            const themeConfigOverrides = generateObject(path, value == initialValue ? undefined : value);
+            this.overrides.theme = removeEmptyObjects(deepmerge(this.overrides.theme || {}, themeConfigOverrides));
+            this.storage.set('overrides.theme', this.overrides.theme);
+            const mergedOverrides = deepmerge(this.initial.theme || {}, this.overrides.theme || {});
+            // update all themes with the new overrides
+            Object.keys(this.templatesStore.themes.library).forEach((themeName) => {
+                const themeStore = this.templatesStore.themes.library[themeName];
+                themeStore.setEditorOverrides({ variables: mergedOverrides.variables || {} });
+            });
+        };
+        this.templatesStore = templatesStore;
+        this.storage = new StorageStore({ type: StorageType.local, key: TEMPLATE_STORE_KEY });
+        this.state = this.storage.get('editor') || this.state;
+        this.overrides = this.storage.get('overrides') || this.overrides;
+        // prevent empty objects in overrides
+        this.overrides.config = this.overrides.config || {};
+        this.overrides.controller = this.overrides.controller || {};
+        this.overrides.theme = this.overrides.theme || {};
+        this.initial.config = deepmerge(this.initial.config, templatesStore.config.config);
+        this.initial.controller = {}; // set when registering controllers
+        const themeConfig = JSON.parse(JSON.stringify(templatesStore.config.theme || {}));
+        delete themeConfig.style;
+        delete themeConfig.overrides;
+        this.initial.theme = deepmerge(this.initial.theme, themeConfig);
+        // normalize all colors to hexadecimal format using the Color library
+        Object.keys(this.initial.theme.variables.colors).forEach((key) => {
+            const color = this.initial.theme.variables.colors[key];
+            this.initial.theme.variables.colors[key] = Color(color).hex();
+        });
+        // switch to the theme set in the initial config if no override is set
+        this.setTheme(this.overrides.theme.extends ?? this.initial.theme.extends);
+        // initialize themes with overrides
+        this.setThemeOverride({ path: [], value: undefined });
+        this.storage.set('initial', this.initial);
+        makeObservable(this, {
+            state: observable,
+            overrides: observable,
+            initial: observable,
+            uiAbstractions: observable,
+        });
+        // makeObservable(this.overrides.config, {
+        // 	language: observable,
+        // 	currency: observable,
+        // });
+    }
+    switchTabs(tab) {
+        this.state.activeTab = tab;
+        this.storage.set('editor', this.state);
+    }
+    toggleHide(hide) {
+        this.state.hidden = hide;
+        this.storage.set('editor', this.state);
+    }
+    setConfigOverride(obj) {
+        const { path, value } = obj;
+        // grab the initial config value using the path provided
+        const initialValue = path.reduce((acc, key) => {
+            return acc && acc[key];
+        }, this.initial.config);
+        const configOverrides = generateObject(path, value == initialValue ? undefined : value);
+        const updatedOverrides = removeEmptyObjects(deepmerge(this.overrides.config || {}, configOverrides));
+        this.overrides.config = updatedOverrides;
+        this.storage.set('overrides.config', updatedOverrides);
+        // TODO: handle setting language and currency separately
+        if (path[0] === 'language') {
+            this.templatesStore.setLanguage((value || initialValue)).then(() => {
+                this.storage.set('overrides.config', updatedOverrides);
+            });
+        }
+        else if (path[0] === 'currency') {
+            this.templatesStore.setCurrency((value || initialValue)).then(() => {
+                this.storage.set('overrides.config', updatedOverrides);
+            });
+        }
+    }
+    setTheme(themeName) {
+        const updatedConfig = { extends: themeName };
+        if (this.initial.theme.extends === themeName) {
+            updatedConfig.extends = undefined;
+        }
+        this.overrides.theme = deepmerge(this.overrides.theme, updatedConfig);
+        this.storage.set('overrides.theme', this.overrides.theme);
+        // loop through all targets in templateStore and call setTheme on them all
+        Object.keys(this.templatesStore.targets).forEach((feature) => {
+            // loop through all the features (search, autocomplete, recommendations)
+            if (feature == 'recommendation') {
+                const recommendationObj = this.templatesStore.targets[feature];
+                Object.keys(recommendationObj).forEach((recType) => {
+                    const targetMap = recommendationObj[recType];
+                    Object.keys(targetMap).forEach((target) => {
+                        const targetStore = targetMap[target];
+                        targetStore.setTheme(themeName, 'library');
+                    });
+                });
+            }
+            else {
+                const targetMap = this.templatesStore.targets[feature];
+                Object.keys(targetMap).forEach((target) => {
+                    const targetStore = targetMap[target];
+                    targetStore.setTheme(themeName, 'library');
+                });
+            }
+        });
+    }
+    setControllerOverride(obj) {
+        const { path, value, controller } = obj;
+        const type = controller.type;
+        const controllerOverrides = {
+            [type]: generateObject(path, value),
+        };
+        this.overrides.controller = deepmerge(this.overrides.controller || {}, controllerOverrides);
+        // recursively remove empty objects and undefined values from this.overrides.controller
+        this.overrides.controller = removeEmptyObjects(this.overrides.controller);
+        this.storage.set(`overrides.controller.${type}`, this.overrides.controller[type]);
+        const mergedConfig = deepmerge({
+            settings: this.initial.controller[type] || {},
+        }, {
+            settings: this.overrides.controller[type] || {},
+        });
+        controller?.setConfig(mergedConfig);
+    }
+    registerController(controller) {
+        const settingsCopy = JSON.parse(JSON.stringify(controller.config.settings));
+        const type = controller.type;
+        this.initial.controller[type] = settingsCopy;
+        this.storage.set(`initial.controller.${type}`, this.initial.controller[type]);
+        const mergedConfig = deepmerge(controller.config, {
+            settings: this.overrides.controller[type] || {},
+        });
+        controller.setConfig(mergedConfig);
+        if (type === 'autocomplete') {
+            updateAutocompleteControllerState(controller);
+        }
+        if (type === 'search') {
+            // @ts-ignore - accessing a private property
+            const clientGlobals = controller.client.config.globals || {};
+            // controller globals > client globals > templates config
+            const siteId = controller.config.globals?.siteId || clientGlobals?.siteId || this.templatesStore.config.config.siteId || '';
+            if (this.initial.config.siteId != siteId) {
+                this.storage.set('overrides.config.siteId', siteId);
+            }
+        }
+    }
+    getTargets() {
+        const storeTargets = this.templatesStore.targets;
+        const searchTargets = Object.keys(storeTargets.search || {}).map((target) => ({
+            type: 'search',
+            target,
+            template: storeTargets.search[target],
+            selector: storeTargets.search[target].selector,
+        }));
+        const autocompleteTargets = Object.keys(storeTargets.autocomplete || {}).map((target) => ({
+            type: 'autocomplete',
+            target,
+            template: storeTargets.autocomplete[target],
+            selector: storeTargets.autocomplete[target].selector,
+        }));
+        const recommendationBundleTargets = Object.keys(storeTargets.recommendation.bundle || {}).map((target) => ({
+            type: 'recommendation/bundle',
+            target,
+            template: storeTargets.recommendation.bundle[target],
+            selector: storeTargets.recommendation.bundle[target].selector,
+        }));
+        const recommendationDefaultTargets = Object.keys(storeTargets.recommendation.default || {}).map((target) => ({
+            type: 'recommendation/default',
+            target,
+            template: storeTargets.recommendation.default[target],
+            selector: storeTargets.recommendation.default[target].selector,
+        }));
+        const recommendationEmailTargets = Object.keys(storeTargets.recommendation.email || {}).map((target) => ({
+            type: 'recommendation/email',
+            target,
+            template: storeTargets.recommendation.email[target],
+            selector: storeTargets.recommendation.email[target].selector,
+        }));
+        const targets = [
+            ...searchTargets,
+            ...autocompleteTargets,
+            ...recommendationBundleTargets,
+            ...recommendationDefaultTargets,
+            ...recommendationEmailTargets,
+        ];
+        return targets;
+    }
+    generateTemplatesConfig() {
+        const originalConfig = JSON.parse(JSON.stringify(this.templatesStore.config));
+        delete originalConfig.search;
+        delete originalConfig.autocomplete;
+        delete originalConfig.recommendation;
+        delete originalConfig.components;
+        const storageConfigData = (this.storage.get('overrides.config') || {});
+        const themeConfigData = (this.storage.get('overrides.theme') || {});
+        const overrideConfig = { config: storageConfigData, theme: themeConfigData };
+        const targets = this.getTargets();
+        const searchTargets = targets
+            .filter((target) => target.type === 'search')
+            .map((target) => ({
+            selector: target.selector,
+            component: target.template.component,
+            resultComponent: target.template.resultComponent,
+        }));
+        const autocompleteTargets = targets
+            .filter((target) => target.type === 'autocomplete')
+            .map((target) => ({
+            selector: target.selector,
+            component: target.template.component,
+            resultComponent: target.template.resultComponent,
+        }));
+        // add search controller settings
+        if (searchTargets.length) {
+            overrideConfig.search = {
+                targets: searchTargets,
+                settings: this.overrides.controller.search || {},
+            };
+        }
+        // add autocomplete controller settings
+        if (autocompleteTargets.length) {
+            overrideConfig.autocomplete = {
+                targets: autocompleteTargets,
+                settings: this.overrides.controller.autocomplete || {},
+            };
+        }
+        const config = deepmerge(originalConfig, overrideConfig);
+        return config;
+    }
+}
+function removeEmptyObjects(object) {
+    // Create a recursive cleaning function that works with any object
+    const cleanObj = (obj) => {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        const result = {};
+        Object.entries(obj).forEach(([key, value]) => {
+            // Skip undefined values
+            if (value === undefined)
+                return;
+            if (value !== null && typeof value === 'object') {
+                // Recursively clean nested objects
+                const cleanedValue = cleanObj(value);
+                // Only add non-empty objects
+                if (Object.keys(cleanedValue).length > 0) {
+                    result[key] = cleanedValue;
+                }
+            }
+            else {
+                // Keep non-object values
+                result[key] = value;
+            }
+        });
+        return result;
+    };
+    // Apply the cleaning function to our controller object
+    return cleanObj(object);
+}
+function generateObject(path, value) {
+    return path
+        .slice()
+        .reverse()
+        .reduce((res, key, index) => {
+        if (index === 0) {
+            return {
+                [key]: value,
+            };
+        }
+        return {
+            [key]: res,
+        };
+    }, {});
+}

package/dist/esm/src/Templates/Stores/TemplateEditor/uiAbstractions/autocompleteControllerUI.d.ts

@@ -0,0 +1,6 @@
+import { AutocompleteController } from '@athoscommerce/snap-controller';
+import { AbstractionGroup } from '../../../../types';
+import { TemplateEditorStore } from '../TemplateEditorStore';
+export declare function autocompleteControllerUI(store: TemplateEditorStore): AbstractionGroup<AutocompleteController>[];
+export declare function updateAutocompleteControllerState(controller: AutocompleteController): Promise<void>;
+//# sourceMappingURL=autocompleteControllerUI.d.ts.map

package/dist/esm/src/Templates/Stores/TemplateEditor/uiAbstractions/autocompleteControllerUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocompleteControllerUI.d.ts","sourceRoot":"","sources":["../../../../../../../src/Templates/Stores/TemplateEditor/uiAbstractions/autocompleteControllerUI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,EAAE,CAgN/G;AAED,wBAAsB,iCAAiC,CAAC,UAAU,EAAE,sBAAsB,iBA2BzF"}

package/dist/esm/src/Templates/Stores/TemplateEditor/uiAbstractions/autocompleteControllerUI.js

@@ -0,0 +1,232 @@
+export function autocompleteControllerUI(store) {
+    return [
+        {
+            title: 'Terms',
+            description: '',
+            controls: [
+                {
+                    type: 'dropdown',
+                    label: 'History Terms',
+                    description: '',
+                    getOptions: () => [
+                        {
+                            options: [
+                                { value: 'Disabled' },
+                                { value: 1 },
+                                { value: 2 },
+                                { value: 3 },
+                                { value: 4 },
+                                { value: 5 },
+                                { value: 6 },
+                                { value: 7 },
+                                { value: 8 },
+                                { value: 9 },
+                                { value: 10 },
+                            ],
+                        },
+                    ],
+                    getValue: (controller) => {
+                        return controller?.store.config.settings?.history?.enabled ? controller.store.config.settings.history.limit ?? 'Disabled' : 'Disabled';
+                    },
+                    shouldShowReset: () => {
+                        const initialConfig = store.initial.controller.autocomplete?.history;
+                        const initialEnabled = Boolean(initialConfig?.enabled !== undefined ? initialConfig.enabled : initialConfig?.limit && initialConfig.limit > 0);
+                        const overrideConfig = store.overrides.controller.autocomplete?.history;
+                        const overrideEnabled = Boolean(overrideConfig?.enabled !== undefined);
+                        return (overrideEnabled && initialEnabled !== overrideEnabled) || initialConfig?.limit !== overrideConfig?.limit;
+                    },
+                    onValueChange: (value, controller) => {
+                        if (typeof value === 'undefined' || !controller)
+                            return;
+                        const initialConfig = store.initial.controller.autocomplete?.history;
+                        const initialValue = initialConfig?.enabled ? initialConfig?.limit : 'Disabled';
+                        if (value === 'Disabled' && initialValue !== 'Disabled') {
+                            store.setControllerOverride({ path: ['history'], value: { enabled: false, limit: undefined, showResults: undefined }, controller });
+                        }
+                        else if (value !== 'Disabled' && initialValue === 'Disabled') {
+                            store.setControllerOverride({ path: ['history'], value: { enabled: true, limit: Number(value) }, controller });
+                        }
+                        else {
+                            store.setControllerOverride({
+                                path: ['history'],
+                                value: { enabled: undefined, limit: undefined, showResults: undefined },
+                                controller,
+                            });
+                        }
+                        updateAutocompleteControllerState(controller);
+                    },
+                    onReset: (controller) => {
+                        if (!controller)
+                            return;
+                        const resetValues = { enabled: undefined, limit: undefined, showResults: undefined };
+                        if (store.initial.controller.autocomplete?.history?.enabled) {
+                            delete resetValues.showResults;
+                        }
+                        store.setControllerOverride({ path: ['history'], value: resetValues, controller });
+                        updateAutocompleteControllerState(controller);
+                    },
+                },
+                {
+                    type: 'dropdown',
+                    label: 'Trending Terms',
+                    description: '',
+                    getOptions: () => [
+                        {
+                            options: [
+                                { value: 'Disabled' },
+                                { value: 1 },
+                                { value: 2 },
+                                { value: 3 },
+                                { value: 4 },
+                                { value: 5 },
+                                { value: 6 },
+                                { value: 7 },
+                                { value: 8 },
+                                { value: 9 },
+                                { value: 10 },
+                            ],
+                        },
+                    ],
+                    getValue: (controller) => {
+                        return controller?.store.config.settings?.trending?.enabled ? controller.store.config.settings.trending.limit ?? 'Disabled' : 'Disabled';
+                    },
+                    shouldShowReset: () => {
+                        const initialConfig = store.initial.controller.autocomplete?.trending;
+                        const initialEnabled = Boolean(initialConfig?.enabled !== undefined ? initialConfig.enabled : initialConfig?.limit && initialConfig.limit > 0);
+                        const overrideConfig = store.overrides.controller.autocomplete?.trending;
+                        const overrideEnabled = Boolean(overrideConfig?.enabled !== undefined);
+                        return overrideEnabled && (initialEnabled !== overrideEnabled || initialConfig?.limit !== overrideConfig?.limit);
+                    },
+                    onValueChange: async (value, controller) => {
+                        if (typeof value === 'undefined' || !controller)
+                            return;
+                        const initialConfig = store.initial.controller.autocomplete?.trending;
+                        const initialValue = initialConfig?.enabled ? initialConfig?.limit : 'Disabled';
+                        if (value === 'Disabled' && initialValue !== 'Disabled') {
+                            store.setControllerOverride({ path: ['trending'], value: { enabled: false, limit: undefined, showResults: undefined }, controller });
+                        }
+                        else if (value !== 'Disabled' && initialValue === 'Disabled') {
+                            store.setControllerOverride({ path: ['trending'], value: { enabled: true, limit: Number(value) }, controller });
+                        }
+                        else if (value !== 'Disabled' && initialValue !== value) {
+                            store.setControllerOverride({ path: ['trending'], value: { enabled: true, limit: Number(value) }, controller });
+                        }
+                        else {
+                            store.setControllerOverride({
+                                path: ['trending'],
+                                value: { enabled: undefined, limit: undefined, showResults: undefined },
+                                controller,
+                            });
+                        }
+                        updateAutocompleteControllerState(controller);
+                    },
+                    onReset: (controller) => {
+                        if (!controller)
+                            return;
+                        const resetValues = { enabled: undefined, limit: undefined, showResults: undefined };
+                        if (store.initial.controller.autocomplete?.trending?.enabled) {
+                            delete resetValues.showResults;
+                        }
+                        store.setControllerOverride({ path: ['trending'], value: resetValues, controller });
+                        updateAutocompleteControllerState(controller);
+                    },
+                },
+                {
+                    type: 'dropdown',
+                    label: 'Initial Results',
+                    description: '',
+                    getDisplayState: (controller) => {
+                        const enabled = controller?.store.config.settings?.history?.enabled || controller?.store.config.settings?.trending?.enabled;
+                        return enabled ? 'visible' : 'disabled';
+                    },
+                    getOptions: (controller) => {
+                        const historyEnabled = controller?.store.config.settings?.history?.enabled;
+                        const trendingEnabled = controller?.store.config.settings?.trending?.enabled;
+                        const opts = [{ value: 'Disabled' }];
+                        if (historyEnabled)
+                            opts.push({ value: 'History' });
+                        if (trendingEnabled)
+                            opts.push({ value: 'Trending' });
+                        return [{ options: opts }];
+                    },
+                    getValue: (controller) => {
+                        if (controller?.store.config.settings?.trending?.showResults)
+                            return 'Trending';
+                        if (controller?.store.config.settings?.history?.showResults)
+                            return 'History';
+                        return 'Disabled';
+                    },
+                    shouldShowReset: () => {
+                        // see what the initial state is
+                        let initialValue = 'Disabled';
+                        const initialConfig = store.initial.controller.autocomplete;
+                        if (initialConfig?.trending?.showResults && initialConfig?.trending?.enabled !== false) {
+                            initialValue = 'Trending';
+                        }
+                        else if (initialConfig?.history?.showResults && initialConfig?.history?.enabled !== false) {
+                            initialValue = 'History';
+                        }
+                        // see what the override state is
+                        let overrideValue = 'Disabled';
+                        const overrideConfig = store.overrides.controller.autocomplete;
+                        if (overrideConfig?.trending?.showResults && overrideConfig?.trending?.enabled !== false) {
+                            overrideValue = 'Trending';
+                        }
+                        else if (overrideConfig?.history?.showResults && overrideConfig?.history?.enabled !== false) {
+                            overrideValue = 'History';
+                        }
+                        return initialValue !== overrideValue;
+                    },
+                    onValueChange: (value, controller) => {
+                        if (typeof value === 'undefined' || !controller)
+                            return;
+                        if (value === 'Disabled') {
+                            store.setControllerOverride({ path: ['history', 'showResults'], controller });
+                            store.setControllerOverride({ path: ['trending', 'showResults'], controller });
+                        }
+                        else if (value === 'History') {
+                            store.setControllerOverride({ path: ['history', 'showResults'], value: true, controller });
+                            store.setControllerOverride({ path: ['trending', 'showResults'], controller });
+                        }
+                        else if (value === 'Trending') {
+                            store.setControllerOverride({ path: ['history', 'showResults'], controller });
+                            store.setControllerOverride({ path: ['trending', 'showResults'], value: true, controller });
+                        }
+                        updateAutocompleteControllerState(controller);
+                    },
+                    onReset: (controller) => {
+                        if (!controller)
+                            return;
+                        store.setControllerOverride({ path: ['history', 'showResults'], controller });
+                        store.setControllerOverride({ path: ['trending', 'showResults'], controller });
+                        updateAutocompleteControllerState(controller);
+                    },
+                },
+            ],
+        },
+    ];
+}
+export async function updateAutocompleteControllerState(controller) {
+    controller.reset();
+    controller.store.initHistory();
+    const trendingResultsEnabled = controller.config.settings?.trending?.enabled ||
+        (controller.config.settings?.trending && controller.config.settings?.trending?.enabled == undefined);
+    const historyResultsEnabled = controller.config.settings?.history?.enabled ||
+        (controller.config.settings?.history && controller.config.settings?.history?.enabled == undefined);
+    if (trendingResultsEnabled) {
+        await controller.searchTrending({ limit: controller.config.settings?.trending?.limit });
+        controller.config.settings?.trending?.showResults &&
+            controller.store.trending.length &&
+            !controller.store.results &&
+            controller.store.trending[0].preview();
+    }
+    else {
+        controller.store.updateTrendingTerms({ trending: { queries: [] } });
+    }
+    if (!trendingResultsEnabled && historyResultsEnabled) {
+        controller.config.settings?.history?.showResults &&
+            controller.store.history.length &&
+            !controller.store.results &&
+            controller.store.history[0].preview();
+    }
+}

package/dist/esm/src/Templates/Stores/TemplateEditor/uiAbstractions/configUI.d.ts

@@ -0,0 +1,4 @@
+import { AbstractionGroup } from '../../../../types';
+import { TemplateEditorStore } from '../TemplateEditorStore';
+export declare const configUI: (store: TemplateEditorStore) => AbstractionGroup[];
+//# sourceMappingURL=configUI.d.ts.map

package/dist/esm/src/Templates/Stores/TemplateEditor/uiAbstractions/configUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configUI.d.ts","sourceRoot":"","sources":["../../../../../../../src/Templates/Stores/TemplateEditor/uiAbstractions/configUI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,eAAO,MAAM,QAAQ,UAAW,mBAAmB,KAAG,gBAAgB,EAgHrE,CAAC"}