@hartl-services/medusa-base 2.11.0 → 3.0.0

package/.medusa/server/src/modules/tax-compliance/service.js

@@ -0,0 +1,693 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAddressVatNumber = void 0;
+const lib_1 = require("../../shared/lib");
+const tax_compliance_1 = require("@hartl-services/medusa-food-supplements-contracts/paths/tax-compliance");
+const modules_sdk_1 = require("@medusajs/framework/modules-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const registry_1 = require("../../tax-compliance/integrations/registry");
+const validation_policy_1 = require("./domain/validation-policy");
+const tax_compliance_state_1 = __importDefault(require("./models/tax-compliance-state"));
+const tax_compliance_validation_1 = __importDefault(require("./models/tax-compliance-validation"));
+const complete_cart_hooks_1 = require("../../tax-compliance/complete-cart-hooks");
+const plugin_features_1 = require("../../tax-compliance/plugin-features");
+const runtime_settings_1 = require("./runtime-settings");
+const subjectFilter = (subject) => subject.kind === "cart"
+    ? { cart_id: subject.cartId }
+    : { customer_address_id: subject.customerAddressId };
+const subjectColumns = (subject) => subject.kind === "cart"
+    ? { cart_id: subject.cartId, customer_address_id: null, customer_id: null }
+    : {
+        cart_id: null,
+        customer_address_id: subject.customerAddressId,
+        customer_id: subject.customerId,
+    };
+// The cart key keeps its original format so running validations and new ones
+// share one lock across a deploy.
+const subjectLockKey = (subject) => subject.kind === "cart"
+    ? `tax-compliance-validation:${subject.cartId}`
+    : `tax-compliance-validation:customer-address:${subject.customerAddressId}`;
+/** `eligible` and `ineligible` both mean: the UID is real and matches company and address. */
+const isVerifiedStatus = (status) => status === "eligible" || status === "ineligible";
+const STATE_SCOPE = "global";
+const normalizeWhitespace = (value) => value.trim().replace(/\s+/g, " ");
+const normalizeCountryCode = (value) => normalizeWhitespace(value).toLowerCase();
+const normalizeAddress = (address) => ({
+    address1: normalizeWhitespace(address.address1),
+    ...(address.address2
+        ? { address2: normalizeWhitespace(address.address2) }
+        : {}),
+    city: normalizeWhitespace(address.city),
+    countryCode: normalizeCountryCode(address.countryCode),
+    postalCode: normalizeWhitespace(address.postalCode),
+});
+const normalizeFacts = (input) => ({
+    company_name: normalizeWhitespace(input.company_name),
+    customer_vat_number: (0, lib_1.normalizeVatNumber)(input.customer_vat_number),
+    billing_address: normalizeAddress(input.billing_address),
+    delivery_country_code: normalizeCountryCode(input.delivery_country_code),
+    merchant_country_code: normalizeCountryCode(input.merchant_country_code),
+    merchant_vat_number: (0, lib_1.normalizeVatNumber)(input.merchant_vat_number),
+});
+const fingerprint = (value) => (0, lib_1.sha256Hex)(JSON.stringify(value));
+const createCartFingerprint = (input) => fingerprint({
+    billing_address: input.billing_address,
+    company_name: input.company_name.toLocaleLowerCase("de-AT"),
+    customer_vat_number: input.customer_vat_number,
+    delivery_country_code: input.delivery_country_code,
+});
+const createMerchantProfileFingerprint = (input) => fingerprint({
+    merchant_country_code: input.merchant_country_code,
+    merchant_vat_number: input.merchant_vat_number,
+});
+/** Only an Austrian merchant with a real UID queries FinanzOnline. */
+const needsFinanzOnlineCredentials = (input) => input.merchant_country_code === "at" &&
+    (0, lib_1.normalizeVatNumber)(input.merchant_vat_number) !==
+        lib_1.VAT_NUMBER_PLACEHOLDER;
+const safeProviderFacts = (facts) => {
+    if (!facts) {
+        return null;
+    }
+    return {
+        valid: facts.valid,
+        name: facts.name,
+        addressLines: [...facts.addressLines],
+        reference: facts.reference,
+        ...(typeof facts.returnCode === "number"
+            ? { returnCode: facts.returnCode }
+            : {}),
+    };
+};
+const asRecord = (value) => value;
+/** The UID an address carries in its metadata; `null` while it has none. */
+const readAddressVatNumber = (metadata) => {
+    const value = metadata?.[tax_compliance_1.TAX_IDENTIFICATION_METADATA_KEY];
+    return typeof value === "string" && value.trim() ? value : null;
+};
+exports.readAddressVatNumber = readAddressVatNumber;
+/**
+ * The facts a saved address carries now, as the address check submitted
+ * them; `null` while company, UID or a required address part is missing.
+ * Merchant fields are left empty: they are not part of the facts fingerprint.
+ */
+const factsFromCustomerAddress = (address) => {
+    const vatNumber = (0, exports.readAddressVatNumber)(address.metadata);
+    if (!vatNumber ||
+        !address.company?.trim() ||
+        !address.address_1 ||
+        !address.city ||
+        !address.country_code ||
+        !address.postal_code) {
+        return null;
+    }
+    return normalizeFacts({
+        company_name: address.company,
+        customer_vat_number: vatNumber,
+        billing_address: {
+            address1: address.address_1,
+            address2: address.address_2,
+            city: address.city,
+            countryCode: address.country_code,
+            postalCode: address.postal_code,
+        },
+        delivery_country_code: address.country_code,
+        merchant_country_code: "",
+        merchant_vat_number: "",
+    });
+};
+class TaxComplianceService extends (0, utils_1.MedusaService)({
+    TaxComplianceState: tax_compliance_state_1.default,
+    TaxComplianceValidation: tax_compliance_validation_1.default,
+}) {
+    /** Discovered by @hartl-services/medusa-base, which runs these workflows. */
+    // eslint-disable-next-line @medusajs/service-methods-must-be-async -- The base discovers the hooks synchronously while it composes completeCartWorkflow (see CompleteCartParticipant).
+    completeCartHooks() {
+        return complete_cart_hooks_1.taxComplianceCompleteCartHooks;
+    }
+    constructor(container, options = {}) {
+        super(container);
+        /** Discovered by @hartl-services/medusa-base for the feature toggles. */
+        this.pluginFeatures = plugin_features_1.taxCompliancePluginFeatures;
+        this.injectedValidator_ = options.validator;
+        this.logger_ = (0, lib_1.resolveOptionalLogger)(container);
+        this.now_ = options.now ?? (() => new Date());
+        this.currentCartLoader_ = options.currentCartLoader;
+        this.customerAddressesLoader_ = options.customerAddressesLoader;
+    }
+    /**
+     * Whether `validateCart` needs the FinanzOnline credentials for this input:
+     * only an Austrian merchant with a real UID queries FinanzOnline (and never
+     * with an injected test validator). The caller reads them only then.
+     */
+    async requiresFinanzOnlineCredentials(rawInput) {
+        return (!this.injectedValidator_ &&
+            needsFinanzOnlineCredentials(normalizeFacts({
+                company_name: "",
+                customer_vat_number: "",
+                billing_address: {
+                    address1: "",
+                    city: "",
+                    countryCode: "",
+                    postalCode: "",
+                },
+                delivery_country_code: "",
+                ...rawInput,
+            })));
+    }
+    /**
+     * `credentials` are the FinanzOnline credentials from the plugin settings,
+     * read by the caller (`undefined` while not configured: the registry then
+     * answers "unavailable" without calling FinanzOnline).
+     */
+    async validateCart(rawInput, credentials) {
+        const { cart_id, ...facts } = rawInput;
+        return await this.validateSubject({ kind: "cart", cartId: normalizeWhitespace(cart_id) }, normalizeFacts(facts), credentials);
+    }
+    /**
+     * Checks the UID of a saved customer address. The same same-day reuse and
+     * locks as for carts apply, so a UID is queried at most once per day across
+     * carts and addresses.
+     */
+    async validateCustomerAddress(rawInput, credentials) {
+        const { customer_address_id, customer_id, ...facts } = rawInput;
+        return await this.validateSubject({
+            kind: "customer_address",
+            customerAddressId: normalizeWhitespace(customer_address_id),
+            customerId: normalizeWhitespace(customer_id),
+        }, normalizeFacts({
+            ...facts,
+            delivery_country_code: facts.billing_address.countryCode,
+        }), credentials);
+    }
+    async validateSubject(subject, input, credentials) {
+        const now = this.now_();
+        try {
+            return await this.validateWithDatabaseLock(subject, input, now, (await this.requiresFinanzOnlineCredentials(input))
+                ? credentials
+                : undefined);
+        }
+        catch (error) {
+            if (!(0, lib_1.isUniqueConstraintViolation)(error)) {
+                throw error;
+            }
+            const winner = await this.reuseMatchingUniqueConflict(subject, input, now);
+            if (winner) {
+                return winner;
+            }
+            throw error;
+        }
+    }
+    async validateWithDatabaseLock(subject, input, now, credentials, sharedContext = {}) {
+        await this.acquireSubjectValidationLock(subject, sharedContext);
+        await this.acquireUidValidationLock(input, now, sharedContext);
+        return await this.validateNormalized(subject, input, now, credentials, sharedContext);
+    }
+    async reuseMatchingUniqueConflict(subject, input, now, sharedContext = {}) {
+        await this.acquireSubjectValidationLock(subject, sharedContext);
+        await this.acquireUidValidationLock(input, now, sharedContext);
+        const matching = await this.findMatchingValidation(subject, input, now, sharedContext);
+        if (!matching) {
+            return null;
+        }
+        return asRecord(await this.updateTaxComplianceValidations({
+            id: matching.id,
+            cache_used: true,
+            reuse_reason: "unique_conflict_matching_input",
+        }, sharedContext));
+    }
+    async validateNormalized(subject, input, now, credentials, sharedContext) {
+        const matching = await this.findMatchingValidation(subject, input, now, sharedContext);
+        // Same rule as the cross-subject reuse below: an "unavailable" without a
+        // provider answer is checked again instead of being returned all day.
+        if (matching && matching.provider_facts !== null) {
+            return asRecord(await this.updateTaxComplianceValidations({
+                id: matching.id,
+                cache_used: true,
+                reuse_reason: "same_day_matching_input",
+            }, sharedContext));
+        }
+        const reusable = await this.findReusableUidValidation(input, now, sharedContext);
+        if (reusable) {
+            return await this.replaceCurrentEvidence(subject, input, now, reusable.provider, this.evaluateReusableProviderResult(reusable, input), true, "same_day_uid_provider_result", sharedContext);
+        }
+        const validator = this.injectedValidator_ ??
+            (0, registry_1.selectQualifiedVatValidator)({
+                merchantCountryCode: input.merchant_country_code,
+                merchantVatNumber: input.merchant_vat_number,
+                credentials,
+                logger: this.logger_,
+            });
+        const result = await validator.validate({
+            billingAddress: input.billing_address,
+            companyName: input.company_name,
+            customerVatNumber: input.customer_vat_number,
+            deliveryCountryCode: input.delivery_country_code,
+            merchantCountryCode: input.merchant_country_code,
+            merchantVatNumber: input.merchant_vat_number,
+        });
+        return await this.replaceCurrentEvidence(subject, input, now, validator.provider, result, false, null, sharedContext);
+    }
+    async replaceCurrentEvidence(subject, input, now, provider, result, cacheUsed, reuseReason, sharedContext) {
+        const validationDate = (0, lib_1.toIsoDate)(now);
+        const cartFingerprint = createCartFingerprint(input);
+        const merchantProfileFingerprint = createMerchantProfileFingerprint(input);
+        // Retire the current record with an immediate statement: MikroORM flushes
+        // inserts before updates, so an ORM update would reach the database
+        // after the insert below and trip the "one current record" unique index.
+        await this.retireCurrentEvidence(subject, sharedContext);
+        return asRecord(await this.createTaxComplianceValidations({
+            ...subjectColumns(subject),
+            order_id: null,
+            status: result.status,
+            company_name: input.company_name,
+            customer_vat_number: input.customer_vat_number,
+            billing_address: input.billing_address,
+            delivery_country_code: input.delivery_country_code,
+            merchant_country_code: input.merchant_country_code,
+            merchant_vat_number: input.merchant_vat_number,
+            provider,
+            provider_facts: safeProviderFacts(result.provider),
+            validation_reason: result.reason,
+            cart_fingerprint: cartFingerprint,
+            merchant_profile_fingerprint: merchantProfileFingerprint,
+            validated_at: now,
+            validation_date: validationDate,
+            is_current: true,
+            cache_used: cacheUsed,
+            reuse_reason: reuseReason,
+        }, sharedContext));
+    }
+    async retireCurrentEvidence(subject, sharedContext) {
+        const manager = this.requireManager(sharedContext);
+        // The column is chosen from the subject kind, never from input.
+        const column = subject.kind === "cart" ? "cart_id" : "customer_address_id";
+        const id = subject.kind === "cart" ? subject.cartId : subject.customerAddressId;
+        await manager.execute(`update "tax_compliance_validation"
+       set "is_current" = false, "updated_at" = now()
+       where "${column}" = ? and "is_current" = true and "deleted_at" is null`, [id], "run");
+    }
+    async findMatchingValidation(subject, input, now, sharedContext) {
+        const records = (await this.listTaxComplianceValidations({
+            ...subjectFilter(subject),
+            customer_vat_number: input.customer_vat_number,
+            cart_fingerprint: createCartFingerprint(input),
+            merchant_profile_fingerprint: createMerchantProfileFingerprint(input),
+            validation_date: (0, lib_1.toIsoDate)(now),
+            is_current: true,
+        }, { take: 1, order: { created_at: "DESC" } }, sharedContext));
+        return records[0] ?? null;
+    }
+    /**
+     * Only a record FinanzOnline actually answered for (provider facts, valid
+     * or not) is reused, keeping every UID at one query per day. An
+     * "unavailable" without an answer (missing credentials, placeholder UID,
+     * outage, login failure) is not: it must not block the UID until midnight.
+     */
+    async findReusableUidValidation(input, now, sharedContext) {
+        const records = (await this.listTaxComplianceValidations({
+            customer_vat_number: input.customer_vat_number,
+            merchant_country_code: input.merchant_country_code,
+            merchant_vat_number: input.merchant_vat_number,
+            validation_date: (0, lib_1.toIsoDate)(now),
+        }, { order: { created_at: "DESC" } }, sharedContext));
+        return records.find((record) => record.provider_facts !== null) ?? null;
+    }
+    evaluateReusableProviderResult(source, input) {
+        if (source.status === "unavailable" || !source.provider_facts) {
+            return {
+                status: "unavailable",
+                provider: null,
+                reason: source.status === "unavailable"
+                    ? source.validation_reason
+                    : "cached_provider_facts_unavailable",
+            };
+        }
+        const provider = safeProviderFacts(source.provider_facts);
+        const decision = (0, validation_policy_1.evaluateEligibility)({
+            billingAddress: input.billing_address,
+            companyName: input.company_name,
+            customerVatNumber: input.customer_vat_number,
+            deliveryCountryCode: input.delivery_country_code,
+            merchantCountryCode: input.merchant_country_code,
+            provider,
+        });
+        return {
+            status: decision.status,
+            provider,
+            reason: decision.reason,
+        };
+    }
+    async acquireSubjectValidationLock(subject, sharedContext) {
+        const manager = this.requireManager(sharedContext);
+        await (0, lib_1.acquireAdvisoryXactLock)(manager, subjectLockKey(subject));
+    }
+    async acquireUidValidationLock(input, now, sharedContext) {
+        const manager = this.requireManager(sharedContext);
+        await (0, lib_1.acquireAdvisoryXactLock)(manager, `tax-compliance-uid-validation:${input.merchant_vat_number}:${input.customer_vat_number}:${(0, lib_1.toIsoDate)(now)}`);
+    }
+    /**
+     * The stored mirror of the `b2b` and `shipping_tax` toggles. Before the
+     * first sync there is no row; both count as on then, as before the toggles
+     * existed. Read errors propagate (see readTaxComplianceState).
+     */
+    async getTaxComplianceState() {
+        const rows = (await this.listTaxComplianceStates({ scope: STATE_SCOPE }, { take: 1 }));
+        const row = rows[0];
+        return {
+            b2b_active: row?.b2b_active !== false,
+            shipping_tax_active: row?.shipping_tax_active !== false,
+        };
+    }
+    /**
+     * Writes the mirror. The partial unique `scope` index keeps a single row:
+     * concurrent writers race on the INSERT and the loser updates instead.
+     */
+    async storeTaxComplianceState(state, sharedContext = {}) {
+        await this.requireManager(sharedContext).execute(`insert into "tax_compliance_state"
+         ("id", "scope", "b2b_active", "shipping_tax_active", "created_at", "updated_at")
+       values (
+         'tcstate_' || substr(md5(random()::text || clock_timestamp()::text), 1, 26),
+         ?, ?, ?, now(), now()
+       )
+       on conflict ("scope") where "deleted_at" is null
+       do update set
+         "b2b_active" = excluded."b2b_active",
+         "shipping_tax_active" = excluded."shipping_tax_active",
+         "updated_at" = now()`, [STATE_SCOPE, state.b2b_active, state.shipping_tax_active], "run");
+    }
+    requireManager(sharedContext) {
+        return (0, lib_1.requireTransactionManager)(sharedContext, "Tax compliance validation requires a database transaction.");
+    }
+    async getCurrentCartValidation(cartId, cartFingerprint) {
+        const validationDate = (0, lib_1.toIsoDate)(this.now_());
+        const records = (await this.listTaxComplianceValidations({
+            cart_id: cartId,
+            cart_fingerprint: cartFingerprint,
+            validation_date: validationDate,
+            is_current: true,
+        }, { take: 1, order: { created_at: "DESC" } }));
+        return records[0] ?? null;
+    }
+    /** Whether the cart has a current check record, i.e. may be zero-rated. */
+    async hasCurrentCartEvidence(cartId) {
+        const records = await this.listTaxComplianceValidations({ cart_id: cartId, is_current: true }, { take: 1, select: ["id"] });
+        return records.length > 0;
+    }
+    /**
+     * Cart tax path (tax-context hook): the caller passes a fail-safe loader,
+     * so a failing master data read answers "no evidence" and the cart keeps
+     * ordinary B2C rates. The loader is only called for a cart with a current
+     * validation record, so B2C carts never touch the base plugin.
+     */
+    async getCurrentValidationId(cart, loadMerchant) {
+        return await this.currentValidationIdFor(cart, loadMerchant);
+    }
+    /**
+     * Reads the validation record first and calls `loadMerchant` only when one
+     * exists; its failures propagate to the caller.
+     */
+    async currentValidationIdFor(cart, loadMerchant) {
+        const records = (await this.listTaxComplianceValidations({ cart_id: cart.id, is_current: true }, { take: 1, order: { created_at: "DESC" } }));
+        const record = records[0];
+        if (!record) {
+            return null;
+        }
+        const loaded = await loadMerchant();
+        if (!loaded) {
+            return null;
+        }
+        const merchant = (0, runtime_settings_1.normalizeMerchantProfile)(loaded);
+        // The tax-line hooks pass a cart without billing address; the current
+        // cart is loaded then, so its billing company, address and UID count.
+        let currentInput = this.inputFromCart(cart, merchant);
+        if (!currentInput) {
+            try {
+                const currentCart = await this.loadCurrentCart(cart.id);
+                currentInput = currentCart
+                    ? this.inputFromCart(currentCart, merchant)
+                    : null;
+            }
+            catch {
+                return null;
+            }
+        }
+        if (!currentInput) {
+            return null;
+        }
+        return record.validation_date === (0, lib_1.toIsoDate)(this.now_()) &&
+            record.cart_fingerprint === createCartFingerprint(currentInput) &&
+            record.merchant_profile_fingerprint ===
+                createMerchantProfileFingerprint({
+                    ...currentInput,
+                    merchant_country_code: merchant.countryCode,
+                    merchant_vat_number: merchant.vatNumber,
+                })
+            ? record.id
+            : null;
+    }
+    /**
+     * Tax provider path: `merchant` is the profile the cart tax-context hook
+     * put into the tax calculation context (`null` while it had none, e.g.
+     * because the master data read failed): no merchant, no zero rate.
+     */
+    async isValidationEligibleForTax(validationId, rawDeliveryCountryCode, rawMerchant) {
+        if (!rawMerchant) {
+            return false;
+        }
+        const merchant = (0, runtime_settings_1.normalizeMerchantProfile)(rawMerchant);
+        const records = (await this.listTaxComplianceValidations({ id: validationId, is_current: true }, { take: 1 }));
+        const record = records[0];
+        // Only cart evidence can zero-rate a cart; address evidence never reaches
+        // the tax provider directly.
+        if (!record || record.status !== "eligible" || !record.cart_id) {
+            return false;
+        }
+        try {
+            const currentCart = await this.loadCurrentCart(record.cart_id);
+            if (!currentCart ||
+                (await this.currentValidationIdFor(currentCart, async () => merchant)) !==
+                    validationId) {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        const deliveryCountryCode = normalizeCountryCode(rawDeliveryCountryCode);
+        const customerCountryPrefix = record.customer_vat_number.slice(0, 2);
+        return (record.validation_date === (0, lib_1.toIsoDate)(this.now_()) &&
+            record.delivery_country_code === deliveryCountryCode &&
+            customerCountryPrefix === deliveryCountryCode.toUpperCase() &&
+            record.merchant_country_code === merchant.countryCode &&
+            record.merchant_vat_number === merchant.vatNumber &&
+            merchant.countryCode !== deliveryCountryCode &&
+            record.merchant_profile_fingerprint ===
+                createMerchantProfileFingerprint({
+                    merchant_country_code: merchant.countryCode,
+                    merchant_vat_number: merchant.vatNumber,
+                }));
+    }
+    async isOrderValidationEligibleForTax(validationId, orderId, rawDeliveryCountryCode) {
+        const records = (await this.listTaxComplianceValidations({ id: validationId, order_id: orderId }, { take: 1 }));
+        const record = records[0];
+        if (!record || record.status !== "eligible" || !record.provider_facts) {
+            return false;
+        }
+        const deliveryCountryCode = normalizeCountryCode(rawDeliveryCountryCode);
+        const frozenInput = normalizeFacts({
+            company_name: record.company_name,
+            customer_vat_number: record.customer_vat_number,
+            billing_address: record.billing_address,
+            delivery_country_code: record.delivery_country_code,
+            merchant_country_code: record.merchant_country_code,
+            merchant_vat_number: record.merchant_vat_number,
+        });
+        const decision = (0, validation_policy_1.evaluateEligibility)({
+            billingAddress: frozenInput.billing_address,
+            companyName: frozenInput.company_name,
+            customerVatNumber: frozenInput.customer_vat_number,
+            deliveryCountryCode: frozenInput.delivery_country_code,
+            merchantCountryCode: frozenInput.merchant_country_code,
+            provider: record.provider_facts,
+        });
+        return (frozenInput.delivery_country_code === deliveryCountryCode &&
+            record.cart_fingerprint === createCartFingerprint(frozenInput) &&
+            record.merchant_profile_fingerprint ===
+                createMerchantProfileFingerprint(frozenInput) &&
+            decision.status === "eligible");
+    }
+    /**
+     * Checkout guard: the caller passes a strict loader, so a read failure
+     * propagates and the freeze step fails a zero-rated order while an
+     * ordinarily taxed one continues.
+     */
+    async freezeOrderEvidence(orderId, cart, loadMerchant) {
+        const validationId = await this.currentValidationIdFor(cart, loadMerchant);
+        if (!validationId) {
+            return null;
+        }
+        const records = (await this.listTaxComplianceValidations({ id: validationId }, { take: 1 }));
+        const current = records[0];
+        if (!current) {
+            return null;
+        }
+        const previousOrderId = current.order_id;
+        return {
+            evidence: asRecord(await this.updateTaxComplianceValidations({
+                id: validationId,
+                order_id: orderId,
+            })),
+            previousOrderId,
+        };
+    }
+    async restoreOrderEvidence(validationId, previousOrderId) {
+        await this.updateTaxComplianceValidations({
+            id: validationId,
+            order_id: previousOrderId,
+        });
+    }
+    async getOrderValidationId(orderId) {
+        const records = (await this.listTaxComplianceValidations({ order_id: orderId }, { take: 1, order: { created_at: "DESC" } }));
+        return records[0]?.id ?? null;
+    }
+    /**
+     * The current evidence of each of the customer's saved addresses, but only
+     * where it still matches the address as it is now (company, UID in
+     * metadata, address). A changed address has no status until checked again.
+     */
+    async listCustomerAddressIdentifications(customerId) {
+        const addresses = await this.loadCustomerAddresses(customerId);
+        if (addresses.length === 0) {
+            return [];
+        }
+        const records = (await this.listTaxComplianceValidations({
+            customer_address_id: addresses.map(({ id }) => id),
+            customer_id: customerId,
+            is_current: true,
+        }));
+        return addresses.flatMap((address) => {
+            const record = records.find(({ customer_address_id }) => customer_address_id === address.id);
+            const facts = factsFromCustomerAddress(address);
+            if (!record ||
+                !facts ||
+                record.cart_fingerprint !== createCartFingerprint(facts)) {
+                return [];
+            }
+            return [
+                {
+                    customer_address_id: address.id,
+                    status: record.status,
+                    customer_vat_number: record.customer_vat_number,
+                    company_name: record.company_name,
+                    validated_at: record.validated_at,
+                    verified: isVerifiedStatus(record.status),
+                    billing_address: record.billing_address,
+                },
+            ];
+        });
+    }
+    /**
+     * For other plugins (resolved by key, e.g. the Affiliate registration): the
+     * verified identification of one of the customer's addresses, or `null`
+     * when the address is not theirs, has changed since the check, or its UID
+     * is not verified.
+     */
+    async getVerifiedCustomerAddressIdentification(customerId, customerAddressId) {
+        const identifications = await this.listCustomerAddressIdentifications(customerId);
+        const identification = identifications.find(({ customer_address_id }) => customer_address_id === customerAddressId);
+        return identification?.verified ? identification : null;
+    }
+    async loadCustomerAddresses(customerId) {
+        if (this.customerAddressesLoader_) {
+            return await this.customerAddressesLoader_(customerId);
+        }
+        const loadedModule = modules_sdk_1.MedusaModule.getModuleInstance(utils_1.Modules.CUSTOMER);
+        const customerService = loadedModule?.[utils_1.Modules.CUSTOMER];
+        if (!customerService) {
+            return [];
+        }
+        return (await customerService.listCustomerAddresses({
+            customer_id: customerId,
+        }));
+    }
+    async loadCurrentCart(cartId) {
+        if (this.currentCartLoader_) {
+            return await this.currentCartLoader_(cartId);
+        }
+        const loadedModule = modules_sdk_1.MedusaModule.getModuleInstance(utils_1.Modules.CART);
+        const cartService = loadedModule?.[utils_1.Modules.CART];
+        if (!cartService) {
+            return null;
+        }
+        return (await cartService.retrieveCart(cartId, {
+            relations: ["billing_address", "shipping_address"],
+        }));
+    }
+    /** The facts the cart carries now; `null` while company, UID or an address part is missing. */
+    inputFromCart(cart, merchant) {
+        const billing = cart.billing_address;
+        const deliveryCountryCode = cart.shipping_address?.country_code;
+        const customerVatNumber = (0, exports.readAddressVatNumber)(billing?.metadata);
+        if (!customerVatNumber ||
+            !billing?.address_1 ||
+            !billing.city ||
+            !billing.company ||
+            !billing.country_code ||
+            !billing.postal_code ||
+            !deliveryCountryCode) {
+            return null;
+        }
+        return normalizeFacts({
+            company_name: billing.company,
+            customer_vat_number: customerVatNumber,
+            billing_address: {
+                address1: billing.address_1,
+                address2: billing.address_2,
+                city: billing.city,
+                countryCode: billing.country_code,
+                postalCode: billing.postal_code,
+            },
+            delivery_country_code: deliveryCountryCode,
+            merchant_country_code: merchant.countryCode,
+            merchant_vat_number: merchant.vatNumber,
+        });
+    }
+}
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(4, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Date, Object, Object]),
+    __metadata("design:returntype", Promise)
+], TaxComplianceService.prototype, "validateWithDatabaseLock", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Date, Object]),
+    __metadata("design:returntype", Promise)
+], TaxComplianceService.prototype, "reuseMatchingUniqueConflict", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], TaxComplianceService.prototype, "storeTaxComplianceState", null);
+exports.default = TaxComplianceService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/tax-compliance/service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,0CAUyB;AACzB,2GAAwH;AAOxH,iEAA8D;AAC9D,qDAMkC;AAElC,yEAGmD;AAEnD,kEAAgE;AAWhE,yFAA8D;AAC9D,mGAAwE;AACxE,kFAAyF;AACzF,0EAAkF;AAClF,yDAG2B;AA8E3B,MAAM,aAAa,GAAG,CAAC,OAAwB,EAAE,EAAE,CACjD,OAAO,CAAC,IAAI,KAAK,MAAM;IACrB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE;IAC7B,CAAC,CAAC,EAAE,mBAAmB,EAAE,OAAO,CAAC,iBAAiB,EAAE,CAAA;AAExD,MAAM,cAAc,GAAG,CAAC,OAAwB,EAAE,EAAE,CAClD,OAAO,CAAC,IAAI,KAAK,MAAM;IACrB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE;IAC3E,CAAC,CAAC;QACE,OAAO,EAAE,IAAI;QACb,mBAAmB,EAAE,OAAO,CAAC,iBAAiB;QAC9C,WAAW,EAAE,OAAO,CAAC,UAAU;KAChC,CAAA;AAEP,6EAA6E;AAC7E,kCAAkC;AAClC,MAAM,cAAc,GAAG,CAAC,OAAwB,EAAU,EAAE,CAC1D,OAAO,CAAC,IAAI,KAAK,MAAM;IACrB,CAAC,CAAC,6BAA6B,OAAO,CAAC,MAAM,EAAE;IAC/C,CAAC,CAAC,8CAA8C,OAAO,CAAC,iBAAiB,EAAE,CAAA;AAE/E,8FAA8F;AAC9F,MAAM,gBAAgB,GAAG,CAAC,MAA2B,EAAW,EAAE,CAChE,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,YAAY,CAAA;AAqBlD,MAAM,WAAW,GAAG,QAAQ,CAAA;AAQ5B,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAU,EAAE,CACpD,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAEnC,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAU,EAAE,CACrD,mBAAmB,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAA;AAE1C,MAAM,gBAAgB,GAAG,CAAC,OAAwB,EAAmB,EAAE,CAAC,CAAC;IACvE,QAAQ,EAAE,mBAAmB,CAAC,OAAO,CAAC,QAAQ,CAAC;IAC/C,GAAG,CAAC,OAAO,CAAC,QAAQ;QAClB,CAAC,CAAC,EAAE,QAAQ,EAAE,mBAAmB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QACrD,CAAC,CAAC,EAAE,CAAC;IACP,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC;IACvC,WAAW,EAAE,oBAAoB,CAAC,OAAO,CAAC,WAAW,CAAC;IACtD,UAAU,EAAE,mBAAmB,CAAC,OAAO,CAAC,UAAU,CAAC;CACpD,CAAC,CAAA;AAEF,MAAM,cAAc,GAAG,CACrB,KAA6B,EACL,EAAE,CAAC,CAAC;IAC5B,YAAY,EAAE,mBAAmB,CAAC,KAAK,CAAC,YAAY,CAAC;IACrD,mBAAmB,EAAE,IAAA,wBAAkB,EAAC,KAAK,CAAC,mBAAmB,CAAC;IAClE,eAAe,EAAE,gBAAgB,CAAC,KAAK,CAAC,eAAe,CAAC;IACxD,qBAAqB,EAAE,oBAAoB,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACxE,qBAAqB,EAAE,oBAAoB,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACxE,mBAAmB,EAAE,IAAA,wBAAkB,EAAC,KAAK,CAAC,mBAAmB,CAAC;CACnE,CAAC,CAAA;AAEF,MAAM,WAAW,GAAG,CAAC,KAAc,EAAU,EAAE,CAC7C,IAAA,eAAS,EAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;AAElC,MAAM,qBAAqB,GAAG,CAAC,KAA6B,EAAU,EAAE,CACtE,WAAW,CAAC;IACV,eAAe,EAAE,KAAK,CAAC,eAAe;IACtC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,OAAO,CAAC;IAC3D,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;IAC9C,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;CACnD,CAAC,CAAA;AAEJ,MAAM,gCAAgC,GAAG,CACvC,KAAoF,EAC5E,EAAE,CACV,WAAW,CAAC;IACV,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;IAClD,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;CAC/C,CAAC,CAAA;AAEJ,sEAAsE;AACtE,MAAM,4BAA4B,GAAG,CAAC,KAA6B,EAAW,EAAE,CAC9E,KAAK,CAAC,qBAAqB,KAAK,IAAI;IACpC,IAAA,wBAAkB,EAAC,KAAK,CAAC,mBAAmB,CAAC;QAC3C,4BAAsB,CAAA;AAE1B,MAAM,iBAAiB,GAAG,CACxB,KAAuC,EACL,EAAE;IACpC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,CAAA;IACb,CAAC;IAED,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC;QACrC,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,GAAG,CAAC,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;YACtC,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;YAClC,CAAC,CAAC,EAAE,CAAC;KACR,CAAA;AACH,CAAC,CAAA;AAED,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAiC,EAAE,CACjE,KAAsC,CAAA;AAExC,4EAA4E;AACrE,MAAM,oBAAoB,GAAG,CAClC,QAAoD,EACrC,EAAE;IACjB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC,gDAA+B,CAAC,CAAA;IACzD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;AACjE,CAAC,CAAA;AALY,QAAA,oBAAoB,wBAKhC;AAED;;;;GAIG;AACH,MAAM,wBAAwB,GAAG,CAC/B,OAA6C,EACd,EAAE;IACjC,MAAM,SAAS,GAAG,IAAA,4BAAoB,EAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACxD,IACE,CAAC,SAAS;QACV,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE;QACxB,CAAC,OAAO,CAAC,SAAS;QAClB,CAAC,OAAO,CAAC,IAAI;QACb,CAAC,OAAO,CAAC,YAAY;QACrB,CAAC,OAAO,CAAC,WAAW,EACpB,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,OAAO,cAAc,CAAC;QACpB,YAAY,EAAE,OAAO,CAAC,OAAO;QAC7B,mBAAmB,EAAE,SAAS;QAC9B,eAAe,EAAE;YACf,QAAQ,EAAE,OAAO,CAAC,SAAS;YAC3B,QAAQ,EAAE,OAAO,CAAC,SAAS;YAC3B,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,WAAW,EAAE,OAAO,CAAC,YAAY;YACjC,UAAU,EAAE,OAAO,CAAC,WAAW;SAChC;QACD,qBAAqB,EAAE,OAAO,CAAC,YAAY;QAC3C,qBAAqB,EAAE,EAAE;QACzB,mBAAmB,EAAE,EAAE;KACxB,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,oBAAqB,SAAQ,IAAA,qBAAa,EAAC;IAC/C,kBAAkB,EAAlB,8BAAkB;IAClB,uBAAuB,EAAvB,mCAAuB;CACxB,CAAC;IAIA,6EAA6E;IAC7E,uLAAuL;IACvL,iBAAiB;QACf,OAAO,oDAA8B,CAAA;IACvC,CAAC;IAYD,YACE,SAA0B,EAC1B,UAAuC,EAAE;QAEzC,KAAK,CAAC,SAAS,CAAC,CAAA;QAvBlB,yEAAyE;QAChE,mBAAc,GAAG,6CAA2B,CAAA;QAuBnD,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,SAAS,CAAA;QAC3C,IAAI,CAAC,OAAO,GAAG,IAAA,2BAAqB,EAAC,SAAS,CAAC,CAAA;QAC/C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;QAC7C,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAA;QACnD,IAAI,CAAC,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,CAAA;IACjE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,+BAA+B,CACnC,QAGC;QAED,OAAO,CACL,CAAC,IAAI,CAAC,kBAAkB;YACxB,4BAA4B,CAC1B,cAAc,CAAC;gBACb,YAAY,EAAE,EAAE;gBAChB,mBAAmB,EAAE,EAAE;gBACvB,eAAe,EAAE;oBACf,QAAQ,EAAE,EAAE;oBACZ,IAAI,EAAE,EAAE;oBACR,WAAW,EAAE,EAAE;oBACf,UAAU,EAAE,EAAE;iBACf;gBACD,qBAAqB,EAAE,EAAE;gBACzB,GAAG,QAAQ;aACZ,CAAC,CACH,CACF,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAChB,QAA4C,EAC5C,WAAqC;QAErC,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,EAAE,GAAG,QAAQ,CAAA;QACtC,OAAO,MAAM,IAAI,CAAC,eAAe,CAC/B,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,CAAC,OAAO,CAAC,EAAE,EACtD,cAAc,CAAC,KAAK,CAAC,EACrB,WAAW,CACZ,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,uBAAuB,CAC3B,QAAuD,EACvD,WAAqC;QAErC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,GAAG,KAAK,EAAE,GAAG,QAAQ,CAAA;QAC/D,OAAO,MAAM,IAAI,CAAC,eAAe,CAC/B;YACE,IAAI,EAAE,kBAAkB;YACxB,iBAAiB,EAAE,mBAAmB,CAAC,mBAAmB,CAAC;YAC3D,UAAU,EAAE,mBAAmB,CAAC,WAAW,CAAC;SAC7C,EACD,cAAc,CAAC;YACb,GAAG,KAAK;YACR,qBAAqB,EAAE,KAAK,CAAC,eAAe,CAAC,WAAW;SACzD,CAAC,EACF,WAAW,CACZ,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,OAAwB,EACxB,KAA6B,EAC7B,WAAgD;QAEhD,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;QAEvB,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,wBAAwB,CACxC,OAAO,EACP,KAAK,EACL,GAAG,EACH,CAAC,MAAM,IAAI,CAAC,+BAA+B,CAAC,KAAK,CAAC,CAAC;gBACjD,CAAC,CAAC,WAAW;gBACb,CAAC,CAAC,SAAS,CACd,CAAA;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAA,iCAA2B,EAAC,KAAK,CAAC,EAAE,CAAC;gBACxC,MAAM,KAAK,CAAA;YACb,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,CAAA;YAC1E,IAAI,MAAM,EAAE,CAAC;gBACX,OAAO,MAAM,CAAA;YACf,CAAC;YAED,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAGa,AAAN,KAAK,CAAC,wBAAwB,CACpC,OAAwB,EACxB,KAA6B,EAC7B,GAAS,EACT,WAAgD,EAC/B,gBAAgC,EAAE;QAEnD,MAAM,IAAI,CAAC,4BAA4B,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;QAC/D,MAAM,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,EAAE,aAAa,CAAC,CAAA;QAC9D,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAClC,OAAO,EACP,KAAK,EACL,GAAG,EACH,WAAW,EACX,aAAa,CACd,CAAA;IACH,CAAC;IAGa,AAAN,KAAK,CAAC,2BAA2B,CACvC,OAAwB,EACxB,KAA6B,EAC7B,GAAS,EACQ,gBAAgC,EAAE;QAEnD,MAAM,IAAI,CAAC,4BAA4B,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;QAC/D,MAAM,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,EAAE,aAAa,CAAC,CAAA;QAC9D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAChD,OAAO,EACP,KAAK,EACL,GAAG,EACH,aAAa,CACd,CAAA;QAED,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,QAAQ,CACb,MAAM,IAAI,CAAC,8BAA8B,CACvC;YACE,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,gCAAgC;SAC/C,EACD,aAAa,CACd,CACF,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAC9B,OAAwB,EACxB,KAA6B,EAC7B,GAAS,EACT,WAAgD,EAChD,aAA6B;QAE7B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAChD,OAAO,EACP,KAAK,EACL,GAAG,EACH,aAAa,CACd,CAAA;QAED,yEAAyE;QACzE,sEAAsE;QACtE,IAAI,QAAQ,IAAI,QAAQ,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC;YACjD,OAAO,QAAQ,CACb,MAAM,IAAI,CAAC,8BAA8B,CACvC;gBACE,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,UAAU,EAAE,IAAI;gBAChB,YAAY,EAAE,yBAAyB;aACxC,EACD,aAAa,CACd,CACF,CAAA;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,yBAAyB,CACnD,KAAK,EACL,GAAG,EACH,aAAa,CACd,CAAA;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,MAAM,IAAI,CAAC,sBAAsB,CACtC,OAAO,EACP,KAAK,EACL,GAAG,EACH,QAAQ,CAAC,QAAQ,EACjB,IAAI,CAAC,8BAA8B,CAAC,QAAQ,EAAE,KAAK,CAAC,EACpD,IAAI,EACJ,8BAA8B,EAC9B,aAAa,CACd,CAAA;QACH,CAAC;QAED,MAAM,SAAS,GACb,IAAI,CAAC,kBAAkB;YACvB,IAAA,sCAA2B,EAAC;gBAC1B,mBAAmB,EAAE,KAAK,CAAC,qBAAqB;gBAChD,iBAAiB,EAAE,KAAK,CAAC,mBAAmB;gBAC5C,WAAW;gBACX,MAAM,EAAE,IAAI,CAAC,OAAO;aACrB,CAAC,CAAA;QACJ,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,QAAQ,CAAC;YACtC,cAAc,EAAE,KAAK,CAAC,eAAe;YACrC,WAAW,EAAE,KAAK,CAAC,YAAY;YAC/B,iBAAiB,EAAE,KAAK,CAAC,mBAAmB;YAC5C,mBAAmB,EAAE,KAAK,CAAC,qBAAqB;YAChD,mBAAmB,EAAE,KAAK,CAAC,qBAAqB;YAChD,iBAAiB,EAAE,KAAK,CAAC,mBAAmB;SAC7C,CAAC,CAAA;QAEF,OAAO,MAAM,IAAI,CAAC,sBAAsB,CACtC,OAAO,EACP,KAAK,EACL,GAAG,EACH,SAAS,CAAC,QAAQ,EAClB,MAAM,EACN,KAAK,EACL,IAAI,EACJ,aAAa,CACd,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,OAAwB,EACxB,KAA6B,EAC7B,GAAS,EACT,QAAgB,EAChB,MAAoC,EACpC,SAAkB,EAClB,WAA0B,EAC1B,aAA6B;QAE7B,MAAM,cAAc,GAAG,IAAA,eAAS,EAAC,GAAG,CAAC,CAAA;QACrC,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAA;QACpD,MAAM,0BAA0B,GAAG,gCAAgC,CAAC,KAAK,CAAC,CAAA;QAC1E,0EAA0E;QAC1E,oEAAoE;QACpE,yEAAyE;QACzE,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;QAExD,OAAO,QAAQ,CACb,MAAM,IAAI,CAAC,8BAA8B,CACvC;YACE,GAAG,cAAc,CAAC,OAAO,CAAC;YAC1B,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;YAClD,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;YAClD,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,QAAQ;YACR,cAAc,EAAE,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC;YAClD,iBAAiB,EAAE,MAAM,CAAC,MAAM;YAChC,gBAAgB,EAAE,eAAe;YACjC,4BAA4B,EAAE,0BAA0B;YACxD,YAAY,EAAE,GAAG;YACjB,eAAe,EAAE,cAAc;YAC/B,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,SAAS;YACrB,YAAY,EAAE,WAAW;SAC1B,EACD,aAAa,CACd,CACF,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,OAAwB,EACxB,aAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAA;QAElD,gEAAgE;QAChE,MAAM,MAAM,GACV,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,qBAAqB,CAAA;QAC7D,MAAM,EAAE,GACN,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAA;QACtE,MAAM,OAAO,CAAC,OAAO,CACnB;;gBAEU,MAAM,wDAAwD,EACxE,CAAC,EAAE,CAAC,EACJ,KAAK,CACN,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,OAAwB,EACxB,KAA6B,EAC7B,GAAS,EACT,aAA6B;QAE7B,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD;YACE,GAAG,aAAa,CAAC,OAAO,CAAC;YACzB,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,gBAAgB,EAAE,qBAAqB,CAAC,KAAK,CAAC;YAC9C,4BAA4B,EAAE,gCAAgC,CAAC,KAAK,CAAC;YACrE,eAAe,EAAE,IAAA,eAAS,EAAC,GAAG,CAAC;YAC/B,UAAU,EAAE,IAAI;SACjB,EACD,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAC1C,aAAa,CACd,CAA+C,CAAA;QAEhD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IAC3B,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,yBAAyB,CACrC,KAA6B,EAC7B,GAAS,EACT,aAA6B;QAE7B,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD;YACE,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;YAClD,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,eAAe,EAAE,IAAA,eAAS,EAAC,GAAG,CAAC;SAChC,EACD,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EACjC,aAAa,CACd,CAA+C,CAAA;QAEhD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,IAAI,IAAI,CAAA;IACzE,CAAC;IAEO,8BAA8B,CACpC,MAAqC,EACrC,KAA6B;QAE7B,IAAI,MAAM,CAAC,MAAM,KAAK,aAAa,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YAC9D,OAAO;gBACL,MAAM,EAAE,aAAa;gBACrB,QAAQ,EAAE,IAAI;gBACd,MAAM,EACJ,MAAM,CAAC,MAAM,KAAK,aAAa;oBAC7B,CAAC,CAAC,MAAM,CAAC,iBAAiB;oBAC1B,CAAC,CAAC,mCAAmC;aAC1C,CAAA;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,iBAAiB,CAAC,MAAM,CAAC,cAAc,CAAE,CAAA;QAC1D,MAAM,QAAQ,GAAG,IAAA,uCAAmB,EAAC;YACnC,cAAc,EAAE,KAAK,CAAC,eAAe;YACrC,WAAW,EAAE,KAAK,CAAC,YAAY;YAC/B,iBAAiB,EAAE,KAAK,CAAC,mBAAmB;YAC5C,mBAAmB,EAAE,KAAK,CAAC,qBAAqB;YAChD,mBAAmB,EAAE,KAAK,CAAC,qBAAqB;YAChD,QAAQ;SACT,CAAC,CAAA;QAEF,OAAO;YACL,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,QAAQ;YACR,MAAM,EAAE,QAAQ,CAAC,MAAM;SACxB,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,4BAA4B,CACxC,OAAwB,EACxB,aAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAA;QAElD,MAAM,IAAA,6BAAuB,EAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAA;IACjE,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,KAA6B,EAC7B,GAAS,EACT,aAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAA;QAElD,MAAM,IAAA,6BAAuB,EAC3B,OAAO,EACP,iCAAiC,KAAK,CAAC,mBAAmB,IAAI,KAAK,CAAC,mBAAmB,IAAI,IAAA,eAAS,EAAC,GAAG,CAAC,EAAE,CAC5G,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,qBAAqB;QACzB,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,uBAAuB,CAC9C,EAAE,KAAK,EAAE,WAAW,EAAE,EACtB,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAAqC,CAAA;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QACnB,OAAO;YACL,UAAU,EAAE,GAAG,EAAE,UAAU,KAAK,KAAK;YACrC,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,KAAK,KAAK;SACxD,CAAA;IACH,CAAC;IAED;;;OAGG;IAEG,AAAN,KAAK,CAAC,uBAAuB,CAC3B,KAA0B,EACT,gBAAgC,EAAE;QAEnD,MAAM,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,OAAO,CAC9C;;;;;;;;;;8BAUwB,EACxB,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,EAC1D,KAAK,CACN,CAAA;IACH,CAAC;IAEO,cAAc,CAAC,aAA6B;QAClD,OAAO,IAAA,+BAAyB,EAC9B,aAAa,EACb,4DAA4D,CAC7D,CAAA;IACH,CAAC;IAED,KAAK,CAAC,wBAAwB,CAC5B,MAAc,EACd,eAAuB;QAEvB,MAAM,cAAc,GAAG,IAAA,eAAS,EAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAA;QAC7C,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD;YACE,OAAO,EAAE,MAAM;YACf,gBAAgB,EAAE,eAAe;YACjC,eAAe,EAAE,cAAc;YAC/B,UAAU,EAAE,IAAI;SACjB,EACD,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,CAC3C,CAA+C,CAAA;QAEhD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IAC3B,CAAC;IAED,2EAA2E;IAC3E,KAAK,CAAC,sBAAsB,CAAC,MAAc;QACzC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACrD,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,EACrC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAC5B,CAAA;QACD,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAA;IAC3B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,sBAAsB,CAC1B,IAA+B,EAC/B,YAAmC;QAEnC,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;IAC9D,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,sBAAsB,CAClC,IAA+B,EAC/B,YAAmC;QAEnC,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,EACtC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,CAC3C,CAA+C,CAAA;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACzB,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,YAAY,EAAE,CAAA;QACnC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAA;QACb,CAAC;QACD,MAAM,QAAQ,GAAG,IAAA,2CAAwB,EAAC,MAAM,CAAC,CAAA;QAEjD,sEAAsE;QACtE,sEAAsE;QACtE,IAAI,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACrD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;gBACvD,YAAY,GAAG,WAAW;oBACxB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,QAAQ,CAAC;oBAC3C,CAAC,CAAC,IAAI,CAAA;YACV,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,IAAI,CAAA;YACb,CAAC;QACH,CAAC;QACD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,MAAM,CAAC,eAAe,KAAK,IAAA,eAAS,EAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACtD,MAAM,CAAC,gBAAgB,KAAK,qBAAqB,CAAC,YAAY,CAAC;YAC/D,MAAM,CAAC,4BAA4B;gBACjC,gCAAgC,CAAC;oBAC/B,GAAG,YAAY;oBACf,qBAAqB,EAAE,QAAQ,CAAC,WAAW;oBAC3C,mBAAmB,EAAE,QAAQ,CAAC,SAAS;iBACxC,CAAC;YACJ,CAAC,CAAC,MAAM,CAAC,EAAE;YACX,CAAC,CAAC,IAAI,CAAA;IACV,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,0BAA0B,CAC9B,YAAoB,EACpB,sBAA8B,EAC9B,WAAgD;QAEhD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,KAAK,CAAA;QACd,CAAC;QACD,MAAM,QAAQ,GAAG,IAAA,2CAAwB,EAAC,WAAW,CAAC,CAAA;QAEtD,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD,EAAE,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,EACtC,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAA+C,CAAA;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACzB,0EAA0E;QAC1E,6BAA6B;QAC7B,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAC/D,OAAO,KAAK,CAAA;QACd,CAAC;QAED,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAC9D,IACE,CAAC,WAAW;gBACZ,CAAC,MAAM,IAAI,CAAC,sBAAsB,CAChC,WAAW,EACX,KAAK,IAAI,EAAE,CAAC,QAAQ,CACrB,CAAC;oBACA,YAAY,EACd,CAAC;gBACD,OAAO,KAAK,CAAA;YACd,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAA;QACd,CAAC;QAED,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAA;QACxE,MAAM,qBAAqB,GAAG,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QAEpE,OAAO,CACL,MAAM,CAAC,eAAe,KAAK,IAAA,eAAS,EAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACjD,MAAM,CAAC,qBAAqB,KAAK,mBAAmB;YACpD,qBAAqB,KAAK,mBAAmB,CAAC,WAAW,EAAE;YAC3D,MAAM,CAAC,qBAAqB,KAAK,QAAQ,CAAC,WAAW;YACrD,MAAM,CAAC,mBAAmB,KAAK,QAAQ,CAAC,SAAS;YACjD,QAAQ,CAAC,WAAW,KAAK,mBAAmB;YAC5C,MAAM,CAAC,4BAA4B;gBACjC,gCAAgC,CAAC;oBAC/B,qBAAqB,EAAE,QAAQ,CAAC,WAAW;oBAC3C,mBAAmB,EAAE,QAAQ,CAAC,SAAS;iBACxC,CAAC,CACL,CAAA;IACH,CAAC;IAED,KAAK,CAAC,+BAA+B,CACnC,YAAoB,EACpB,OAAe,EACf,sBAA8B;QAE9B,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD,EAAE,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,EACvC,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAA+C,CAAA;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACzB,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACtE,OAAO,KAAK,CAAA;QACd,CAAC;QAED,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAA;QACxE,MAAM,WAAW,GAAG,cAAc,CAAC;YACjC,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;YAC/C,eAAe,EAAE,MAAM,CAAC,eAAe;YACvC,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;YACnD,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;YACnD,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;SAChD,CAAC,CAAA;QACF,MAAM,QAAQ,GAAG,IAAA,uCAAmB,EAAC;YACnC,cAAc,EAAE,WAAW,CAAC,eAAe;YAC3C,WAAW,EAAE,WAAW,CAAC,YAAY;YACrC,iBAAiB,EAAE,WAAW,CAAC,mBAAmB;YAClD,mBAAmB,EAAE,WAAW,CAAC,qBAAqB;YACtD,mBAAmB,EAAE,WAAW,CAAC,qBAAqB;YACtD,QAAQ,EAAE,MAAM,CAAC,cAAc;SAChC,CAAC,CAAA;QAEF,OAAO,CACL,WAAW,CAAC,qBAAqB,KAAK,mBAAmB;YACzD,MAAM,CAAC,gBAAgB,KAAK,qBAAqB,CAAC,WAAW,CAAC;YAC9D,MAAM,CAAC,4BAA4B;gBACjC,gCAAgC,CAAC,WAAW,CAAC;YAC/C,QAAQ,CAAC,MAAM,KAAK,UAAU,CAC/B,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,mBAAmB,CACvB,OAAe,EACf,IAA+B,EAC/B,YAAmC;QAEnC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;QAC1E,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD,EAAE,EAAE,EAAE,YAAY,EAAE,EACpB,EAAE,IAAI,EAAE,CAAC,EAAE,CACZ,CAA+C,CAAA;QAChD,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAA;QACb,CAAC;QACD,MAAM,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAA;QAExC,OAAO;YACL,QAAQ,EAAE,QAAQ,CAChB,MAAM,IAAI,CAAC,8BAA8B,CAAC;gBACxC,EAAE,EAAE,YAAY;gBAChB,QAAQ,EAAE,OAAO;aAClB,CAAC,CACH;YACD,eAAe;SAChB,CAAA;IACH,CAAC;IAED,KAAK,CAAC,oBAAoB,CACxB,YAAoB,EACpB,eAA8B;QAE9B,MAAM,IAAI,CAAC,8BAA8B,CAAC;YACxC,EAAE,EAAE,YAAY;YAChB,QAAQ,EAAE,eAAe;SAC1B,CAAC,CAAA;IACJ,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,OAAe;QACxC,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CACtD,EAAE,QAAQ,EAAE,OAAO,EAAE,EACrB,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,CAC3C,CAA+C,CAAA;QAEhD,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,IAAI,CAAA;IAC/B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kCAAkC,CACtC,UAAkB;QAElB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAA;QAC9D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,CAAA;QACX,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,4BAA4B,CAAC;YACvD,mBAAmB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;YAClD,WAAW,EAAE,UAAU;YACvB,UAAU,EAAE,IAAI;SACjB,CAAC,CAA+C,CAAA;QAEjD,OAAO,SAAS,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACnC,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CACzB,CAAC,EAAE,mBAAmB,EAAE,EAAE,EAAE,CAAC,mBAAmB,KAAK,OAAO,CAAC,EAAE,CAChE,CAAA;YACD,MAAM,KAAK,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAA;YAC/C,IACE,CAAC,MAAM;gBACP,CAAC,KAAK;gBACN,MAAM,CAAC,gBAAgB,KAAK,qBAAqB,CAAC,KAAK,CAAC,EACxD,CAAC;gBACD,OAAO,EAAE,CAAA;YACX,CAAC;YAED,OAAO;gBACL;oBACE,mBAAmB,EAAE,OAAO,CAAC,EAAE;oBAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;oBAC/C,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,QAAQ,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;oBACzC,eAAe,EAAE,MAAM,CAAC,eAAe;iBACxC;aACF,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,wCAAwC,CAC5C,UAAkB,EAClB,iBAAyB;QAEzB,MAAM,eAAe,GACnB,MAAM,IAAI,CAAC,kCAAkC,CAAC,UAAU,CAAC,CAAA;QAC3D,MAAM,cAAc,GAAG,eAAe,CAAC,IAAI,CACzC,CAAC,EAAE,mBAAmB,EAAE,EAAE,EAAE,CAAC,mBAAmB,KAAK,iBAAiB,CACvE,CAAA;QACD,OAAO,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAA;IACzD,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,UAAkB;QAElB,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAClC,OAAO,MAAM,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAA;QACxD,CAAC;QAED,MAAM,YAAY,GAAG,0BAAY,CAAC,iBAAiB,CAAC,eAAO,CAAC,QAAQ,CAEvD,CAAA;QACb,MAAM,eAAe,GAAG,YAAY,EAAE,CAAC,eAAO,CAAC,QAAQ,CAAC,CAAA;QACxD,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO,EAAE,CAAA;QACX,CAAC;QAED,OAAO,CAAC,MAAM,eAAe,CAAC,qBAAqB,CAAC;YAClD,WAAW,EAAE,UAAU;SACxB,CAAC,CAA2C,CAAA;IAC/C,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,MAAc;QAEd,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAA;QAC9C,CAAC;QAED,MAAM,YAAY,GAAG,0BAAY,CAAC,iBAAiB,CAAC,eAAO,CAAC,IAAI,CAEnD,CAAA;QACb,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC,eAAO,CAAC,IAAI,CAAC,CAAA;QAChD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,CAAC,MAAM,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE;YAC7C,SAAS,EAAE,CAAC,iBAAiB,EAAE,kBAAkB,CAAC;SACnD,CAAC,CAA8B,CAAA;IAClC,CAAC;IAED,+FAA+F;IACvF,aAAa,CACnB,IAA+B,EAC/B,QAAsC;QAEtC,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAA;QACpC,MAAM,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAA;QAC/D,MAAM,iBAAiB,GAAG,IAAA,4BAAoB,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QACjE,IACE,CAAC,iBAAiB;YAClB,CAAC,OAAO,EAAE,SAAS;YACnB,CAAC,OAAO,CAAC,IAAI;YACb,CAAC,OAAO,CAAC,OAAO;YAChB,CAAC,OAAO,CAAC,YAAY;YACrB,CAAC,OAAO,CAAC,WAAW;YACpB,CAAC,mBAAmB,EACpB,CAAC;YACD,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,cAAc,CAAC;YACpB,YAAY,EAAE,OAAO,CAAC,OAAO;YAC7B,mBAAmB,EAAE,iBAAiB;YACtC,eAAe,EAAE;gBACf,QAAQ,EAAE,OAAO,CAAC,SAAS;gBAC3B,QAAQ,EAAE,OAAO,CAAC,SAAS;gBAC3B,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,WAAW,EAAE,OAAO,CAAC,YAAY;gBACjC,UAAU,EAAE,OAAO,CAAC,WAAW;aAChC;YACD,qBAAqB,EAAE,mBAAmB;YAC1C,qBAAqB,EAAE,QAAQ,CAAC,WAAW;YAC3C,mBAAmB,EAAE,QAAQ,CAAC,SAAS;SACxC,CAAC,CAAA;IACJ,CAAC;CACF;AA1tBe;IADb,IAAA,gCAAwB,GAAE;IAMxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;qDAFX,IAAI;;oEAaV;AAGa;IADb,IAAA,gCAAwB,GAAE;IAKxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;qDADX,IAAI;;uEA0BV;AA2QK;IADL,IAAA,gCAAwB,GAAE;IAGxB,WAAA,IAAA,qBAAa,GAAE,CAAA;;;;mEAiBjB;AA8YH,kBAAe,oBAAoB,CAAA"}