@voyant-travel/commerce 0.1.0

package/dist/pricing/schema-relations.d.ts

@@ -0,0 +1,59 @@
+export declare const pricingCategoriesRelations: import("drizzle-orm").Relations<"pricing_categories", {
+    childDependencies: import("drizzle-orm").Many<"pricing_category_dependencies">;
+    masterDependencies: import("drizzle-orm").Many<"pricing_category_dependencies">;
+    unitPriceRules: import("drizzle-orm").Many<"option_unit_price_rules">;
+}>;
+export declare const pricingCategoryDependenciesRelations: import("drizzle-orm").Relations<"pricing_category_dependencies", {
+    pricingCategory: import("drizzle-orm").One<"pricing_categories", true>;
+    masterPricingCategory: import("drizzle-orm").One<"pricing_categories", true>;
+}>;
+export declare const cancellationPoliciesRelations: import("drizzle-orm").Relations<"cancellation_policies", {
+    rules: import("drizzle-orm").Many<"cancellation_policy_rules">;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+}>;
+export declare const cancellationPolicyRulesRelations: import("drizzle-orm").Relations<"cancellation_policy_rules", {
+    cancellationPolicy: import("drizzle-orm").One<"cancellation_policies", true>;
+}>;
+export declare const priceCatalogsRelations: import("drizzle-orm").Relations<"price_catalogs", {
+    schedules: import("drizzle-orm").Many<"price_schedules">;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+    departureOverrides: import("drizzle-orm").Many<"departure_price_overrides">;
+}>;
+export declare const departurePriceOverridesRelations: import("drizzle-orm").Relations<"departure_price_overrides", {
+    priceCatalog: import("drizzle-orm").One<"price_catalogs", true>;
+}>;
+export declare const priceSchedulesRelations: import("drizzle-orm").Relations<"price_schedules", {
+    priceCatalog: import("drizzle-orm").One<"price_catalogs", true>;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+}>;
+export declare const optionPriceRulesRelations: import("drizzle-orm").Relations<"option_price_rules", {
+    priceCatalog: import("drizzle-orm").One<"price_catalogs", true>;
+    priceSchedule: import("drizzle-orm").One<"price_schedules", false>;
+    cancellationPolicy: import("drizzle-orm").One<"cancellation_policies", false>;
+    unitRules: import("drizzle-orm").Many<"option_unit_price_rules">;
+    startTimeRules: import("drizzle-orm").Many<"option_start_time_rules">;
+    pickupRules: import("drizzle-orm").Many<"pickup_price_rules">;
+    dropoffRules: import("drizzle-orm").Many<"dropoff_price_rules">;
+    extraRules: import("drizzle-orm").Many<"extra_price_rules">;
+}>;
+export declare const optionUnitPriceRulesRelations: import("drizzle-orm").Relations<"option_unit_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+    pricingCategory: import("drizzle-orm").One<"pricing_categories", false>;
+    tiers: import("drizzle-orm").Many<"option_unit_tiers">;
+}>;
+export declare const optionStartTimeRulesRelations: import("drizzle-orm").Relations<"option_start_time_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const optionUnitTiersRelations: import("drizzle-orm").Relations<"option_unit_tiers", {
+    optionUnitPriceRule: import("drizzle-orm").One<"option_unit_price_rules", true>;
+}>;
+export declare const pickupPriceRulesRelations: import("drizzle-orm").Relations<"pickup_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const dropoffPriceRulesRelations: import("drizzle-orm").Relations<"dropoff_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const extraPriceRulesRelations: import("drizzle-orm").Relations<"extra_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map

package/dist/pricing/schema-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../../src/pricing/schema-relations.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,0BAA0B;;;;EAIpC,CAAA;AAEH,eAAO,MAAM,oCAAoC;;;EAchD,CAAA;AAED,eAAO,MAAM,6BAA6B;;;EAGvC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;EAK1C,CAAA;AAEH,eAAO,MAAM,sBAAsB;;;;EAIhC,CAAA;AAEH,eAAO,MAAM,gCAAgC;;EAK1C,CAAA;AAEH,eAAO,MAAM,uBAAuB;;;EAMjC,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;EAkBnC,CAAA;AAEH,eAAO,MAAM,6BAA6B;;;;EAUvC,CAAA;AAEH,eAAO,MAAM,6BAA6B;;EAKvC,CAAA;AAEH,eAAO,MAAM,wBAAwB;;EAKlC,CAAA;AAEH,eAAO,MAAM,yBAAyB;;EAKnC,CAAA;AAEH,eAAO,MAAM,0BAA0B;;EAKpC,CAAA;AAEH,eAAO,MAAM,wBAAwB;;EAKlC,CAAA"}

package/dist/pricing/schema-relations.js

@@ -0,0 +1,111 @@
+import { relations } from "drizzle-orm";
+import { priceCatalogs, priceSchedules } from "./schema-catalogs.js";
+import { pricingCategories, pricingCategoryDependencies } from "./schema-categories.js";
+import { departurePriceOverrides } from "./schema-departure-overrides.js";
+import { dropoffPriceRules, extraPriceRules, optionPriceRules, optionStartTimeRules, optionUnitPriceRules, optionUnitTiers, pickupPriceRules, } from "./schema-option-rules.js";
+import { cancellationPolicies, cancellationPolicyRules } from "./schema-policies.js";
+export const pricingCategoriesRelations = relations(pricingCategories, ({ many }) => ({
+    childDependencies: many(pricingCategoryDependencies, { relationName: "pricingCategoryChild" }),
+    masterDependencies: many(pricingCategoryDependencies, { relationName: "pricingCategoryMaster" }),
+    unitPriceRules: many(optionUnitPriceRules),
+}));
+export const pricingCategoryDependenciesRelations = relations(pricingCategoryDependencies, ({ one }) => ({
+    pricingCategory: one(pricingCategories, {
+        relationName: "pricingCategoryChild",
+        fields: [pricingCategoryDependencies.pricingCategoryId],
+        references: [pricingCategories.id],
+    }),
+    masterPricingCategory: one(pricingCategories, {
+        relationName: "pricingCategoryMaster",
+        fields: [pricingCategoryDependencies.masterPricingCategoryId],
+        references: [pricingCategories.id],
+    }),
+}));
+export const cancellationPoliciesRelations = relations(cancellationPolicies, ({ many }) => ({
+    rules: many(cancellationPolicyRules),
+    optionPriceRules: many(optionPriceRules),
+}));
+export const cancellationPolicyRulesRelations = relations(cancellationPolicyRules, ({ one }) => ({
+    cancellationPolicy: one(cancellationPolicies, {
+        fields: [cancellationPolicyRules.cancellationPolicyId],
+        references: [cancellationPolicies.id],
+    }),
+}));
+export const priceCatalogsRelations = relations(priceCatalogs, ({ many }) => ({
+    schedules: many(priceSchedules),
+    optionPriceRules: many(optionPriceRules),
+    departureOverrides: many(departurePriceOverrides),
+}));
+export const departurePriceOverridesRelations = relations(departurePriceOverrides, ({ one }) => ({
+    priceCatalog: one(priceCatalogs, {
+        fields: [departurePriceOverrides.priceCatalogId],
+        references: [priceCatalogs.id],
+    }),
+}));
+export const priceSchedulesRelations = relations(priceSchedules, ({ one, many }) => ({
+    priceCatalog: one(priceCatalogs, {
+        fields: [priceSchedules.priceCatalogId],
+        references: [priceCatalogs.id],
+    }),
+    optionPriceRules: many(optionPriceRules),
+}));
+export const optionPriceRulesRelations = relations(optionPriceRules, ({ one, many }) => ({
+    priceCatalog: one(priceCatalogs, {
+        fields: [optionPriceRules.priceCatalogId],
+        references: [priceCatalogs.id],
+    }),
+    priceSchedule: one(priceSchedules, {
+        fields: [optionPriceRules.priceScheduleId],
+        references: [priceSchedules.id],
+    }),
+    cancellationPolicy: one(cancellationPolicies, {
+        fields: [optionPriceRules.cancellationPolicyId],
+        references: [cancellationPolicies.id],
+    }),
+    unitRules: many(optionUnitPriceRules),
+    startTimeRules: many(optionStartTimeRules),
+    pickupRules: many(pickupPriceRules),
+    dropoffRules: many(dropoffPriceRules),
+    extraRules: many(extraPriceRules),
+}));
+export const optionUnitPriceRulesRelations = relations(optionUnitPriceRules, ({ one, many }) => ({
+    optionPriceRule: one(optionPriceRules, {
+        fields: [optionUnitPriceRules.optionPriceRuleId],
+        references: [optionPriceRules.id],
+    }),
+    pricingCategory: one(pricingCategories, {
+        fields: [optionUnitPriceRules.pricingCategoryId],
+        references: [pricingCategories.id],
+    }),
+    tiers: many(optionUnitTiers),
+}));
+export const optionStartTimeRulesRelations = relations(optionStartTimeRules, ({ one }) => ({
+    optionPriceRule: one(optionPriceRules, {
+        fields: [optionStartTimeRules.optionPriceRuleId],
+        references: [optionPriceRules.id],
+    }),
+}));
+export const optionUnitTiersRelations = relations(optionUnitTiers, ({ one }) => ({
+    optionUnitPriceRule: one(optionUnitPriceRules, {
+        fields: [optionUnitTiers.optionUnitPriceRuleId],
+        references: [optionUnitPriceRules.id],
+    }),
+}));
+export const pickupPriceRulesRelations = relations(pickupPriceRules, ({ one }) => ({
+    optionPriceRule: one(optionPriceRules, {
+        fields: [pickupPriceRules.optionPriceRuleId],
+        references: [optionPriceRules.id],
+    }),
+}));
+export const dropoffPriceRulesRelations = relations(dropoffPriceRules, ({ one }) => ({
+    optionPriceRule: one(optionPriceRules, {
+        fields: [dropoffPriceRules.optionPriceRuleId],
+        references: [optionPriceRules.id],
+    }),
+}));
+export const extraPriceRulesRelations = relations(extraPriceRules, ({ one }) => ({
+    optionPriceRule: one(optionPriceRules, {
+        fields: [extraPriceRules.optionPriceRuleId],
+        references: [optionPriceRules.id],
+    }),
+}));

package/dist/pricing/schema-shared.d.ts

@@ -0,0 +1,11 @@
+export declare const pricingCategoryTypeEnum: import("drizzle-orm/pg-core").PgEnum<["adult", "child", "infant", "senior", "group", "room", "vehicle", "service", "other"]>;
+export declare const pricingDependencyTypeEnum: import("drizzle-orm/pg-core").PgEnum<["requires", "limits_per_master", "limits_sum", "excludes"]>;
+export declare const cancellationPolicyTypeEnum: import("drizzle-orm/pg-core").PgEnum<["simple", "advanced", "non_refundable", "custom"]>;
+export declare const cancellationChargeTypeEnum: import("drizzle-orm/pg-core").PgEnum<["none", "amount", "percentage"]>;
+export declare const priceCatalogTypeEnum: import("drizzle-orm/pg-core").PgEnum<["public", "contract", "net", "gross", "promo", "internal", "other"]>;
+export declare const optionPricingModeEnum: import("drizzle-orm/pg-core").PgEnum<["per_person", "per_booking", "starting_from", "free", "on_request"]>;
+export declare const optionUnitPricingModeEnum: import("drizzle-orm/pg-core").PgEnum<["per_unit", "per_person", "per_booking", "included", "free", "on_request"]>;
+export declare const optionStartTimeRuleModeEnum: import("drizzle-orm/pg-core").PgEnum<["included", "excluded", "override", "adjustment"]>;
+export declare const priceAdjustmentTypeEnum: import("drizzle-orm/pg-core").PgEnum<["fixed", "percentage"]>;
+export declare const addonPricingModeEnum: import("drizzle-orm/pg-core").PgEnum<["included", "per_person", "per_booking", "on_request", "unavailable"]>;
+//# sourceMappingURL=schema-shared.d.ts.map

package/dist/pricing/schema-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-shared.d.ts","sourceRoot":"","sources":["../../src/pricing/schema-shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,8HAUlC,CAAA;AAEF,eAAO,MAAM,yBAAyB,mGAKpC,CAAA;AAEF,eAAO,MAAM,0BAA0B,0FAKrC,CAAA;AAEF,eAAO,MAAM,0BAA0B,wEAIrC,CAAA;AAEF,eAAO,MAAM,oBAAoB,4GAQ/B,CAAA;AAEF,eAAO,MAAM,qBAAqB,4GAMhC,CAAA;AAEF,eAAO,MAAM,yBAAyB,mHAOpC,CAAA;AAEF,eAAO,MAAM,2BAA2B,0FAKtC,CAAA;AAEF,eAAO,MAAM,uBAAuB,+DAA2D,CAAA;AAE/F,eAAO,MAAM,oBAAoB,8GAM/B,CAAA"}

package/dist/pricing/schema-shared.js

@@ -0,0 +1,67 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const pricingCategoryTypeEnum = pgEnum("pricing_category_type", [
+    "adult",
+    "child",
+    "infant",
+    "senior",
+    "group",
+    "room",
+    "vehicle",
+    "service",
+    "other",
+]);
+export const pricingDependencyTypeEnum = pgEnum("pricing_dependency_type", [
+    "requires",
+    "limits_per_master",
+    "limits_sum",
+    "excludes",
+]);
+export const cancellationPolicyTypeEnum = pgEnum("cancellation_policy_type", [
+    "simple",
+    "advanced",
+    "non_refundable",
+    "custom",
+]);
+export const cancellationChargeTypeEnum = pgEnum("cancellation_charge_type", [
+    "none",
+    "amount",
+    "percentage",
+]);
+export const priceCatalogTypeEnum = pgEnum("price_catalog_type", [
+    "public",
+    "contract",
+    "net",
+    "gross",
+    "promo",
+    "internal",
+    "other",
+]);
+export const optionPricingModeEnum = pgEnum("option_pricing_mode", [
+    "per_person",
+    "per_booking",
+    "starting_from",
+    "free",
+    "on_request",
+]);
+export const optionUnitPricingModeEnum = pgEnum("option_unit_pricing_mode", [
+    "per_unit",
+    "per_person",
+    "per_booking",
+    "included",
+    "free",
+    "on_request",
+]);
+export const optionStartTimeRuleModeEnum = pgEnum("option_start_time_rule_mode", [
+    "included",
+    "excluded",
+    "override",
+    "adjustment",
+]);
+export const priceAdjustmentTypeEnum = pgEnum("price_adjustment_type", ["fixed", "percentage"]);
+export const addonPricingModeEnum = pgEnum("addon_pricing_mode", [
+    "included",
+    "per_person",
+    "per_booking",
+    "on_request",
+    "unavailable",
+]);

package/dist/pricing/schema.d.ts

@@ -0,0 +1,8 @@
+export * from "./schema-catalogs.js";
+export * from "./schema-categories.js";
+export * from "./schema-departure-overrides.js";
+export * from "./schema-option-rules.js";
+export * from "./schema-policies.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/pricing/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/pricing/schema.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA"}

package/dist/pricing/schema.js

@@ -0,0 +1,7 @@
+export * from "./schema-catalogs.js";
+export * from "./schema-categories.js";
+export * from "./schema-departure-overrides.js";
+export * from "./schema-option-rules.js";
+export * from "./schema-policies.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";

package/dist/pricing/service-catalog-plane-pricing.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Projection extension that aggregates a "price from" amount across the
+ * product's future bookable rate-plan prices and contributes
+ * `priceFromAmountCents`, `priceFromCurrency`, and `hasPricing` to the
+ * product search document.
+ *
+ * Lives in `@voyant-travel/commerce` because:
+ *   - The data lives here (`option_price_rules`, `option_unit_price_rules`,
+ *     `price_catalogs`).
+ *   - Product owns the document-builder implementation, while this package
+ *     exposes a structural extension that satisfies that builder contract.
+ *
+ * Wire via `createProductDocumentBuilder({ extensions: [pricingExtension] })`
+ * after composing `productPricingCatalogPolicy` into the registry.
+ *
+ * Scope intentionally narrow:
+ *   - **No schedule-aware rule resolution.** Only `is_default = true`
+ *     rules contribute. Seasonal / promo rules with schedules don't
+ *     surface here; they require per-slice rule evaluation beyond the
+ *     future-departure presence check below.
+ *   - **No per-departure overrides.** Same reason.
+ *   - **Currency consistency.** Only rules whose catalog currency matches
+ *     the product's `sellCurrency` (or whose catalog currency is null
+ *     and therefore inherits the product's) are MIN'd together.
+ *
+ * Document churn: this projection is `now()`-dependent because it only
+ * considers future bookable departures. A product can move to "unpriced"
+ * once its final departure starts unless a row-level fallback remains.
+ */
+import type { IndexerSlice } from "@voyant-travel/catalog";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+interface PricingProjectionOptions {
+    /**
+     * Resolve the product's row-level `sellAmountCents` + `sellCurrency`.
+     * Templates use the default raw-SQL loader; tests can stub it without
+     * standing up the products schema.
+     *
+     * Returns `null` for both fields when the product doesn't exist.
+     */
+    loadProductPricing?: (db: AnyDrizzleDb, productId: string) => Promise<{
+        sellAmountCents: number | null;
+        sellCurrency: string | null;
+    }>;
+    /**
+     * Resolve future bookable rate-plan prices for the product. Tests can
+     * stub this without standing up availability/product option tables.
+     */
+    loadRatePlanPricing?: (db: AnyDrizzleDb, productId: string, productCurrency: string) => Promise<RatePlanPricing>;
+}
+interface PricingAggregate {
+    priceFromAmountCents: number | null;
+    priceFromCurrency: string | null;
+    hasPricing: boolean;
+}
+interface RatePlanPricing {
+    roomPrices: number[];
+    basePrices: number[];
+}
+export interface ProductProjectionExtension {
+    readonly name: string;
+    project(db: AnyDrizzleDb, productId: string, slice: IndexerSlice): Promise<ReadonlyMap<string, unknown>>;
+}
+/**
+ * Pure aggregation kernel. Room prices take precedence over base/unit
+ * prices, which take precedence over the product-row fallback. Non-
+ * positive values are treated as absent so stale `0` caches don't block
+ * nullish fallbacks in catalog consumers.
+ */
+declare function aggregatePricing(productPrice: number | null, currency: string | null, roomPrices: ReadonlyArray<number>, basePrices: ReadonlyArray<number>): PricingAggregate;
+/**
+ * Construct the pricing projection extension.
+ *
+ * Pass loaders in tests to stub DB reads; production uses raw SQL against
+ * the deployed schema.
+ */
+export declare function createProductPricingProjectionExtension(options?: PricingProjectionOptions): ProductProjectionExtension;
+/**
+ * Resolve the same "from price" value emitted by the pricing projection.
+ * Promotion projection wiring uses this so strikethrough base prices
+ * follow the same rate-plan-first fallback chain.
+ */
+export declare function loadProductPriceFrom(db: AnyDrizzleDb, productId: string): Promise<{
+    amountCents: number | null;
+    currency: string | null;
+}>;
+declare function firstPositiveMin(values: ReadonlyArray<number>): number | null;
+declare function isMissingCatalogPricingDependencyError(error: unknown): boolean;
+export declare const __test__: {
+    aggregatePricing: typeof aggregatePricing;
+    EMPTY_AGGREGATE: PricingAggregate;
+    firstPositiveMin: typeof firstPositiveMin;
+    isMissingCatalogPricingDependencyError: typeof isMissingCatalogPricingDependencyError;
+};
+export {};
+//# sourceMappingURL=service-catalog-plane-pricing.d.ts.map

package/dist/pricing/service-catalog-plane-pricing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog-plane-pricing.d.ts","sourceRoot":"","sources":["../../src/pricing/service-catalog-plane-pricing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,UAAU,wBAAwB;IAChC;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,CACnB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;IAE7E;;;OAGG;IACH,mBAAmB,CAAC,EAAE,CACpB,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,KACpB,OAAO,CAAC,eAAe,CAAC,CAAA;CAC9B;AAED,UAAU,gBAAgB;IACxB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,UAAU,eAAe;IACvB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,OAAO,CACL,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACzC;AAQD;;;;;GAKG;AACH,iBAAS,gBAAgB,CACvB,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,EACjC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAChC,gBAAgB,CAYlB;AAED;;;;;GAKG;AACH,wBAAgB,uCAAuC,CACrD,OAAO,GAAE,wBAA6B,GACrC,0BAA0B,CA2B5B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAclE;AAoRD,iBAAS,gBAAgB,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAOtE;AAYD,iBAAS,sCAAsC,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWvE;AAWD,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAA"}