@unifiedcommerce/core 0.4.4 → 0.5.0

package/dist/modules/promotions/service.js

@@ -0,0 +1,368 @@
+import { CommerceNotFoundError, CommerceValidationError, } from "../../kernel/errors.js";
+import { Err, Ok } from "../../kernel/result.js";
+import { DEFAULT_ORG_ID, resolveOrgId } from "../../auth/org.js";
+function matchesWindow(promotion, timestamp) {
+    if (!promotion.isActive)
+        return false;
+    if (promotion.validFrom && timestamp < promotion.validFrom)
+        return false;
+    if (promotion.validUntil && timestamp > promotion.validUntil)
+        return false;
+    return true;
+}
+function toConditions(raw) {
+    if (!raw)
+        return {};
+    const conditions = {};
+    if (typeof raw.minimumOrderValue === "number") {
+        conditions.minimumOrderValue = raw.minimumOrderValue;
+    }
+    if (typeof raw.minimumQuantity === "number") {
+        conditions.minimumQuantity = raw.minimumQuantity;
+    }
+    if (Array.isArray(raw.entityTypes)) {
+        conditions.entityTypes = raw.entityTypes.filter((item) => typeof item === "string");
+    }
+    if (Array.isArray(raw.categories)) {
+        conditions.categories = raw.categories.filter((item) => typeof item === "string");
+    }
+    if (Array.isArray(raw.customerGroups)) {
+        conditions.customerGroups = raw.customerGroups.filter((item) => typeof item === "string");
+    }
+    if (typeof raw.firstOrderOnly === "boolean") {
+        conditions.firstOrderOnly = raw.firstOrderOnly;
+    }
+    return conditions;
+}
+function roundMoney(amount) {
+    return Math.max(0, Math.round(amount));
+}
+function totalQuantity(items) {
+    return items.reduce((sum, item) => sum + item.quantity, 0);
+}
+function sortByPriority(promotions) {
+    return [...promotions].sort((a, b) => a.priority - b.priority);
+}
+export class PromotionService {
+    deps;
+    repo;
+    catalogRepo;
+    ordersRepo;
+    constructor(deps) {
+        this.deps = deps;
+        this.repo = deps.repository;
+        this.catalogRepo = deps.catalogRepository;
+        this.ordersRepo = deps.ordersRepository;
+    }
+    async create(input, actor, ctx) {
+        if (!input.name) {
+            return Err(new CommerceValidationError("Promotion name is required."));
+        }
+        if (input.value < 0) {
+            return Err(new CommerceValidationError("Promotion value cannot be negative."));
+        }
+        // Validate promotion type
+        const validTypes = [
+            "percentage_off_order",
+            "fixed_off_order",
+            "percentage_off_item",
+            "fixed_off_item",
+            "free_shipping",
+            "buy_x_get_y",
+        ];
+        if (!validTypes.includes(input.type)) {
+            return Err(new CommerceValidationError(`Invalid promotion type "${input.type}". Must be one of: ${validTypes.join(", ")}`));
+        }
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        if (input.code) {
+            const normalized = input.code.trim().toUpperCase();
+            const existing = await this.repo.findByCode(orgId, normalized, ctx);
+            if (existing) {
+                return Err(new CommerceValidationError(`Promotion code ${normalized} already exists.`));
+            }
+        }
+        const promotion = await this.repo.create({
+            organizationId: orgId,
+            name: input.name,
+            type: input.type,
+            value: roundMoney(input.value),
+            isAutomatic: input.isAutomatic ?? false,
+            isActive: input.isActive ?? true,
+            priority: input.priority ?? 100,
+            conditions: (input.conditions ?? {}),
+            metadata: input.metadata ?? {},
+            code: input.code ? input.code.trim().toUpperCase() : null,
+            buyQuantity: input.buyQuantity ?? null,
+            getQuantity: input.getQuantity ?? null,
+            usageLimitTotal: input.usageLimitTotal ?? null,
+            usageLimitPerCustomer: input.usageLimitPerCustomer ?? null,
+            validFrom: input.validFrom ?? null,
+            validUntil: input.validUntil ?? null,
+        }, ctx);
+        return Ok(promotion);
+    }
+    async deactivate(orgId, id, ctx) {
+        const promotion = await this.repo.findById(orgId, id, ctx);
+        if (!promotion) {
+            return Err(new CommerceNotFoundError("Promotion not found."));
+        }
+        const updated = await this.repo.update(id, { isActive: false }, ctx);
+        if (!updated) {
+            return Err(new CommerceNotFoundError("Promotion not found."));
+        }
+        return Ok(updated);
+    }
+    async list(filter, actor, ctx) {
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const all = await this.repo.findAll(orgId, ctx);
+        const now = new Date();
+        if (!filter?.status)
+            return Ok(sortByPriority(all));
+        const filtered = all.filter((p) => {
+            const isActive = p.isActive && matchesWindow(p, now);
+            const isExpired = p.isActive && p.validUntil && new Date(p.validUntil) < now;
+            const isScheduled = p.isActive && p.validFrom && new Date(p.validFrom) > now;
+            const isInactive = !p.isActive;
+            switch (filter.status) {
+                case "active": return isActive;
+                case "inactive": return isInactive;
+                case "expired": return isExpired;
+                case "scheduled": return isScheduled;
+                default: return true;
+            }
+        });
+        return Ok(sortByPriority(filtered));
+    }
+    async listActive(actor, timestamp = new Date(), ctx) {
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const active = await this.repo.findActive(orgId, ctx);
+        // Further filter by timestamp in case repo returns slightly stale results
+        const filtered = active.filter((p) => matchesWindow(p, timestamp));
+        return Ok(sortByPriority(filtered));
+    }
+    async validate(code, context, ctx) {
+        const normalized = code.trim().toUpperCase();
+        const evalOrgId = context.orgId ?? DEFAULT_ORG_ID;
+        const promotion = await this.repo.findByCode(evalOrgId, normalized, ctx);
+        if (!promotion) {
+            return Err(new CommerceNotFoundError(`Promotion code ${normalized} not found.`));
+        }
+        const validation = await this.validatePromotionForContext(promotion, context, context.timestamp ?? new Date(), ctx);
+        if (validation !== undefined) {
+            return Err(new CommerceValidationError(validation));
+        }
+        return Ok(promotion);
+    }
+    async apply(code, context, ctx) {
+        const validation = await this.validate(code, context, ctx);
+        if (!validation.ok)
+            return validation;
+        const evaluated = await this.evaluatePromotion(validation.value, context, ctx);
+        return Ok({
+            totalDiscount: evaluated.discountAmount,
+            freeShipping: evaluated.freeShipping,
+            applied: [evaluated],
+            rejectedCodes: [],
+        });
+    }
+    async applyPromotions(context, ctx) {
+        const timestamp = context.timestamp ?? new Date();
+        const applyOrgId = context.orgId ?? DEFAULT_ORG_ID;
+        const result = {
+            totalDiscount: 0,
+            freeShipping: false,
+            applied: [],
+            rejectedCodes: [],
+        };
+        const selectedPromotions = [];
+        // Process explicit promotion codes
+        const codeSet = new Set((context.promotionCodes ?? []).map((code) => code.trim().toUpperCase()));
+        if (codeSet.size > 0) {
+            for (const code of codeSet) {
+                const promotion = await this.repo.findByCode(applyOrgId, code, ctx);
+                if (!promotion) {
+                    result.rejectedCodes.push({ code, reason: "Code not found." });
+                    continue;
+                }
+                const reason = await this.validatePromotionForContext(promotion, context, timestamp, ctx);
+                if (reason !== undefined) {
+                    result.rejectedCodes.push({ code, reason });
+                    continue;
+                }
+                selectedPromotions.push(promotion);
+            }
+        }
+        // Process automatic promotions
+        const automaticPromotions = await this.repo.findAutomatic(applyOrgId, ctx);
+        for (const promotion of automaticPromotions) {
+            const reason = await this.validatePromotionForContext(promotion, context, timestamp, ctx);
+            if (reason !== undefined)
+                continue;
+            selectedPromotions.push(promotion);
+        }
+        for (const promotion of sortByPriority(selectedPromotions)) {
+            const evaluated = await this.evaluatePromotion(promotion, context, ctx);
+            if (evaluated.discountAmount <= 0 && !evaluated.freeShipping)
+                continue;
+            result.totalDiscount += evaluated.discountAmount;
+            result.freeShipping = result.freeShipping || evaluated.freeShipping;
+            result.applied.push(evaluated);
+        }
+        result.totalDiscount = Math.min(roundMoney(result.totalDiscount), roundMoney(context.subtotal));
+        return Ok(result);
+    }
+    async recordUsage(input, ctx) {
+        const usages = [];
+        for (const applied of input.promotions) {
+            const usage = await this.repo.createUsage({
+                promotionId: applied.promotionId,
+                customerId: input.customerId ?? null,
+                orderId: input.orderId ?? null,
+            }, ctx);
+            usages.push(usage);
+        }
+        return Ok(usages);
+    }
+    async validatePromotionForContext(promotion, context, timestamp, ctx) {
+        if (!matchesWindow(promotion, timestamp)) {
+            return "Promotion is inactive or outside validity window.";
+        }
+        const conditions = toConditions(promotion.conditions);
+        if (conditions.minimumOrderValue !== undefined &&
+            roundMoney(context.subtotal) < roundMoney(conditions.minimumOrderValue)) {
+            return `Requires minimum order value of ${conditions.minimumOrderValue}.`;
+        }
+        if (conditions.minimumQuantity !== undefined &&
+            totalQuantity(context.lineItems) < conditions.minimumQuantity) {
+            return `Requires minimum quantity of ${conditions.minimumQuantity}.`;
+        }
+        if (conditions.customerGroups && conditions.customerGroups.length > 0) {
+            const set = new Set(context.customerGroupIds ?? []);
+            const matchesGroup = conditions.customerGroups.some((group) => set.has(group));
+            if (!matchesGroup) {
+                return "Customer group not eligible for this promotion.";
+            }
+        }
+        if (conditions.entityTypes && conditions.entityTypes.length > 0) {
+            const hasType = context.lineItems.some((lineItem) => conditions.entityTypes.includes(lineItem.entityType));
+            if (!hasType)
+                return "Cart does not include required entity type.";
+        }
+        if (conditions.categories && conditions.categories.length > 0) {
+            const categoryMatches = await this.checkCategoryMatch(context.lineItems, conditions.categories, ctx);
+            if (!categoryMatches)
+                return "Cart does not include required category.";
+        }
+        if (conditions.firstOrderOnly) {
+            if (!context.customerId) {
+                return "First-order promotion requires authenticated customer.";
+            }
+            const orders = await this.ordersRepo.findByCustomerId(context.orgId ?? DEFAULT_ORG_ID, context.customerId, ctx);
+            if (orders.length > 0) {
+                return "Promotion is valid for first order only.";
+            }
+        }
+        // Check usage limits
+        const usageCount = await this.repo.countUsages(promotion.id, ctx);
+        if (promotion.usageLimitTotal !== null &&
+            usageCount >= promotion.usageLimitTotal) {
+            return "Promotion usage limit reached.";
+        }
+        if (promotion.usageLimitPerCustomer !== null && context.customerId) {
+            const customerUses = await this.repo.countUsagesByCustomer(promotion.id, context.customerId, ctx);
+            if (customerUses >= promotion.usageLimitPerCustomer) {
+                return "Promotion per-customer usage limit reached.";
+            }
+        }
+        return undefined;
+    }
+    async checkCategoryMatch(lineItems, categorySlugs, ctx) {
+        for (const lineItem of lineItems) {
+            const entityCategories = await this.catalogRepo.findEntityCategories(lineItem.entityId, ctx);
+            for (const link of entityCategories) {
+                const category = await this.catalogRepo.findCategoryById(link.categoryId, ctx);
+                if (category && categorySlugs.includes(category.slug)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async evaluatePromotion(promotion, context, ctx) {
+        const conditions = toConditions(promotion.conditions);
+        const eligibleItems = await this.filterEligibleLineItems(context.lineItems, conditions, ctx);
+        const eligibleSubtotal = eligibleItems.reduce((sum, item) => sum + item.totalPrice, 0);
+        let discountAmount = 0;
+        let freeShipping = false;
+        switch (promotion.type) {
+            case "percentage_off_order":
+                discountAmount = Math.round((context.subtotal * promotion.value) / 100);
+                break;
+            case "fixed_off_order":
+                discountAmount = promotion.value;
+                break;
+            case "percentage_off_item":
+                discountAmount = Math.round((eligibleSubtotal * promotion.value) / 100);
+                break;
+            case "fixed_off_item": {
+                const totalUnits = eligibleItems.reduce((sum, item) => sum + item.quantity, 0);
+                discountAmount = totalUnits * promotion.value;
+                break;
+            }
+            case "free_shipping":
+                freeShipping = true;
+                break;
+            case "buy_x_get_y": {
+                const buy = promotion.buyQuantity ?? 0;
+                const get = promotion.getQuantity ?? 0;
+                const totalUnits = eligibleItems.reduce((sum, item) => sum + item.quantity, 0);
+                if (buy > 0 && get > 0 && totalUnits > 0) {
+                    const groups = Math.floor(totalUnits / (buy + get));
+                    const freeUnits = groups * get;
+                    const minUnitPrice = eligibleItems.length
+                        ? Math.min(...eligibleItems.map((item) => item.unitPrice))
+                        : 0;
+                    discountAmount = freeUnits * minUnitPrice;
+                }
+                break;
+            }
+            default:
+                discountAmount = 0;
+        }
+        return {
+            promotionId: promotion.id,
+            type: promotion.type,
+            discountAmount: roundMoney(discountAmount),
+            freeShipping,
+            description: promotion.code
+                ? `Promotion ${promotion.code}`
+                : `Promotion ${promotion.name}`,
+            ...(promotion.code !== null ? { code: promotion.code } : {}),
+        };
+    }
+    async filterEligibleLineItems(lineItems, conditions, ctx) {
+        const eligible = [];
+        for (const lineItem of lineItems) {
+            if (conditions.entityTypes && conditions.entityTypes.length > 0) {
+                if (!conditions.entityTypes.includes(lineItem.entityType))
+                    continue;
+            }
+            if (conditions.categories && conditions.categories.length > 0) {
+                const entityCats = await this.catalogRepo.findEntityCategories(lineItem.entityId, ctx);
+                const hasCategory = await (async () => {
+                    for (const link of entityCats) {
+                        const category = await this.catalogRepo.findCategoryById(link.categoryId, ctx);
+                        if (category && conditions.categories.includes(category.slug)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                })();
+                if (!hasCategory)
+                    continue;
+            }
+            eligible.push(lineItem);
+        }
+        return eligible;
+    }
+}

package/dist/modules/search/adapter.d.ts

@@ -0,0 +1,51 @@
+import type { Result } from "../../kernel/result.js";
+export interface SearchDocument {
+    id: string;
+    type: string;
+    slug: string;
+    title: string;
+    description?: string;
+    status?: string;
+    categories: string[];
+    brands: string[];
+    text: string;
+    payload?: Record<string, unknown>;
+}
+export interface SearchFilters {
+    type?: string;
+    category?: string;
+    brand?: string;
+    status?: string;
+}
+export interface SearchQueryParams {
+    query: string;
+    page?: number;
+    limit?: number;
+    filters?: SearchFilters;
+    facets?: string[];
+}
+export interface SearchSuggestParams {
+    prefix: string;
+    type?: string;
+    limit?: number;
+}
+export interface SearchHit {
+    id: string;
+    score?: number;
+    document: SearchDocument;
+}
+export interface SearchQueryResult {
+    hits: SearchHit[];
+    total: number;
+    page: number;
+    limit: number;
+    facets: Record<string, Record<string, number>>;
+}
+export interface SearchAdapter {
+    readonly providerId: string;
+    index(documents: SearchDocument[]): Promise<Result<void>>;
+    remove(ids: string[]): Promise<Result<void>>;
+    search(params: SearchQueryParams): Promise<Result<SearchQueryResult>>;
+    suggest(params: SearchSuggestParams): Promise<Result<string[]>>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/modules/search/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/modules/search/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1D,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACtE,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CACjE"}

package/dist/modules/search/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/search/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { HookContext } from "../../kernel/hooks/types.js";
+export declare function syncToSearchIndex(args: {
+    result: {
+        id: string;
+    };
+    context: HookContext;
+}): Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/modules/search/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/modules/search/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKhB"}

package/dist/modules/search/hooks.js

@@ -0,0 +1,6 @@
+export async function syncToSearchIndex(args) {
+    const service = args.context.services.search;
+    if (!service)
+        return;
+    await service.syncEntity(args.result.id);
+}

package/dist/modules/search/repository/index.d.ts

@@ -0,0 +1,5 @@
+import type { TxContext } from "../../../kernel/database/tx-context.js";
+export interface SearchRepository {
+    ping(ctx: TxContext): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/search/repository/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/search/repository/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAExE,MAAM,WAAW,gBAAgB;IAE/B,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import { type Result } from "../../kernel/result.js";
+import type { TxContext } from "../../kernel/database/tx-context.js";
+import type { CatalogRepository } from "../catalog/repository/index.js";
+import type { SearchAdapter, SearchQueryParams, SearchQueryResult, SearchSuggestParams } from "./adapter.js";
+interface SearchServiceDeps {
+    catalogRepository: CatalogRepository;
+    adapter?: SearchAdapter;
+    defaultFacets?: string[];
+}
+export declare class SearchService {
+    private deps;
+    constructor(deps: SearchServiceDeps);
+    private entityCategories;
+    private entityBrands;
+    private buildDocument;
+    private allDocuments;
+    private matchesFilters;
+    private computeFacets;
+    syncEntity(entityId: string, ctx?: TxContext): Promise<Result<void>>;
+    query(params: SearchQueryParams, ctx?: TxContext): Promise<Result<SearchQueryResult>>;
+    suggest(params: SearchSuggestParams, ctx?: TxContext): Promise<Result<string[]>>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/modules/search/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAkB,MAAM,gCAAgC,CAAC;AACxF,OAAO,KAAK,EACV,aAAa,EAGb,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,UAAU,iBAAiB;IACzB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAuCD,qBAAa,aAAa;IACZ,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,iBAAiB;YAE7B,gBAAgB;YAwBhB,YAAY;YAwBZ,aAAa;YAyCb,YAAY;IAY1B,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,aAAa;IAgDf,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAcpE,KAAK,CACT,MAAM,EAAE,iBAAiB,EACzB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;IA8C/B,OAAO,CACX,MAAM,EAAE,mBAAmB,EAC3B,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;CA2B7B"}