medusa-storefront-data 1.0.0 → 2.0.0

package/dist/server/returns.js

@@ -1,78 +1,19 @@
 "use server";
-import { sdk } from "../config";
+import { medusaReturnCreate, medusaReturnCreateGuest, medusaReturnList, medusaReturnListGuest, medusaReturnReasonList, medusaReturnShippingOptionsResolve, medusaReturnUpdatePayment, } from "medusa-services/returns";
 import { cookies } from "next/headers";
-import { getAuthHeaders, getCacheOptions } from "../cookies";
 import { revalidateTag } from "next/cache";
+import { getStoreClientOptions, getStoreClientOptionsWithToken } from "../util/store-client";
 export const listReturnReasons = async () => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    const next = {
-        ...(await getCacheOptions("return_reasons")),
-    };
-    return sdk.client
-        .fetch(`/store/return-reasons`, {
-        method: "GET",
-        headers,
-        next,
-        cache: "force-cache", // Reasons change rarely
-    })
-        .then(({ return_reasons }) => return_reasons)
-        .catch(() => []);
+    const options = await getStoreClientOptions();
+    return medusaReturnReasonList(options);
 };
 export const listReturnShippingOptions = async (cartId, regionId, productIds) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    const next = {
-        ...(await getCacheOptions("fulfillment")),
-    };
-    // Strategy 1: Try with cart_id (preferred as it has context)
-    if (cartId) {
-        try {
-            const { shipping_options } = await sdk.client.fetch(`/store/shipping-options`, {
-                method: "GET",
-                query: {
-                    cart_id: cartId,
-                    is_return: true,
-                },
-                headers,
-                next,
-                cache: "no-store",
-            });
-            if (shipping_options.length > 0) {
-                return shipping_options;
-            }
-        }
-        catch (e) {
-            // Fallback strategy
-        }
-    }
-    // Strategy 2: Fallback - Create ephemeral cart if region_id is available
-    // This is required because /store/shipping-options STRICTLY requires a cart_id for return options
-    if (regionId) {
-        try {
-            // Create a temporary cart for this region to get valid shipping options
-            const { cart } = await sdk.store.cart.create({ region_id: regionId }, {}, headers);
-            if (cart?.id) {
-                const { shipping_options } = await sdk.client.fetch(`/store/shipping-options`, {
-                    method: "GET",
-                    query: {
-                        cart_id: cart.id,
-                        is_return: true,
-                    },
-                    headers,
-                    next,
-                    cache: "no-store",
-                });
-                return shipping_options;
-            }
-        }
-        catch (e) {
-            // Silence error
-        }
-    }
-    return [];
+    const options = await getStoreClientOptions();
+    const shippingOptions = await medusaReturnShippingOptionsResolve(options, {
+        cartId,
+        regionId,
+    });
+    return shippingOptions;
 };
 export const createReturnRequest = async (state, formData) => {
     const orderId = formData.get("order_id");
@@ -88,146 +29,101 @@ export const createReturnRequest = async (state, formData) => {
     try {
         items = JSON.parse(itemsJson);
     }
-    catch (e) {
+    catch {
         return { success: false, error: "Invalid items data", return: null };
     }
     if (items.length === 0) {
         return { success: false, error: "At least one item must be selected", return: null };
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
+    const options = await getStoreClientOptions();
     try {
-        // Standard Medusa v2 payload
         const payload = {
             order_id: orderId,
             items: items.map((item) => ({
                 id: item.id,
                 quantity: item.quantity,
                 reason_id: item.return_reason_id || undefined,
-                note: (note && note.trim().length > 0) ? note : undefined,
+                note: note && note.trim().length > 0 ? note : undefined,
             })),
-            ...(returnShippingOptionId ? {
-                return_shipping: {
-                    option_id: returnShippingOptionId,
-                    location_id: locationId || items[0].location_id || "default_location"
+            ...(returnShippingOptionId
+                ? {
+                    return_shipping: {
+                        option_id: returnShippingOptionId,
+                        location_id: locationId || items[0]?.location_id || "default_location",
+                    },
                 }
-            } : {}),
-            // Optional: keep global note if supported
-            note: (note && note.trim().length > 0) ? note : "Return request",
+                : {}),
+            note: note && note.trim().length > 0 ? note : "Return request",
         };
-        // Double check location_id is NOT nested incorrectly if already set above
-        // The plugin expects return_shipping.location_id
-        // Check for any available guest tokens
         const cookieStore = await cookies();
-        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value
-            || cookieStore.get("_medusa_guest_token")?.value
-            || cookieStore.get("guest_id")?.value;
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value ||
+            cookieStore.get("_medusa_guest_token")?.value ||
+            cookieStore.get("guest_id")?.value;
         const token = cookieStore.get("_medusa_jwt")?.value;
         let returnData;
-        // If we have a guest token, try the guest specific endpoint
         if (guestToken && !token) {
             try {
-                const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/returns`, {
-                    method: "POST",
-                    body: payload,
-                    headers: {
-                        ...headers,
-                        "Authorization": `Bearer ${guestToken}`
-                    },
-                    cache: "no-store",
-                });
-                returnData = response.return || response;
+                const guestOptions = await getStoreClientOptionsWithToken(guestToken);
+                returnData = (await medusaReturnCreateGuest(orderId, payload, guestOptions));
             }
-            catch (e) {
-                // Fallback to standard if guest endpoint fails
-                const response = await sdk.client.fetch(`/store/returns`, {
-                    method: "POST",
-                    body: payload,
-                    headers,
-                    cache: "no-store",
-                });
-                returnData = response.return;
+            catch {
+                returnData = (await medusaReturnCreate(payload, options));
             }
         }
         else {
-            // Standard flow
-            const response = await sdk.client.fetch(`/store/returns`, {
-                method: "POST",
-                body: payload,
-                headers,
-                cache: "no-store",
-            });
-            returnData = response.return;
+            returnData = (await medusaReturnCreate(payload, options));
         }
         revalidateTag("orders");
         return { success: true, error: null, return: returnData };
     }
     catch (error) {
-        return { success: false, error: error.message || "Failed to create return request", return: null };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to create return request",
+            return: null,
+        };
     }
 };
 /**
  * Link a payment method to a return (for Refund Destination)
  */
 export const updateReturnPayment = async (returnId, paymentId) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
+    const options = await getStoreClientOptions();
     try {
-        const response = await sdk.client.fetch(`/store/refund-payment-mapping/${returnId}`, {
-            method: "PUT",
-            body: { payment_id: paymentId },
-            headers,
-            cache: "no-store",
-        });
-        return { success: true, data: response };
+        const data = await medusaReturnUpdatePayment(returnId, paymentId, options);
+        return { success: true, data };
     }
     catch (error) {
         console.error("Update return payment fail:", error);
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 };
 /**
  * List returns for an order or customer
  */
 export const listReturns = async (orderId) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    // Authenticated flow
-    const authHeaders = headers;
-    if (authHeaders.authorization || authHeaders.Authorization) {
+    const options = await getStoreClientOptions();
+    if (options.authorization) {
         try {
-            const response = await sdk.client.fetch(`/store/returns`, {
-                method: "GET",
-                query: orderId ? { order_id: orderId } : {},
-                headers,
-                cache: "no-store",
-            });
-            return response;
+            return await medusaReturnList(options, orderId ? { order_id: orderId } : undefined);
         }
-        catch (e) {
+        catch {
             return { returns: [], count: 0 };
         }
     }
-    // Guest flow
     if (orderId) {
         const cookieStore = await cookies();
-        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value ||
+            cookieStore.get("_medusa_guest_token")?.value;
         if (guestToken) {
             try {
-                const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/returns`, {
-                    method: "GET",
-                    headers: {
-                        ...headers,
-                        "Authorization": `Bearer ${guestToken}`
-                    },
-                    cache: "no-store",
-                });
-                return response;
+                const guestOptions = await getStoreClientOptionsWithToken(guestToken);
+                return await medusaReturnListGuest(orderId, guestOptions);
             }
-            catch (e) {
+            catch {
                 return { returns: [], count: 0 };
             }
         }

package/dist/server/swaps.d.ts

@@ -2,13 +2,13 @@
  * Create an exchange (swap) request.
  * Supports both authenticated customers and guest users.
  */
-export declare const createSwapRequest: (prevState: any, formData: FormData) => Promise<{
+export declare const createSwapRequest: (prevState: unknown, formData: FormData) => Promise<{
     success: boolean;
     error: string | null;
-    swap: any | null;
+    swap: Record<string, unknown> | null;
 }>;
 /**
  * List swaps for an order or customer
  */
-export declare const listSwaps: (orderId?: string) => Promise<any>;
+export declare const listSwaps: (orderId?: string) => Promise<import("medusa-services/swaps").StoreSwapListResponse>;
 //# sourceMappingURL=swaps.d.ts.map

package/dist/server/swaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swaps.d.ts","sourceRoot":"","sources":["../../src/server/swaps.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC1B,WAAW,GAAG,EACd,UAAU,QAAQ,KACnB,OAAO,CAAC;IACP,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;CACnB,CA4FA,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,UAAU,MAAM,iBAgC/C,CAAA"}
+{"version":3,"file":"swaps.d.ts","sourceRoot":"","sources":["../../src/server/swaps.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,OAAO,EAClB,UAAU,QAAQ,KACjB,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CACrC,CAsEA,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,UAAU,MAAM,mEAoB/C,CAAA"}

package/dist/server/swaps.js

@@ -1,8 +1,8 @@
 "use server";
-import { sdk } from "../config";
+import { medusaSwapCreate, medusaSwapCreateGuest, medusaSwapList, medusaSwapListGuest, } from "medusa-services/swaps";
 import { cookies } from "next/headers";
-import { getAuthHeaders } from "../cookies";
 import { revalidateTag } from "next/cache";
+import { getStoreClientOptions, getStoreClientOptionsWithToken } from "../util/store-client";
 /**
  * Create an exchange (swap) request.
  * Supports both authenticated customers and guest users.
@@ -25,15 +25,13 @@ export const createSwapRequest = async (prevState, formData) => {
         returnItems = JSON.parse(returnItemsJson);
         newItems = JSON.parse(newItemsJson);
     }
-    catch (e) {
+    catch {
         return { success: false, error: "Invalid items data format", swap: null };
     }
     if (returnItems.length === 0) {
         return { success: false, error: "At least one item must be selected for return", swap: null };
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
+    const options = await getStoreClientOptions();
     try {
         const payload = {
             order_id: orderId,
@@ -43,46 +41,28 @@ export const createSwapRequest = async (prevState, formData) => {
             note: note || "Exchange requested from storefront",
         };
         const cookieStore = await cookies();
-        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value ||
+            cookieStore.get("_medusa_guest_token")?.value;
         const token = cookieStore.get("_medusa_jwt")?.value;
         let swapData;
-        // Check if we should use the guest endpoint
         if (guestToken && !token) {
-            const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/swaps`, {
-                method: "POST",
-                body: {
-                    return_items: payload.return_items,
-                    new_items: payload.new_items,
-                    reason: payload.reason,
-                    note: payload.note,
-                },
-                headers: {
-                    ...headers,
-                    "Authorization": `Bearer ${guestToken}`
-                },
-                cache: "no-store",
-            });
-            swapData = response.swap || response;
+            const guestOptions = await getStoreClientOptionsWithToken(guestToken);
+            swapData = await medusaSwapCreateGuest(orderId, {
+                return_items: payload.return_items,
+                new_items: payload.new_items,
+                reason: payload.reason,
+                note: payload.note,
+            }, guestOptions);
         }
         else {
-            const response = await sdk.client.fetch(`/store/swaps`, {
-                method: "POST",
-                body: payload,
-                headers,
-                cache: "no-store",
-            });
-            swapData = response.swap || response;
+            swapData = await medusaSwapCreate(payload, options);
         }
         revalidateTag("orders");
         return { success: true, error: null, swap: swapData };
     }
     catch (error) {
-        // Extract error message from response if possible
         let errorMsg = "Failed to create exchange request";
-        if (error.response?.data?.message) {
-            errorMsg = error.response.data.message;
-        }
-        else if (error.message) {
+        if (error instanceof Error && error.message) {
             errorMsg = error.message;
         }
         return { success: false, error: errorMsg, swap: null };
@@ -92,31 +72,17 @@ export const createSwapRequest = async (prevState, formData) => {
  * List swaps for an order or customer
  */
 export const listSwaps = async (orderId) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    // Authenticated flow
-    if (headers.authorization) {
-        return sdk.client.fetch(`/store/swaps`, {
-            method: "GET",
-            query: orderId ? { order_id: orderId } : {},
-            headers,
-            cache: "no-store",
-        });
+    const options = await getStoreClientOptions();
+    if (options.authorization) {
+        return medusaSwapList(options, orderId ? { order_id: orderId } : undefined);
     }
-    // Guest flow
     if (orderId) {
         const cookieStore = await cookies();
-        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value ||
+            cookieStore.get("_medusa_guest_token")?.value;
         if (guestToken) {
-            return sdk.client.fetch(`/store/guest-orders/${orderId}/swaps`, {
-                method: "GET",
-                headers: {
-                    ...headers,
-                    "Authorization": `Bearer ${guestToken}`
-                },
-                cache: "no-store",
-            });
+            const guestOptions = await getStoreClientOptionsWithToken(guestToken);
+            return medusaSwapListGuest(orderId, guestOptions);
         }
     }
     return { swaps: [], count: 0 };

package/dist/server/variants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../../src/server/variants.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAI3C,eAAO,MAAM,eAAe,GAC1B,YAAY,MAAM,KACjB,OAAO,CAAC,SAAS,CAAC,mBAAmB,GAAG,IAAI,CA4B9C,CAAA"}
+{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../../src/server/variants.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAI3C,eAAO,MAAM,eAAe,GAC1B,YAAY,MAAM,KACjB,OAAO,CAAC,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAU9C,CAAA"}

package/dist/server/variants.js

@@ -1,26 +1,15 @@
 "use server";
-import { sdk } from "../config";
-import { getAuthHeaders, getCacheOptions } from "../cookies";
+import { medusaVariantRetrieve } from "medusa-services/variants";
+import { getStoreClientOptions } from "../util/store-client";
 export const retrieveVariant = async (variant_id) => {
-    const authHeaders = await getAuthHeaders();
-    if (!authHeaders)
+    try {
+        const options = await getStoreClientOptions();
+        if (!options.authorization)
+            return null;
+        const { variant } = await medusaVariantRetrieve(variant_id, options, { fields: "*images" });
+        return variant;
+    }
+    catch {
         return null;
-    const headers = {
-        ...authHeaders,
-    };
-    const next = {
-        ...(await getCacheOptions("variants")),
-    };
-    return await sdk.client
-        .fetch(`/store/product-variants/${variant_id}`, {
-        method: "GET",
-        query: {
-            fields: "*images",
-        },
-        headers,
-        next,
-        cache: "force-cache",
-    })
-        .then(({ variant }) => variant)
-        .catch(() => null);
+    }
 };

package/dist/server/wishlist.d.ts

@@ -0,0 +1,11 @@
+/** Wishlist entries enriched with full Medusa product payloads. */
+export declare function getWishlist(includeDetails?: boolean, countryCode?: string): Promise<{
+    success: false;
+    error: string;
+    data: unknown[];
+} | {
+    success: true;
+    data: Record<string, unknown>[];
+    error?: undefined;
+}>;
+//# sourceMappingURL=wishlist.d.ts.map

package/dist/server/wishlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wishlist.d.ts","sourceRoot":"","sources":["../../src/server/wishlist.ts"],"names":[],"mappings":"AAOA,mEAAmE;AACnE,wBAAsB,WAAW,CAAC,cAAc,UAAO,EAAE,WAAW,CAAC,EAAE,MAAM;;;UAGF,OAAO,EAAE;;;;;GAoDnF"}

package/dist/server/wishlist.js

@@ -0,0 +1,49 @@
+"use server";
+import { sdk } from "../config";
+import { getRegion } from "./regions";
+import { fetchWishlist } from "medusa-wishlist-logic/server";
+/** Wishlist entries enriched with full Medusa product payloads. */
+export async function getWishlist(includeDetails = true, countryCode) {
+    const result = await fetchWishlist(includeDetails);
+    if (!result.success) {
+        return { success: false, error: result.error, data: [] };
+    }
+    let wishlistItems = result.data;
+    if (!includeDetails || wishlistItems.length === 0) {
+        return { success: true, data: wishlistItems };
+    }
+    const productIds = wishlistItems
+        .map((item) => {
+        const id = item.product_id ?? item.id;
+        return typeof id === "string" ? id : null;
+    })
+        .filter((id) => Boolean(id));
+    if (productIds.length === 0) {
+        return { success: true, data: wishlistItems };
+    }
+    try {
+        let regionId;
+        if (countryCode) {
+            const region = await getRegion(countryCode);
+            regionId = region?.id;
+        }
+        const productsResponse = await sdk.store.product.list({
+            id: productIds,
+            fields: "*thumbnail,*images,*variants,*variants.options,*options,*options.values,*variants.calculated_price,*variants.inventory_quantity,*variants.manage_inventory,*variants.allow_backorder",
+            ...(regionId ? { region_id: regionId } : {}),
+        }, { next: { tags: ["products"] } });
+        const fullProducts = productsResponse.products;
+        wishlistItems = wishlistItems.map((item) => {
+            const itemId = (item.product_id ?? item.id);
+            const fullProduct = fullProducts.find((p) => p.id === itemId);
+            if (fullProduct) {
+                return { ...item, product: fullProduct };
+            }
+            return item;
+        });
+    }
+    catch {
+        // Return API wishlist without enrichment
+    }
+    return { success: true, data: wishlistItems };
+}

package/dist/util/get-locale-header.d.ts

@@ -1,4 +1,4 @@
 export declare function getLocaleHeader(): Promise<{
-    readonly "x-medusa-locale": string;
+    readonly "x-medusa-locale": string | null;
 }>;
 //# sourceMappingURL=get-locale-header.d.ts.map

package/dist/util/revalidate-cart.d.ts

@@ -0,0 +1,2 @@
+export declare function revalidateCartTags(): Promise<void>;
+//# sourceMappingURL=revalidate-cart.d.ts.map

package/dist/util/revalidate-cart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate-cart.d.ts","sourceRoot":"","sources":["../../src/util/revalidate-cart.ts"],"names":[],"mappings":"AAGA,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMxD"}

package/dist/util/revalidate-cart.js

@@ -0,0 +1,8 @@
+import { revalidateTag } from "next/cache";
+import { getCacheTag } from "../cookies";
+export async function revalidateCartTags() {
+    const cartCacheTag = await getCacheTag("carts");
+    revalidateTag(cartCacheTag);
+    const fulfillmentCacheTag = await getCacheTag("fulfillment");
+    revalidateTag(fulfillmentCacheTag);
+}

package/dist/util/sort-products.d.ts

@@ -0,0 +1,3 @@
+export type { SortOptions } from "medusa-services/product-listing";
+export { sortProducts } from "medusa-services/product-listing";
+//# sourceMappingURL=sort-products.d.ts.map

package/dist/util/sort-products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-products.d.ts","sourceRoot":"","sources":["../../src/util/sort-products.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/util/sort-products.js

@@ -0,0 +1 @@
+export { sortProducts } from "medusa-services/product-listing";

package/dist/util/store-client.d.ts

@@ -0,0 +1,13 @@
+import type { MedusaStoreClientOptions } from "medusa-services/store-api";
+import { type MedusaAuthClientOptions } from "medusa-services/auth";
+/**
+ * Builds portable Medusa store client options from Next.js cookies and env.
+ */
+export declare function getStoreClientOptions(): Promise<MedusaStoreClientOptions>;
+/** @deprecated Use getStoreClientOptions */
+export declare const getStoreCartClientOptions: typeof getStoreClientOptions;
+export declare function getMedusaBackendUrl(): string;
+export declare function getGuestStoreClientOptions(): Promise<MedusaStoreClientOptions | null>;
+export declare function getStoreClientOptionsWithToken(token: string): Promise<MedusaStoreClientOptions>;
+export declare function getAuthClientOptions(authorization?: string): Promise<MedusaAuthClientOptions>;
+//# sourceMappingURL=store-client.d.ts.map

package/dist/util/store-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-client.d.ts","sourceRoot":"","sources":["../../src/util/store-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AACzE,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAqBxF;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAY/E;AAED,4CAA4C;AAC5C,eAAO,MAAM,yBAAyB,8BAAwB,CAAA;AAE9D,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC,CAuB3F;AAED,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,wBAAwB,CAAC,CAMnC;AAED,wBAAsB,oBAAoB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAWnG"}