@voyant-travel/storefront 0.120.1

package/dist/routes-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"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"}

package/dist/routes-public.js

@@ -0,0 +1,362 @@
+// agent-quality: file-size exception -- owner: storefront; existing route module stays co-located until a dedicated split preserves behavior and tests.
+import { checkoutCapabilityActions, checkoutCapabilityCookie, issueCheckoutCapability, } from "@voyant-travel/bookings/checkout-capability";
+import { enqueueWriteIntent, getWriteIntent } from "@voyant-travel/db/write-intents";
+import { idempotencyKey, parseJsonBody, parseQuery, } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { BOOKING_BOOTSTRAP_INTENT_EVENT, BOOKING_BOOTSTRAP_INTENT_KIND, } from "./booking-intents.js";
+import { createStorefrontService, } from "./service.js";
+import { storefrontBookingSessionBootstrapInputSchema, storefrontDepartureListQuerySchema, storefrontDeparturePricePreviewInputSchema, storefrontLeadIntakeInputSchema, storefrontNewsletterSubscribeInputSchema, storefrontOfferApplyInputSchema, storefrontOfferRedeemInputSchema, storefrontProductAvailabilitySummaryQuerySchema, storefrontProductExtensionsQuerySchema, storefrontPromotionalOfferListQuerySchema, } from "./validation.js";
+import { storefrontTransportEligibilityInputSchema } from "./validation-transport-eligibility.js";
+/**
+ * Shared-cache marker for non-personalized catalog reads (departure
+ * detail/list, itineraries). Same data for every visitor; the framework
+ * cache layer (`publicResponseCache` in @voyant-travel/hono) and the platform
+ * dispatcher only cache responses explicitly marked like this. Applied
+ * to success responses only.
+ */
+const PUBLIC_CACHE_CONTROL = "public, s-maxage=60, stale-while-revalidate=300";
+/**
+ * KV read-model TTL for the departure list (RFC voyant#1687 Phase 2.2).
+ * Departure availability shifts with every booking, so unlike the
+ * product-detail documents (24h + exact invalidation in products) this
+ * is purely TTL-bounded: browse-grade freshness within 2 minutes, and
+ * checkout always re-verifies capacity on the live transactional path.
+ */
+const DEPARTURES_DOC_TTL_SECONDS = 120;
+export function departuresDocKey(productId, query) {
+    const entries = Object.entries(query)
+        .filter(([, value]) => value !== undefined && value !== null)
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join("&");
+    return `rm:v1:departures:${productId}:${entries || "default"}`;
+}
+/**
+ * Read-through KV cache for a departures payload. Best-effort: any KV
+ * failure (or a missing CACHE binding) degrades to the live query.
+ */
+export async function readThroughDepartures(c, key, compute) {
+    const kv = c.env?.CACHE;
+    if (kv) {
+        try {
+            const hit = await kv.get(key, { type: "json" });
+            if (hit !== null && hit !== undefined)
+                return hit;
+        }
+        catch {
+            // fall through to live
+        }
+    }
+    const data = await compute();
+    if (kv && data !== null && data !== undefined) {
+        try {
+            await kv.put(key, JSON.stringify(data), { expirationTtl: DEPARTURES_DOC_TTL_SECONDS });
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return data;
+}
+function getRuntimeEnv(c) {
+    const processEnv = globalThis.process?.env ?? {};
+    return {
+        ...processEnv,
+        ...(c.env ?? {}),
+    };
+}
+function sessionConflictError(status) {
+    switch (status) {
+        case "insufficient_capacity":
+            return "Insufficient slot capacity";
+        case "slot_unavailable":
+            return "Availability slot is not bookable";
+        case "pricing_unavailable":
+            return "Pricing is not available for the selected booking session items";
+        case "stale_quote":
+            return "Booking session quote is stale";
+        case "invalid_slot":
+            return "Booking session slot does not match the requested departure";
+        default:
+            return "Unable to bootstrap booking session";
+    }
+}
+function attachCheckoutCapability(session, issued) {
+    return {
+        ...session,
+        checkoutCapability: {
+            token: issued.token,
+            expiresAt: issued.expiresAt.toISOString(),
+            actions: [...checkoutCapabilityActions],
+        },
+    };
+}
+export function createStorefrontPublicRoutes(options) {
+    const storefrontService = createStorefrontService(options);
+    function getRequestContext(c) {
+        return {
+            db: c.get("db"),
+            eventBus: c.get("eventBus"),
+            env: c.env,
+            context: c,
+        };
+    }
+    async function runIntakeGuard(input) {
+        const decision = await storefrontService.checkIntakeGuard(input);
+        if (!decision || decision.allowed)
+            return null;
+        return {
+            status: decision.status ?? 403,
+            error: decision.error ?? "Storefront intake rejected",
+        };
+    }
+    return new Hono()
+        .get("/settings", async (c) => {
+        return c.json({ data: await storefrontService.resolveSettings(getRequestContext(c)) });
+    })
+        .post("/leads", async (c) => {
+        const context = getRequestContext(c);
+        const body = await parseJsonBody(c, storefrontLeadIntakeInputSchema);
+        const rejected = await runIntakeGuard({ kind: "lead", body, context });
+        if (rejected)
+            return c.json({ error: rejected.error }, rejected.status);
+        return c.json({
+            data: await storefrontService.createLead({
+                body,
+                context,
+            }),
+        }, 201);
+    })
+        .post("/newsletter/subscribe", async (c) => {
+        const context = getRequestContext(c);
+        const body = await parseJsonBody(c, storefrontNewsletterSubscribeInputSchema);
+        const rejected = await runIntakeGuard({ kind: "newsletter", body, context });
+        if (rejected)
+            return c.json({ error: rejected.error }, rejected.status);
+        return c.json({
+            data: await storefrontService.subscribeNewsletter({
+                body,
+                context,
+            }),
+        }, 202);
+    })
+        .get("/departures/:departureId", async (c) => {
+        const departure = await storefrontService.getDeparture(c.get("db"), c.req.param("departureId"));
+        if (!departure)
+            return c.json({ error: "Storefront departure not found" }, 404);
+        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        return c.json({ data: departure });
+    })
+        .get("/products/:productId/departures", async (c) => {
+        const productId = c.req.param("productId");
+        const query = await parseQuery(c, storefrontDepartureListQuerySchema);
+        const result = await readThroughDepartures(c, departuresDocKey(productId, query), () => storefrontService.listProductDepartures(c.get("db"), productId, query));
+        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        return c.json(result);
+    })
+        .post("/departures/:departureId/price", async (c) => {
+        const preview = await storefrontService.previewDeparturePrice(c.get("db"), c.req.param("departureId"), await parseJsonBody(c, storefrontDeparturePricePreviewInputSchema), getRequestContext(c));
+        return preview
+            ? c.json({ data: preview })
+            : c.json({ error: "Storefront departure not found" }, 404);
+    })
+        .post("/bookings/sessions/bootstrap", idempotencyKey({
+        scope: "POST /v1/public/bookings/sessions/bootstrap",
+        replayResponses: false,
+    }), async (c) => {
+        // Async mode (RFC voyant#1687 Phase 3.2): `?async=1` or
+        // `Prefer: respond-async` stores a write intent + durably emits
+        // its event (outbox), and answers 202 + a status URL — under a
+        // booking spike, callers get instant 202s and the reserve
+        // transactions drain at the outbox's pace instead of
+        // thundering-herding the slot locks. The handler is
+        // `createBookingBootstrapIntentHandler` (booking-intents.ts),
+        // registered on the app bus by the deployment.
+        // Async mode is honored ONLY when the deployment wired the
+        // intent handler (`bookingIntents` option) — otherwise a 202'd
+        // intent would never be settled and the caller would watch it
+        // stale-fail. Unwired deployments silently get the sync path.
+        const wantsAsync = Boolean(options?.bookingIntents) &&
+            (c.req.query("async") === "1" ||
+                (c.req.header("prefer") ?? "").toLowerCase().includes("respond-async"));
+        if (wantsAsync) {
+            const idempotencyKey = c.req.header("idempotency-key")?.trim();
+            if (!idempotencyKey) {
+                return c.json({ error: "Idempotency-Key header is required for async bootstrap" }, 428);
+            }
+            const body = await parseJsonBody(c, storefrontBookingSessionBootstrapInputSchema);
+            const db = c.get("db");
+            const { intent, created } = await enqueueWriteIntent(db, {
+                kind: BOOKING_BOOTSTRAP_INTENT_KIND,
+                payload: {
+                    input: body,
+                    userId: c.get("userId"),
+                },
+                idempotencyKey,
+            });
+            if (created) {
+                const eventBus = c.get("eventBus");
+                await eventBus?.emit(BOOKING_BOOTSTRAP_INTENT_EVENT, { intentId: intent.id });
+            }
+            return c.json({
+                data: {
+                    intentId: intent.id,
+                    status: intent.status,
+                    statusUrl: `/v1/public/bookings/intents/${intent.id}`,
+                },
+            }, 202);
+        }
+        const result = await storefrontService.bootstrapBookingSession(getRequestContext(c), await parseJsonBody(c, storefrontBookingSessionBootstrapInputSchema), c.get("userId"));
+        if (result.status === "departure_not_found") {
+            return c.json({ error: "Storefront departure not found" }, 404);
+        }
+        if (result.status === "slot_not_found") {
+            return c.json({ error: "Availability slot not found" }, 404);
+        }
+        if (result.status !== "ok") {
+            return c.json({
+                error: sessionConflictError(result.status),
+                ...(result.status === "stale_quote" && "repricing" in result
+                    ? { data: { repricing: result.repricing } }
+                    : {}),
+            }, result.status === "invalid_slot" ? 400 : 409);
+        }
+        if (!("bootstrap" in result)) {
+            return c.json({ error: "Unable to bootstrap booking session" }, 409);
+        }
+        const { bootstrap } = result;
+        const capability = await issueCheckoutCapability(bootstrap.session.sessionId, getRuntimeEnv(c));
+        c.header("Set-Cookie", checkoutCapabilityCookie(capability.token, capability.expiresAt), {
+            append: true,
+        });
+        return c.json({
+            data: {
+                ...bootstrap,
+                session: attachCheckoutCapability(bootstrap.session, capability),
+            },
+        }, 201);
+    })
+        .get("/bookings/intents/:intentId", async (c) => {
+        const db = c.get("db");
+        const intent = await getWriteIntent(db, c.req.param("intentId"));
+        if (!intent || intent.kind !== BOOKING_BOOTSTRAP_INTENT_KIND) {
+            return c.json({ error: "Booking intent not found" }, 404);
+        }
+        if (intent.status === "succeeded") {
+            const stored = intent.result;
+            const bootstrap = stored?.bootstrap;
+            if (bootstrap?.session?.sessionId) {
+                // The checkout capability is issued at POLL time (it's a
+                // signed short-lived token derived from the sessionId — the
+                // async handler has no response to attach a cookie to).
+                const capability = await issueCheckoutCapability(bootstrap.session.sessionId, getRuntimeEnv(c));
+                c.header("Set-Cookie", checkoutCapabilityCookie(capability.token, capability.expiresAt), {
+                    append: true,
+                });
+                return c.json({
+                    data: {
+                        intentId: intent.id,
+                        status: "succeeded",
+                        ...bootstrap,
+                        session: attachCheckoutCapability(bootstrap.session, capability),
+                    },
+                });
+            }
+        }
+        if (intent.status === "failed") {
+            const detail = (intent.result ?? {});
+            return c.json({
+                data: {
+                    intentId: intent.id,
+                    status: "failed",
+                    error: detail.conflict
+                        ? sessionConflictError(detail.conflict)
+                        : (intent.error ?? "Booking intent failed"),
+                    ...(detail.conflict ? { conflict: detail.conflict } : {}),
+                    ...(detail.httpStatus ? { httpStatus: detail.httpStatus } : {}),
+                    ...(detail.repricing !== undefined ? { repricing: detail.repricing } : {}),
+                },
+            });
+        }
+        return c.json({ data: { intentId: intent.id, status: "pending" } });
+    })
+        .post("/departures/:departureId/eligibility", async (c) => {
+        return c.json({
+            data: await storefrontService.checkDepartureTransportEligibility({
+                departureId: c.req.param("departureId"),
+                body: await parseJsonBody(c, storefrontTransportEligibilityInputSchema),
+                context: getRequestContext(c),
+            }),
+        });
+    })
+        .post("/products/:productId/departures/:departureId/eligibility", async (c) => {
+        return c.json({
+            data: await storefrontService.checkDepartureTransportEligibility({
+                departureId: c.req.param("departureId"),
+                productId: c.req.param("productId"),
+                body: await parseJsonBody(c, storefrontTransportEligibilityInputSchema),
+                context: getRequestContext(c),
+            }),
+        });
+    })
+        .get("/products/:productId/extensions", async (c) => {
+        const query = await parseQuery(c, storefrontProductExtensionsQuerySchema);
+        return c.json({
+            data: await storefrontService.getProductExtensions(c.get("db"), c.req.param("productId"), query.optionId),
+        });
+    })
+        .get("/products/:productId/availability", async (c) => {
+        return c.json({
+            data: await storefrontService.getProductAvailabilitySummary(c.get("db"), c.req.param("productId"), await parseQuery(c, storefrontProductAvailabilitySummaryQuerySchema)),
+        });
+    })
+        .get("/products/:productId/departures/:departureId/itinerary", async (c) => {
+        const itinerary = await storefrontService.getDepartureItinerary(c.get("db"), {
+            departureId: c.req.param("departureId"),
+            productId: c.req.param("productId"),
+        });
+        if (!itinerary)
+            return c.json({ error: "Storefront itinerary not found" }, 404);
+        c.header("Cache-Control", PUBLIC_CACHE_CONTROL);
+        return c.json({ data: itinerary });
+    })
+        .get("/products/:productId/offers", async (c) => {
+        const query = await parseQuery(c, storefrontPromotionalOfferListQuerySchema);
+        return c.json({
+            data: await storefrontService.listApplicableOffers({
+                productId: c.req.param("productId"),
+                departureId: query.departureId,
+                locale: query.locale,
+                context: getRequestContext(c),
+            }),
+        });
+    })
+        .get("/offers/:slug", async (c) => {
+        const query = await parseQuery(c, storefrontPromotionalOfferListQuerySchema);
+        const offer = await storefrontService.getOfferBySlug({
+            slug: c.req.param("slug"),
+            locale: query.locale,
+            context: getRequestContext(c),
+        });
+        return offer ? c.json({ data: offer }) : c.json({ error: "Storefront offer not found" }, 404);
+    })
+        .post("/offers/:slug/apply", async (c) => {
+        const result = await storefrontService.applyOffer({
+            slug: c.req.param("slug"),
+            body: await parseJsonBody(c, storefrontOfferApplyInputSchema),
+            context: getRequestContext(c),
+        });
+        return result
+            ? c.json({ data: result })
+            : c.json({ error: "Storefront offer application is not configured" }, 501);
+    })
+        .post("/offers/redeem", async (c) => {
+        const result = await storefrontService.redeemOffer({
+            body: await parseJsonBody(c, storefrontOfferRedeemInputSchema),
+            context: getRequestContext(c),
+        });
+        return result
+            ? c.json({ data: result })
+            : c.json({ error: "Storefront offer redemption is not configured" }, 501);
+    });
+}

package/dist/service-booking-session-bootstrap.d.ts

@@ -0,0 +1,227 @@
+import { type PaymentPolicy } from "@voyant-travel/finance";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { StorefrontBookingSessionBootstrapInput } from "./validation.js";
+export interface StorefrontBootstrapRequestContext {
+    db: PostgresJsDatabase;
+    env?: unknown;
+    context?: unknown;
+}
+export interface StorefrontBookingSessionBootstrapOptions {
+    paymentPolicy?: PaymentPolicy;
+    resolvePaymentPolicy?: (input: StorefrontBookingSessionBootstrapInput & StorefrontBootstrapRequestContext) => Promise<PaymentPolicy | null | undefined> | PaymentPolicy | null | undefined;
+    today?: Date;
+}
+export declare function bootstrapStorefrontBookingSession(context: StorefrontBootstrapRequestContext, input: StorefrontBookingSessionBootstrapInput, options: StorefrontBookingSessionBootstrapOptions | undefined, userId?: string): Promise<{
+    status: Exclude<string, "ok">;
+} | {
+    status: "stale_quote";
+    repricing: {
+        originalQuote: {
+            currencyCode: string;
+            totalSellAmountCents: number;
+            quotedAt?: string | null | undefined;
+            expiresAt?: string | null | undefined;
+        };
+        current: {
+            sessionId: string;
+            catalogId: string | null;
+            currencyCode: string;
+            totalSellAmountCents: number;
+            items: {
+                inputIndex: number;
+                itemId: string;
+                title: string;
+                productId: string | null;
+                optionId: string | null;
+                optionUnitId: string | null;
+                optionUnitName: string | null;
+                optionUnitType: string | null;
+                pricingCategoryId: string | null;
+                quantity: number;
+                pricingMode: string;
+                unitSellAmountCents: number | null;
+                totalSellAmountCents: number | null;
+                warnings: string[];
+            }[];
+            warnings: never[];
+            appliedToSession: boolean;
+        };
+        deltaAmountCents: number;
+        staleQuote: boolean;
+    };
+    bootstrap?: undefined;
+} | {
+    status: "ok";
+    bootstrap: {
+        session: {
+            sessionId: string;
+            bookingNumber: string;
+            status: "draft" | "confirmed" | "cancelled" | "on_hold" | "awaiting_payment" | "in_progress" | "completed" | "expired";
+            externalBookingRef: string | null;
+            communicationLanguage: string | null;
+            sellCurrency: string;
+            sellAmountCents: number | null;
+            startDate: string | null;
+            endDate: string | null;
+            pax: number | null;
+            holdExpiresAt: string | null;
+            confirmedAt: string | null;
+            expiredAt: string | null;
+            cancelledAt: string | null;
+            completedAt: string | null;
+            travelers: {
+                id: string;
+                participantType: "other" | "traveler" | "occupant";
+                travelerCategory: "other" | "adult" | "child" | "infant" | "senior" | null;
+                firstName: string;
+                lastName: string;
+                email: string | null;
+                phone: string | null;
+                preferredLanguage: string | null;
+                specialRequests: string | null;
+                isPrimary: boolean;
+                notes: string | null;
+            }[];
+            items: {
+                id: string;
+                title: string;
+                description: string | null;
+                itemType: "service" | "unit" | "other" | "extra" | "fee" | "tax" | "discount" | "adjustment" | "accommodation" | "transport";
+                status: "draft" | "confirmed" | "cancelled" | "fulfilled" | "on_hold" | "expired";
+                serviceDate: string | null;
+                startsAt: string | null;
+                endsAt: string | null;
+                quantity: number;
+                sellCurrency: string;
+                unitSellAmountCents: number | null;
+                totalSellAmountCents: number | null;
+                costCurrency: string | null;
+                unitCostAmountCents: number | null;
+                totalCostAmountCents: number | null;
+                notes: string | null;
+                productId: string | null;
+                optionId: string | null;
+                optionUnitId: string | null;
+                pricingCategoryId: string | null;
+                travelerLinks: {
+                    id: string;
+                    travelerId: string;
+                    role: string;
+                    isPrimary: boolean;
+                }[];
+            }[];
+            allocations: {
+                id: string;
+                bookingItemId: string;
+                productId: string | null;
+                optionId: string | null;
+                optionUnitId: string | null;
+                pricingCategoryId: string | null;
+                availabilitySlotId: string | null;
+                quantity: number;
+                allocationType: "unit" | "pickup" | "resource";
+                status: "confirmed" | "cancelled" | "fulfilled" | "expired" | "held" | "released";
+                holdExpiresAt: string | null;
+                confirmedAt: string | null;
+                releasedAt: string | null;
+            }[];
+            checklist: {
+                hasTravelers: boolean;
+                hasPrimaryTraveler: boolean;
+                hasItems: boolean;
+                hasAllocations: boolean;
+                readyForConfirmation: boolean;
+            };
+            state: {
+                sessionId: string;
+                stateKey: "wizard";
+                currentStep: string | null;
+                completedSteps: string[];
+                payload: Record<string, unknown>;
+                version: number;
+                createdAt: string;
+                updatedAt: string;
+            } | null;
+        };
+        paymentPlan: {
+            source: "storefront_default";
+            depositKind: import("@voyant-travel/finance").DepositKind;
+            depositPercent: number | null;
+            depositAmountCents: number | null;
+            requiresFullPayment: boolean;
+        };
+        paymentSchedule: {
+            id: string;
+            scheduleType: "other" | "deposit" | "installment" | "balance" | "hold";
+            status: "pending" | "cancelled" | "waived" | "expired" | "paid" | "due";
+            dueDate: string;
+            currency: string;
+            amountCents: number;
+            notes: string | null;
+        }[];
+        repricing: {
+            originalQuote: {
+                currencyCode: string;
+                totalSellAmountCents: number;
+                quotedAt?: string | null | undefined;
+                expiresAt?: string | null | undefined;
+            };
+            current: {
+                sessionId: string;
+                items: {
+                    itemId: string;
+                    title: string;
+                    productId: string | null;
+                    optionId: string | null;
+                    optionUnitId: string | null;
+                    optionUnitName: string | null;
+                    optionUnitType: string | null;
+                    pricingCategoryId: string | null;
+                    quantity: number;
+                    pricingMode: string;
+                    unitSellAmountCents: number | null;
+                    totalSellAmountCents: number | null;
+                    warnings: string[];
+                }[];
+                catalogId: string | null;
+                currencyCode: string;
+                totalSellAmountCents: number;
+                warnings: never[];
+                appliedToSession: boolean;
+            };
+            deltaAmountCents: number;
+            staleQuote: boolean;
+        };
+        availability: {
+            departureId: string;
+            slotId: string;
+            productId: string;
+            optionId: string | null;
+            dateLocal: string | Date;
+            startsAt: string | null;
+            endsAt: string | null;
+            timezone: string;
+            status: import("./service-boundary-sql.js").StorefrontSlotStatus;
+            capacity: number | null;
+            remaining: number | null;
+        };
+        allocation: {
+            id: string;
+            bookingItemId: string;
+            productId: string | null;
+            optionId: string | null;
+            optionUnitId: string | null;
+            pricingCategoryId: string | null;
+            availabilitySlotId: string | null;
+            quantity: number;
+            allocationType: "unit" | "pickup" | "resource";
+            status: "confirmed" | "cancelled" | "fulfilled" | "expired" | "held" | "released";
+            holdExpiresAt: string | null;
+            confirmedAt: string | null;
+            releasedAt: string | null;
+        }[];
+        currency: string;
+    };
+    repricing?: undefined;
+}>;
+//# sourceMappingURL=service-booking-session-bootstrap.d.ts.map

package/dist/service-booking-session-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-booking-session-bootstrap.d.ts","sourceRoot":"","sources":["../src/service-booking-session-bootstrap.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,iBAAiB,CAAA;AAE7E,MAAM,WAAW,iCAAiC;IAChD,EAAE,EAAE,kBAAkB,CAAA;IACtB,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,wCAAwC;IACvD,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,oBAAoB,CAAC,EAAE,CACrB,KAAK,EAAE,sCAAsC,GAAG,iCAAiC,KAC9E,OAAO,CAAC,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,aAAa,GAAG,IAAI,GAAG,SAAS,CAAA;IACjF,KAAK,CAAC,EAAE,IAAI,CAAA;CACb;AAqPD,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,iCAAiC,EAC1C,KAAK,EAAE,sCAAsC,EAC7C,OAAO,EAAE,wCAAwC,GAAG,SAAS,EAC7D,MAAM,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;4BAhKD,MAAM;wBACV,MAAM;uBACP,MAAM;2BACF,MAAM,GAAG,IAAI;0BACd,MAAM,GAAG,IAAI;8BACT,MAAM,GAAG,IAAI;gCACX,MAAM,GAAG,IAAI;gCACb,MAAM,GAAG,IAAI;mCACV,MAAM,GAAG,IAAI;0BACtB,MAAM;6BACH,MAAM;qCACE,MAAM,GAAG,IAAI;sCACZ,MAAM,GAAG,IAAI;0BACzB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAXX,MAAM;+BACF,MAAM,GAAG,IAAI;8BACd,MAAM,GAAG,IAAI;kCACT,MAAM,GAAG,IAAI;oCACX,MAAM,GAAG,IAAI;oCACb,MAAM,GAAG,IAAI;uCACV,MAAM,GAAG,IAAI;8BACtB,MAAM;iCACH,MAAM;yCACE,MAAM,GAAG,IAAI;0CACZ,MAAM,GAAG,IAAI;8BACzB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmTrB"}