@stackbit/cms-core 1.0.10-develop.1 → 1.0.10-develop.2

package/src/utils/csi-to-store-docs-converter.ts

@@ -52,6 +52,7 @@ function sourceAssetToStoreAsset({
         updatedAt: csiAsset.updatedAt,
         updatedBy: csiAsset.updatedBy,
         locale: csiAsset.locale,
+        hidden: csiAsset.hidden,
         fields: {
             title: {
                 label: 'Title',
@@ -166,6 +167,7 @@ function mapCSIDocumentToStoreDocument({
         createdBy: csiDocument.createdBy,
         updatedAt: csiDocument.updatedAt,
         updatedBy: csiDocument.updatedBy,
+        hidden: typeof csiDocument.hidden === 'boolean' ? csiDocument.hidden : model.hidden,
         locale: getDocumentLocale({ csiDocument, model }),
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
@@ -825,8 +827,7 @@ function getObjectTitleFromLabelField({
     document,
     documentField,
     modelOrObjectField,
-    delegate,
-    locale
+    delegate
 }: {
     document: StackbitTypes.DocumentWithSource;
     documentField?: StackbitTypes.DocumentModelField | StackbitTypes.DocumentObjectField;

package/src/utils/document-utils.ts

@@ -0,0 +1,39 @@
+import * as StackbitTypes from '@stackbit/types';
+
+const getModelsFromFields = (fields: StackbitTypes.DocumentField[], foundModels: Set<string>) => {
+    fields.forEach((field) => {
+        if (field.type === 'model') {
+            if (field.localized) {
+                for (const localeObject of Object.values(field.locales)) {
+                    foundModels.add(localeObject.modelName);
+                    getModelsFromFields(Object.values(localeObject.fields), foundModels);
+                }
+            } else {
+                foundModels.add(field.modelName);
+                getModelsFromFields(Object.values(field.fields), foundModels);
+            }
+        } else if (field.type === 'object') {
+            if (field.localized) {
+                for (const localeObject of Object.values(field.locales)) {
+                    getModelsFromFields(Object.values(localeObject.fields), foundModels);
+                }
+            } else {
+                getModelsFromFields(Object.values(field.fields), foundModels);
+            }
+        } else if (field.type === 'list') {
+            if (field.localized) {
+                for (const localeObject of Object.values(field.locales)) {
+                    getModelsFromFields(localeObject.items, foundModels);
+                }
+            } else {
+                getModelsFromFields(field.items, foundModels);
+            }
+        }
+    });
+};
+
+export function getAllModelsFromCSIDocument({ document }: { document: StackbitTypes.Document }): string[] {
+    const models = new Set<string>([document.modelName]);
+    getModelsFromFields(Object.values(document.fields), models);
+    return Array.from(models);
+}

package/src/utils/filtered-entities.ts

@@ -0,0 +1,247 @@
+import * as CSITypes from '@stackbit/types';
+import _ from 'lodash';
+import { ContentStoreTypes } from '../';
+import { STACKBIT_PRESET_MODEL_NAME } from '../consts';
+import { getContentSourceDataByIdOrThrow, getContentSourceId } from '../content-store-utils';
+import { mapCSIAssetsToStoreAssets, mapCSIDocumentsToStoreDocuments } from './csi-to-store-docs-converter';
+import { getAllModelsFromCSIDocument } from './document-utils';
+
+export const getFilteredDocumentsForUser = ({
+    user,
+    documents,
+    filterModel,
+    filterDocument,
+    contentSourceDataById,
+    assetSources,
+    createConfigDelegate,
+    customActionRunStateMap,
+    logger
+}: {
+    user?: ContentStoreTypes.User;
+    filterModel: CSITypes.StackbitConfig['filterModel'];
+    filterDocument: CSITypes.StackbitConfig['filterDocument'];
+    documents: ContentStoreTypes.Document[];
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+    assetSources: CSITypes.AssetSource[];
+    createConfigDelegate: () => CSITypes.ConfigDelegate;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
+    logger: CSITypes.Logger;
+}): ContentStoreTypes.Document[] => {
+    if (!user || (!filterDocument && !filterModel)) {
+        return documents;
+    }
+
+    const documentsBySourceId = _.groupBy(documents, (object) => getContentSourceId(object.srcType, object.srcProjectId));
+
+    const transformedCsiDocuments: CSITypes.DocumentWithSource[] = [];
+
+    const resultDocuments: ContentStoreTypes.Document[] = [];
+
+    const configDelegate = createConfigDelegate();
+
+    for (const [contentSourceId, contentSourceDocuments] of Object.entries(documentsBySourceId)) {
+        const contentSourceData = getContentSourceDataByIdOrThrow(contentSourceId, contentSourceDataById);
+        const filteredModelsMap: Record<string, CSITypes.Model> = {};
+
+        contentSourceDocuments.forEach((document) => {
+            const csiDoc = contentSourceData.csiDocumentMap[document.srcObjectId];
+            if (!csiDoc) {
+                throw new Error(`Document with id '${document.srcObjectId}' not found in content source '${contentSourceId}'`);
+            }
+
+            getAllModelsFromCSIDocument({ document: csiDoc }).forEach((modelName) => {
+                if (!filteredModelsMap[modelName]) {
+                    const filteredModel = getFilteredModelForUser({
+                        user,
+                        name: modelName,
+                        contentSourceData,
+                        configDelegate,
+                        filterModel
+                    });
+                    filteredModelsMap[modelName] = filteredModel;
+                }
+            });
+            const documentModel = filteredModelsMap[document.srcModelName];
+            if (!documentModel) {
+                throw new Error(
+                    `Can't find model with name '${document.srcModelName}' for object with id '${document.srcObjectId}' in content source '${contentSourceId}'`
+                );
+            }
+            if (documentModel.hidden) {
+                // model is hidden - return csiDocument right away as hidden
+                resultDocuments.push({
+                    ...document,
+                    hidden: true
+                });
+                return;
+            }
+
+            if (!filterDocument) {
+                // no filter function is defined, but the model is not hidden - just add this document as is
+                resultDocuments.push(document);
+                return;
+            }
+
+            const csiDocWithSource: CSITypes.DocumentWithSource = {
+                ..._.cloneDeep(csiDoc),
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId
+            };
+            const shouldIncludeDoc = filterDocument({
+                ...configDelegate,
+                document: csiDocWithSource,
+                userContext: user
+            });
+            if (typeof shouldIncludeDoc === 'undefined') {
+                transformedCsiDocuments.push(csiDocWithSource);
+            } else {
+                transformedCsiDocuments.push({
+                    ...csiDocWithSource,
+                    hidden: !shouldIncludeDoc
+                });
+            }
+        });
+
+        if (transformedCsiDocuments.length) {
+            const csResultDocuments = mapCSIDocumentsToStoreDocuments({
+                csiDocuments: transformedCsiDocuments,
+                contentSourceInstance: contentSourceData.instance,
+                modelMap: filteredModelsMap,
+                defaultLocaleCode: contentSourceData.defaultLocaleCode,
+                assetSources,
+                customActionRunStateMap,
+                createConfigDelegate,
+                logger
+            });
+
+            resultDocuments.push(...(csResultDocuments ?? []));
+        }
+    }
+
+    return resultDocuments;
+};
+
+export const getFilteredAssetsForUser = ({
+    user,
+    assets,
+    filterAsset,
+    configDelegate,
+    contentSourceDataById
+}: {
+    user?: ContentStoreTypes.User;
+    assets: ContentStoreTypes.Asset[];
+    filterAsset: CSITypes.StackbitConfig['filterAsset'];
+    configDelegate: CSITypes.ConfigDelegate;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+}): ContentStoreTypes.Asset[] => {
+    if (!user || !filterAsset) {
+        return assets;
+    }
+
+    const assetsBySourceId = _.groupBy(assets, (object) => getContentSourceId(object.srcType, object.srcProjectId));
+
+    const transformedCsiAssets: CSITypes.AssetWithSource[] = [];
+
+    const resultAssets: ContentStoreTypes.Asset[] = [];
+
+    for (const [contentSourceId, contentSourceAssets] of Object.entries(assetsBySourceId)) {
+        const contentSourceData = getContentSourceDataByIdOrThrow(contentSourceId, contentSourceDataById);
+
+        contentSourceAssets.forEach((asset) => {
+            const csiAsset = contentSourceData.csiAssetMap[asset.srcObjectId];
+            if (!csiAsset) {
+                throw new Error(`Asset with id '${asset.srcObjectId}' not found in content source '${contentSourceId}'`);
+            }
+
+            const csiAssetWithSource: CSITypes.AssetWithSource = {
+                ..._.cloneDeep(csiAsset),
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId
+            };
+            const shouldIncludeAsset = filterAsset({
+                ...configDelegate,
+                asset: csiAssetWithSource,
+                userContext: user
+            });
+            if (typeof shouldIncludeAsset === 'undefined') {
+                transformedCsiAssets.push(csiAssetWithSource);
+            } else {
+                transformedCsiAssets.push({
+                    ...csiAssetWithSource,
+                    hidden: !shouldIncludeAsset
+                });
+            }
+        });
+
+        if (transformedCsiAssets.length) {
+            const csResultAssets = mapCSIAssetsToStoreAssets({
+                csiAssets: transformedCsiAssets,
+                contentSourceInstance: contentSourceData.instance,
+                defaultLocaleCode: contentSourceData.defaultLocaleCode
+            });
+
+            resultAssets.push(...csResultAssets);
+        }
+    }
+
+    return resultAssets;
+};
+
+export const getContentSourceFilteredModelsForUser = ({
+    user,
+    configDelegate,
+    contentSourceData,
+    filterModel
+}: {
+    user?: ContentStoreTypes.User;
+    configDelegate: CSITypes.ConfigDelegate;
+    contentSourceData: ContentStoreTypes.ContentSourceData;
+    filterModel: CSITypes.StackbitConfig['filterModel'];
+}): CSITypes.Model[] => {
+    const filteredModels = contentSourceData.models.map((model) => {
+        return getFilteredModelForUser({
+            user,
+            configDelegate,
+            name: model.name,
+            contentSourceData,
+            filterModel
+        });
+    });
+    const cleanModels = filteredModels.filter((model) => model.name !== STACKBIT_PRESET_MODEL_NAME);
+    return cleanModels;
+};
+
+export const getFilteredModelForUser = ({
+    user,
+    name,
+    configDelegate,
+    contentSourceData,
+    filterModel
+}: {
+    user?: ContentStoreTypes.User;
+    name: string;
+    configDelegate: CSITypes.ConfigDelegate;
+    contentSourceData: ContentStoreTypes.ContentSourceData;
+    filterModel: CSITypes.StackbitConfig['filterModel'];
+}): CSITypes.Model => {
+    const model = contentSourceData.modelMap[name];
+    if (!model) {
+        throw new Error(`Model with name ${name} not found in source`);
+    }
+    if (!user || !filterModel) {
+        return model;
+    }
+    const modelWithSource = {
+        ..._.cloneDeep(model),
+        srcType: contentSourceData.srcType,
+        srcProjectId: contentSourceData.srcProjectId
+    };
+    const shouldIncludeModel = filterModel({ ...configDelegate, model: modelWithSource, userContext: user });
+    if (typeof shouldIncludeModel === 'undefined') {
+        return model;
+    }
+    return {
+        ...model,
+        hidden: !shouldIncludeModel
+    };
+};

package/src/utils/model-utils.ts

@@ -176,3 +176,10 @@ export function validateModels<T extends Model>({ models, logger }: { models: T[
 
     return config.models as T[];
 }
+
+export function getModelMap<T extends Model>({ models }: { models: T[] }): Record<string, T> {
+    return models.reduce((res, model) => {
+        res[model.name] = model;
+        return res;
+    }, {} as Record<string, T>);
+}

package/src/utils/search-utils.ts

@@ -4,7 +4,7 @@ import { ScheduledAction } from '@stackbit/types';
 import { append } from '@stackbit/utils';
 
 import * as ContentStoreTypes from '../types';
-import { ReferenceValueType, SearchFilter, SearchFilterItem } from '../types';
+import { ReferenceValueType, SearchFilter, SearchFilterItem, SearchFilterItemGrouped } from '../types';
 import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 import { META_FIELDS, MetaFieldMethod } from './meta-fields-filters';
 
@@ -55,25 +55,13 @@ export const searchDocuments = (data: {
             }
         }
 
-        if (data.filter?.and) {
-            // only 'and' supported for now; later we can add e.g. 'or'
-            const matches = data.filter.and.every((filter) => {
-                const filterFieldResult = getFieldForFilter({
-                    document,
-                    filter,
-                    context: {
-                        activeScheduledActionsByDocumentId,
-                        locale: data.locale ?? data.defaultLocales?.[contentSourceId],
-                        schema
-                    }
-                });
-
-                if ('result' in filterFieldResult) {
-                    return filterFieldResult.result;
-                }
-
-                const { field, model } = filterFieldResult;
-                return isFieldMatchesFilter({ field, filter, document, model, locale: data.locale ?? data.defaultLocales?.[contentSourceId] });
+        if (data.filter) {
+            const matches = isFilterMatches({
+                filter: data.filter,
+                document,
+                locale: data.locale ?? data.defaultLocales?.[contentSourceId],
+                schema,
+                activeScheduledActionsByDocumentId
             });
 
             if (!matches) {
@@ -95,8 +83,13 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
         return true;
     }
 
-    return _.some(document.fields, (field) => {
+    return areFieldsMatchingPattern(Object.values(document.fields), query, locale);
+};
+
+const areFieldsMatchingPattern = (fields: ContentStoreTypes.DocumentField[], query: string, locale?: string): boolean => {
+    return fields.some((field) => {
         let value;
+
         switch (field.type) {
             case 'string':
             case 'slug':
@@ -106,6 +99,27 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
             case 'html':
                 value = getDocumentFieldForLocale(field, locale)?.value;
                 break;
+
+            case 'list': {
+                const list = getDocumentFieldForLocale(field, locale);
+                const result = list ? areFieldsMatchingPattern(list.items, query, locale) : false;
+                if (result) {
+                    return result;
+                }
+                break;
+            }
+
+            case 'model':
+            case 'object': {
+                const object = getDocumentFieldForLocale(field, locale);
+                if (object && !object.isUnset) {
+                    const result = areFieldsMatchingPattern(Object.values(object.fields), query, locale);
+                    if (result) {
+                        return result;
+                    }
+                }
+                break;
+            }
         }
 
         if (value) {
@@ -116,6 +130,65 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
     });
 };
 
+const isFilterMatches = ({
+    filter,
+    document,
+    locale,
+    schema,
+    activeScheduledActionsByDocumentId
+}: {
+    filter: SearchFilterItemGrouped;
+    document: ContentStoreTypes.Document;
+    locale?: string;
+    schema: SearchSchema;
+    activeScheduledActionsByDocumentId: Record<string, ScheduledAction[]>;
+}): boolean => {
+    if (_.intersection(Object.keys(filter), ['and', 'or', 'field']).length > 1) {
+        throw new Error(`Unsupported filter - 'and', 'or' and 'field' are mutually exclusive.`);
+    }
+
+    if ('field' in filter) {
+        const filterFieldResult = getFieldForFilter({
+            document,
+            filter,
+            context: {
+                activeScheduledActionsByDocumentId,
+                locale,
+                schema
+            }
+        });
+
+        if ('result' in filterFieldResult) {
+            return filterFieldResult.result;
+        }
+
+        const { field, model } = filterFieldResult;
+        return isFieldMatchesFilter({ field, filter, document, model, locale });
+    } else {
+        if (!('and' in filter) && !('or' in filter)) {
+            throw new Error(`Unsupported filter - neither 'and' nor 'or' provided`);
+        }
+
+        const comparisonMethod = 'and' in filter ? 'every' : 'some';
+        const root = 'and' in filter ? filter.and : filter.or;
+
+        if (!root.length) {
+            // for empty search groups - match
+            return true;
+        }
+
+        return root[comparisonMethod]((childFilter) => {
+            return isFilterMatches({
+                filter: childFilter,
+                document,
+                locale,
+                schema,
+                activeScheduledActionsByDocumentId
+            });
+        });
+    }
+};
+
 const getFieldForFilter: MetaFieldMethod = ({ document, filter, context }) => {
     if (filter.isMeta) {
         const filterField = filter.field;

package/src/utils/site-map.ts

@@ -6,7 +6,6 @@ import * as CSITypes from '@stackbit/types';
 import * as ContentStoreTypes from '../types';
 import { mapStoreDocumentsToCSIDocumentsWithSource } from './store-to-csi-docs-converter';
 import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
-import { createConfigDelegate } from './config-delegate';
 
 export const SiteMapStaticEntriesKey = Symbol.for('SiteMapStaticEntriesKey');
 export type SiteMapEntriesSourceKeys = string | symbol;

package/src/utils/store-to-csi-docs-converter.ts

@@ -52,6 +52,7 @@ export function mapStoreDocumentToCSIDocumentWithSource({
         updatedBy: document.updatedBy,
         locale: document.locale,
         context: csiDocument.context,
+        hidden: document.hidden,
         fields: mapStoreFieldsToCSIFields(document.fields)
     };
 }

package/src/utils/tree-views.ts

@@ -70,3 +70,46 @@ export async function getSanitizedTreeViews({
 
     return mapTreeViews(treeViews);
 }
+
+export function removeHiddenTreeViews({
+    treeViews,
+    getDocumentForUser
+}: {
+    treeViews: CSITypes.TreeViewNode[];
+    getDocumentForUser: (opts: { srcDocumentId: string; srcType: string; srcProjectId: string }) => ContentStoreTypes.Document | undefined;
+}) {
+    const mapTreeViews = (treeViews: CSITypes.TreeViewNode[]): CSITypes.TreeViewNode[] => {
+        return treeViews.map((treeView) => {
+            let resultTreeView = treeView;
+
+            if ('document' in treeView && treeView.document) {
+                const document = getDocumentForUser({
+                    srcDocumentId: treeView.document.id,
+                    srcType: treeView.document.srcType,
+                    srcProjectId: treeView.document.srcProjectId
+                });
+
+                if (!document) {
+                    throw new Error(`Could not found a document with id ${treeView.document.id} when iterating tree views`);
+                }
+
+                if (document.hidden) {
+                    resultTreeView = _.omit(treeView, ['document']) as CSITypes.TreeViewBaseNode;
+                }
+            }
+
+            if ('children' in treeView && treeView.children) {
+                if (treeView.stableId && treeView.label) {
+                    resultTreeView = {
+                        ...resultTreeView,
+                        children: mapTreeViews(treeView.children)
+                    };
+                }
+            }
+
+            return resultTreeView;
+        });
+    };
+
+    return mapTreeViews(treeViews);
+}

package/dist/utils/custom-search-filters.d.ts

@@ -1,12 +0,0 @@
-import * as ContentStoreTypes from '../types';
-import { SearchFilterItem } from '../types';
-import { ScheduledAction } from '@stackbit/types';
-import { SchemaForSearch } from './search-utils';
-declare type CustomFilterMethod = (filter: SearchFilterItem, document: ContentStoreTypes.Document, opts: {
-    locale?: string;
-    schema: SchemaForSearch;
-    activeScheduledActionsByDocumentId: Record<string, ScheduledAction[]>;
-}) => boolean;
-export declare const CUSTOM_FILTERS: Record<string, CustomFilterMethod>;
-export {};
-//# sourceMappingURL=custom-search-filters.d.ts.map

package/dist/utils/custom-search-filters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-search-filters.d.ts","sourceRoot":"","sources":["../../src/utils/custom-search-filters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,iBAAiB,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAqB,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAAiE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEhH,aAAK,kBAAkB,GAAG,CACtB,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,EACpC,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,kCAAkC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAA;CAAE,KACxH,OAAO,CAAC;AAEb,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAwC7D,CAAC"}

package/dist/utils/custom-search-filters.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_FILTERS = void 0;
-const search_utils_1 = require("./search-utils");
-exports.CUSTOM_FILTERS = {
-    hasSchedules: (filter, document, opts) => {
-        var _a;
-        const field = {
-            type: 'boolean',
-            value: !!((_a = opts.activeScheduledActionsByDocumentId[document.srcObjectId]) === null || _a === void 0 ? void 0 : _a.length)
-        };
-        return (0, search_utils_1.isBooleanFieldMatches)({ field, filter, locale: opts.locale });
-    },
-    scheduledActionId: (filter, document, opts) => {
-        var _a, _b;
-        const field = {
-            type: 'list',
-            items: (_b = (_a = opts.activeScheduledActionsByDocumentId[document.srcObjectId]) === null || _a === void 0 ? void 0 : _a.map((scheduledAction) => ({
-                type: 'string',
-                value: scheduledAction.id
-            }))) !== null && _b !== void 0 ? _b : []
-        };
-        const model = {
-            type: 'object',
-            name: '',
-            fields: [
-                {
-                    name: '',
-                    type: 'list',
-                    items: {
-                        type: 'string'
-                    }
-                }
-            ]
-        };
-        return (0, search_utils_1.isListFieldMatches)({ field, filter, model, locale: opts.locale, document });
-    },
-    scheduledActionDate: (filter, document, opts) => {
-        var _a, _b;
-        return ((_b = (_a = opts.activeScheduledActionsByDocumentId[document.srcObjectId]) === null || _a === void 0 ? void 0 : _a.some((scheduledAction) => {
-            const field = { type: 'date', value: scheduledAction.executeAt };
-            return (0, search_utils_1.isDateFieldMatches)({ field, filter, locale: opts.locale });
-        })) !== null && _b !== void 0 ? _b : false);
-    }
-};
-//# sourceMappingURL=custom-search-filters.js.map

package/dist/utils/custom-search-filters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-search-filters.js","sourceRoot":"","sources":["../../src/utils/custom-search-filters.ts"],"names":[],"mappings":";;;AAIA,iDAAgH;AAQnG,QAAA,cAAc,GAAuC;IAC9D,YAAY,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;;QACrC,MAAM,KAAK,GAAG;YACV,IAAI,EAAE,SAAkB;YACxB,KAAK,EAAE,CAAC,CAAC,CAAA,MAAA,IAAI,CAAC,kCAAkC,CAAC,QAAQ,CAAC,WAAW,CAAC,0CAAE,MAAM,CAAA;SACjF,CAAC;QACF,OAAO,IAAA,oCAAqB,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IACzE,CAAC;IACD,iBAAiB,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;;QAC1C,MAAM,KAAK,GAAsB;YAC7B,IAAI,EAAE,MAAM;YACZ,KAAK,EACD,MAAA,MAAA,IAAI,CAAC,kCAAkC,CAAC,QAAQ,CAAC,WAAW,CAAC,0CAAE,GAAG,CAAC,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;gBACrF,IAAI,EAAE,QAAQ;gBACd,KAAK,EAAE,eAAe,CAAC,EAAE;aAC5B,CAAC,CAAC,mCAAI,EAAE;SAChB,CAAC;QACF,MAAM,KAAK,GAAU;YACjB,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,EAAE;YACR,MAAM,EAAE;gBACJ;oBACI,IAAI,EAAE,EAAE;oBACR,IAAI,EAAE,MAAM;oBACZ,KAAK,EAAE;wBACH,IAAI,EAAE,QAAQ;qBACjB;iBACJ;aACJ;SACJ,CAAC;QACF,OAAO,IAAA,iCAAkB,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvF,CAAC;IACD,mBAAmB,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;;QAC5C,OAAO,CACH,MAAA,MAAA,IAAI,CAAC,kCAAkC,CAAC,QAAQ,CAAC,WAAW,CAAC,0CAAE,IAAI,CAAC,CAAC,eAAe,EAAE,EAAE;YACpF,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,MAAe,EAAE,KAAK,EAAE,eAAe,CAAC,SAAS,EAAE,CAAC;YAC1E,OAAO,IAAA,iCAAkB,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACtE,CAAC,CAAC,mCAAI,KAAK,CACd,CAAC;IACN,CAAC;CACJ,CAAC"}