@searchspring/snap-preact 0.20.0

package/dist/esm/Instantiators/RecommendationInstantiator.js

@@ -0,0 +1,127 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { render } from 'preact';
+import { DomTargeter, getContext } from '@searchspring/snap-toolbox';
+export class RecommendationInstantiator {
+    constructor(config, { client, logger, tracker }) {
+        this.controllers = {};
+        this.uses = [];
+        this.plugins = [];
+        this.middleware = [];
+        this.config = config;
+        if (!this.config) {
+            throw new Error(`Recommendation Instantiator config is required`);
+        }
+        if (!this.config.config?.branch) {
+            throw new Error(`Recommendation Instantiator config must contain 'branch' property`);
+        }
+        if (!this.config.components || typeof this.config.components != 'object') {
+            throw new Error(`Recommendation Instantiator config must contain 'components' mapping property`);
+        }
+        this.client = client;
+        this.tracker = tracker;
+        this.logger = logger;
+        const profileCount = {};
+        this.targeter = new DomTargeter([
+            {
+                selector: `script[type="searchspring/recommend"], script[type="searchspring/personalized-recommendations"]${this.config.selector ? ` , ${this.config.selector}` : ''}`,
+                inject: {
+                    action: 'before',
+                    element: (target, origElement) => {
+                        const profile = origElement.getAttribute('profile');
+                        if (profile) {
+                            const recsContainer = document.createElement('div');
+                            recsContainer.setAttribute('searchspring-recommend', profile);
+                            return recsContainer;
+                        }
+                        else {
+                            this.logger.warn(`'profile' attribute is missing from <script> tag, skipping this profile`, origElement);
+                        }
+                    },
+                },
+            },
+        ], async (target, injectedElem, elem) => {
+            const globals = {};
+            const { shopper, shopperId, product, seed, options } = getContext(['shopperId', 'shopper', 'product', 'seed', 'options'], elem);
+            /*
+                type instantiatorContext = {
+                    shopper?: string;
+                    shopperId?: string;
+                    product?: string;
+                    seed?: string;
+                    options?: {
+                        siteId?: string;
+                        branch?: string;
+                        batched?: boolean;
+                        realtime?: boolean;
+                        categories?: any;
+                    }
+                }
+            */
+            if (shopper || shopperId) {
+                globals.shopper = shopper || shopperId;
+            }
+            if (product || seed) {
+                globals.product = product || seed;
+            }
+            if (options?.branch) {
+                globals.branch = options.branch;
+            }
+            if (options?.siteId) {
+                globals.siteId = options.siteId;
+            }
+            if (options?.categories) {
+                globals.categories = options.categories;
+            }
+            const tag = injectedElem.getAttribute('searchspring-recommend');
+            profileCount[tag] = profileCount[tag] + 1 || 1;
+            const controllerConfig = {
+                id: `recommend_${tag + (profileCount[tag] - 1)}`,
+                tag,
+                batched: options?.batched ?? true,
+                realtime: Boolean(options?.realtime),
+                globals,
+                ...this.config.config,
+            };
+            const createRecommendationController = (await import('../create/createRecommendationController')).default;
+            const client = this.config.services?.client || this.client;
+            const tracker = this.config.services?.tracker || this.tracker;
+            const recs = createRecommendationController({
+                url: this.config.url || {},
+                controller: controllerConfig,
+            }, { client, tracker });
+            this.uses.forEach((attachements) => recs.use(attachements));
+            this.plugins.forEach((plugin) => recs.plugin(plugin));
+            this.middleware.forEach((middleware) => recs.on(middleware.event, ...middleware.func));
+            await recs.search();
+            recs.addTargeter(this.targeter);
+            this.controllers[recs.config.id] = recs;
+            const profileVars = recs.store.profile.display.templateParameters;
+            const component = recs.store.profile.display.template?.component;
+            if (!profileVars) {
+                recs.log.error(`profile failed to load!`);
+                return;
+            }
+            if (!component) {
+                recs.log.error(`template does not support components!`);
+                return;
+            }
+            const RecommendationsComponent = this.config.components && (await this.config.components[component]());
+            if (!RecommendationsComponent) {
+                recs.log.error(`component '${profileVars.component}' not found!`);
+                return;
+            }
+            setTimeout(() => {
+                render(_jsx(RecommendationsComponent, { controller: recs }, void 0), injectedElem);
+            });
+        });
+    }
+    plugin(func) {
+        this.plugins.push(func);
+    }
+    on(event, ...func) {
+        this.middleware.push({ event, func });
+    }
+    use(attachments) {
+        this.uses.push(attachments);
+    }
+}

package/dist/esm/Snap.d.ts

@@ -0,0 +1,93 @@
+import { Client } from '@searchspring/snap-client';
+import { Logger } from '@searchspring/snap-logger';
+import { Tracker } from '@searchspring/snap-tracker';
+import type { ClientConfig, ClientGlobals } from '@searchspring/snap-client';
+import type { AbstractController, SearchController, AutocompleteController, FinderController, RecommendationController, SearchControllerConfig, AutocompleteControllerConfig, FinderControllerConfig, RecommendationControllerConfig, ControllerConfigs } from '@searchspring/snap-controller';
+import type { Product } from '@searchspring/snap-tracker';
+import type { Target, OnTarget } from '@searchspring/snap-toolbox';
+import type { UrlTranslatorConfig } from '@searchspring/snap-url-manager';
+import { RecommendationInstantiator, RecommendationInstantiatorConfig } from './Instantiators/RecommendationInstantiator';
+import type { SnapControllerServices, RootComponent } from './types';
+declare type ExtendedTarget = Target & {
+    name?: string;
+    controller?: AbstractController;
+    component?: () => Promise<RootComponent> | RootComponent;
+    skeleton?: () => Promise<any>;
+    props?: unknown;
+    onTarget?: OnTarget;
+    prefetch?: boolean;
+};
+declare type ContextVariables = {
+    shopper?: {
+        id: string;
+        cart?: Product[];
+        [variable: string]: any;
+    };
+    [variable: string]: any;
+};
+export declare type SnapConfig = {
+    context?: ContextVariables;
+    url?: UrlTranslatorConfig;
+    client: {
+        globals: ClientGlobals;
+        config?: ClientConfig;
+    };
+    instantiators?: {
+        recommendation?: RecommendationInstantiatorConfig;
+    };
+    controllers?: {
+        search?: {
+            config: SearchControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        autocomplete?: {
+            config: AutocompleteControllerConfig;
+            targeters: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        finder?: {
+            config: FinderControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        recommendation?: {
+            config: RecommendationControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+    };
+};
+declare type ControllerTypes = SearchController | AutocompleteController | FinderController | RecommendationController;
+declare enum DynamicImportNames {
+    SEARCH = "searchController",
+    AUTOCOMPLETE = "autocompleteController",
+    FINDER = "finderController",
+    RECOMMENDATION = "recommendationController"
+}
+export declare class Snap {
+    config: SnapConfig;
+    logger: Logger;
+    client: Client;
+    tracker: Tracker;
+    _controllerPromises: {
+        [controllerConfigId: string]: Promise<ControllerTypes>;
+    };
+    controllers: {
+        [controllerConfigId: string]: ControllerTypes;
+    };
+    _instantiatorPromises: {
+        [instantiatorId: string]: Promise<RecommendationInstantiator>;
+    };
+    getInstantiator: (id: string) => Promise<RecommendationInstantiator>;
+    getController: (id: string) => Promise<ControllerTypes>;
+    getControllers: (...controllerIds: string[]) => Promise<ControllerTypes[]>;
+    createController: (type: DynamicImportNames, config: ControllerConfigs, services: SnapControllerServices, urlConfig: UrlTranslatorConfig, resolve: (value?: ControllerTypes | PromiseLike<ControllerTypes>) => void) => Promise<ControllerTypes>;
+    constructor(config: SnapConfig);
+}
+export {};
+//# sourceMappingURL=Snap.d.ts.map

package/dist/esm/Snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Snap.d.ts","sourceRoot":"","sources":["../../src/Snap.tsx"],"names":[],"mappings":"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"}

package/dist/esm/Snap.js

@@ -0,0 +1,396 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import deepmerge from 'deepmerge';
+import { render } from 'preact';
+import { Client } from '@searchspring/snap-client';
+import { Logger, LogMode } from '@searchspring/snap-logger';
+import { Tracker } from '@searchspring/snap-tracker';
+import { version, DomTargeter, url, cookies, featureFlags } from '@searchspring/snap-toolbox';
+import { default as createSearchController } from './create/createSearchController';
+const BRANCH_COOKIE = 'ssBranch';
+const SS_DEV_COOKIE = 'ssDev';
+var DynamicImportNames;
+(function (DynamicImportNames) {
+    DynamicImportNames["SEARCH"] = "searchController";
+    DynamicImportNames["AUTOCOMPLETE"] = "autocompleteController";
+    DynamicImportNames["FINDER"] = "finderController";
+    DynamicImportNames["RECOMMENDATION"] = "recommendationController";
+})(DynamicImportNames || (DynamicImportNames = {}));
+export class Snap {
+    constructor(config) {
+        this.getInstantiator = (id) => {
+            return this._instantiatorPromises[id] || Promise.reject(`getInstantiator could not find instantiator with id: ${id}`);
+        };
+        this.getController = (id) => {
+            return this._controllerPromises[id] || Promise.reject(`getController could not find controller with id: ${id}`);
+        };
+        this.getControllers = (...controllerIds) => {
+            const getControllerPromises = [];
+            controllerIds.forEach((id) => getControllerPromises.push(this.getController(id)));
+            return Promise.all(getControllerPromises);
+        };
+        this.createController = (type, config, services, urlConfig, resolve) => {
+            let importPromise;
+            switch (type) {
+                case DynamicImportNames.SEARCH:
+                    importPromise = import('./create/createSearchController');
+                    break;
+                case DynamicImportNames.AUTOCOMPLETE:
+                    importPromise = import('./create/createAutocompleteController');
+                    break;
+                case DynamicImportNames.FINDER:
+                    importPromise = import('./create/createFinderController');
+                    break;
+                case DynamicImportNames.RECOMMENDATION:
+                    importPromise = import('./create/createRecommendationController');
+                    break;
+            }
+            return importPromise.then((_) => {
+                if (!this.controllers[config.id]) {
+                    this.controllers[config.id] = _.default({
+                        url: deepmerge(this.config.url || {}, urlConfig || {}),
+                        controller: config,
+                    }, { client: services?.client || this.client, tracker: services?.tracker || this.tracker });
+                    resolve(this.controllers[config.id]);
+                }
+                return this.controllers[config.id];
+            });
+        };
+        this.config = config;
+        this.logger = new Logger('Snap Preact ');
+        if (!this.config?.client?.globals?.siteId) {
+            throw new Error(`Snap: config provided must contain a valid config.client.globals.siteId value`);
+        }
+        this.client = new Client(this.config.client.globals, this.config.client.config);
+        this.tracker = new Tracker(this.config.client.globals);
+        this._controllerPromises = {};
+        this._instantiatorPromises = {};
+        this.controllers = {};
+        // TODO environment switch using URL?
+        this.logger.setMode(process.env.NODE_ENV);
+        // log version
+        this.logger.imageText({
+            url: 'https://snapui.searchspring.io/favicon.svg',
+            text: `[${version}]`,
+            style: `color: ${this.logger.colors.indigo}; font-weight: bold;`,
+        });
+        try {
+            const urlParams = url(window.location.href);
+            const branchParam = urlParams.params?.query?.branch || cookies.get(BRANCH_COOKIE);
+            if (branchParam && !document.querySelector(`script[${BRANCH_COOKIE}]`)) {
+                // set a cookie or localstorage with branch
+                if (featureFlags.cookies) {
+                    cookies.set(BRANCH_COOKIE, branchParam, 'Lax', 3600000); // 1 hour
+                    cookies.set(SS_DEV_COOKIE, '1', 'Lax', 0);
+                }
+                else {
+                    this.logger.warn('Cookies are not supported/enabled by this browser, branch overrides will not persist!');
+                }
+                this.logger.setMode(LogMode.DEVELOPMENT);
+                this.logger.warn(`...loading build... '${branchParam}'`);
+                // append script with new branch in path
+                const script = document.createElement('script');
+                const src = `https://snapui.searchspring.io/${this.config.client.globals.siteId}/${branchParam}/bundle.js`;
+                script.src = src;
+                script.setAttribute(BRANCH_COOKIE, '');
+                document.head.appendChild(script);
+                new DomTargeter([
+                    {
+                        selector: 'body',
+                        inject: {
+                            action: 'append',
+                            element: () => {
+                                const branchContainer = document.createElement('div');
+                                branchContainer.className = 'ss__branch--target';
+                                return branchContainer;
+                            },
+                        },
+                    },
+                ], async (target, elem) => {
+                    const BranchOverride = (await import('./components/BranchOverride')).BranchOverride;
+                    render(_jsx(BranchOverride, { branch: branchParam, cookieName: BRANCH_COOKIE, bundleUrl: src }, void 0), elem);
+                });
+                // prevent further instantiation of config
+                return;
+            }
+        }
+        catch (e) { }
+        if (window.searchspring) {
+            if (this.config.context)
+                window.searchspring.context = this.config.context;
+            if (this.client)
+                window.searchspring.client = this.client;
+        }
+        // autotrack shopper id from the context
+        if (this.config.context?.shopper?.id) {
+            this.tracker.track.shopper.login({
+                id: this.config.context.shopper.id,
+            });
+        }
+        // auto populate cart cookie from the context
+        if (this.config.context?.shopper?.cart) {
+            const cart = this.config.context.shopper.cart;
+            if (Array.isArray(cart)) {
+                const cartItems = cart.filter((item) => item?.sku || item?.childSku).map((item) => (item?.sku || item?.childSku).trim());
+                this.tracker.cookies.cart.set(cartItems);
+            }
+        }
+        Object.keys(this.config?.controllers || {}).forEach((type) => {
+            switch (type) {
+                case 'search': {
+                    this.config.controllers[type].forEach((controller, index) => {
+                        try {
+                            const cntrlr = createSearchController({
+                                url: deepmerge(this.config.url || {}, controller.url || {}),
+                                controller: controller.config,
+                            }, { client: controller.services?.client || this.client, tracker: controller.services?.tracker || this.tracker });
+                            this.controllers[cntrlr.config.id] = cntrlr;
+                            this._controllerPromises[cntrlr.config.id] = new Promise((resolve) => resolve(cntrlr));
+                            let searched = false;
+                            const runSearch = () => {
+                                if (!searched) {
+                                    searched = true;
+                                    this.controllers[controller.config.id].search();
+                                }
+                            };
+                            const targetFunction = async (target, elem, originalElem) => {
+                                runSearch();
+                                const onTarget = target.onTarget;
+                                onTarget && onTarget(target, elem, originalElem);
+                                try {
+                                    const Component = await target.component();
+                                    setTimeout(() => {
+                                        render(_jsx(Component, { controller: this.controllers[controller.config.id], ...target.props }, void 0), elem);
+                                    });
+                                }
+                                catch (err) {
+                                    this.logger.error(`Uncaught Error - Invalid value passed as the component.
+	This usually happens when you pass a JSX Element, and not a function that returns the component, in the snap config. 
+			
+				instead of - 
+
+			targeters: [
+				{
+					selector: '#searchspring-content',
+					hideTarget: true,
+					component: <Content/>,
+				},
+			]
+
+				or - 
+
+			targeters: [
+				{
+					selector: '#searchspring-content',
+					hideTarget: true,
+					component: Content,
+				},
+			]
+
+				please try - 
+
+			targeters: [
+				{
+					selector: '#searchspring-content',
+					hideTarget: true,
+					component: () => Content
+				},
+			]
+
+			
+The error above happened in the following targeter in the Snap Config`, target);
+                                }
+                            };
+                            controller?.targeters?.forEach(async (target, target_index) => {
+                                if (!target.selector) {
+                                    throw new Error(`Targets at index ${target_index} missing selector value (string).`);
+                                }
+                                if (!target.component) {
+                                    throw new Error(`Targets at index ${target_index} missing component value (Component).`);
+                                }
+                                if (target.prefetch) {
+                                    runSearch();
+                                }
+                                cntrlr.createTargeter({ controller: cntrlr, ...target }, async (target, elem, originalElem) => {
+                                    if (target.skeleton) {
+                                        const Skeleton = await target.skeleton();
+                                        setTimeout(() => {
+                                            render(_jsx(Skeleton, {}, void 0), elem);
+                                        });
+                                    }
+                                    targetFunction(target, elem, originalElem);
+                                });
+                            });
+                        }
+                        catch (err) {
+                            this.logger.error(`Failed to instantiate ${type} controller at index ${index}.`, err);
+                        }
+                    });
+                    break;
+                }
+                case 'autocomplete': {
+                    this.config.controllers[type].forEach((controller, index) => {
+                        this._controllerPromises[controller.config.id] = new Promise((resolve) => {
+                            try {
+                                let bound = false;
+                                const runBind = () => {
+                                    if (!bound) {
+                                        bound = true;
+                                        setTimeout(() => {
+                                            this.controllers[controller.config.id].bind();
+                                        });
+                                    }
+                                };
+                                const targetFunction = async (target, elem, originalElem) => {
+                                    const onTarget = target.onTarget;
+                                    onTarget && onTarget(target, elem, originalElem);
+                                    const Component = (await target.component());
+                                    setTimeout(() => {
+                                        render(_jsx(Component, { controller: this.controllers[controller.config.id], input: originalElem, ...target.props }, void 0), elem);
+                                    });
+                                };
+                                if (!controller?.targeters || controller?.targeters.length === 0) {
+                                    this.createController(DynamicImportNames.AUTOCOMPLETE, controller.config, controller.services, controller.url, resolve);
+                                }
+                                controller?.targeters?.forEach(async (target, target_index) => {
+                                    if (!target.selector) {
+                                        throw new Error(`Targets at index ${target_index} missing selector value (string).`);
+                                    }
+                                    if (!target.component) {
+                                        throw new Error(`Targets at index ${target_index} missing component value (Component).`);
+                                    }
+                                    const targeter = new DomTargeter([
+                                        {
+                                            inject: {
+                                                action: 'after',
+                                                element: () => {
+                                                    const acContainer = document.createElement('div');
+                                                    acContainer.className = 'ss__autocomplete--target';
+                                                    acContainer.addEventListener('click', (e) => {
+                                                        e.stopPropagation();
+                                                    });
+                                                    return acContainer;
+                                                },
+                                            },
+                                            ...target,
+                                        },
+                                    ], async (target, elem, originalElem) => {
+                                        const cntrlr = await this.createController(DynamicImportNames.AUTOCOMPLETE, controller.config, controller.services, controller.url, resolve);
+                                        runBind();
+                                        targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
+                                        cntrlr.addTargeter(targeter);
+                                    });
+                                });
+                            }
+                            catch (err) {
+                                this.logger.error(`Failed to instantiate ${type} controller at index ${index}.`, err);
+                            }
+                        });
+                    });
+                    break;
+                }
+                case 'finder': {
+                    this.config.controllers[type].forEach((controller, index) => {
+                        this._controllerPromises[controller.config.id] = new Promise((resolve) => {
+                            try {
+                                let searched = false;
+                                const runSearch = () => {
+                                    if (!searched) {
+                                        this.controllers[controller.config.id].search();
+                                        searched = true;
+                                    }
+                                };
+                                const targetFunction = async (target, elem, originalElem) => {
+                                    const onTarget = target.onTarget;
+                                    onTarget && onTarget(target, elem, originalElem);
+                                    const Component = await target.component();
+                                    setTimeout(() => {
+                                        render(_jsx(Component, { controller: this.controllers[controller.config.id], ...target.props }, void 0), elem);
+                                    });
+                                };
+                                if (!controller?.targeters || controller?.targeters.length === 0) {
+                                    this.createController(DynamicImportNames.FINDER, controller.config, controller.services, controller.url, resolve);
+                                }
+                                controller?.targeters?.forEach(async (target, target_index) => {
+                                    if (!target.selector) {
+                                        throw new Error(`Targets at index ${target_index} missing selector value (string).`);
+                                    }
+                                    if (!target.component) {
+                                        throw new Error(`Targets at index ${target_index} missing component value (Component).`);
+                                    }
+                                    const targeter = new DomTargeter([{ ...target }], async (target, elem, originalElem) => {
+                                        const cntrlr = await this.createController(DynamicImportNames.FINDER, controller.config, controller.services, controller.url, resolve);
+                                        runSearch();
+                                        targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
+                                        cntrlr.addTargeter(targeter);
+                                    });
+                                });
+                            }
+                            catch (err) {
+                                this.logger.error(`Failed to instantiate ${type} controller at index ${index}.`, err);
+                            }
+                        });
+                    });
+                    break;
+                }
+                case 'recommendation': {
+                    this.config.controllers[type].forEach((controller, index) => {
+                        this._controllerPromises[controller.config.id] = new Promise((resolve) => {
+                            try {
+                                let searched = false;
+                                const runSearch = () => {
+                                    if (!searched) {
+                                        this.controllers[controller.config.id].search();
+                                        searched = true;
+                                    }
+                                };
+                                const targetFunction = async (target, elem, originalElem) => {
+                                    const onTarget = target.onTarget;
+                                    onTarget && onTarget(target, elem, originalElem);
+                                    const Component = await target.component();
+                                    setTimeout(() => {
+                                        render(_jsx(Component, { controller: this.controllers[controller.config.id], ...target.props }, void 0), elem);
+                                    });
+                                };
+                                if (!controller?.targeters || controller?.targeters.length === 0) {
+                                    this.createController(DynamicImportNames.RECOMMENDATION, controller.config, controller.services, controller.url, resolve);
+                                }
+                                controller?.targeters?.forEach(async (target, target_index) => {
+                                    if (!target.selector) {
+                                        throw new Error(`Targets at index ${target_index} missing selector value (string).`);
+                                    }
+                                    if (!target.component) {
+                                        throw new Error(`Targets at index ${target_index} missing component value (Component).`);
+                                    }
+                                    const targeter = new DomTargeter([{ ...target }], async (target, elem, originalElem) => {
+                                        const cntrlr = await this.createController(DynamicImportNames.RECOMMENDATION, controller.config, controller.services, controller.url, resolve);
+                                        runSearch();
+                                        targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
+                                        cntrlr.addTargeter(targeter);
+                                    });
+                                });
+                            }
+                            catch (err) {
+                                this.logger.error(`Failed to instantiate ${type} controller at index ${index}.`, err);
+                            }
+                        });
+                    });
+                    break;
+                }
+            }
+        });
+        if (config?.instantiators?.recommendation) {
+            try {
+                this._instantiatorPromises.recommendations = import('./Instantiators/RecommendationInstantiator').then(({ RecommendationInstantiator }) => {
+                    return new RecommendationInstantiator(config.instantiators.recommendation, {
+                        client: config.instantiators.recommendation?.services?.client || this.client,
+                        tracker: config.instantiators.recommendation?.services?.tracker || this.tracker,
+                        logger: config.instantiators.recommendation?.services?.logger || this.logger,
+                    });
+                });
+            }
+            catch (err) {
+                this.logger.error(`Failed to create Recommendations Instantiator.`, err);
+            }
+        }
+    }
+}

package/dist/esm/components/BranchOverride.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const BranchOverride: (props: {
+    branch: string;
+    cookieName: string;
+    bundleUrl: string;
+}) => JSX.Element;
+//# sourceMappingURL=BranchOverride.d.ts.map

package/dist/esm/components/BranchOverride.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BranchOverride.d.ts","sourceRoot":"","sources":["../../../src/components/BranchOverride.tsx"],"names":[],"mappings":";AA8IA,eAAO,MAAM,cAAc,UAAW;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KAAG,WA+FjG,CAAC"}