@mercurjs/core 2.1.2 → 2.2.0-canary.1

package/.medusa/server/src/modules/product/models/product.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const types_1 = require("@mercurjs/types");
+const product_attribute_1 = __importDefault(require("./product-attribute"));
+const product_attribute_value_1 = __importDefault(require("./product-attribute-value"));
+const product_brand_1 = __importDefault(require("./product-brand"));
+const product_category_1 = __importDefault(require("./product-category"));
+const product_change_1 = __importDefault(require("./product-change"));
+const product_collection_1 = __importDefault(require("./product-collection"));
+const product_image_1 = __importDefault(require("./product-image"));
+const product_tag_1 = __importDefault(require("./product-tag"));
+const product_type_1 = __importDefault(require("./product-type"));
+const product_variant_1 = __importDefault(require("./product-variant"));
+const Product = utils_1.model
+    .define("Product", {
+    // --- Medusa original fields (unchanged) ---
+    id: utils_1.model.id({ prefix: "prod" }).primaryKey(),
+    title: utils_1.model.text().searchable().translatable(),
+    handle: utils_1.model.text(),
+    subtitle: utils_1.model.text().searchable().translatable().nullable(),
+    description: utils_1.model.text().searchable().translatable().nullable(),
+    is_giftcard: utils_1.model.boolean().default(false),
+    thumbnail: utils_1.model.text().nullable(),
+    weight: utils_1.model.text().nullable(),
+    length: utils_1.model.text().nullable(),
+    height: utils_1.model.text().nullable(),
+    width: utils_1.model.text().nullable(),
+    origin_country: utils_1.model.text().nullable(),
+    hs_code: utils_1.model.text().nullable(),
+    mid_code: utils_1.model.text().nullable(),
+    material: utils_1.model.text().translatable().nullable(),
+    discountable: utils_1.model.boolean().default(true),
+    external_id: utils_1.model.text().nullable(),
+    metadata: utils_1.model.json().nullable(),
+    // --- Marketplace additions ---
+    status: utils_1.model.enum(types_1.ProductStatus).default(types_1.ProductStatus.PROPOSED),
+    is_restricted: utils_1.model.boolean().default(false),
+    created_by: utils_1.model.text().nullable(),
+    created_by_actor: utils_1.model.text().searchable().nullable(),
+    // --- Medusa original relations (unchanged) ---
+    variants: utils_1.model.hasMany(() => product_variant_1.default, {
+        mappedBy: "product",
+    }),
+    type: utils_1.model
+        .belongsTo(() => product_type_1.default, {
+        mappedBy: "products",
+    })
+        .nullable(),
+    brand: utils_1.model
+        .belongsTo(() => product_brand_1.default, {
+        mappedBy: "products",
+    })
+        .nullable(),
+    tags: utils_1.model.manyToMany(() => product_tag_1.default, {
+        mappedBy: "products",
+        pivotTable: "product_tags",
+    }),
+    images: utils_1.model.hasMany(() => product_image_1.default, {
+        mappedBy: "product",
+    }),
+    collection: utils_1.model
+        .belongsTo(() => product_collection_1.default, {
+        mappedBy: "products",
+    })
+        .nullable(),
+    categories: utils_1.model.manyToMany(() => product_category_1.default, {
+        pivotTable: "product_category_product",
+        mappedBy: "products",
+    }),
+    variant_attributes: utils_1.model.manyToMany(() => product_attribute_1.default, {
+        pivotTable: "product_variant_attribute",
+        mappedBy: "variant_products",
+    }),
+    custom_attributes: utils_1.model.hasMany(() => product_attribute_1.default, {
+        mappedBy: "product",
+    }),
+    attribute_values: utils_1.model.manyToMany(() => product_attribute_value_1.default, {
+        pivotTable: "product_attribute_value_link",
+        mappedBy: "products",
+    }),
+    changes: utils_1.model.hasMany(() => product_change_1.default, {
+        mappedBy: "product",
+    }),
+})
+    .cascades({
+    delete: ["variants", "images", "custom_attributes"],
+})
+    .indexes([
+    {
+        name: "IDX_product_handle_unique",
+        on: ["handle"],
+        unique: true,
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_product_type_id",
+        on: ["type_id"],
+        unique: false,
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_product_collection_id",
+        on: ["collection_id"],
+        unique: false,
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_product_status",
+        on: ["status"],
+        unique: false,
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_product_brand_id",
+        on: ["brand_id"],
+        unique: false,
+        where: "deleted_at IS NULL",
+    },
+    {
+        name: "IDX_product_created_by",
+        on: ["created_by"],
+        unique: false,
+        where: "deleted_at IS NULL AND created_by IS NOT NULL",
+    },
+    {
+        name: "IDX_product_created_by_actor",
+        on: ["created_by_actor"],
+        unique: false,
+        where: "deleted_at IS NULL AND created_by_actor IS NOT NULL",
+    },
+]);
+exports.default = Product;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/modules/product/repositories/product-category.d.ts

@@ -0,0 +1,53 @@
+import { Context, DAL, InferEntityType, ProductCategoryTransformOptions } from "@medusajs/framework/types";
+import { DALUtils } from "@medusajs/framework/utils";
+import { SqlEntityManager } from "@medusajs/framework/mikro-orm/postgresql";
+import { ProductCategory } from "../models";
+type UpdateCategoryInput = {
+    id: string;
+    name?: string;
+    description?: string;
+    handle?: string;
+    is_active?: boolean;
+    is_internal?: boolean;
+    is_restricted?: boolean;
+    rank?: number;
+    parent_category_id?: string | null;
+    parent_category?: {
+        id: string;
+    } | null;
+    category_children?: any[];
+    metadata?: Record<string, unknown> | null;
+    mpath?: string;
+};
+export declare class ProductCategoryRepository extends DALUtils.MikroOrmBaseTreeRepository<typeof ProductCategory> {
+    buildFindOptions(findOptions?: DAL.FindOptions<typeof ProductCategory>, familyOptions?: ProductCategoryTransformOptions): DAL.FindOptions<typeof ProductCategory>;
+    find(findOptions?: DAL.FindOptions<typeof ProductCategory>, transformOptions?: ProductCategoryTransformOptions, context?: Context): Promise<InferEntityType<typeof ProductCategory>[]>;
+    sortCategoriesByRank(categories: InferEntityType<typeof ProductCategory>[]): InferEntityType<typeof ProductCategory>[];
+    buildProductCategoriesWithTree(include: {
+        descendants?: boolean;
+        ancestors?: boolean;
+    }, productCategories: InferEntityType<typeof ProductCategory>[], findOptions?: DAL.FindOptions<typeof ProductCategory> & {
+        serialize?: boolean;
+    }, context?: Context): Promise<InferEntityType<typeof ProductCategory>[]>;
+    findAndCount(findOptions?: DAL.FindOptions<typeof ProductCategory>, transformOptions?: ProductCategoryTransformOptions, context?: Context): Promise<[InferEntityType<typeof ProductCategory>[], number]>;
+    delete(ids: string[], context?: Context): Promise<string[]>;
+    softDelete(ids: string[], context?: Context): Promise<[
+        InferEntityType<typeof ProductCategory>[],
+        Record<string, unknown[]>
+    ]>;
+    restore(ids: string[], context?: Context): Promise<[
+        InferEntityType<typeof ProductCategory>[],
+        Record<string, unknown[]>
+    ]>;
+    baseDelete(ids: string[], context?: Context): Promise<void>;
+    create(data: any[], context?: Context): Promise<InferEntityType<typeof ProductCategory>[]>;
+    update(data: UpdateCategoryInput[], context?: Context): Promise<InferEntityType<typeof ProductCategory>[]>;
+    protected rerankSiblingsAfterDeletion(manager: SqlEntityManager, removedSibling: Partial<InferEntityType<typeof ProductCategory>>): Promise<void>;
+    protected rerankSiblingsAfterCreation(manager: SqlEntityManager, addedSibling: Partial<InferEntityType<typeof ProductCategory>>): Promise<void>;
+    protected rerankAllSiblings(manager: SqlEntityManager, originalSibling: Partial<InferEntityType<typeof ProductCategory>> & {
+        rank: number;
+    }, updatedSibling: Partial<InferEntityType<typeof ProductCategory>> & {
+        rank: number;
+    }): Promise<void>;
+}
+export {};

package/.medusa/server/src/modules/product/repositories/product-category.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCategoryRepository = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const core_1 = require("@medusajs/framework/mikro-orm/core");
+const models_1 = require("../models");
+// eslint-disable-next-line max-len
+class ProductCategoryRepository extends utils_1.DALUtils.MikroOrmBaseTreeRepository {
+    buildFindOptions(findOptions = { where: {} }, familyOptions = {}) {
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ??= {};
+        findOptions_.options.orderBy ??= {
+            id: "ASC",
+            rank: "ASC",
+        };
+        const fields = (findOptions_.options.fields ??= []);
+        const populate = (findOptions_.options.populate ??= []);
+        if (familyOptions.includeDescendantsTree ||
+            familyOptions.includeAncestorsTree) {
+            fields.indexOf("mpath") === -1 && fields.push("mpath");
+            fields.indexOf("parent_category_id") === -1 &&
+                fields.push("parent_category_id");
+        }
+        const shouldExpandParent = familyOptions.includeAncestorsTree ||
+            populate.includes("parent_category") ||
+            fields.some((field) => field.startsWith("parent_category."));
+        if (shouldExpandParent) {
+            populate.indexOf("parent_category") === -1 &&
+                populate.push("parent_category");
+        }
+        const shouldExpandChildren = familyOptions.includeDescendantsTree ||
+            populate.includes("category_children") ||
+            fields.some((field) => field.startsWith("category_children."));
+        if (shouldExpandChildren) {
+            populate.indexOf("category_children") === -1 &&
+                populate.push("category_children");
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return findOptions_;
+    }
+    async find(findOptions = { where: {} }, transformOptions = {}, context = {}) {
+        const manager = super.getActiveManager(context);
+        const findOptions_ = this.buildFindOptions(findOptions, transformOptions);
+        const productCategories = await manager.find(models_1.ProductCategory.name, findOptions_.where, { ...findOptions_.options });
+        if (!transformOptions.includeDescendantsTree &&
+            !transformOptions.includeAncestorsTree) {
+            return productCategories;
+        }
+        const categoriesTree = await this.buildProductCategoriesWithTree({
+            descendants: transformOptions.includeDescendantsTree,
+            ancestors: transformOptions.includeAncestorsTree,
+        }, productCategories, findOptions_, context);
+        return this.sortCategoriesByRank(categoriesTree);
+    }
+    sortCategoriesByRank(categories) {
+        const sortedCategories = categories.sort((a, b) => a.rank - b.rank);
+        for (const category of sortedCategories) {
+            if (category.category_children) {
+                category.category_children = this.sortCategoriesByRank(category.category_children);
+            }
+        }
+        return sortedCategories;
+    }
+    async buildProductCategoriesWithTree(include, productCategories, findOptions = { where: {} }, context = {}) {
+        const { serialize = true } = findOptions;
+        delete findOptions.serialize;
+        const manager = super.getActiveManager(context);
+        let relationIndex = findOptions.options?.populate?.indexOf("parent_category") ?? -1;
+        const shouldPopulateParent = relationIndex !== -1;
+        if (shouldPopulateParent && include.ancestors) {
+            findOptions.options.populate.splice(relationIndex, 1);
+        }
+        relationIndex =
+            findOptions.options?.populate?.indexOf("category_children") ?? -1;
+        const shouldPopulateChildren = relationIndex !== -1;
+        if (shouldPopulateChildren && include.descendants) {
+            findOptions.options.populate.splice(relationIndex, 1);
+        }
+        const mpaths = [];
+        const parentMpaths = new Set();
+        for (const cat of productCategories) {
+            if (include.descendants) {
+                mpaths.push({ mpath: { $like: `${cat.mpath}%` } });
+            }
+            if (include.ancestors) {
+                let parent = "";
+                cat.mpath?.split(".").forEach((mpath) => {
+                    parentMpaths.add(parent + mpath);
+                    parent += mpath + ".";
+                });
+            }
+        }
+        mpaths.push({ mpath: Array.from(parentMpaths) });
+        const where = { ...findOptions.where, $or: mpaths };
+        const options = {
+            ...findOptions.options,
+            limit: undefined,
+            offset: 0,
+        };
+        delete where.id;
+        delete where.handle;
+        delete where.mpath;
+        delete where.parent_category_id;
+        const categoriesInTree = serialize
+            ? await this.serialize(await manager.find(models_1.ProductCategory.name, where, options))
+            : await manager.find(models_1.ProductCategory.name, where, options);
+        const categoriesById = new Map(categoriesInTree.map((cat) => [cat.id, cat]));
+        categoriesInTree.forEach((cat) => {
+            if (cat.parent_category_id && include.ancestors) {
+                cat.parent_category = categoriesById.get(cat.parent_category_id);
+                cat.parent_category_id = categoriesById.get(cat.parent_category_id)?.["id"];
+            }
+        });
+        const populateChildren = (category, level = 0) => {
+            const categories = categoriesInTree.filter((child) => child.parent_category_id === category.id);
+            if (include.descendants) {
+                category.category_children = categories.map((child) => {
+                    return populateChildren(categoriesById.get(child.id), level + 1);
+                });
+            }
+            if (level === 0) {
+                if (!include.ancestors && !shouldPopulateParent) {
+                    delete category.parent_category;
+                }
+                return category;
+            }
+            if (include.ancestors) {
+                delete category.category_children;
+            }
+            if (include.descendants) {
+                delete category.parent_category;
+            }
+            return category;
+        };
+        const populatedProductCategories = productCategories.map((cat) => {
+            const fullCategory = categoriesById.get(cat.id);
+            return populateChildren(fullCategory);
+        });
+        return populatedProductCategories;
+    }
+    async findAndCount(findOptions = { where: {} }, transformOptions = {}, context = {}) {
+        const manager = super.getActiveManager(context);
+        const findOptions_ = this.buildFindOptions(findOptions, transformOptions);
+        const [productCategories, count] = (await manager.findAndCount(models_1.ProductCategory.name, findOptions_.where, findOptions_.options));
+        if (!transformOptions.includeDescendantsTree &&
+            !transformOptions.includeAncestorsTree) {
+            return [productCategories, count];
+        }
+        const categoriesTree = await this.buildProductCategoriesWithTree({
+            descendants: transformOptions.includeDescendantsTree,
+            ancestors: transformOptions.includeAncestorsTree,
+        }, productCategories, findOptions_, context);
+        return [this.sortCategoriesByRank(categoriesTree), count];
+    }
+    async delete(ids, context = {}) {
+        const manager = super.getActiveManager(context);
+        await this.baseDelete(ids, context);
+        await manager.nativeDelete(models_1.ProductCategory.name, { id: ids }, {});
+        return ids;
+    }
+    async softDelete(ids, context = {}) {
+        const manager = super.getActiveManager(context);
+        await this.baseDelete(ids, context);
+        const categories = await Promise.all(ids.map(async (id) => {
+            const productCategory = await manager.findOne(models_1.ProductCategory.name, {
+                id,
+            });
+            if (!productCategory) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `ProductCategory with id: ${id} was not found`);
+            }
+            manager.assign(productCategory, { deleted_at: new Date() });
+            return productCategory;
+        }));
+        manager.persist(categories);
+        return [categories, {}];
+    }
+    async restore(ids, context = {}) {
+        const manager = super.getActiveManager(context);
+        const categories = await Promise.all(ids.map(async (id) => {
+            const productCategory = await manager.findOneOrFail(models_1.ProductCategory.name, {
+                id,
+            });
+            manager.assign(productCategory, { deleted_at: null });
+            return productCategory;
+        }));
+        manager.persist(categories);
+        return [categories, {}];
+    }
+    async baseDelete(ids, context = {}) {
+        const manager = super.getActiveManager(context);
+        await Promise.all(ids.map(async (id) => {
+            const productCategory = await manager.findOne(models_1.ProductCategory.name, { id }, {
+                populate: ["category_children"],
+            });
+            if (!productCategory) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `ProductCategory with id: ${id} was not found`);
+            }
+            if (productCategory.category_children.length > 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Deleting ProductCategory (${id}) with category children is not allowed`);
+            }
+            await this.rerankSiblingsAfterDeletion(manager, productCategory);
+        }));
+    }
+    async create(data, context = {}) {
+        const manager = super.getActiveManager(context);
+        const categories = await Promise.all(data.map(async (entry, i) => {
+            const categoryData = {
+                ...entry,
+            };
+            const siblingsCount = await manager.count(models_1.ProductCategory.name, {
+                parent_category_id: categoryData?.parent_category_id || null,
+            });
+            categoryData.rank ??= siblingsCount + i;
+            if (categoryData.rank > siblingsCount + i) {
+                categoryData.rank = siblingsCount + i;
+            }
+            if (categoryData.rank < siblingsCount + i) {
+                await this.rerankSiblingsAfterCreation(manager, categoryData);
+            }
+            let parentCategory = null;
+            const parentCategoryId = categoryData.parent_category_id ??
+                categoryData.parent_category?.id;
+            if (parentCategoryId) {
+                parentCategory = await manager.findOne(models_1.ProductCategory.name, parentCategoryId);
+                if (!parentCategory) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Parent category with id: '${parentCategoryId}' does not exist`);
+                }
+            }
+            const result = await manager.create(models_1.ProductCategory.name, categoryData);
+            manager.assign(result, {
+                mpath: parentCategory
+                    ? `${parentCategory.mpath}.${result.id}`
+                    : result.id,
+            });
+            return result;
+        }));
+        manager.persist(categories);
+        return categories;
+    }
+    async update(data, context = {}) {
+        const manager = super.getActiveManager(context);
+        const categories = await Promise.all(data.map(async (entry, i) => {
+            const categoryData = {
+                ...entry,
+            };
+            let productCategory = await manager.findOne(models_1.ProductCategory.name, categoryData.id);
+            if (!productCategory) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `ProductCategory with id: ${categoryData.id} was not found`);
+            }
+            if (!(0, utils_1.isDefined)(categoryData.parent_category_id) &&
+                !(0, utils_1.isDefined)(categoryData.rank)) {
+                for (const key in categoryData) {
+                    if ((0, utils_1.isDefined)(categoryData[key])) {
+                        productCategory[key] = categoryData[key];
+                    }
+                }
+                manager.assign(productCategory, categoryData);
+                return productCategory;
+            }
+            if ((0, utils_1.isDefined)(categoryData.parent_category_id) &&
+                categoryData.parent_category_id !== productCategory.parent_category_id) {
+                if (categoryData.parent_category_id === null) {
+                    categoryData.mpath = "";
+                }
+                else {
+                    productCategory = (await this.buildProductCategoriesWithTree({
+                        descendants: true,
+                    }, [productCategory], {
+                        where: { id: productCategory.id },
+                        serialize: false,
+                    }, context))[0];
+                    const newParentCategory = await manager.findOne(models_1.ProductCategory.name, categoryData.parent_category_id);
+                    if (!newParentCategory) {
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Parent category with id: '${categoryData.parent_category_id}' does not exist`);
+                    }
+                    const categoryDataChildren = categoryData.category_children?.flatMap((child) => child.category_children ?? []);
+                    const categoryDataChildrenMap = new Map(categoryDataChildren?.map((child) => [child.id, child]));
+                    function updateMpathRecursively(category, newBaseMpath) {
+                        const newMpath = `${newBaseMpath}.${category.id}`;
+                        category.mpath = newMpath;
+                        for (let child of category.category_children) {
+                            child = manager.getReference(models_1.ProductCategory.name, child.id);
+                            manager.assign(child, categoryDataChildrenMap.get(child.id) ?? {});
+                            updateMpathRecursively(child, newMpath);
+                        }
+                    }
+                    updateMpathRecursively(productCategory, newParentCategory.mpath);
+                }
+                const siblingsCount = await manager.count(models_1.ProductCategory.name, {
+                    parent_category_id: categoryData.parent_category_id,
+                });
+                categoryData.rank ??= siblingsCount + i;
+                if (categoryData.rank > siblingsCount + i) {
+                    categoryData.rank = siblingsCount + i;
+                }
+                if (categoryData.rank < siblingsCount + i) {
+                    await this.rerankSiblingsAfterCreation(manager, categoryData);
+                }
+                await this.rerankSiblingsAfterDeletion(manager, productCategory);
+                for (const key in categoryData) {
+                    if ((0, utils_1.isDefined)(categoryData[key])) {
+                        productCategory[key] = categoryData[key];
+                    }
+                }
+                manager.assign(productCategory, categoryData);
+                return productCategory;
+            }
+            else if ((0, utils_1.isDefined)(categoryData.rank)) {
+                const siblingsCount = await manager.count(models_1.ProductCategory.name, {
+                    parent_category_id: productCategory.parent_category_id,
+                });
+                if (categoryData.rank > siblingsCount - 1 + i) {
+                    categoryData.rank = siblingsCount - 1 + i;
+                }
+                await this.rerankAllSiblings(manager, productCategory, categoryData);
+            }
+            for (const key in categoryData) {
+                if ((0, utils_1.isDefined)(categoryData[key])) {
+                    productCategory[key] = categoryData[key];
+                }
+            }
+            manager.assign(productCategory, categoryData);
+            return productCategory;
+        }));
+        manager.persist(categories);
+        return categories;
+    }
+    async rerankSiblingsAfterDeletion(manager, removedSibling) {
+        const affectedSiblings = await manager.find(models_1.ProductCategory.name, {
+            parent_category_id: removedSibling.parent_category_id,
+            rank: { $gt: removedSibling.rank },
+        });
+        const updatedSiblings = affectedSiblings.map((sibling) => {
+            manager.assign(sibling, { rank: sibling.rank - 1 });
+            return sibling;
+        });
+        manager.persist(updatedSiblings);
+    }
+    async rerankSiblingsAfterCreation(manager, addedSibling) {
+        const affectedSiblings = await manager.find(models_1.ProductCategory.name, {
+            parent_category_id: addedSibling.parent_category_id,
+            rank: { $gte: addedSibling.rank },
+        });
+        const updatedSiblings = affectedSiblings.map((sibling) => {
+            manager.assign(sibling, { rank: sibling.rank + 1 });
+            return sibling;
+        });
+        manager.persist(updatedSiblings);
+    }
+    async rerankAllSiblings(manager, originalSibling, updatedSibling) {
+        if (originalSibling.rank === updatedSibling.rank) {
+            return;
+        }
+        if (originalSibling.rank < updatedSibling.rank) {
+            const siblings = await manager.find(models_1.ProductCategory.name, {
+                parent_category_id: originalSibling.parent_category_id,
+                rank: { $gt: originalSibling.rank, $lte: updatedSibling.rank },
+            }, { orderBy: { rank: "ASC" } });
+            const updatedSiblings = siblings.map((sibling) => {
+                manager.assign(sibling, { rank: sibling.rank - 1 });
+                return sibling;
+            });
+            manager.persist(updatedSiblings);
+        }
+        else {
+            const siblings = await manager.find(models_1.ProductCategory.name, {
+                parent_category_id: originalSibling.parent_category_id,
+                rank: { $gte: updatedSibling.rank, $lt: originalSibling.rank },
+            }, { orderBy: { rank: "ASC" } });
+            const updatedSiblings = siblings.map((sibling) => {
+                manager.assign(sibling, { rank: sibling.rank + 1 });
+                return sibling;
+            });
+            manager.persist(updatedSiblings);
+        }
+    }
+}
+exports.ProductCategoryRepository = ProductCategoryRepository;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-category.js","sourceRoot":"","sources":["../../../../../../src/modules/product/repositories/product-category.ts"],"names":[],"mappings":";;;AAMA,qDAA4E;AAC5E,6DAG2C;AAE3C,sCAA2C;AAkB3C,mCAAmC;AACnC,MAAa,yBAA0B,SAAQ,gBAAQ,CAAC,0BAEvD;IACC,gBAAgB,CACd,cAAuD,EAAE,KAAK,EAAE,EAAE,EAAE,EACpE,gBAAiD,EAAE;QAEnD,MAAM,YAAY,GAAG,EAAE,GAAG,WAAW,EAAE,CAAA;QACvC,YAAY,CAAC,OAAO,KAAK,EAAE,CAAA;QAC3B,YAAY,CAAC,OAAO,CAAC,OAAO,KAAK;YAC/B,EAAE,EAAE,KAAK;YACT,IAAI,EAAE,KAAK;SACZ,CAAA;QAED,MAAM,MAAM,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,KAAK,EAAE,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,KAAK,EAAE,CAAC,CAAA;QAEvD,IACE,aAAa,CAAC,sBAAsB;YACpC,aAAa,CAAC,oBAAoB,EAClC,CAAC;YACD,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YACtD,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;gBACzC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAA;QACrC,CAAC;QAED,MAAM,kBAAkB,GACtB,aAAa,CAAC,oBAAoB;YAClC,QAAQ,CAAC,QAAQ,CAAC,iBAAiB,CAAC;YACpC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAA;QAE9D,IAAI,kBAAkB,EAAE,CAAC;YACvB,QAAQ,CAAC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;gBACxC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;QACpC,CAAC;QAED,MAAM,oBAAoB,GACxB,aAAa,CAAC,sBAAsB;YACpC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAA;QAEhE,IAAI,oBAAoB,EAAE,CAAC;YACzB,QAAQ,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;gBAC1C,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAA;QACtC,CAAC;QAED,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;YAClC,QAAQ,EAAE,mBAAY,CAAC,SAAS;SACjC,CAAC,CAAA;QAEF,OAAO,YAAY,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,IAAI,CACR,cAAuD,EAAE,KAAK,EAAE,EAAE,EAAE,EACpE,mBAAoD,EAAE,EACtD,UAAmB,EAAE;QAErB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAA;QAEzE,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,IAAI,CAG1C,wBAAe,CAAC,IAAI,EACpB,YAAY,CAAC,KAAK,EAClB,EAAE,GAAG,YAAY,CAAC,OAAO,EAAS,CACnC,CAAA;QAED,IACE,CAAC,gBAAgB,CAAC,sBAAsB;YACxC,CAAC,gBAAgB,CAAC,oBAAoB,EACtC,CAAC;YACD,OAAO,iBAAiB,CAAA;QAC1B,CAAC;QAED,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAC9D;YACE,WAAW,EAAE,gBAAgB,CAAC,sBAAsB;YACpD,SAAS,EAAE,gBAAgB,CAAC,oBAAoB;SACjD,EACD,iBAAiB,EACjB,YAAY,EACZ,OAAO,CACR,CAAA;QAED,OAAO,IAAI,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAA;IAClD,CAAC;IAED,oBAAoB,CAClB,UAAqD;QAErD,MAAM,gBAAgB,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAA;QAEnE,KAAK,MAAM,QAAQ,IAAI,gBAAgB,EAAE,CAAC;YACxC,IAAI,QAAQ,CAAC,iBAAiB,EAAE,CAAC;gBAC/B,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,CACpD,QAAQ,CAAC,iBAAwB,CAC3B,CAAA;YACV,CAAC;QACH,CAAC;QAED,OAAO,gBAAgB,CAAA;IACzB,CAAC;IAED,KAAK,CAAC,8BAA8B,CAClC,OAGC,EACD,iBAA4D,EAC5D,cAEI,EAAE,KAAK,EAAE,EAAE,EAAE,EACjB,UAAmB,EAAE;QAErB,MAAM,EAAE,SAAS,GAAG,IAAI,EAAE,GAAG,WAAW,CAAA;QACxC,OAAO,WAAW,CAAC,SAAS,CAAA;QAE5B,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QAEjE,IAAI,aAAa,GACf,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAA;QACjE,MAAM,oBAAoB,GAAG,aAAa,KAAK,CAAC,CAAC,CAAA;QACjD,IAAI,oBAAoB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YAC9C,WAAW,CAAC,OAAQ,CAAC,QAAS,CAAC,MAAM,CAAC,aAAuB,EAAE,CAAC,CAAC,CAAA;QACnE,CAAC;QAED,aAAa;YACX,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAA;QACnE,MAAM,sBAAsB,GAAG,aAAa,KAAK,CAAC,CAAC,CAAA;QAEnD,IAAI,sBAAsB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YAClD,WAAW,CAAC,OAAQ,CAAC,QAAS,CAAC,MAAM,CAAC,aAAuB,EAAE,CAAC,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,MAAM,GAAU,EAAE,CAAA;QACxB,MAAM,YAAY,GAAG,IAAI,GAAG,EAAE,CAAA;QAE9B,KAAK,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;YACpC,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC,CAAA;YACpD,CAAC;YAED,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,IAAI,MAAM,GAAG,EAAE,CAAA;gBACf,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oBACtC,YAAY,CAAC,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,CAAA;oBAChC,MAAM,IAAI,KAAK,GAAG,GAAG,CAAA;gBACvB,CAAC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAA;QAEhD,MAAM,KAAK,GAAG,EAAE,GAAG,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,CAAA;QACnD,MAAM,OAAO,GAAG;YACd,GAAG,WAAW,CAAC,OAAO;YACtB,KAAK,EAAE,SAAS;YAChB,MAAM,EAAE,CAAC;SACW,CAAA;QAEtB,OAAO,KAAK,CAAC,EAAE,CAAA;QACf,OAAO,KAAK,CAAC,MAAM,CAAA;QACnB,OAAO,KAAK,CAAC,KAAK,CAAA;QAClB,OAAO,KAAK,CAAC,kBAAkB,CAAA;QAE/B,MAAM,gBAAgB,GAAG,SAAS;YAChC,CAAC,CAAC,MAAM,IAAI,CAAC,SAAS,CAClB,MAAM,OAAO,CAAC,IAAI,CAAC,wBAAe,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CACzD;YACH,CAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,wBAAe,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAA;QAE5D,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;QAE5E,gBAAgB,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;YACpC,IAAI,GAAG,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBAChD,GAAG,CAAC,eAAe,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;gBAChE,GAAG,CAAC,kBAAkB,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE,CACnE,IAAI,CACL,CAAA;YACH,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,MAAM,gBAAgB,GAAG,CAAC,QAAa,EAAE,KAAK,GAAG,CAAC,EAAE,EAAE;YACpD,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CACxC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,kBAAkB,KAAK,QAAQ,CAAC,EAAE,CACpD,CAAA;YAED,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;gBACxB,QAAQ,CAAC,iBAAiB,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;oBACpD,OAAO,gBAAgB,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;gBAClE,CAAC,CAAC,CAAA;YACJ,CAAC;YAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;gBAChB,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAChD,OAAO,QAAQ,CAAC,eAAe,CAAA;gBACjC,CAAC;gBAED,OAAO,QAAQ,CAAA;YACjB,CAAC;YAED,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,OAAO,QAAQ,CAAC,iBAAiB,CAAA;YACnC,CAAC;YAED,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;gBACxB,OAAO,QAAQ,CAAC,eAAe,CAAA;YACjC,CAAC;YAED,OAAO,QAAQ,CAAA;QACjB,CAAC,CAAA;QAED,MAAM,0BAA0B,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC/D,MAAM,YAAY,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YAC/C,OAAO,gBAAgB,CAAC,YAAY,CAAC,CAAA;QACvC,CAAC,CAAC,CAAA;QAEF,OAAO,0BAA0B,CAAA;IACnC,CAAC;IAED,KAAK,CAAC,YAAY,CAChB,cAAuD,EAAE,KAAK,EAAE,EAAE,EAAE,EACpE,mBAAoD,EAAE,EACtD,UAAmB,EAAE;QAErB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAA;QAEzE,MAAM,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,OAAO,CAAC,YAAY,CAC5D,wBAAe,CAAC,IAAI,EACpB,YAAY,CAAC,KAAK,EAClB,YAAY,CAAC,OAAc,CAC5B,CAAmE,CAAA;QAEpE,IACE,CAAC,gBAAgB,CAAC,sBAAsB;YACxC,CAAC,gBAAgB,CAAC,oBAAoB,EACtC,CAAC;YACD,OAAO,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAA;QACnC,CAAC;QAED,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAC9D;YACE,WAAW,EAAE,gBAAgB,CAAC,sBAAsB;YACpD,SAAS,EAAE,gBAAgB,CAAC,oBAAoB;SACjD,EACD,iBAAiB,EACjB,YAAY,EACZ,OAAO,CACR,CAAA;QAED,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,cAAc,CAAC,EAAE,KAAK,CAAC,CAAA;IAC3D,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAa,EAAE,UAAmB,EAAE;QAC/C,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;QACnC,MAAM,OAAO,CAAC,YAAY,CAAC,wBAAe,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAA;QACjE,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,UAAU,CACd,GAAa,EACb,UAAmB,EAAE;QAIrB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;QAEnC,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACnB,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,OAAO,CAE3C,wBAAe,CAAC,IAAI,EAAE;gBACtB,EAAE;aACH,CAAC,CAAA;YAEF,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,SAAS,EAC3B,4BAA4B,EAAE,gBAAgB,CAC/C,CAAA;YACH,CAAC;YAED,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAA;YAC3D,OAAO,eAAe,CAAA;QACxB,CAAC,CAAC,CACH,CAAA;QAED,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QAC3B,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;IACzB,CAAC;IAED,KAAK,CAAC,OAAO,CACX,GAAa,EACb,UAAmB,EAAE;QAIrB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACnB,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,aAAa,CAEjD,wBAAe,CAAC,IAAI,EAAE;gBACtB,EAAE;aACH,CAAC,CAAA;YACF,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;YACrD,OAAO,eAAe,CAAA;QACxB,CAAC,CAAC,CACH,CAAA;QAED,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QAC3B,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;IACzB,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,GAAa,EAAE,UAAmB,EAAE;QACnD,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QAEjE,MAAM,OAAO,CAAC,GAAG,CACf,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACnB,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,OAAO,CAG3C,wBAAe,CAAC,IAAI,EACpB,EAAE,EAAE,EAAE,EACN;gBACE,QAAQ,EAAE,CAAC,mBAAmB,CAAC;aACzB,CACT,CAAA;YAED,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,SAAS,EAC3B,4BAA4B,EAAE,gBAAgB,CAC/C,CAAA;YACH,CAAC;YAED,IAAI,eAAe,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACjD,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,WAAW,EAC7B,6BAA6B,EAAE,yCAAyC,CACzE,CAAA;YACH,CAAC;YAED,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;QAClE,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CACV,IAAW,EACX,UAAmB,EAAE;QAErB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QAEjE,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;YAC1B,MAAM,YAAY,GAAqD;gBACrE,GAAG,KAAK;aACT,CAAA;YACD,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,wBAAe,CAAC,IAAI,EAAE;gBAC9D,kBAAkB,EAAE,YAAY,EAAE,kBAAkB,IAAI,IAAI;aAC7D,CAAC,CAAA;YAEF,YAAY,CAAC,IAAI,KAAK,aAAa,GAAG,CAAC,CAAA;YACvC,IAAI,YAAY,CAAC,IAAK,GAAG,aAAa,GAAG,CAAC,EAAE,CAAC;gBAC3C,YAAY,CAAC,IAAI,GAAG,aAAa,GAAG,CAAC,CAAA;YACvC,CAAC;YAED,IAAI,YAAY,CAAC,IAAK,GAAG,aAAa,GAAG,CAAC,EAAE,CAAC;gBAC3C,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;YAC/D,CAAC;YAED,IAAI,cAAc,GAChB,IAAI,CAAA;YACN,MAAM,gBAAgB,GACpB,YAAY,CAAC,kBAAkB;gBAC9B,YAAoB,CAAC,eAAe,EAAE,EAAE,CAAA;YAE3C,IAAI,gBAAgB,EAAE,CAAC;gBACrB,cAAc,GAAG,MAAM,OAAO,CAAC,OAAO,CAEpC,wBAAe,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;gBAEzC,IAAI,CAAC,cAAc,EAAE,CAAC;oBACpB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,6BAA6B,gBAAgB,kBAAkB,CAChE,CAAA;gBACH,CAAC;YACH,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,MAAM,CAGjC,wBAAe,CAAC,IAAI,EACpB,YAAkE,CACnE,CAAA;YAED,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;gBACrB,KAAK,EAAE,cAAc;oBACnB,CAAC,CAAC,GAAG,cAAc,CAAC,KAAK,IAAI,MAAM,CAAC,EAAE,EAAE;oBACxC,CAAC,CAAC,MAAM,CAAC,EAAE;aACd,CAAC,CAAA;YAEF,OAAO,MAAM,CAAA;QACf,CAAC,CAAC,CACH,CAAA;QAED,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QAC3B,OAAO,UAAU,CAAA;IACnB,CAAC;IAED,KAAK,CAAC,MAAM,CACV,IAA2B,EAC3B,UAAmB,EAAE;QAErB,MAAM,OAAO,GAAG,KAAK,CAAC,gBAAgB,CAAmB,OAAO,CAAC,CAAA;QACjE,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;YAC1B,MAAM,YAAY,GAAQ;gBACxB,GAAG,KAAK;aACT,CAAA;YACD,IAAI,eAAe,GAAG,MAAM,OAAO,CAAC,OAAO,CAEzC,wBAAe,CAAC,IAAI,EAAE,YAAY,CAAC,EAAG,CAAC,CAAA;YAEzC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,SAAS,EAC3B,4BAA4B,YAAY,CAAC,EAAE,gBAAgB,CAC5D,CAAA;YACH,CAAC;YAED,IACE,CAAC,IAAA,iBAAS,EAAC,YAAY,CAAC,kBAAkB,CAAC;gBAC3C,CAAC,IAAA,iBAAS,EAAC,YAAY,CAAC,IAAI,CAAC,EAC7B,CAAC;gBACD,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;oBAC/B,IAAI,IAAA,iBAAS,EAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;wBACjC,eAAe,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;oBAC1C,CAAC;gBACH,CAAC;gBAED,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,YAAY,CAAC,CAAA;gBAC7C,OAAO,eAAe,CAAA;YACxB,CAAC;YAED,IACE,IAAA,iBAAS,EAAC,YAAY,CAAC,kBAAkB,CAAC;gBAC1C,YAAY,CAAC,kBAAkB,KAAK,eAAe,CAAC,kBAAkB,EACtE,CAAC;gBACD,IAAI,YAAY,CAAC,kBAAkB,KAAK,IAAI,EAAE,CAAC;oBAC7C,YAAY,CAAC,KAAK,GAAG,EAAE,CAAA;gBACzB,CAAC;qBAAM,CAAC;oBACN,eAAe,GAAG,CAChB,MAAM,IAAI,CAAC,8BAA8B,CACvC;wBACE,WAAW,EAAE,IAAI;qBAClB,EACD,CAAC,eAAe,CAAC,EACjB;wBACE,KAAK,EAAE,EAAE,EAAE,EAAE,eAAe,CAAC,EAAE,EAAE;wBACjC,SAAS,EAAE,KAAK;qBACjB,EACD,OAAO,CACR,CACF,CAAC,CAAC,CAAC,CAAA;oBAEJ,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,OAAO,CAE7C,wBAAe,CAAC,IAAI,EAAE,YAAY,CAAC,kBAAkB,CAAC,CAAA;oBAExD,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACvB,MAAM,IAAI,mBAAW,CACnB,mBAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,6BAA6B,YAAY,CAAC,kBAAkB,kBAAkB,CAC/E,CAAA;oBACH,CAAC;oBAED,MAAM,oBAAoB,GACxB,YAAY,CAAC,iBAAiB,EAAE,OAAO,CACrC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,IAAI,EAAE,CAC9C,CAAA;oBAEH,MAAM,uBAAuB,GAAG,IAAI,GAAG,CACrC,oBAAoB,EAAE,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAC7D,CAAA;oBAED,SAAS,sBAAsB,CAC7B,QAAiD,EACjD,YAAoB;wBAEpB,MAAM,QAAQ,GAAG,GAAG,YAAY,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAA;wBACjD,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAA;wBACzB,KAAK,IAAI,KAAK,IAAI,QAAQ,CAAC,iBAAiB,EAAE,CAAC;4BAC7C,KAAK,GAAG,OAAO,CAAC,YAAY,CAC1B,wBAAe,CAAC,IAAI,EACpB,KAAK,CAAC,EAAE,CACF,CAAA;4BACR,OAAO,CAAC,MAAM,CACZ,KAAK,EACL,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAC5C,CAAA;4BACD,sBAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;wBACzC,CAAC;oBACH,CAAC;oBAED,sBAAsB,CACpB,eAAgB,EACf,iBAAyB,CAAC,KAAM,CAClC,CAAA;gBACH,CAAC;gBAED,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,wBAAe,CAAC,IAAI,EAAE;oBAC9D,kBAAkB,EAAE,YAAY,CAAC,kBAAkB;iBACpD,CAAC,CAAA;gBAEF,YAAY,CAAC,IAAI,KAAK,aAAa,GAAG,CAAC,CAAA;gBACvC,IAAI,YAAY,CAAC,IAAK,GAAG,aAAa,GAAG,CAAC,EAAE,CAAC;oBAC3C,YAAY,CAAC,IAAI,GAAG,aAAa,GAAG,CAAC,CAAA;gBACvC,CAAC;gBAED,IAAI,YAAY,CAAC,IAAK,GAAG,aAAa,GAAG,CAAC,EAAE,CAAC;oBAC3C,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;gBAC/D,CAAC;gBAED,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;gBAEhE,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;oBAC/B,IAAI,IAAA,iBAAS,EAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;wBACjC,eAAe,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;oBAC1C,CAAC;gBACH,CAAC;gBAED,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,YAAY,CAAC,CAAA;gBAC7C,OAAO,eAAe,CAAA;YACxB,CAAC;iBAAM,IAAI,IAAA,iBAAS,EAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,wBAAe,CAAC,IAAI,EAAE;oBAC9D,kBAAkB,EAAE,eAAe,CAAC,kBAAkB;iBACvD,CAAC,CAAA;gBAEF,IAAI,YAAY,CAAC,IAAK,GAAG,aAAa,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC/C,YAAY,CAAC,IAAI,GAAG,aAAa,GAAG,CAAC,GAAG,CAAC,CAAA;gBAC3C,CAAC;gBAED,MAAM,IAAI,CAAC,iBAAiB,CAC1B,OAAO,EACP,eAAe,EACf,YAEC,CACF,CAAA;YACH,CAAC;YAED,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;gBAC/B,IAAI,IAAA,iBAAS,EAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;oBACjC,eAAe,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;gBAC1C,CAAC;YACH,CAAC;YAED,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,YAAY,CAAC,CAAA;YAC7C,OAAO,eAAe,CAAA;QACxB,CAAC,CAAC,CACH,CAAA;QAED,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;QAC3B,OAAO,UAAU,CAAA;IACnB,CAAC;IAES,KAAK,CAAC,2BAA2B,CACzC,OAAyB,EACzB,cAAgE;QAEhE,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,IAAI,CAEzC,wBAAe,CAAC,IAAI,EAAE;YACtB,kBAAkB,EAAE,cAAc,CAAC,kBAAkB;YACrD,IAAI,EAAE,EAAE,GAAG,EAAE,cAAc,CAAC,IAAI,EAAE;SACnC,CAAC,CAAA;QAEF,MAAM,eAAe,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;YACvD,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,CAAA;YACnD,OAAO,OAAO,CAAA;QAChB,CAAC,CAAC,CAAA;QAEF,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IAClC,CAAC;IAES,KAAK,CAAC,2BAA2B,CACzC,OAAyB,EACzB,YAA8D;QAE9D,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,IAAI,CAEzC,wBAAe,CAAC,IAAI,EAAE;YACtB,kBAAkB,EAAE,YAAY,CAAC,kBAAkB;YACnD,IAAI,EAAE,EAAE,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE;SAClC,CAAC,CAAA;QAEF,MAAM,eAAe,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;YACvD,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,CAAA;YACnD,OAAO,OAAO,CAAA;QAChB,CAAC,CAAC,CAAA;QAEF,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IAClC,CAAC;IAES,KAAK,CAAC,iBAAiB,CAC/B,OAAyB,EACzB,eAEC,EACD,cAEC;QAED,IAAI,eAAe,CAAC,IAAI,KAAK,cAAc,CAAC,IAAI,EAAE,CAAC;YACjD,OAAM;QACR,CAAC;QAED,IAAI,eAAe,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC;YAC/C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,IAAI,CAGjC,wBAAe,CAAC,IAAI,EACpB;gBACE,kBAAkB,EAAE,eAAe,CAAC,kBAAkB;gBACtD,IAAI,EAAE,EAAE,GAAG,EAAE,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,EAAE;aAC/D,EACD,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAC7B,CAAA;YAED,MAAM,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC/C,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,CAAA;gBACnD,OAAO,OAAO,CAAA;YAChB,CAAC,CAAC,CAAA;YAEF,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;QAClC,CAAC;aAAM,CAAC;YACN,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,IAAI,CAGjC,wBAAe,CAAC,IAAI,EACpB;gBACE,kBAAkB,EAAE,eAAe,CAAC,kBAAkB;gBACtD,IAAI,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,eAAe,CAAC,IAAI,EAAE;aAC/D,EACD,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAC7B,CAAA;YAED,MAAM,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC/C,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,CAAA;gBACnD,OAAO,OAAO,CAAA;YAChB,CAAC,CAAC,CAAA;YAEF,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;QAClC,CAAC;IACH,CAAC;CACF;AAvpBD,8DAupBC"}