@porulle/core 0.1.0

package/dist/modules/webhooks/repository/index.js

@@ -0,0 +1,183 @@
+import { eq, and, lte, isNull, or, desc, sql } from "drizzle-orm";
+import { webhookEndpoints, webhookDeliveries } from "../schema.js";
+/**
+ * WebhooksRepository provides type-safe database operations for webhooks.
+ *
+ * This repository manages webhook endpoints and their delivery tracking.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class WebhooksRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getDb(ctx) {
+        return ctx?.tx ?? this.db;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Webhook Endpoints
+    // ─────────────────────────────────────────────────────────────────────────────
+    // VAPT r2 (codex) finding: every read/delete on webhookEndpoints was
+    // org-agnostic. A tenant could list/delete other tenants' endpoints
+    // (HIGH cross-tenant), and event fan-out queried all endpoints in the
+    // database — Tenant B's webhooks fired on Tenant A's events, leaking
+    // payload across tenants. Org filtering is now mandatory.
+    async findEndpointById(id, orgId, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(webhookEndpoints)
+            .where(and(eq(webhookEndpoints.id, id), eq(webhookEndpoints.organizationId, orgId)));
+        return rows[0];
+    }
+    async findAllEndpoints(orgId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(webhookEndpoints)
+            .where(eq(webhookEndpoints.organizationId, orgId));
+    }
+    async findActiveEndpoints(orgId, ctx) {
+        const db = this.getDb(ctx);
+        return db
+            .select()
+            .from(webhookEndpoints)
+            .where(and(eq(webhookEndpoints.organizationId, orgId), eq(webhookEndpoints.isActive, true)));
+    }
+    async findEndpointsForEvent(eventName, orgId, ctx) {
+        const active = await this.findActiveEndpoints(orgId, ctx);
+        // Filter endpoints that subscribe to this event
+        return active.filter((endpoint) => {
+            const events = endpoint.events;
+            return events.includes(eventName) || events.includes("*");
+        });
+    }
+    async createEndpoint(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(webhookEndpoints).values(data).returning();
+        return rows[0];
+    }
+    async updateEndpoint(id, data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(webhookEndpoints)
+            .set(data)
+            .where(eq(webhookEndpoints.id, id))
+            .returning();
+        return rows[0];
+    }
+    async deleteEndpoint(id, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .delete(webhookEndpoints)
+            .where(eq(webhookEndpoints.id, id))
+            .returning();
+        return result.length > 0;
+    }
+    async activateEndpoint(id, ctx) {
+        return this.updateEndpoint(id, { isActive: true }, ctx);
+    }
+    async deactivateEndpoint(id, ctx) {
+        return this.updateEndpoint(id, { isActive: false }, ctx);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Webhook Deliveries
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findDeliveryById(id, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(webhookDeliveries)
+            .where(eq(webhookDeliveries.id, id));
+        return rows[0];
+    }
+    async findDeliveriesByEndpointId(endpointId, options, ctx) {
+        const db = this.getDb(ctx);
+        let query = db
+            .select()
+            .from(webhookDeliveries)
+            .where(eq(webhookDeliveries.endpointId, endpointId))
+            .orderBy(desc(webhookDeliveries.createdAt))
+            .$dynamic();
+        if (options?.limit !== undefined) {
+            query = query.limit(options.limit);
+        }
+        return query;
+    }
+    async findPendingDeliveries(ctx) {
+        const db = this.getDb(ctx);
+        const now = new Date();
+        return db
+            .select()
+            .from(webhookDeliveries)
+            .where(and(isNull(webhookDeliveries.deliveredAt), isNull(webhookDeliveries.failedAt), or(isNull(webhookDeliveries.nextRetryAt), lte(webhookDeliveries.nextRetryAt, now))))
+            .orderBy(webhookDeliveries.createdAt);
+    }
+    async findFailedDeliveries(endpointId, ctx) {
+        const db = this.getDb(ctx);
+        if (endpointId) {
+            return db
+                .select()
+                .from(webhookDeliveries)
+                .where(and(eq(webhookDeliveries.endpointId, endpointId), sql `${webhookDeliveries.failedAt} IS NOT NULL`))
+                .orderBy(desc(webhookDeliveries.failedAt));
+        }
+        return db
+            .select()
+            .from(webhookDeliveries)
+            .where(sql `${webhookDeliveries.failedAt} IS NOT NULL`)
+            .orderBy(desc(webhookDeliveries.failedAt));
+    }
+    async createDelivery(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(webhookDeliveries).values(data).returning();
+        return rows[0];
+    }
+    async updateDelivery(id, data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .update(webhookDeliveries)
+            .set(data)
+            .where(eq(webhookDeliveries.id, id))
+            .returning();
+        return rows[0];
+    }
+    async markDelivered(id, statusCode, ctx) {
+        return this.updateDelivery(id, {
+            statusCode,
+            deliveredAt: new Date(),
+            nextRetryAt: null,
+        }, ctx);
+    }
+    async markFailed(id, statusCode, nextRetryAt, ctx) {
+        const delivery = await this.findDeliveryById(id, ctx);
+        if (!delivery)
+            return undefined;
+        const data = {
+            statusCode: statusCode ?? undefined,
+            attemptCount: delivery.attemptCount + 1,
+        };
+        if (nextRetryAt) {
+            data.nextRetryAt = nextRetryAt;
+        }
+        else {
+            data.failedAt = new Date();
+            data.nextRetryAt = null;
+        }
+        return this.updateDelivery(id, data, ctx);
+    }
+    async deleteDelivery(id, ctx) {
+        const db = this.getDb(ctx);
+        const result = await db
+            .delete(webhookDeliveries)
+            .where(eq(webhookDeliveries.id, id))
+            .returning();
+        return result.length > 0;
+    }
+    async deleteDeliveriesByEndpointId(endpointId, ctx) {
+        const db = this.getDb(ctx);
+        await db
+            .delete(webhookDeliveries)
+            .where(eq(webhookDeliveries.endpointId, endpointId));
+    }
+}

package/dist/modules/webhooks/schema.d.ts

@@ -0,0 +1,404 @@
+export declare const webhookEndpoints: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_endpoints";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        url: import("drizzle-orm/pg-core").PgColumn<{
+            name: "url";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secret: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secret";
+            tableName: "webhook_endpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        events: import("drizzle-orm/pg-core").PgColumn<{
+            name: "events";
+            tableName: "webhook_endpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        isActive: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_active";
+            tableName: "webhook_endpoints";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "webhook_endpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Tracks processed incoming webhook events for idempotency.
+ * Prevents double-processing when Stripe (or other providers) retry delivery.
+ */
+export declare const processedWebhookEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "processed_webhook_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "processed_webhook_events";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_id";
+            tableName: "processed_webhook_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "processed_webhook_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "processed_webhook_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        processedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "processed_at";
+            tableName: "processed_webhook_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const webhookDeliveries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "webhook_deliveries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endpointId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endpoint_id";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_name";
+            tableName: "webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "webhook_deliveries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        statusCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status_code";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attemptCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt_count";
+            tableName: "webhook_deliveries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextRetryAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_retry_at";
+            tableName: "webhook_deliveries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deliveredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivered_at";
+            tableName: "webhook_deliveries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_at";
+            tableName: "webhook_deliveries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "webhook_deliveries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/webhooks/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/webhooks/schema.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB5B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC"}

package/dist/modules/webhooks/schema.js

@@ -0,0 +1,40 @@
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uuid, } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+export const webhookEndpoints = pgTable("webhook_endpoints", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+        .notNull()
+        .references(() => organization.id, { onDelete: "cascade" }),
+    url: text("url").notNull(),
+    secret: text("secret").notNull(),
+    events: jsonb("events").$type().notNull(),
+    isActive: boolean("is_active").notNull().default(true),
+    metadata: jsonb("metadata").$type().default({}),
+}, (table) => ({
+    orgIdx: index("idx_webhook_endpoints_org").on(table.organizationId),
+}));
+/**
+ * Tracks processed incoming webhook events for idempotency.
+ * Prevents double-processing when Stripe (or other providers) retry delivery.
+ */
+export const processedWebhookEvents = pgTable("processed_webhook_events", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    eventId: text("event_id").notNull().unique(),
+    provider: text("provider").notNull(), // "stripe", "paypal", etc.
+    eventType: text("event_type").notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true }).defaultNow().notNull(),
+});
+export const webhookDeliveries = pgTable("webhook_deliveries", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    endpointId: uuid("endpoint_id")
+        .references(() => webhookEndpoints.id)
+        .notNull(),
+    eventName: text("event_name").notNull(),
+    payload: jsonb("payload").notNull(),
+    statusCode: integer("status_code"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    nextRetryAt: timestamp("next_retry_at", { withTimezone: true }),
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+    failedAt: timestamp("failed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+});

package/dist/modules/webhooks/service.d.ts

@@ -0,0 +1,23 @@
+import type { Actor } from "../../auth/types.js";
+import { type Result } from "../../kernel/result.js";
+import type { TxContext } from "../../kernel/database/tx-context.js";
+import type { WebhooksRepository, WebhookEndpoint } from "./repository/index.js";
+interface WebhookServiceDeps {
+    repository: WebhooksRepository;
+}
+export declare class WebhookService {
+    private deps;
+    private readonly repo;
+    constructor(deps: WebhookServiceDeps);
+    createEndpoint(input: {
+        url: string;
+        secret: string;
+        events: string[];
+        metadata?: Record<string, unknown>;
+    }, actor?: Actor | null, ctx?: TxContext): Promise<Result<WebhookEndpoint>>;
+    listEndpoints(actor?: Actor | null, ctx?: TxContext): Promise<Result<WebhookEndpoint[]>>;
+    deleteEndpoint(id: string, actor?: Actor | null, ctx?: TxContext): Promise<Result<void>>;
+    getEndpointsForEvent(eventName: string, orgId: string, ctx?: TxContext): Promise<Result<WebhookEndpoint[]>>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/modules/webhooks/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/modules/webhooks/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AA4CjF,UAAU,kBAAkB;IAC1B,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAED,qBAAa,cAAc;IAGb,OAAO,CAAC,IAAI;IAFxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;gBAEtB,IAAI,EAAE,kBAAkB;IAItC,cAAc,CAClB,KAAK,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,EACD,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,EACpB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IAyB7B,aAAa,CACjB,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,EACpB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;IAM/B,cAAc,CAClB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,EACpB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAWlB,oBAAoB,CACxB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;CAItC"}