@mints-cloud/cxf-codegen 1.0.0

package/dist/lib/api-route-helpers.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQueryString = buildQueryString;
+exports.normalizePath = normalizePath;
+exports.setAuthCookies = setAuthCookies;
+exports.handleError = handleError;
+exports.sendResponse = sendResponse;
+const cxf_auth_1 = require("./cxf-auth");
+function buildQueryString(query) {
+    const params = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+        if (key !== "path" && value != null) {
+            if (Array.isArray(value)) {
+                value.forEach((v) => params.append(key, String(v)));
+            }
+            else {
+                params.append(key, String(value));
+            }
+        }
+    });
+    const str = params.toString();
+    return str ? `?${str}` : "";
+}
+function normalizePath(pathSegments) {
+    if (!pathSegments || (Array.isArray(pathSegments) && pathSegments.length === 0)) {
+        throw new Error("Missing path");
+    }
+    return (Array.isArray(pathSegments) ? pathSegments : [pathSegments])
+        .join("/")
+        .replace(/^\/+/, "");
+}
+function setAuthCookies(res, tokens) {
+    const cookieOptions = { secure: true, sameSite: "Lax", httpOnly: true, path: "/" };
+    const cookies = [];
+    if (tokens.accessToken) {
+        cookies.push((0, cxf_auth_1.buildCookieString)(cxf_auth_1.CXF_COOKIE_NAMES.ACCESS_TOKEN, tokens.accessToken, cookieOptions));
+    }
+    if (tokens.refreshToken) {
+        cookies.push((0, cxf_auth_1.buildCookieString)(cxf_auth_1.CXF_COOKIE_NAMES.REFRESH_TOKEN, tokens.refreshToken, cookieOptions));
+    }
+    if (cookies.length > 0) {
+        res.setHeader("Set-Cookie", cookies);
+    }
+}
+function handleError(res, err) {
+    const dev = process.env.NODE_ENV !== "production";
+    return res.status(500).json({
+        error: err?.message || "Unknown error",
+        ...(dev && { cause: err?.cause?.code || err?.code, note: "Check CXF_BASE_URL, protocol, DNS, and network reachability" }),
+    });
+}
+async function sendResponse(res, response) {
+    const contentType = response.headers.get("content-type") || "";
+    const status = response.status;
+    // JSON
+    if (contentType.includes("application/json")) {
+        const data = await response.json();
+        return res.status(status).json(data);
+    }
+    // Text (incl. SVG/XML)
+    if (contentType.startsWith("text/") || contentType.includes("xml") || contentType.includes("svg")) {
+        const text = await response.text();
+        if (contentType)
+            res.setHeader("content-type", contentType);
+        return res.status(status).send(text);
+    }
+    // Binary (images, files)
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    if (contentType)
+        res.setHeader("content-type", contentType);
+    return res.status(status).send(buffer);
+}

package/dist/lib/cxf-auth.d.ts

@@ -0,0 +1,43 @@
+export declare const CXF_COOKIE_NAMES: {
+    readonly ACCESS_TOKEN: "cxf_contact_access_token";
+    readonly REFRESH_TOKEN: "cxf_contact_refresh_token";
+};
+export declare const CXF_HEADER_NAMES: {
+    readonly ACCESS_TOKEN: "Access-Token";
+    readonly REFRESH_TOKEN: "Refresh-Token";
+    readonly API_KEY: "Api-Key";
+    readonly USER_TOKEN: "User-Token";
+};
+export interface CxfTokens {
+    accessToken: string | null;
+    refreshToken: string | null;
+}
+export declare function getTokensFromCookies(cookieHeader?: string | null): CxfTokens;
+export declare function buildAuthHeaders(tokens: CxfTokens, apiKey?: string | null, userToken?: string | null): Record<string, string>;
+export declare function makeAuthenticatedRequest(url: string, options?: {
+    method?: string;
+    body?: any;
+    tokens?: CxfTokens;
+    apiKey?: string | null;
+    userToken?: string | null;
+    cookieHeader?: string | null;
+    retryOnAuthError?: boolean;
+}): Promise<{
+    response: Response;
+    newTokens: CxfTokens;
+}>;
+export declare function extractSetCookieHeaders(response: Response): string[];
+export declare function extractTokensFromSetCookie(setCookieHeaders: string[] | null | undefined): CxfTokens;
+export declare function buildCookieHeader(tokens: CxfTokens): string;
+export declare function getCxfBaseUrl(): string;
+export declare function getCxfApiKey(type?: "public" | "dev" | "user"): string | null;
+export declare function buildCookieString(name: string, value: string, options?: {
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+    maxAge?: number;
+    path?: string;
+    httpOnly?: boolean;
+}): string;
+export declare function setTokensAsCookies(tokens: CxfTokens): void;
+export declare function clearAuthCookies(): void;
+//# sourceMappingURL=cxf-auth.d.ts.map

package/dist/lib/cxf-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cxf-auth.d.ts","sourceRoot":"","sources":["../../src/lib/cxf-auth.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAC;AAEX,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAiBD,wBAAgB,oBAAoB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAS5E;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxB;AAED,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACvB,GACL,OAAO,CAAC;IACT,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC,CAmDD;AAMD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,CAUpE;AAED,wBAAgB,0BAA0B,CACxC,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAC5C,SAAS,CAmBX;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAS3D;AAED,wBAAgB,aAAa,IAAI,MAAM,CAMtC;AAED,wBAAgB,YAAY,CAAC,IAAI,GAAE,QAAQ,GAAG,KAAK,GAAG,MAAiB,GAAG,MAAM,GAAG,IAAI,CAYtF;AAMD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACf,GACL,MAAM,CAaR;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAuB1D;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAQvC"}

package/dist/lib/cxf-auth.js

@@ -0,0 +1,189 @@
+"use strict";
+// CXF authentication and cookie handling utilities
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CXF_HEADER_NAMES = exports.CXF_COOKIE_NAMES = void 0;
+exports.getTokensFromCookies = getTokensFromCookies;
+exports.buildAuthHeaders = buildAuthHeaders;
+exports.makeAuthenticatedRequest = makeAuthenticatedRequest;
+exports.extractSetCookieHeaders = extractSetCookieHeaders;
+exports.extractTokensFromSetCookie = extractTokensFromSetCookie;
+exports.buildCookieHeader = buildCookieHeader;
+exports.getCxfBaseUrl = getCxfBaseUrl;
+exports.getCxfApiKey = getCxfApiKey;
+exports.buildCookieString = buildCookieString;
+exports.setTokensAsCookies = setTokensAsCookies;
+exports.clearAuthCookies = clearAuthCookies;
+exports.CXF_COOKIE_NAMES = {
+    ACCESS_TOKEN: "cxf_contact_access_token",
+    REFRESH_TOKEN: "cxf_contact_refresh_token",
+};
+exports.CXF_HEADER_NAMES = {
+    ACCESS_TOKEN: "Access-Token",
+    REFRESH_TOKEN: "Refresh-Token",
+    API_KEY: "Api-Key",
+    USER_TOKEN: "User-Token",
+};
+// ============================================================================
+// Universal functions (work in both client and server)
+// ============================================================================
+function parseCookies(cookieString) {
+    const cookies = {};
+    cookieString.split(";").forEach((cookie) => {
+        const [name, ...rest] = cookie.trim().split("=");
+        if (name && rest.length > 0) {
+            cookies[name] = decodeURIComponent(rest.join("="));
+        }
+    });
+    return cookies;
+}
+function getTokensFromCookies(cookieHeader) {
+    const cookieString = typeof window !== "undefined" ? document.cookie : cookieHeader || "";
+    const cookies = parseCookies(cookieString);
+    return {
+        accessToken: cookies[exports.CXF_COOKIE_NAMES.ACCESS_TOKEN] || null,
+        refreshToken: cookies[exports.CXF_COOKIE_NAMES.REFRESH_TOKEN] || null,
+    };
+}
+function buildAuthHeaders(tokens, apiKey, userToken) {
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+    if (apiKey)
+        headers[exports.CXF_HEADER_NAMES.API_KEY] = apiKey;
+    if (tokens.accessToken)
+        headers[exports.CXF_HEADER_NAMES.ACCESS_TOKEN] = tokens.accessToken;
+    if (tokens.refreshToken)
+        headers[exports.CXF_HEADER_NAMES.REFRESH_TOKEN] = tokens.refreshToken;
+    if (userToken)
+        headers[exports.CXF_HEADER_NAMES.USER_TOKEN] = userToken;
+    return headers;
+}
+async function makeAuthenticatedRequest(url, options = {}) {
+    const { method = "GET", body, tokens: providedTokens, apiKey, userToken, cookieHeader, retryOnAuthError = true, } = options;
+    const tokens = providedTokens || getTokensFromCookies(cookieHeader);
+    const buildRequestOptions = (tokens, cookieStr) => {
+        const headers = buildAuthHeaders(tokens, apiKey, userToken);
+        if (cookieStr) {
+            headers.Cookie = cookieStr;
+        }
+        const requestOptions = { method, headers };
+        if (body && method !== "GET" && method !== "HEAD") {
+            requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        return requestOptions;
+    };
+    const cookieStr = cookieHeader || buildCookieHeader(tokens);
+    let response = await fetch(url, buildRequestOptions(tokens, cookieStr));
+    const setCookieHeaders = extractSetCookieHeaders(response);
+    let newTokens = extractTokensFromSetCookie(setCookieHeaders);
+    if (!newTokens.accessToken && !newTokens.refreshToken) {
+        newTokens = tokens;
+    }
+    if (retryOnAuthError &&
+        (response.status === 401 || response.status === 419) &&
+        (newTokens.accessToken || newTokens.refreshToken)) {
+        const retryCookieStr = buildCookieHeader(newTokens);
+        response = await fetch(url, buildRequestOptions(newTokens, retryCookieStr));
+        const retrySetCookieHeaders = extractSetCookieHeaders(response);
+        const retryTokens = extractTokensFromSetCookie(retrySetCookieHeaders);
+        if (retryTokens.accessToken || retryTokens.refreshToken) {
+            newTokens = retryTokens;
+        }
+    }
+    return { response, newTokens };
+}
+// ============================================================================
+// Server-side only functions
+// ============================================================================
+function extractSetCookieHeaders(response) {
+    const headers = response.headers;
+    if (typeof headers.getSetCookie === "function") {
+        return headers.getSetCookie();
+    }
+    const rawHeaders = headers.raw?.() || {};
+    const setCookieRaw = rawHeaders["set-cookie"] || rawHeaders["Set-Cookie"] || [];
+    return Array.isArray(setCookieRaw) ? setCookieRaw : [setCookieRaw];
+}
+function extractTokensFromSetCookie(setCookieHeaders) {
+    const tokens = { accessToken: null, refreshToken: null };
+    if (!setCookieHeaders)
+        return tokens;
+    for (const header of setCookieHeaders) {
+        const match = header.match(/^([^=]+)=([^;]+)/);
+        if (!match)
+            continue;
+        const name = match[1].trim();
+        const value = match[2].trim();
+        if (name === exports.CXF_COOKIE_NAMES.ACCESS_TOKEN) {
+            tokens.accessToken = value;
+        }
+        else if (name === exports.CXF_COOKIE_NAMES.REFRESH_TOKEN) {
+            tokens.refreshToken = value;
+        }
+    }
+    return tokens;
+}
+function buildCookieHeader(tokens) {
+    const cookies = [];
+    if (tokens.accessToken) {
+        cookies.push(`${exports.CXF_COOKIE_NAMES.ACCESS_TOKEN}=${encodeURIComponent(tokens.accessToken)}`);
+    }
+    if (tokens.refreshToken) {
+        cookies.push(`${exports.CXF_COOKIE_NAMES.REFRESH_TOKEN}=${encodeURIComponent(tokens.refreshToken)}`);
+    }
+    return cookies.join("; ");
+}
+function getCxfBaseUrl() {
+    const baseUrl = (process.env.CXF_BASE_URL || process.env.URL || "").trim();
+    if (!baseUrl) {
+        throw new Error("Missing CXF_BASE_URL or URL environment variable");
+    }
+    return baseUrl.replace(/\/+$/, "");
+}
+function getCxfApiKey(type = "public") {
+    const envKeys = {
+        dev: ["CXF_DEV_API_KEY"],
+        user: ["CXF_USER_API_KEY"],
+        public: ["CXF_API_KEY", "API_KEY"],
+    };
+    const key = envKeys[type]
+        .map((k) => process.env[k])
+        .find((v) => v?.trim());
+    return key?.trim() || null;
+}
+// ============================================================================
+// Client-side only functions
+// ============================================================================
+function buildCookieString(name, value, options = {}) {
+    const { secure = true, sameSite = "Lax", maxAge, path = "/", httpOnly } = options;
+    const parts = [
+        `${name}=${encodeURIComponent(value)}`,
+        `Path=${path}`,
+        maxAge && `Max-Age=${maxAge}`,
+        secure && "Secure",
+        httpOnly && "HttpOnly",
+        `SameSite=${sameSite}`,
+    ].filter(Boolean);
+    return parts.join("; ");
+}
+function setTokensAsCookies(tokens) {
+    if (typeof window === "undefined") {
+        console.warn("setTokensAsCookies can only be called client-side");
+        return;
+    }
+    const cookieOptions = { secure: true, sameSite: "Lax" };
+    if (tokens.accessToken) {
+        document.cookie = buildCookieString(exports.CXF_COOKIE_NAMES.ACCESS_TOKEN, tokens.accessToken, cookieOptions);
+    }
+    if (tokens.refreshToken) {
+        document.cookie = buildCookieString(exports.CXF_COOKIE_NAMES.REFRESH_TOKEN, tokens.refreshToken, cookieOptions);
+    }
+}
+function clearAuthCookies() {
+    if (typeof window === "undefined")
+        return;
+    const clearCookie = (name) => `${name}=; Path=/; Max-Age=0; Secure; SameSite=Lax`;
+    document.cookie = clearCookie(exports.CXF_COOKIE_NAMES.ACCESS_TOKEN);
+    document.cookie = clearCookie(exports.CXF_COOKIE_NAMES.REFRESH_TOKEN);
+}

package/dist/lib/server-props.d.ts

@@ -0,0 +1,77 @@
+import * as React from "react";
+import { GetStaticProps, GetServerSideProps } from "next";
+import { ReactElement, ComponentType } from "react";
+export interface EndpointConfig {
+    endpointPath: string;
+    params?: Record<string, any>;
+}
+export interface ServerPageProps {
+    queryCache?: Record<string, any>;
+    endpointData?: Record<string, any>;
+    buildId?: string;
+    buildTimestamp?: string;
+    queriesFound?: number;
+    _prefetchEnabled?: boolean;
+}
+export interface ServerPageWrapperProps extends ServerPageProps {
+    children: ReactElement;
+}
+export declare const EndpointDataContext: React.Context<Record<string, any>>;
+export declare function normalizeEndpointPath(endpointPath: string): string;
+export declare function buildQueryString(params?: Record<string, any>): string;
+export declare function buildEndpointKey(endpointPath: string, params?: Record<string, any>): string;
+export type PrefetchRequest = {
+    endpointPath: string;
+    params?: Record<string, any>;
+};
+export declare const PrefetchCollectorContext: React.Context<{
+    register: (req: PrefetchRequest) => void;
+} | null>;
+export declare function PrefetchCollectorProvider({ children, collector, }: {
+    children: React.ReactNode;
+    collector: PrefetchRequest[];
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Wrapper component that provides pre-fetched data to child components.
+ *
+ * CACHING STRATEGY:
+ * - queryCache: Pre-fetched Plasmic query data (from extractPlasmicQueryData)
+ * - endpointData: Pre-fetched custom endpoint data (from ApiCall)
+ *
+ * Components receive data via React Context, eliminating client-side loading states.
+ * This enables instant page loads with zero API calls on initial render.
+ */
+export declare function ServerPageWrapper({ children, queryCache, endpointData, buildId, buildTimestamp, queriesFound, }: ServerPageWrapperProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Create Next.js data fetching functions with ISR/SSR support.
+ *
+ * PRERENDERING PROCESS:
+ * 1. Renders the Plasmic component to discover all API calls
+ *    - extractPlasmicQueryData: Discovers Plasmic queries
+ *    - PrefetchCollectorProvider: Collects ApiCall requests
+ *
+ * 2. Prefetches all discovered data in parallel
+ *    - Fetches Plasmic query data
+ *    - Fetches custom endpoint data (with Contact Auth when available)
+ *    - Deduplicates requests by cache key
+ *
+ * 3. Returns props with data
+ *    - ISR mode: Caches data with revalidate period (stale-while-revalidate)
+ *    - SSR mode: Returns fresh data on every request
+ *
+ * CACHING BEHAVIOR:
+ * - ISR: Data cached at build time, regenerates in background after revalidate
+ * - SSR: Fresh data on every request, always has access to request cookies
+ */
+export declare function createServerProps<P extends ServerPageProps = ServerPageProps>(path: string, PlasmicComponent: ComponentType<any>, options?: {
+    mode?: "isr" | "ssr";
+    revalidate?: number;
+    endpoints?: EndpointConfig[];
+    generateParams?: () => Promise<Array<{
+        [key: string]: string | string[];
+    }>>;
+}): {
+    getStaticProps?: GetStaticProps<P>;
+    getServerSideProps?: GetServerSideProps<P>;
+};
+//# sourceMappingURL=server-props.d.ts.map

package/dist/lib/server-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-props.d.ts","sourceRoot":"","sources":["../../src/lib/server-props.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKpD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAuB,SAAQ,eAAe;IAC7D,QAAQ,EAAE,YAAY,CAAC;CACxB;AAID,eAAO,MAAM,mBAAmB,oCAA+C,CAAC;AAEhF,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAGlE;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAgBrE;AAID,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAI3F;AAeD,MAAM,MAAM,eAAe,GAAG;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC;AACrF,eAAO,MAAM,wBAAwB;cACzB,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI;SAC3B,CAAC;AAIhB,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,2CAUA;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,OAAO,EACP,cAAc,EACd,YAAY,GACb,EAAE,sBAAsB,2CAwCxB;AAqID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,EAC3E,IAAI,EAAE,MAAM,EACZ,gBAAgB,EAAE,aAAa,CAAC,GAAG,CAAC,EACpC,OAAO,GAAE;IACP,IAAI,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC,CAAC;CACxE,GACL;IACD,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACnC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CAC5C,CAwGA"}