@voyant-travel/inventory 0.1.0

package/dist/service-public.js

@@ -0,0 +1,374 @@
+// agent-quality: file-size exception -- owner: inventory; existing service module stays co-located until a dedicated split preserves behavior and tests.
+import { and, asc, desc, eq, ilike, inArray, notInArray, or, sql } from "drizzle-orm";
+import { destinations, destinationTranslations, productCategories, productCategoryProducts, productDestinations, productLocations, products, productTagProducts, productTags, productTranslations, productVisibilitySettings, } from "./schema.js";
+import { catalogProductsService } from "./service-catalog.js";
+function impossibleCondition() {
+    return sql `1 = 0`;
+}
+function normalizeLanguageTag(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized || null;
+}
+async function listProductIdsForCategory(db, categoryId) {
+    const rows = await db
+        .select({ productId: productCategoryProducts.productId })
+        .from(productCategoryProducts)
+        .innerJoin(productCategories, eq(productCategories.id, productCategoryProducts.categoryId))
+        .where(and(eq(productCategoryProducts.categoryId, categoryId), eq(productCategories.active, true)));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForTag(db, tagId) {
+    const rows = await db
+        .select({ productId: productTagProducts.productId })
+        .from(productTagProducts)
+        .where(eq(productTagProducts.tagId, tagId));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForDestinationId(db, destinationId) {
+    const rows = await db
+        .select({ productId: productDestinations.productId })
+        .from(productDestinations)
+        .where(eq(productDestinations.destinationId, destinationId));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForDestinationSlug(db, slug) {
+    const rows = await db
+        .select({ productId: productDestinations.productId })
+        .from(productDestinations)
+        .innerJoin(destinations, eq(destinations.id, productDestinations.destinationId))
+        .where(eq(destinations.slug, slug));
+    return rows.map((row) => row.productId);
+}
+async function listFeaturedProductIds(db) {
+    const rows = await db
+        .select({ productId: productVisibilitySettings.productId })
+        .from(productVisibilitySettings)
+        .where(eq(productVisibilitySettings.isFeatured, true));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationTitle(db, title) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(ilike(productLocations.title, title));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationCity(db, city) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(ilike(productLocations.city, city));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationCountryCode(db, countryCode) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(eq(productLocations.countryCode, countryCode));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationType(db, locationType) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(eq(productLocations.locationType, locationType));
+    return rows.map((row) => row.productId);
+}
+async function hydrateCatalogProducts(db, productRows, options) {
+    return catalogProductsService.hydrateProducts(db, productRows, {
+        includeContent: options?.includeContent,
+        languageTag: options?.languageTag,
+        fallbackLanguageTags: options?.languageTag ? [options.languageTag] : [],
+    });
+}
+function orderProducts(query) {
+    const direction = query.direction === "desc" ? desc : asc;
+    switch (query.sort) {
+        case "createdAt":
+            return direction(products.createdAt);
+        case "startDate":
+            return direction(products.startDate);
+        case "price":
+            return direction(products.sellAmountCents);
+        default:
+            return direction(products.name);
+    }
+}
+export const publicProductsService = {
+    async listCatalogProducts(db, query) {
+        const conditions = [
+            eq(products.status, "active"),
+            eq(products.activated, true),
+            eq(products.visibility, "public"),
+        ];
+        if (query.search) {
+            const term = `%${query.search}%`;
+            const searchCondition = or(ilike(products.name, term), ilike(products.description, term));
+            if (searchCondition) {
+                conditions.push(searchCondition);
+            }
+        }
+        if (query.bookingMode) {
+            conditions.push(eq(products.bookingMode, query.bookingMode));
+        }
+        if (query.capacityMode) {
+            conditions.push(eq(products.capacityMode, query.capacityMode));
+        }
+        if (query.productTypeId) {
+            conditions.push(eq(products.productTypeId, query.productTypeId));
+        }
+        if (query.categoryId) {
+            const productIds = await listProductIdsForCategory(db, query.categoryId);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.tagId) {
+            const productIds = await listProductIdsForTag(db, query.tagId);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.destinationId) {
+            const productIds = await listProductIdsForDestinationId(db, query.destinationId);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.destinationSlug) {
+            const productIds = await listProductIdsForDestinationSlug(db, query.destinationSlug);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.featured !== undefined) {
+            const productIds = await listFeaturedProductIds(db);
+            conditions.push(query.featured
+                ? productIds.length > 0
+                    ? inArray(products.id, productIds)
+                    : impossibleCondition()
+                : productIds.length > 0
+                    ? notInArray(products.id, productIds)
+                    : sql `1 = 1`);
+        }
+        if (query.locationTitle) {
+            const productIds = await listProductIdsForLocationTitle(db, query.locationTitle);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationCity) {
+            const productIds = await listProductIdsForLocationCity(db, query.locationCity);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationCountryCode) {
+            const productIds = await listProductIdsForLocationCountryCode(db, query.locationCountryCode.toUpperCase());
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationType) {
+            const productIds = await listProductIdsForLocationType(db, query.locationType);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        const where = and(...conditions);
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(products)
+                .where(where)
+                .orderBy(orderProducts(query), asc(products.id))
+                .limit(query.limit)
+                .offset(query.offset),
+            db.select({ count: sql `count(*)::int` }).from(products).where(where),
+        ]);
+        return {
+            data: await hydrateCatalogProducts(db, rows, {
+                includeContent: query.includeContent === true,
+                languageTag: normalizeLanguageTag(query.languageTag),
+            }),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getCatalogProductById(db, id, query = {}) {
+        const [row] = await db
+            .select()
+            .from(products)
+            .where(and(eq(products.id, id), eq(products.status, "active"), eq(products.activated, true), eq(products.visibility, "public")))
+            .limit(1);
+        if (!row) {
+            return null;
+        }
+        const [product] = await hydrateCatalogProducts(db, [row], {
+            includeContent: true,
+            languageTag: normalizeLanguageTag(query.languageTag),
+        });
+        return product ?? null;
+    },
+    async getCatalogProductBySlug(db, slug, query = {}) {
+        const normalizedSlug = slug.trim().toLowerCase();
+        const normalizedLanguageTag = normalizeLanguageTag(query.languageTag);
+        const conditions = [
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `lower(${productTranslations.slug}) = ${normalizedSlug}`,
+            eq(products.status, "active"),
+            eq(products.activated, true),
+            eq(products.visibility, "public"),
+        ];
+        if (normalizedLanguageTag) {
+            conditions.push(eq(productTranslations.languageTag, normalizedLanguageTag));
+        }
+        const [row] = await db
+            .select({
+            productId: products.id,
+            languageTag: productTranslations.languageTag,
+        })
+            .from(productTranslations)
+            .innerJoin(products, eq(products.id, productTranslations.productId))
+            .where(and(...conditions))
+            .orderBy(desc(productTranslations.updatedAt))
+            .limit(1);
+        if (!row) {
+            return null;
+        }
+        return this.getCatalogProductById(db, row.productId, {
+            languageTag: normalizedLanguageTag ?? row.languageTag,
+        });
+    },
+    async getCatalogProductBrochure(db, productId, query = {}) {
+        const product = await this.getCatalogProductById(db, productId, query);
+        return product && "brochure" in product ? product.brochure : null;
+    },
+    async listCatalogCategories(db, query) {
+        const conditions = [eq(productCategories.active, true)];
+        if (query.parentId) {
+            conditions.push(eq(productCategories.parentId, query.parentId));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            const searchCondition = or(ilike(productCategories.name, term), ilike(productCategories.slug, term));
+            if (searchCondition) {
+                conditions.push(searchCondition);
+            }
+        }
+        const where = and(...conditions);
+        const [rows, countResult] = await Promise.all([
+            db
+                .select({
+                id: productCategories.id,
+                parentId: productCategories.parentId,
+                name: productCategories.name,
+                slug: productCategories.slug,
+                description: productCategories.description,
+                sortOrder: productCategories.sortOrder,
+            })
+                .from(productCategories)
+                .where(where)
+                .orderBy(asc(productCategories.sortOrder), asc(productCategories.name))
+                .limit(query.limit)
+                .offset(query.offset),
+            db.select({ count: sql `count(*)::int` }).from(productCategories).where(where),
+        ]);
+        return {
+            data: rows.map((row) => ({
+                ...row,
+                parentId: row.parentId ?? null,
+                description: row.description ?? null,
+            })),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async listCatalogTags(db, query) {
+        const conditions = [];
+        if (query.search) {
+            conditions.push(ilike(productTags.name, `%${query.search}%`));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select({
+                id: productTags.id,
+                name: productTags.name,
+            })
+                .from(productTags)
+                .where(where)
+                .orderBy(asc(productTags.name))
+                .limit(query.limit)
+                .offset(query.offset),
+            db.select({ count: sql `count(*)::int` }).from(productTags).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async listCatalogDestinations(db, query) {
+        const conditions = [];
+        if (query.parentId) {
+            conditions.push(eq(destinations.parentId, query.parentId));
+        }
+        if (query.active !== undefined) {
+            conditions.push(eq(destinations.active, query.active));
+        }
+        if (query.destinationType) {
+            conditions.push(eq(destinations.destinationType, query.destinationType));
+        }
+        if (query.canonicalPlaceId) {
+            conditions.push(eq(destinations.canonicalPlaceId, query.canonicalPlaceId));
+        }
+        if (query.search) {
+            const translationRows = await db
+                .select({ destinationId: destinationTranslations.destinationId })
+                .from(destinationTranslations)
+                .where(and(...(query.languageTag
+                ? [eq(destinationTranslations.languageTag, query.languageTag)]
+                : []), or(ilike(destinationTranslations.name, `%${query.search}%`), ilike(destinationTranslations.description, `%${query.search}%`))));
+            const destinationIds = translationRows.map((row) => row.destinationId);
+            conditions.push(destinationIds.length > 0
+                ? inArray(destinations.id, destinationIds)
+                : impossibleCondition());
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(destinations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(destinations.sortOrder), asc(destinations.slug)),
+            db.select({ count: sql `count(*)::int` }).from(destinations).where(where),
+        ]);
+        const destinationIds = rows.map((row) => row.id);
+        const translations = destinationIds.length > 0
+            ? await db
+                .select()
+                .from(destinationTranslations)
+                .where(and(inArray(destinationTranslations.destinationId, destinationIds), ...(query.languageTag
+                ? [eq(destinationTranslations.languageTag, query.languageTag)]
+                : [])))
+            : [];
+        const translationByDestination = new Map();
+        for (const row of translations) {
+            if (!translationByDestination.has(row.destinationId)) {
+                translationByDestination.set(row.destinationId, row);
+            }
+        }
+        return {
+            data: rows.map((row) => {
+                const translation = translationByDestination.get(row.id);
+                return {
+                    id: row.id,
+                    parentId: row.parentId ?? null,
+                    slug: row.slug,
+                    canonicalPlaceId: row.canonicalPlaceId ?? null,
+                    name: translation?.name ?? row.slug,
+                    description: translation?.description ?? null,
+                    seoTitle: translation?.seoTitle ?? null,
+                    seoDescription: translation?.seoDescription ?? null,
+                    destinationType: row.destinationType,
+                    latitude: row.latitude ?? null,
+                    longitude: row.longitude ?? null,
+                    sortOrder: row.sortOrder,
+                };
+            }),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+};

package/dist/service-taxonomy.d.ts

@@ -0,0 +1,197 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductCategorySchema, insertProductTagSchema, insertProductTypeSchema, productCategoryListQuerySchema, productTagListQuerySchema, productTypeListQuerySchema, updateProductCategorySchema, updateProductTagSchema, updateProductTypeSchema } from "./validation.js";
+type ProductTypeListQuery = z.infer<typeof productTypeListQuerySchema>;
+type CreateProductTypeInput = z.infer<typeof insertProductTypeSchema>;
+type UpdateProductTypeInput = z.infer<typeof updateProductTypeSchema>;
+type ProductCategoryListQuery = z.infer<typeof productCategoryListQuerySchema>;
+type CreateProductCategoryInput = z.infer<typeof insertProductCategorySchema>;
+type UpdateProductCategoryInput = z.infer<typeof updateProductCategorySchema>;
+type ProductTagListQuery = z.infer<typeof productTagListQuerySchema>;
+type CreateProductTagInput = z.infer<typeof insertProductTagSchema>;
+type UpdateProductTagInput = z.infer<typeof updateProductTagSchema>;
+export declare const taxonomyProductsService: {
+    listProductTypes(db: PostgresJsDatabase, query: ProductTypeListQuery): Promise<{
+        data: {
+            id: string;
+            name: string;
+            code: string;
+            description: string | null;
+            sortOrder: number;
+            active: boolean;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductTypeById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProductType(db: PostgresJsDatabase, data: CreateProductTypeInput): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        code: string;
+        sortOrder: number;
+    } | undefined>;
+    updateProductType(db: PostgresJsDatabase, id: string, data: UpdateProductTypeInput): Promise<{
+        id: string;
+        name: string;
+        code: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductType(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listProductCategories(db: PostgresJsDatabase, query: ProductCategoryListQuery): Promise<{
+        data: {
+            id: string;
+            parentId: string | null;
+            name: string;
+            slug: string;
+            description: string | null;
+            sortOrder: number;
+            active: boolean;
+            customerPaymentPolicy: unknown;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductCategoryById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        customerPaymentPolicy: unknown;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProductCategory(db: PostgresJsDatabase, data: CreateProductCategoryInput): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        description: string | null;
+        customerPaymentPolicy: unknown;
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        sortOrder: number;
+        parentId: string | null;
+        slug: string;
+    } | undefined>;
+    updateProductCategory(db: PostgresJsDatabase, id: string, data: UpdateProductCategoryInput): Promise<{
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        customerPaymentPolicy: unknown;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductCategory(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listProductTags(db: PostgresJsDatabase, query: ProductTagListQuery): Promise<{
+        data: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductTagById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProductTag(db: PostgresJsDatabase, data: CreateProductTagInput): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+    } | undefined>;
+    updateProductTag(db: PostgresJsDatabase, id: string, data: UpdateProductTagInput): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductTag(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    addProductToCategory(db: PostgresJsDatabase, productId: string, categoryId: string, sortOrder?: number): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        categoryId: string;
+        productId: string;
+        sortOrder: number;
+    } | null>;
+    removeProductFromCategory(db: PostgresJsDatabase, productId: string, categoryId: string): Promise<{
+        productId: string;
+    } | null>;
+    listProductCategories_(db: PostgresJsDatabase, productId: string): Promise<{
+        id: string;
+        parentId: string | null;
+        name: string;
+        slug: string;
+        description: string | null;
+        sortOrder: number;
+        active: boolean;
+        customerPaymentPolicy: unknown;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    addProductTag(db: PostgresJsDatabase, productId: string, tagId: string): Promise<{
+        createdAt: Date;
+        productId: string;
+        tagId: string;
+    } | null>;
+    removeProductTag(db: PostgresJsDatabase, productId: string, tagId: string): Promise<{
+        productId: string;
+    } | null>;
+    listProductTags_(db: PostgresJsDatabase, productId: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+};
+export {};
+//# sourceMappingURL=service-taxonomy.d.ts.map

package/dist/service-taxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-taxonomy.d.ts","sourceRoot":"","sources":["../src/service-taxonomy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQ5B,OAAO,KAAK,EACV,2BAA2B,EAC3B,sBAAsB,EACtB,uBAAuB,EACvB,8BAA8B,EAC9B,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,iBAAiB,CAAA;AAExB,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AACtE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACrE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACrE,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC9E,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACpE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEnE,eAAO,MAAM,uBAAuB;yBAKP,kBAAkB,SAAS,oBAAoB;;;;;;;;;;;;;;;;2BAiC7C,kBAAkB,MAAM,MAAM;;;;;;;;;;;0BAK/B,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;0BAKhD,kBAAkB,MAAM,MAAM,QAAQ,sBAAsB;;;;;;;;;;;0BAU5D,kBAAkB,MAAM,MAAM;;;8BAa1B,kBAAkB,SAAS,wBAAwB;;;;;;;;;;;;;;;;;;+BAqClD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;8BAS/B,kBAAkB,QAAQ,0BAA0B;;;;;;;;;;;;;8BAM9E,kBAAkB,MAClB,MAAM,QACJ,0BAA0B;;;;;;;;;;;;;8BAWF,kBAAkB,MAAM,MAAM;;;wBAapC,kBAAkB,SAAS,mBAAmB;;;;;;;;;;;0BA6B5C,kBAAkB,MAAM,MAAM;;;;;;yBAK/B,kBAAkB,QAAQ,qBAAqB;;;;;;yBAK/C,kBAAkB,MAAM,MAAM,QAAQ,qBAAqB;;;;;;yBAU3D,kBAAkB,MAAM,MAAM;;;6BAcnD,kBAAkB,aACX,MAAM,cACL,MAAM;;;;;;;kCAYgB,kBAAkB,aAAa,MAAM,cAAc,MAAM;;;+BAc5D,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;sBAe9C,kBAAkB,aAAa,MAAM,SAAS,MAAM;;;;;yBAUjD,kBAAkB,aAAa,MAAM,SAAS,MAAM;;;yBASpD,kBAAkB,aAAa,MAAM;;;;;;CAUjE,CAAA"}