@recombine-ai/platform 0.4.0 → 0.5.0-test.0

package/build/analytics/postgres-analytics-query.js

@@ -0,0 +1,504 @@
+import { Pool } from 'pg';
+export class AnalyticsQueryError extends Error {
+    name = 'AnalyticsQueryError';
+}
+export class AnalyticsFieldNotFoundError extends Error {
+    agentId;
+    field;
+    name = 'AnalyticsFieldNotFoundError';
+    constructor(agentId, field) {
+        super(`Analytics field '${field}' does not exist for agent '${agentId}'`);
+        this.agentId = agentId;
+        this.field = field;
+    }
+}
+export class PostgresAnalyticsQueryService {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    async getConversation(conversationId) {
+        const result = await this.database.query(`SELECT c.conversation_id, c.agent_id, c.channel, c.region, c.started_at,
+                    c.ended_at, c.analytics,
+                    p.phone_number, p.recording_url, p.duration_seconds
+             FROM conversations c
+             LEFT JOIN phone_calls p ON p.conversation_id = c.conversation_id
+             WHERE c.conversation_id = $1`, [conversationId]);
+        const row = result.rows[0];
+        return row?.agent_id ? conversationRowToJson(row) : undefined;
+    }
+    async getConversations(query) {
+        const parsedLimit = Number.parseInt(optionalString(query.limit, 'limit') ?? '10', 10);
+        const requestedLimit = Number.isFinite(parsedLimit)
+            ? Math.min(100, Math.max(1, parsedLimit))
+            : 10;
+        const cursor = parseConversationCursor(optionalString(query.lastConversationId, 'lastConversationId'));
+        const filters = parseAnalyticsFilterQuery(query.filters);
+        const { bind, conditions, values } = buildConversationConditions(query, filters, filters.length > 0);
+        if (cursor) {
+            conditions.push(`(c.started_at, c.conversation_id) < (${bind(cursor.startedAt)}, ${bind(cursor.conversationId)})`);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limitParameter = bind(requestedLimit + 1);
+        const result = await this.database.query(`SELECT c.conversation_id, c.agent_id, c.channel, c.region, c.started_at,
+                    c.ended_at, c.analytics,
+                    p.phone_number, p.recording_url, p.duration_seconds
+             FROM conversations c
+             LEFT JOIN phone_calls p ON p.conversation_id = c.conversation_id
+             ${where}
+             ORDER BY c.started_at DESC, c.conversation_id DESC
+             LIMIT ${limitParameter}`, values);
+        const hasNextPage = result.rows.length > requestedLimit;
+        const rows = result.rows.slice(0, requestedLimit);
+        return {
+            limit: requestedLimit,
+            items: rows.map(conversationRowToJson),
+            lastConversationId: hasNextPage && rows.length > 0 ? makeConversationCursor(rows.at(-1)) : undefined,
+        };
+    }
+    async getAnalyticsFields(query) {
+        const agentId = requiredString(query.agentId, 'agentId');
+        const result = await this.database.query(`SELECT entry.key AS field,
+                    MIN(jsonb_typeof(entry.value)) AS type,
+                    COUNT(DISTINCT entry.value)::bigint AS distinct_value_count,
+                    COUNT(DISTINCT jsonb_typeof(entry.value))::integer AS type_count
+             FROM conversations c
+             CROSS JOIN LATERAL jsonb_each(c.analytics) AS entry(key, value)
+             WHERE c.agent_id = $1
+               AND jsonb_typeof(entry.value) IN ('boolean', 'number', 'string')
+             GROUP BY entry.key
+             ORDER BY field ASC`, [agentId]);
+        return {
+            items: result.rows.map((row) => {
+                if (Number(row.type_count) !== 1) {
+                    throw new AnalyticsQueryError(`Analytics field '${row.field}' has inconsistent stored types`);
+                }
+                return {
+                    field: row.field,
+                    type: row.type,
+                    distinctValueCount: Number(row.distinct_value_count),
+                };
+            }),
+        };
+    }
+    async getAnalyticsFieldValues(field, query) {
+        const validatedField = validateFieldName(field, 'Field');
+        const agentId = requiredString(query.agentId, 'agentId');
+        const limit = parsePageLimit(query.limit);
+        const cursor = parseAnalyticsFieldValueCursor(optionalString(query.cursor, 'cursor'));
+        const values = [agentId, validatedField];
+        const bind = (value) => {
+            values.push(value);
+            return `$${values.length}`;
+        };
+        let cursorCondition = '';
+        if (cursor) {
+            const count = bind(cursor.count);
+            const value = bind(JSON.stringify(cursor.value));
+            cursorCondition =
+                `WHERE occurrence_count < ${count}::bigint OR ` +
+                    `(occurrence_count = ${count}::bigint AND value > ${value}::jsonb)`;
+        }
+        const pageLimit = bind(limit + 1);
+        const result = await this.database.query(`WITH value_counts AS (
+                 SELECT entry.value AS value,
+                        COUNT(*)::bigint AS occurrence_count
+                 FROM conversations c
+                 CROSS JOIN LATERAL jsonb_each(c.analytics) AS entry(key, value)
+                 WHERE c.agent_id = $1
+                   AND entry.key = $2
+                   AND jsonb_typeof(entry.value) IN ('boolean', 'number', 'string')
+                 GROUP BY entry.value
+             ),
+             page AS (
+                 SELECT value, occurrence_count
+                 FROM value_counts
+                 ${cursorCondition}
+                 ORDER BY occurrence_count DESC, value ASC
+                 LIMIT ${pageLimit}
+             )
+             SELECT page.value,
+                    page.occurrence_count,
+                    EXISTS (SELECT 1 FROM value_counts) AS field_exists
+             FROM (SELECT TRUE) AS seed
+             LEFT JOIN page ON TRUE
+             ORDER BY page.occurrence_count DESC, page.value ASC`, values);
+        if (!result.rows[0]?.field_exists) {
+            throw new AnalyticsFieldNotFoundError(agentId, validatedField);
+        }
+        const rows = result.rows.filter((row) => row.value !== null && row.occurrence_count !== null);
+        const hasNextPage = rows.length > limit;
+        const page = rows.slice(0, limit);
+        return {
+            items: page.map((row) => ({
+                value: row.value,
+                count: Number(row.occurrence_count),
+            })),
+            nextCursor: hasNextPage && page.length > 0 ? makeAnalyticsFieldValueCursor(page.at(-1)) : null,
+        };
+    }
+    async getTimeSeries(request) {
+        const query = validateRequestObject(request);
+        const metric = parseMetric(query.metric);
+        const granularity = requiredString(query.granularity, 'granularity');
+        if (!['hour', 'day', 'week', 'month'].includes(granularity)) {
+            throw new AnalyticsQueryError('granularity must be hour, day, week, or month');
+        }
+        const filters = validateAnalyticsFilters(query.filters);
+        if (metric.operation === 'average' || metric.operation === 'sum') {
+            await this.assertNumericAnalyticsField(requiredString(query.agentId, 'agentId'), metric.field);
+        }
+        const { bind, conditions, from, to, values } = buildConversationConditions(query, filters);
+        if (!from || !to) {
+            throw new AnalyticsQueryError('from and to are required for a time series');
+        }
+        const bucketExpression = `date_trunc(${bind(granularity)}::text, c.started_at, 'UTC')`;
+        let valueExpression;
+        let numeratorExpression = 'NULL::bigint';
+        if (metric.operation === 'count') {
+            valueExpression = 'COUNT(*)::double precision';
+        }
+        else if (metric.operation === 'rate') {
+            const predicate = makeAnalyticsPredicate(metric.filter, bind);
+            numeratorExpression = `COUNT(*) FILTER (WHERE ${predicate})::bigint`;
+            valueExpression =
+                `COUNT(*) FILTER (WHERE ${predicate})::double precision / ` + 'NULLIF(COUNT(*), 0)';
+        }
+        else {
+            const field = bind(metric.field);
+            const numericValue = `CASE WHEN jsonb_typeof(c.analytics -> (${field}::text)) = 'number' ` +
+                `THEN (c.analytics ->> (${field}::text))::double precision END`;
+            valueExpression =
+                metric.operation === 'average' ? `AVG(${numericValue})` : `SUM(${numericValue})`;
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const result = await this.database.query(`SELECT ${bucketExpression} AS bucket_start,
+                    ${valueExpression} AS metric_value,
+                    ${numeratorExpression} AS numerator,
+                    COUNT(*)::bigint AS denominator
+             FROM conversations c
+             LEFT JOIN phone_calls p ON p.conversation_id = c.conversation_id
+             ${where}
+             GROUP BY bucket_start
+             ORDER BY bucket_start ASC`, values);
+        return {
+            metric,
+            granularity,
+            from: from.toISOString(),
+            to: to.toISOString(),
+            items: result.rows.map((row) => ({
+                startAt: new Date(row.bucket_start).toISOString(),
+                value: row.metric_value === null ? null : Number(row.metric_value),
+                ...(metric.operation === 'rate'
+                    ? {
+                        numerator: Number(row.numerator),
+                        denominator: Number(row.denominator),
+                    }
+                    : {}),
+            })),
+        };
+    }
+    async assertNumericAnalyticsField(agentId, field) {
+        const result = await this.database.query(`SELECT ARRAY_AGG(DISTINCT jsonb_typeof(c.analytics -> $2::text)) AS types
+             FROM conversations c
+             WHERE c.agent_id = $1
+               AND c.analytics ? ($2::text)`, [agentId, field]);
+        const types = result.rows[0]?.types ?? [];
+        if (types.length !== 1 || types[0] !== 'number') {
+            throw new AnalyticsQueryError(`Metric field '${field}' must be numeric`);
+        }
+    }
+}
+export function createPostgresAnalyticsQueryServices(config) {
+    const pool = new Pool(config);
+    return {
+        queries: new PostgresAnalyticsQueryService(pool),
+        close: () => pool.end(),
+    };
+}
+function optionalString(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string') {
+        throw new AnalyticsQueryError(`${name} must be a string`);
+    }
+    return value;
+}
+function requiredString(value, name) {
+    const result = optionalString(value, name);
+    if (!result || result.trim() === '') {
+        throw new AnalyticsQueryError(`${name} is required`);
+    }
+    return result;
+}
+function validateRequestObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new AnalyticsQueryError('request must be an object');
+    }
+    return value;
+}
+function parseDateFilter(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        throw new AnalyticsQueryError(`${name} must be a string or number`);
+    }
+    const date = typeof value === 'number' || /^\d+$/.test(value) ? new Date(Number(value)) : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new AnalyticsQueryError(`${name} must be a valid date`);
+    }
+    return date;
+}
+function parseDurationFilter(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        throw new AnalyticsQueryError(`${name} must be a number`);
+    }
+    const duration = Number(value);
+    if (!Number.isFinite(duration) || duration < 0) {
+        throw new AnalyticsQueryError(`${name} must be a non-negative number`);
+    }
+    return duration;
+}
+function parseAnalyticsFilterQuery(value) {
+    const stringValue = optionalString(value, 'filters');
+    if (!stringValue)
+        return [];
+    let filters;
+    try {
+        filters = JSON.parse(stringValue);
+    }
+    catch {
+        throw new AnalyticsQueryError('filters must be valid JSON');
+    }
+    return validateAnalyticsFilters(filters);
+}
+function validateAnalyticsFilters(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        throw new AnalyticsQueryError('filters must be an array');
+    }
+    return value.map(validateAnalyticsFilter);
+}
+function validateAnalyticsFilter(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new AnalyticsQueryError('Each filter must be an object');
+    }
+    const filter = value;
+    const field = validateFieldName(filter.field, 'Filter field');
+    if (!['eq', 'exists', 'gt', 'gte', 'in', 'lt', 'lte'].includes(String(filter.operator))) {
+        throw new AnalyticsQueryError(`Filter '${field}' has an invalid operator`);
+    }
+    const operator = filter.operator;
+    if (operator === 'exists') {
+        return { field, operator };
+    }
+    if (operator === 'in') {
+        if (!Array.isArray(filter.values) || filter.values.length === 0) {
+            throw new AnalyticsQueryError(`Filter '${field}' has invalid values`);
+        }
+        const values = filter.values.map((item) => validateAnalyticsScalar(item, field));
+        const type = typeof values[0];
+        if (values.some((item) => typeof item !== type)) {
+            throw new AnalyticsQueryError(`Filter '${field}' has invalid values`);
+        }
+        return { field, operator, values };
+    }
+    if (operator === 'eq') {
+        return { field, operator, value: validateAnalyticsScalar(filter.value, field) };
+    }
+    if (typeof filter.value !== 'number' || !Number.isFinite(filter.value)) {
+        throw new AnalyticsQueryError(`Filter '${field}' has an invalid value`);
+    }
+    return { field, operator, value: filter.value };
+}
+function validateAnalyticsScalar(value, field) {
+    if (typeof value !== 'boolean' &&
+        typeof value !== 'string' &&
+        (typeof value !== 'number' || !Number.isFinite(value))) {
+        throw new AnalyticsQueryError(`Filter '${field}' has an invalid value`);
+    }
+    return value;
+}
+function validateFieldName(value, name) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value)) {
+        throw new AnalyticsQueryError(`${name} is invalid`);
+    }
+    return value;
+}
+function parseMetric(metric) {
+    if (!metric || typeof metric !== 'object' || Array.isArray(metric)) {
+        throw new AnalyticsQueryError('metric must be an object');
+    }
+    const record = metric;
+    if (!['count', 'rate', 'average', 'sum'].includes(String(record.operation))) {
+        throw new AnalyticsQueryError('metric operation is invalid');
+    }
+    if (record.operation === 'rate') {
+        return { operation: 'rate', filter: validateAnalyticsFilter(record.filter) };
+    }
+    if (record.operation === 'average' || record.operation === 'sum') {
+        return {
+            operation: record.operation,
+            field: validateFieldName(record.field, 'Metric field'),
+        };
+    }
+    return { operation: 'count' };
+}
+function parseConversationCursor(value) {
+    if (!value)
+        return undefined;
+    try {
+        const cursor = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        const startedAt = new Date(String(cursor.startedAt));
+        if (Number.isNaN(startedAt.getTime()) ||
+            typeof cursor.conversationId !== 'string' ||
+            cursor.conversationId === '') {
+            throw new Error('invalid cursor');
+        }
+        return { startedAt, conversationId: cursor.conversationId };
+    }
+    catch {
+        throw new AnalyticsQueryError('lastConversationId is invalid');
+    }
+}
+function makeConversationCursor(row) {
+    return Buffer.from(JSON.stringify({
+        startedAt: new Date(row.started_at).toISOString(),
+        conversationId: row.conversation_id,
+    })).toString('base64url');
+}
+function parsePageLimit(value) {
+    const stringValue = optionalString(value, 'limit');
+    if (stringValue === undefined)
+        return 50;
+    if (!/^\d+$/.test(stringValue)) {
+        throw new AnalyticsQueryError('limit must be an integer from 1 to 100');
+    }
+    const limit = Number(stringValue);
+    if (limit < 1 || limit > 100) {
+        throw new AnalyticsQueryError('limit must be an integer from 1 to 100');
+    }
+    return limit;
+}
+function parseAnalyticsFieldValueCursor(value) {
+    if (!value)
+        return undefined;
+    try {
+        const cursor = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (!Number.isSafeInteger(cursor.count) || Number(cursor.count) < 1) {
+            throw new Error('invalid cursor');
+        }
+        return {
+            count: Number(cursor.count),
+            value: validateCursorScalar(cursor.value),
+        };
+    }
+    catch {
+        throw new AnalyticsQueryError('cursor is invalid');
+    }
+}
+function validateCursorScalar(value) {
+    if (typeof value !== 'boolean' &&
+        typeof value !== 'string' &&
+        (typeof value !== 'number' || !Number.isFinite(value))) {
+        throw new Error('invalid cursor');
+    }
+    return value;
+}
+function makeAnalyticsFieldValueCursor(row) {
+    return Buffer.from(JSON.stringify({
+        count: Number(row.occurrence_count),
+        value: row.value,
+    })).toString('base64url');
+}
+function conversationRowToJson(row) {
+    return {
+        conversationId: row.conversation_id,
+        medium: row.channel,
+        agentId: row.agent_id,
+        region: row.region || undefined,
+        phoneNumber: row.phone_number || undefined,
+        duration: row.duration_seconds ?? undefined,
+        audioUrl: row.recording_url || undefined,
+        createdAt: new Date(row.started_at).getTime(),
+        endedAt: row.ended_at ? new Date(row.ended_at).getTime() : undefined,
+        analytics: analyticsScalars(row.analytics),
+    };
+}
+function analyticsScalars(values) {
+    return Object.fromEntries(Object.entries(values ?? {}).filter((entry) => {
+        const value = entry[1];
+        return (typeof value === 'boolean' ||
+            typeof value === 'string' ||
+            (typeof value === 'number' && Number.isFinite(value)));
+    }));
+}
+function buildConversationConditions(query, filters = parseAnalyticsFilterQuery(query.filters), requireAgentId = true) {
+    const values = [];
+    const bind = (value) => {
+        values.push(value);
+        return `$${values.length}`;
+    };
+    const conditions = [];
+    const from = parseDateFilter(query.from, 'from');
+    const to = parseDateFilter(query.to, 'to');
+    if (from && to && from >= to) {
+        throw new AnalyticsQueryError('from must be earlier than to');
+    }
+    const agentId = optionalString(query.agentId, 'agentId');
+    if (requireAgentId && (!agentId || agentId.trim() === '')) {
+        throw new AnalyticsQueryError('agentId is required');
+    }
+    if (agentId !== undefined && agentId.trim() === '') {
+        throw new AnalyticsQueryError('agentId is required');
+    }
+    const region = optionalString(query.region, 'region');
+    const channel = optionalString(query.channel, 'channel');
+    const phoneNumber = optionalString(query.phoneNumber, 'phoneNumber');
+    if (agentId)
+        conditions.push(`c.agent_id = ${bind(agentId)}`);
+    if (region)
+        conditions.push(`c.region = ${bind(region)}`);
+    if (channel)
+        conditions.push(`c.channel = ${bind(channel)}`);
+    if (phoneNumber)
+        conditions.push(`p.phone_number = ${bind(phoneNumber)}`);
+    if (from)
+        conditions.push(`c.started_at >= ${bind(from)}`);
+    if (to)
+        conditions.push(`c.started_at < ${bind(to)}`);
+    const minDuration = parseDurationFilter(query.minDurationSeconds, 'minDurationSeconds');
+    const maxDuration = parseDurationFilter(query.maxDurationSeconds, 'maxDurationSeconds');
+    if (minDuration !== undefined)
+        conditions.push(`p.duration_seconds >= ${bind(minDuration)}`);
+    if (maxDuration !== undefined)
+        conditions.push(`p.duration_seconds <= ${bind(maxDuration)}`);
+    if (minDuration !== undefined && maxDuration !== undefined && minDuration > maxDuration) {
+        throw new AnalyticsQueryError('minDurationSeconds must not exceed maxDurationSeconds');
+    }
+    for (const filter of filters) {
+        conditions.push(makeAnalyticsPredicate(filter, bind));
+    }
+    return { bind, conditions, from, to, values };
+}
+function makeAnalyticsPredicate(filter, bind) {
+    const field = bind(filter.field);
+    if (filter.operator === 'exists') {
+        return `c.analytics ? (${field}::text)`;
+    }
+    if (filter.operator === 'eq') {
+        return `c.analytics @> jsonb_build_object(${field}::text, ${bind(JSON.stringify(filter.value))}::jsonb)`;
+    }
+    if (filter.operator === 'in') {
+        return `(${filter.values
+            .map((value) => `c.analytics @> jsonb_build_object(${field}::text, ${bind(JSON.stringify(value))}::jsonb)`)
+            .join(' OR ')})`;
+    }
+    const operator = { gt: '>', gte: '>=', lt: '<', lte: '<=' }[filter.operator];
+    return (`(CASE WHEN jsonb_typeof(c.analytics -> (${field}::text)) = 'number' THEN ` +
+        `(c.analytics ->> (${field}::text))::double precision ${operator} ${bind(filter.value)} ` +
+        'ELSE false END)');
+}

package/build/analytics/postgres-analytics.d.ts

@@ -0,0 +1,33 @@
+import { Pool, PoolConfig, QueryResult } from 'pg';
+import { AnalyticsScalar, AnalyticsStore, ConversationRecord, ConversationRepository, PhoneCallRecord } from './analytics';
+import { PostgresAnalyticsQueryService } from './postgres-analytics-query';
+interface Queryable {
+    query<TResult extends Record<string, unknown> = Record<string, unknown>>(text: string, values?: unknown[]): Promise<QueryResult<TResult>>;
+}
+export declare class PostgresAnalytics implements AnalyticsStore {
+    private readonly database;
+    constructor(database: Queryable);
+    set(conversationId: string, agentId: string, values: Readonly<Record<string, AnalyticsScalar>>): Promise<void>;
+    clear(conversationId: string, agentId: string, fieldNames: readonly string[]): Promise<void>;
+    get(conversationId: string, agentId: string, fieldName: string): Promise<unknown>;
+}
+export declare class PostgresConversationRepository implements ConversationRepository {
+    private readonly pool;
+    constructor(pool: Pool);
+    saveConversation(conversation: ConversationRecord, phoneCall?: PhoneCallRecord): Promise<{
+        changed: boolean;
+        created: boolean;
+    }>;
+    private upsertConversation;
+    private upsertPhoneCall;
+}
+export declare function migrateAnalyticsDatabase(pool: Pool): Promise<void>;
+export interface PostgresAnalyticsServices {
+    analytics: PostgresAnalytics;
+    conversations: PostgresConversationRepository;
+    queries: PostgresAnalyticsQueryService;
+    close(): Promise<void>;
+}
+export declare function createPostgresAnalyticsServices(config: PoolConfig): Promise<PostgresAnalyticsServices>;
+export {};
+//# sourceMappingURL=postgres-analytics.d.ts.map

package/build/analytics/postgres-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-analytics.d.ts","sourceRoot":"","sources":["../../src/analytics/postgres-analytics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAc,UAAU,EAAE,WAAW,EAAE,MAAM,IAAI,CAAA;AAE9D,OAAO,EACH,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EAElB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAA;AAI1E,UAAU,SAAS;IACf,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,EAAE,GACnB,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAA;CACnC;AAID,qBAAa,iBAAkB,YAAW,cAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,SAAS;IAE1C,GAAG,CACL,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,GAClD,OAAO,CAAC,IAAI,CAAC;IAiBV,KAAK,CACP,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,MAAM,EAAE,GAC9B,OAAO,CAAC,IAAI,CAAC;IAYV,GAAG,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAc1F;AAgBD,qBAAa,8BAA+B,YAAW,sBAAsB;IAC7D,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,IAAI;IAEjC,gBAAgB,CAClB,YAAY,EAAE,kBAAkB,EAChC,SAAS,CAAC,EAAE,eAAe,GAC5B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;YAuBpC,kBAAkB;YAkElB,eAAe;CAwChC;AA2FD,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAgDxE;AA6BD,MAAM,WAAW,yBAAyB;IACtC,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,EAAE,8BAA8B,CAAA;IAC7C,OAAO,EAAE,6BAA6B,CAAA;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAID,wBAAsB,+BAA+B,CACjD,MAAM,EAAE,UAAU,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAgBpC"}