prostgles-server 4.0.57 → 4.0.59

package/lib/PublishParser.js

@@ -1,421 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PublishParser = void 0;
-const prostgles_types_1 = require("prostgles-types");
-const DboBuilder_1 = require("./DboBuilder");
-const Prostgles_1 = require("./Prostgles");
-const RULE_TO_METHODS = [
-    {
-        rule: "getColumns",
-        sqlRule: "select",
-        methods: prostgles_types_1.RULE_METHODS.getColumns,
-        no_limits: true,
-        allowed_params: [],
-        table_only: false,
-        hint: ` expecting false | true | undefined`
-    },
-    {
-        rule: "getInfo",
-        sqlRule: "select",
-        methods: prostgles_types_1.RULE_METHODS.getInfo,
-        no_limits: true,
-        allowed_params: [],
-        table_only: false,
-        hint: ` expecting false | true | undefined`
-    },
-    {
-        rule: "insert",
-        sqlRule: "insert",
-        methods: prostgles_types_1.RULE_METHODS.insert,
-        no_limits: { fields: "*" },
-        table_only: true,
-        allowed_params: ["fields", "forcedData", "returningFields", "validate", "preValidate", "postValidate"],
-        hint: ` expecting "*" | true | { fields: string | string[] | {}  }`
-    },
-    {
-        rule: "update",
-        sqlRule: "update",
-        methods: prostgles_types_1.RULE_METHODS.update,
-        no_limits: { fields: "*", filterFields: "*", returningFields: "*" },
-        table_only: true,
-        allowed_params: ["fields", "filterFields", "forcedFilter", "forcedData", "returningFields", "validate", "postValidate", "dynamicFields"],
-        hint: ` expecting "*" | true | { fields: string | string[] | {}  }`
-    },
-    {
-        rule: "select",
-        sqlRule: "select",
-        methods: prostgles_types_1.RULE_METHODS.select,
-        no_limits: { fields: "*", filterFields: "*" },
-        table_only: false,
-        allowed_params: ["fields", "filterFields", "forcedFilter", "validate", "maxLimit", "orderByFields"],
-        hint: ` expecting "*" | true | { fields: ( string | string[] | {} )  }`
-    },
-    {
-        rule: "delete",
-        sqlRule: "delete",
-        methods: prostgles_types_1.RULE_METHODS.delete,
-        no_limits: { filterFields: "*" },
-        table_only: true,
-        allowed_params: ["filterFields", "forcedFilter", "returningFields", "validate"],
-        hint: ` expecting "*" | true | { filterFields: ( string | string[] | {} ) } \n Will use "select", "update", "delete" and "insert" rules`
-    },
-    {
-        rule: "sync",
-        sqlRule: "select",
-        methods: prostgles_types_1.RULE_METHODS.sync,
-        no_limits: null,
-        table_only: true,
-        allowed_params: ["id_fields", "synced_field", "sync_type", "allow_delete", "throttle", "batch_size"],
-        hint: ` expecting "*" | true | { id_fields: string[], synced_field: string }`
-    },
-    {
-        rule: "subscribe",
-        sqlRule: "select",
-        methods: prostgles_types_1.RULE_METHODS.subscribe,
-        no_limits: { throttle: 0 },
-        table_only: false,
-        allowed_params: ["throttle", "throttleOpts"],
-        hint: ` expecting "*" | true | { throttle: number; throttleOpts?: { skipFirst?: boolean; } } \n Will use "select" rules`
-    }
-];
-const PubSubManager_1 = require("./PubSubManager/PubSubManager");
-class PublishParser {
-    publish;
-    publishMethods;
-    publishRawSQL;
-    dbo;
-    db;
-    prostgles;
-    constructor(publish, publishMethods, publishRawSQL, dbo, db, prostgles) {
-        this.publish = publish;
-        this.publishMethods = publishMethods;
-        this.publishRawSQL = publishRawSQL;
-        this.dbo = dbo;
-        this.db = db;
-        this.prostgles = prostgles;
-        if (!this.dbo || !this.publish)
-            throw "INTERNAL ERROR: dbo and/or publish missing";
-    }
-    async getPublishParams(localParams, clientInfo) {
-        if (!this.dbo)
-            throw "dbo missing";
-        return {
-            ...(clientInfo || await this.prostgles.authHandler?.getClientInfo(localParams)),
-            dbo: this.dbo,
-            db: this.db,
-            socket: localParams.socket,
-            tables: (this.prostgles.dboBuilder.tablesOrViews ?? []).map(({ name, columns }) => ({
-                name,
-                columns,
-                info: this.dbo[name].tableOrViewInfo
-            }))
-        };
-    }
-    async getAllowedMethods(socket, userData) {
-        const methods = {};
-        const publishParams = await this.getPublishParams({ socket }, userData);
-        const _methods = await applyParamsIfFunc(this.publishMethods, publishParams);
-        if (_methods && Object.keys(_methods).length) {
-            (0, prostgles_types_1.getKeys)(_methods).map(key => {
-                const isFuncLike = (maybeFunc) => (typeof maybeFunc === "function" || maybeFunc && typeof maybeFunc.then === "function");
-                const method = _methods[key];
-                if (method && (isFuncLike(method) || (0, prostgles_types_1.isObject)(method) && isFuncLike(method.run))) {
-                    methods[key] = _methods[key];
-                }
-                else {
-                    throw `invalid publishMethods item -> ${key} \n Expecting a function or promise`;
-                }
-            });
-        }
-        return methods;
-    }
-    /**
-     * Parses the first level of publish. (If false then nothing if * then all tables and views)
-     * @param socket
-     * @param user
-     */
-    async getPublish(localParams, clientInfo) {
-        const publishParams = await this.getPublishParams(localParams, clientInfo);
-        const _publish = await applyParamsIfFunc(this.publish, publishParams);
-        if (_publish === "*") {
-            const publish = {};
-            this.prostgles.dboBuilder.tablesOrViews?.map(tov => {
-                publish[tov.name] = "*";
-            });
-            return publish;
-        }
-        return _publish;
-    }
-    async getValidatedRequestRuleWusr({ tableName, command, localParams }) {
-        const clientInfo = await this.prostgles.authHandler.getClientInfo(localParams);
-        return await this.getValidatedRequestRule({ tableName, command, localParams }, clientInfo);
-    }
-    async getValidatedRequestRule({ tableName, command, localParams }, clientInfo) {
-        if (!this.dbo)
-            throw "INTERNAL ERROR: dbo is missing";
-        if (!command || !tableName)
-            throw "command OR tableName are missing";
-        //@ts-ignore
-        const rtm = RULE_TO_METHODS.find(rtms => rtms.methods.includes(command));
-        if (!rtm) {
-            throw "Invalid command: " + command;
-        }
-        /* Must be local request -> allow everything */
-        if (!localParams || (!localParams.socket && !localParams.httpReq)) {
-            return RULE_TO_METHODS.reduce((a, v) => ({
-                ...a,
-                [v.rule]: v.no_limits
-            }), {});
-        }
-        /* Must be from socket. Must have a publish */
-        if (!this.publish)
-            throw "publish is missing";
-        /* Get any publish errors for socket */
-        const schm = localParams?.socket?.prostgles?.schema?.[tableName]?.[command];
-        if (schm && schm.err)
-            throw schm.err;
-        const table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
-        if (!table_rule)
-            throw { stack: ["getValidatedRequestRule()"], message: "Invalid or disallowed table: " + tableName };
-        if (command === "upsert") {
-            if (!table_rule.update || !table_rule.insert) {
-                throw { stack: ["getValidatedRequestRule()"], message: `Invalid or disallowed command: upsert` };
-            }
-        }
-        if (rtm && table_rule && table_rule[rtm.rule]) {
-            return table_rule;
-        }
-        else
-            throw { stack: ["getValidatedRequestRule()"], message: `Invalid or disallowed command: ${tableName}.${command}` };
-    }
-    async getTableRules({ tableName, localParams }, clientInfo) {
-        if (!localParams || !tableName)
-            throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
-        const _publish = await this.getPublish(localParams, clientInfo);
-        const raw_table_rules = _publish[tableName];
-        if (!raw_table_rules || (0, prostgles_types_1.isObject)(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
-            return undefined;
-        }
-        let parsed_table = {};
-        /* Get view or table specific rules */
-        const tHandler = this.dbo[tableName];
-        const is_view = tHandler.is_view;
-        const canSubscribe = (!is_view || tHandler.columns.some(c => c.references));
-        if (!tHandler) {
-            throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
-        }
-        //@ts-ignore
-        const MY_RULES = RULE_TO_METHODS.filter(r => {
-            /** Check PG User privileges */
-            const pgUserIsAllowedThis = tHandler.tableOrViewInfo.privileges[r.sqlRule];
-            let result = (!is_view || !r.table_only) && pgUserIsAllowedThis;
-            if (!pgUserIsAllowedThis && (0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.sqlRule]) {
-                throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
-            }
-            if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
-                result = false;
-                if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && raw_table_rules[r.rule]) {
-                    throw `Cannot publish realtime rule ${tableName}.${r.rule}. Superuser is required for this`;
-                }
-            }
-            if (r.rule === "subscribe" && !canSubscribe) {
-                result = false;
-            }
-            return result;
-        });
-        /* All methods allowed. Add no limits for table rules */
-        if ([true, "*"].includes(raw_table_rules)) {
-            parsed_table = {};
-            MY_RULES.filter(r => r.no_limits).forEach(r => {
-                parsed_table[r.rule] = { ...r.no_limits };
-            });
-            /** Specific rules allowed */
-        }
-        else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules) && (0, prostgles_types_1.getKeys)(raw_table_rules).length) {
-            const allRuleKeys = (0, prostgles_types_1.getKeys)(raw_table_rules);
-            const dissallowedRuleKeys = allRuleKeys.filter(m => !raw_table_rules[m]);
-            MY_RULES.map(r => {
-                /** Unless specifically disabled these are allowed */
-                if (["getInfo", "getColumns"].includes(r.rule) && !dissallowedRuleKeys.includes(r.rule)) {
-                    parsed_table[r.rule] = r.no_limits;
-                    return;
-                }
-                /** Add no_limit values for implied/ fully allowed methods */
-                if ([true, "*"].includes(raw_table_rules[r.rule]) && r.no_limits) {
-                    parsed_table[r.rule] = Object.assign({}, r.no_limits);
-                    /** Carry over detailed config */
-                }
-                else if ((0, DboBuilder_1.isPlainObject)(raw_table_rules[r.rule])) {
-                    parsed_table[r.rule] = raw_table_rules[r.rule];
-                }
-            });
-            allRuleKeys.filter(m => parsed_table[m])
-                .forEach((method) => {
-                const rule = parsed_table[method];
-                const rm = MY_RULES.find(r => r.rule === method || r.methods.includes(method));
-                if (!rm) {
-                    let extraInfo = "";
-                    if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || r.methods.includes(method))) {
-                        extraInfo = "You've specified table rules to a view\n";
-                    }
-                    throw `Invalid rule in publish.${tableName} -> ${method} \n${extraInfo}Expecting any of: ${MY_RULES.flatMap(r => [r.rule, ...r.methods]).join(", ")}`;
-                }
-                /* Check RULES for invalid params */
-                /* Methods do not have params -> They use them from rules */
-                if (method === rm.rule && (0, prostgles_types_1.isObject)(rule)) {
-                    const method_params = (0, prostgles_types_1.getKeys)(rule);
-                    const iparam = method_params.find(p => !rm?.allowed_params.includes(p));
-                    if (iparam) {
-                        throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${rm.allowed_params.join(", ")}`;
-                    }
-                }
-                /* Add default params (if missing) */
-                if (method === "sync") {
-                    if ([true, "*"].includes(parsed_table[method])) {
-                        throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
-                    }
-                    if (typeof parsed_table[method]?.throttle !== "number") {
-                        parsed_table[method].throttle = 100;
-                    }
-                    if (typeof parsed_table[method]?.batch_size !== "number") {
-                        parsed_table[method].batch_size = PubSubManager_1.DEFAULT_SYNC_BATCH_SIZE;
-                    }
-                }
-                /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
-                const subKey = "subscribe";
-                if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
-                    const sr = MY_RULES.find(r => r.rule === subKey);
-                    if (sr && canSubscribe) {
-                        parsed_table[subKey] = { ...sr.no_limits };
-                        parsed_table.subscribeOne = { ...sr.no_limits };
-                    }
-                }
-            });
-        }
-        else {
-            throw "Unexpected publish";
-        }
-        const getImpliedMethods = (tableRules) => {
-            const res = { ...tableRules };
-            /* Add implied methods if not specifically dissallowed */
-            MY_RULES.map(r => {
-                /** THIS IS A MESS -> some methods cannot be dissallowed (unsync, unsubscribe...) */
-                r.methods.forEach(method => {
-                    const isAllowed = tableRules[r.rule] && tableRules[method] === undefined;
-                    if (isAllowed) {
-                        if (method === "updateBatch" && !tableRules.update) {
-                            // not allowed
-                        }
-                        else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
-                            // not allowed
-                        }
-                        else {
-                            res[method] ??= true;
-                        }
-                    }
-                });
-            });
-            return res;
-        };
-        parsed_table = getImpliedMethods(parsed_table);
-        return parsed_table;
-    }
-    /* Prepares schema for client. Only allowed views and commands will be present */
-    async getSchemaFromPublish(socket, userData) {
-        const schema = {};
-        const tables = [];
-        try {
-            /* Publish tables and views based on socket */
-            const clientInfo = userData ?? await this.prostgles.authHandler?.getClientInfo({ socket });
-            let _publish;
-            try {
-                _publish = await this.getPublish(socket, clientInfo);
-            }
-            catch (err) {
-                console.error("Error within then Publish function ", err);
-                throw err;
-            }
-            if (_publish && Object.keys(_publish).length) {
-                let txKey = "tx";
-                if (!this.prostgles.opts.transactions)
-                    txKey = "";
-                if (typeof this.prostgles.opts.transactions === "string")
-                    txKey = this.prostgles.opts.transactions;
-                const tableNames = Object.keys(_publish).filter(k => !txKey || txKey !== k);
-                await Promise.all(tableNames
-                    .map(async (tableName) => {
-                    if (!this.dbo[tableName]) {
-                        throw `Table ${tableName} does not exist
-                          Expecting one of: ${this.prostgles.dboBuilder.tablesOrViews?.map(tov => tov.name).join(", ")}
-                          DBO tables: ${Object.keys(this.dbo).filter(k => this.dbo[k].find).join(", ")}
-                          `;
-                    }
-                    const table_rules = await this.getTableRules({ localParams: { socket }, tableName }, clientInfo);
-                    if (table_rules && Object.keys(table_rules).length) {
-                        schema[tableName] = {};
-                        const tableSchema = schema[tableName];
-                        let methods = [];
-                        let tableInfo;
-                        let tableColumns;
-                        if (typeof table_rules === "object") {
-                            methods = (0, prostgles_types_1.getKeys)(table_rules);
-                        }
-                        await Promise.all(methods.filter(m => m !== "select").map(async (method) => {
-                            if (method === "sync" && table_rules[method]) {
-                                /* Pass sync info */
-                                tableSchema[method] = table_rules[method];
-                            }
-                            else if (table_rules[method]) {
-                                tableSchema[method] = {};
-                                /* Test for issues with the common table CRUD methods () */
-                                if (Prostgles_1.TABLE_METHODS.includes(method)) {
-                                    let err = null;
-                                    try {
-                                        const valid_table_command_rules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
-                                        await this.dbo[tableName][method]({}, {}, {}, valid_table_command_rules, { socket, isRemoteRequest: true, testRule: true });
-                                    }
-                                    catch (e) {
-                                        err = "INTERNAL PUBLISH ERROR";
-                                        tableSchema[method] = { err };
-                                        throw `publish.${tableName}.${method}: \n   -> ${e}`;
-                                    }
-                                }
-                                if (method === "getInfo" || method === "getColumns") {
-                                    const tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
-                                    const res = await this.dbo[tableName][method](undefined, undefined, undefined, tableRules, { socket, isRemoteRequest: true });
-                                    if (method === "getInfo") {
-                                        tableInfo = res;
-                                    }
-                                    else if (method === "getColumns") {
-                                        tableColumns = res;
-                                    }
-                                }
-                            }
-                        }));
-                        if (tableInfo && tableColumns) {
-                            tables.push({
-                                name: tableName,
-                                info: tableInfo,
-                                columns: tableColumns
-                            });
-                        }
-                    }
-                    return true;
-                }));
-            }
-        }
-        catch (e) {
-            console.error("Prostgles \nERRORS IN PUBLISH: ", JSON.stringify(e));
-            throw e;
-        }
-        return { schema, tables };
-    }
-}
-exports.PublishParser = PublishParser;
-function applyParamsIfFunc(maybeFunc, ...params) {
-    if ((maybeFunc !== null && maybeFunc !== undefined) &&
-        (typeof maybeFunc === "function" || typeof maybeFunc.then === "function")) {
-        return maybeFunc(...params);
-    }
-    return maybeFunc;
-}

package/lib/SchemaWatch.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import { DboBuilder } from "./DboBuilder";
-import { ProstglesInitOptions } from "./Prostgles";
-export type VoidFunction = () => void;
-export declare class SchemaWatch {
-    schema_checkIntervalMillis?: NodeJS.Timeout;
-    loaded: boolean;
-    constructor({ watchSchema, watchSchemaType, tsGeneratedTypesDir, currDbuilder, onSchemaChanged }: ProstglesInitOptions & {
-        currDbuilder: DboBuilder;
-        onSchemaChanged: VoidFunction;
-    });
-}
-//# sourceMappingURL=SchemaWatch.d.ts.map

package/lib/SchemaWatch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaWatch.d.ts","sourceRoot":"","sources":["SchemaWatch.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC,qBAAa,WAAW;IACtB,0BAA0B,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAC5C,MAAM,UAAS;gBAEH,EAAE,WAAW,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,oBAAoB,GAAG;QAAE,YAAY,EAAE,UAAU,CAAC;QAAC,eAAe,EAAE,YAAY,CAAA;KAAE;CA8BrL"}

package/lib/SchemaWatch.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaWatch = void 0;
-const prostgles_types_1 = require("prostgles-types");
-const DboBuilder_1 = require("./DboBuilder");
-class SchemaWatch {
-    schema_checkIntervalMillis;
-    loaded = false;
-    constructor({ watchSchema, watchSchemaType, tsGeneratedTypesDir, currDbuilder, onSchemaChanged }) {
-        if (!watchSchema)
-            return;
-        if (watchSchema === "hotReloadMode" && !tsGeneratedTypesDir) {
-            throw "tsGeneratedTypesDir option is needed for watchSchema: hotReloadMode to work ";
-        }
-        else if ((0, prostgles_types_1.isObject)(watchSchemaType) &&
-            "checkIntervalMillis" in watchSchemaType &&
-            typeof watchSchemaType.checkIntervalMillis === "number") {
-            if (this.schema_checkIntervalMillis) {
-                clearInterval(this.schema_checkIntervalMillis);
-            }
-            this.schema_checkIntervalMillis = setInterval(async () => {
-                if (!this.loaded)
-                    return;
-                const dbuilder = await DboBuilder_1.DboBuilder.create(this);
-                if (dbuilder.tsTypesDefinition !== currDbuilder.tsTypesDefinition) {
-                    onSchemaChanged();
-                }
-            }, watchSchemaType.checkIntervalMillis);
-        }
-        else if (watchSchemaType === "DDL_trigger") {
-            /** Do nothing */
-        }
-    }
-}
-exports.SchemaWatch = SchemaWatch;

package/lib/SyncReplication.d.ts

@@ -1,34 +0,0 @@
-import { PubSubManager, SyncParams } from "./PubSubManager/PubSubManager";
-import { AnyObject } from "prostgles-types";
-export type ClientSyncInfo = Partial<{
-    c_fr: AnyObject;
-    c_lr: AnyObject;
-    /**
-     * PG count is ussually string due to bigint
-     */
-    c_count: number | string;
-}>;
-export type ServerSyncInfo = Partial<{
-    s_fr: AnyObject;
-    s_lr: AnyObject;
-    /**
-     * PG count is ussually string due to bigint
-     */
-    s_count: number | string;
-}>;
-export type SyncBatchInfo = Partial<{
-    from_synced: number | null;
-    to_synced: number | null;
-    end_offset: number | null;
-}>;
-export type onSyncRequestResponse = {
-    onSyncRequest?: ClientSyncInfo;
-} | {
-    err: AnyObject | string;
-};
-export type ClientExpressData = ClientSyncInfo & {
-    data?: AnyObject[];
-    deleted?: AnyObject[];
-};
-export declare const syncData: (_this: PubSubManager, sync: SyncParams, clientData: ClientExpressData | undefined, source: "trigger" | "client") => Promise<void>;
-//# sourceMappingURL=SyncReplication.d.ts.map

package/lib/SyncReplication.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyncReplication.d.ts","sourceRoot":"","sources":["SyncReplication.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,EAA2B,MAAM,+BAA+B,CAAC;AACnG,OAAO,EAAgB,SAAS,EAAmB,MAAM,iBAAiB,CAAC;AAG3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B,CAAC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B,CAAC,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC;IAClC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,cAAc,CAAA;CAC/B,GAAG;IACF,GAAG,EAAE,SAAS,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG;IAC/C,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACvB,CAAA;AAMD,eAAO,MAAM,QAAQ,UAAiB,aAAa,QAAQ,UAAU,cAAc,iBAAiB,GAAG,SAAS,UAAU,SAAS,GAAG,QAAQ,kBA0d7I,CAAA"}