@cedros/pay-react 0.1.0

package/dist/testing/index.mjs

@@ -0,0 +1,374 @@
+import { vi as n } from "vitest";
+import { jsx as c, Fragment as k } from "react/jsx-runtime";
+import { C as f } from "../CedrosContext-vX9uqZKp.mjs";
+const P = {
+  clusterApiUrl: n.fn(() => "https://api.devnet.solana.com"),
+  Connection: class {
+    async getLatestBlockhash() {
+      return {
+        blockhash: "mockedBlockhash123",
+        lastValidBlockHeight: 1e6
+      };
+    }
+    async getBalance() {
+      return 1e9;
+    }
+    async getSignatureStatus() {
+      return { value: { confirmationStatus: "confirmed" } };
+    }
+    async getAccountInfo() {
+      return {
+        data: new Uint8Array(),
+        executable: !1,
+        lamports: 1e6,
+        owner: new Uint8Array(32),
+        rentEpoch: 0
+      };
+    }
+    async sendRawTransaction() {
+      return "mockedSignature123";
+    }
+    async confirmTransaction() {
+      return { value: { err: null } };
+    }
+  },
+  SystemProgram: {
+    transfer: n.fn(() => ({
+      keys: [],
+      programId: {},
+      data: new Uint8Array()
+    }))
+  },
+  Transaction: class {
+    recentBlockhash;
+    feePayer;
+    instructions = [];
+    add(t) {
+      return this.instructions.push(t), this;
+    }
+    serialize() {
+      return new Uint8Array([1, 2, 3, 4, 5]);
+    }
+  },
+  LAMPORTS_PER_SOL: 1e9,
+  PublicKey: class {
+    constructor(t) {
+      this.value = t;
+    }
+    toString() {
+      return typeof this.value == "string" ? this.value : "mockPublicKey123";
+    }
+    toBase58() {
+      return this.toString();
+    }
+    toBytes() {
+      return new Uint8Array(32);
+    }
+  }
+}, T = {
+  getAssociatedTokenAddress: n.fn(async () => ({
+    toBase58: () => "mockTokenAddress123"
+  })),
+  createTransferInstruction: n.fn(() => ({
+    keys: [],
+    programId: {},
+    data: new Uint8Array()
+  })),
+  TOKEN_PROGRAM_ID: "mockTokenProgramId"
+}, w = {
+  ConnectionProvider: ({ children: e }) => e,
+  WalletProvider: ({ children: e }) => e,
+  useWallet: () => ({
+    connected: !1,
+    connecting: !1,
+    connect: n.fn(),
+    disconnect: n.fn(),
+    publicKey: null,
+    signTransaction: n.fn(),
+    signAllTransactions: n.fn(),
+    select: n.fn()
+  })
+}, M = {
+  PhantomWalletAdapter: class {
+  },
+  SolflareWalletAdapter: class {
+  },
+  BackpackWalletAdapter: class {
+  }
+}, C = {
+  loadStripe: n.fn(async () => ({
+    redirectToCheckout: n.fn(async (e) => ({
+      error: null
+    })),
+    confirmCardPayment: n.fn(async () => ({
+      paymentIntent: { id: "pi_mock123", status: "succeeded" },
+      error: null
+    }))
+  }))
+};
+function x(e = !0, t = "mockWallet123") {
+  return {
+    connected: e,
+    connecting: !1,
+    connect: n.fn().mockResolvedValue(void 0),
+    disconnect: n.fn().mockResolvedValue(void 0),
+    publicKey: e ? { toBase58: () => t, toString: () => t } : null,
+    signTransaction: n.fn().mockResolvedValue({
+      signature: new Uint8Array(64),
+      serialize: () => new Uint8Array([1, 2, 3])
+    }),
+    signAllTransactions: n.fn().mockResolvedValue([]),
+    select: n.fn()
+  };
+}
+function R(e = {}) {
+  const { redirectSuccess: t = !0 } = e, o = e.sessionId ?? "cs_test_mock123";
+  return {
+    redirectToCheckout: n.fn().mockResolvedValue({
+      error: t ? null : { message: "Mock redirect error" }
+    }),
+    confirmCardPayment: n.fn().mockResolvedValue({
+      paymentIntent: {
+        id: "pi_mock123",
+        status: "succeeded"
+      },
+      error: null
+    }),
+    _sessionId: o
+    // Store for potential inspection
+  };
+}
+function U(e) {
+  return n.fn((t) => {
+    for (const [o, r] of Object.entries(e))
+      if (t.includes(o))
+        return Promise.resolve({
+          ok: r.status >= 200 && r.status < 300,
+          status: r.status,
+          json: async () => r.body,
+          text: async () => JSON.stringify(r.body),
+          headers: new Map(Object.entries(r.headers || {}))
+        });
+    return Promise.resolve({
+      ok: !1,
+      status: 404,
+      json: async () => ({ error: "Not found" }),
+      text: async () => JSON.stringify({ error: "Not found" }),
+      headers: /* @__PURE__ */ new Map()
+    });
+  });
+}
+function p(e = {}) {
+  return function({ children: o }) {
+    const r = {
+      stripePublicKey: e.stripePublicKey ?? "pk_test_mock_key_for_testing",
+      serverUrl: e.serverUrl ?? "http://localhost:8080",
+      solanaCluster: e.solanaCluster ?? "devnet",
+      solanaEndpoint: e.solanaEndpoint,
+      theme: e.theme ?? "light",
+      themeOverrides: e.themeOverrides,
+      unstyled: !1,
+      tokenMint: void 0,
+      dangerouslyAllowUnknownMint: !0,
+      // Allow any mint in test mode
+      logLevel: 4
+      // LogLevel.SILENT - no logs in tests
+    };
+    return /* @__PURE__ */ c(f, { config: r, children: o });
+  };
+}
+function I() {
+  return p({
+    stripePublicKey: "pk_test_minimal",
+    serverUrl: "http://localhost:8080",
+    solanaCluster: "devnet"
+  });
+}
+function j(e = {}) {
+  return e.connected, e.publicKey, e.connecting, function({ children: o }) {
+    return /* @__PURE__ */ c(k, { children: o });
+  };
+}
+function B(e = "cs_test_mock123") {
+  return {
+    success: !0,
+    transactionId: e,
+    error: void 0
+  };
+}
+function O(e = "Payment failed") {
+  return {
+    success: !1,
+    transactionId: void 0,
+    error: e
+  };
+}
+function q(e = {}) {
+  const {
+    scheme: t = "solana-spl-transfer",
+    network: o = "mainnet-beta",
+    maxAmountRequired: r = "1000000",
+    resource: s = "test-resource",
+    description: a = "Test Payment",
+    mimeType: i = "application/json",
+    payTo: l = "mockRecipient123",
+    maxTimeoutSeconds: u = 300,
+    asset: m = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    // USDC mint
+    extra: d = {
+      recipientTokenAccount: "mockTokenAccount123",
+      decimals: 6,
+      tokenSymbol: "USDC",
+      memo: "test-payment"
+    }
+  } = e;
+  return {
+    scheme: t,
+    network: o,
+    maxAmountRequired: r,
+    resource: s,
+    description: a,
+    mimeType: i,
+    payTo: l,
+    maxTimeoutSeconds: u,
+    asset: m,
+    extra: d
+  };
+}
+function K(e = {}) {
+  const {
+    success: t = !0,
+    error: o = null,
+    txHash: r = "mockSignature123",
+    networkId: s = "mainnet-beta",
+    metadata: a
+  } = e;
+  return {
+    success: t,
+    error: o,
+    txHash: r,
+    networkId: s,
+    metadata: a
+  };
+}
+async function E() {
+  return new Promise((e) => setTimeout(e, 0));
+}
+async function N(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+function V(e, t = {}) {
+  const {
+    maxAmountRequired: o = "1000000",
+    asset: r = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    // USDC mint
+    payTo: s = "mockRecipient123"
+  } = t;
+  return {
+    ok: !1,
+    status: 402,
+    json: async () => ({
+      x402Version: 0,
+      error: "payment required",
+      accepts: [
+        {
+          scheme: "solana-spl-transfer",
+          network: "mainnet-beta",
+          maxAmountRequired: o,
+          resource: e,
+          description: "Payment required",
+          mimeType: "application/json",
+          payTo: s,
+          maxTimeoutSeconds: 300,
+          asset: r,
+          extra: {
+            recipientTokenAccount: "mockTokenAccount123",
+            decimals: 6,
+            tokenSymbol: "USDC",
+            memo: `${e}:${Date.now()}`
+          }
+        }
+      ]
+    }),
+    headers: /* @__PURE__ */ new Map([
+      ["content-type", "application/json"]
+    ])
+  };
+}
+function G(e = !0) {
+  const t = e ? {
+    success: !0,
+    error: null,
+    txHash: "mockSignature123",
+    networkId: "mainnet-beta"
+  } : {
+    success: !1,
+    error: "Payment verification failed",
+    txHash: null,
+    networkId: null
+  };
+  return {
+    ok: e,
+    status: e ? 200 : 402,
+    json: async () => t,
+    headers: /* @__PURE__ */ new Map([
+      ["x-payment-response", JSON.stringify(t)]
+    ])
+  };
+}
+function D(e = "cs_test_mock123") {
+  return {
+    ok: !0,
+    status: 200,
+    json: async () => ({
+      sessionId: e,
+      url: `https://checkout.stripe.com/pay/${e}`
+    })
+  };
+}
+function F(e = "mockWallet123") {
+  return {
+    publicKey: {
+      toBase58: () => e,
+      toString: () => e
+    }
+  };
+}
+function z() {
+  return {
+    signature: new Uint8Array(64).fill(1),
+    serialize: () => new Uint8Array([1, 2, 3, 4, 5])
+  };
+}
+function H(e) {
+  return n.fn(e);
+}
+async function J() {
+  return new Promise((e) => setImmediate(e));
+}
+export {
+  I as createMinimalMockProvider,
+  p as createMockCedrosProvider,
+  U as createMockFetch,
+  R as createMockStripe,
+  x as createMockWallet,
+  H as createSpy,
+  J as flushPromises,
+  O as mockPaymentFailure,
+  B as mockPaymentSuccess,
+  V as mockQuoteResponse,
+  K as mockSettlement,
+  z as mockSignTransaction,
+  P as mockSolanaWeb3,
+  T as mockSplToken,
+  C as mockStripeJs,
+  D as mockStripeSessionResponse,
+  G as mockVerifyResponse,
+  w as mockWalletAdapter,
+  M as mockWalletAdapterWallets,
+  F as mockWalletConnect,
+  j as mockWalletProvider,
+  q as mockX402Quote,
+  N as wait,
+  E as waitForNextTick
+};

package/dist/testing/mocks.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Mock implementations for Solana and Stripe dependencies
+ *
+ * These mocks can be used with vi.mock() in Vitest or jest.mock() in Jest
+ * to avoid needing real Solana/Stripe connections in tests.
+ */
+/**
+ * Mock Solana web3.js with common methods
+ *
+ * @example
+ * ```typescript
+ * vi.mock('@solana/web3.js', () => mockSolanaWeb3);
+ * ```
+ */
+export declare const mockSolanaWeb3: {
+    clusterApiUrl: import('vitest').Mock<() => string>;
+    Connection: {
+        new (): {
+            getLatestBlockhash(): Promise<{
+                blockhash: string;
+                lastValidBlockHeight: number;
+            }>;
+            getBalance(): Promise<number>;
+            getSignatureStatus(): Promise<{
+                value: {
+                    confirmationStatus: string;
+                };
+            }>;
+            getAccountInfo(): Promise<{
+                data: Uint8Array<ArrayBuffer>;
+                executable: boolean;
+                lamports: number;
+                owner: Uint8Array<ArrayBuffer>;
+                rentEpoch: number;
+            }>;
+            sendRawTransaction(): Promise<string>;
+            confirmTransaction(): Promise<{
+                value: {
+                    err: null;
+                };
+            }>;
+        };
+    };
+    SystemProgram: {
+        transfer: import('vitest').Mock<() => {
+            keys: never[];
+            programId: {};
+            data: Uint8Array<ArrayBuffer>;
+        }>;
+    };
+    Transaction: {
+        new (): {
+            recentBlockhash?: string;
+            feePayer?: unknown;
+            instructions: unknown[];
+            add(instruction: unknown): /*elided*/ any;
+            serialize(): Uint8Array<ArrayBuffer>;
+        };
+    };
+    LAMPORTS_PER_SOL: number;
+    PublicKey: {
+        new (value: string | Uint8Array): {
+            value: string | Uint8Array;
+            toString(): string;
+            toBase58(): string;
+            toBytes(): Uint8Array<ArrayBuffer>;
+        };
+    };
+};
+/**
+ * Mock SPL Token with transfer instruction
+ *
+ * @example
+ * ```typescript
+ * vi.mock('@solana/spl-token', () => mockSplToken);
+ * ```
+ */
+export declare const mockSplToken: {
+    getAssociatedTokenAddress: import('vitest').Mock<() => Promise<{
+        toBase58: () => "mockTokenAddress123";
+    }>>;
+    createTransferInstruction: import('vitest').Mock<() => {
+        keys: never[];
+        programId: {};
+        data: Uint8Array<ArrayBuffer>;
+    }>;
+    TOKEN_PROGRAM_ID: string;
+};
+/**
+ * Mock Solana wallet adapter (react)
+ *
+ * @example
+ * ```typescript
+ * vi.mock('@solana/wallet-adapter-react', () => mockWalletAdapter);
+ * ```
+ */
+export declare const mockWalletAdapter: {
+    ConnectionProvider: ({ children }: {
+        children: React.ReactNode;
+    }) => import('react').ReactNode;
+    WalletProvider: ({ children }: {
+        children: React.ReactNode;
+    }) => import('react').ReactNode;
+    useWallet: () => {
+        connected: boolean;
+        connecting: boolean;
+        connect: import('vitest').Mock<import('@vitest/spy').Procedure>;
+        disconnect: import('vitest').Mock<import('@vitest/spy').Procedure>;
+        publicKey: null;
+        signTransaction: import('vitest').Mock<import('@vitest/spy').Procedure>;
+        signAllTransactions: import('vitest').Mock<import('@vitest/spy').Procedure>;
+        select: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    };
+};
+/**
+ * Mock Solana wallet adapter wallets
+ *
+ * @example
+ * ```typescript
+ * vi.mock('@solana/wallet-adapter-wallets', () => mockWalletAdapterWallets);
+ * ```
+ */
+export declare const mockWalletAdapterWallets: {
+    PhantomWalletAdapter: {
+        new (): {};
+    };
+    SolflareWalletAdapter: {
+        new (): {};
+    };
+    BackpackWalletAdapter: {
+        new (): {};
+    };
+};
+/**
+ * Mock Stripe.js
+ *
+ * @example
+ * ```typescript
+ * vi.mock('@stripe/stripe-js', () => mockStripeJs);
+ * ```
+ */
+export declare const mockStripeJs: {
+    loadStripe: import('vitest').Mock<() => Promise<{
+        redirectToCheckout: import('vitest').Mock<(_options: {
+            sessionId: string;
+        }) => Promise<{
+            error: null;
+        }>>;
+        confirmCardPayment: import('vitest').Mock<() => Promise<{
+            paymentIntent: {
+                id: string;
+                status: string;
+            };
+            error: null;
+        }>>;
+    }>>;
+};
+/**
+ * Create a mock wallet with custom behavior
+ *
+ * @param connected - Whether wallet is connected
+ * @param publicKey - Mock public key string
+ * @returns Mock wallet object
+ */
+export declare function createMockWallet(connected?: boolean, publicKey?: string): {
+    connected: boolean;
+    connecting: boolean;
+    connect: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    disconnect: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    publicKey: {
+        toBase58: () => string;
+        toString: () => string;
+    } | null;
+    signTransaction: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    signAllTransactions: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    select: import('vitest').Mock<import('@vitest/spy').Procedure>;
+};
+/**
+ * Create a mock Stripe instance
+ *
+ * @param options - Options for mock behavior
+ * @returns Mock Stripe object
+ */
+export declare function createMockStripe(options?: {
+    redirectSuccess?: boolean;
+    sessionId?: string;
+}): {
+    redirectToCheckout: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    confirmCardPayment: import('vitest').Mock<import('@vitest/spy').Procedure>;
+    _sessionId: string;
+};
+/**
+ * Mock fetch for backend API calls
+ *
+ * @param responses - Map of URL patterns to responses
+ * @returns Mock fetch function
+ *
+ * @example
+ * ```typescript
+ * global.fetch = createMockFetch({
+ *   '/paywall/v1/quote': { status: 402, body: { recipient: '...' } },
+ *   '/paywall/v1/verify': { status: 200, body: { success: true } },
+ * });
+ * ```
+ */
+export declare function createMockFetch(responses: Record<string, {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+}>): import('vitest').Mock<(url: string) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+    text: () => Promise<string>;
+    headers: Map<string, string>;
+}> | Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<{
+        error: string;
+    }>;
+    text: () => Promise<string>;
+    headers: Map<any, any>;
+}>>;
+//# sourceMappingURL=mocks.d.ts.map

package/dist/testing/mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/testing/mocks.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA4CL,MAAM;uBACb,OAAO;0BACJ,OAAO,EAAE;6BAEN,OAAO;;;;;;oBAWE,MAAM,GAAG,UAAU;mBAAnB,MAAM,GAAG,UAAU;;;;;;CAchD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAUxB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;uCACO;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE;mCACjC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE;;;;;;;;;;;CAW7D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;CAIpC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;6DAEsB;YAAE,SAAS,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;CAQnE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,GAAE,OAAc,EACzB,SAAS,GAAE,MAAwB;;;;;;;;;;;;EAepC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE;IACxC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACf;;;;EAiBL;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC,+BAE3E,MAAM;;;;;;;;;;;;;;IAsB1B"}

package/dist/testing/providers.d.ts

@@ -0,0 +1,89 @@
+import { ReactNode } from 'react';
+import { CedrosConfig } from '../types';
+/**
+ * Configuration for creating a mock Cedros provider
+ */
+export interface MockCedrosProviderConfig extends Partial<CedrosConfig> {
+    /** Mock implementations for managers (optional) */
+    mockManagers?: {
+        stripeManager?: Record<string, unknown>;
+        x402Manager?: Record<string, unknown>;
+        walletManager?: Record<string, unknown>;
+        routeDiscoveryManager?: Record<string, unknown>;
+    };
+}
+/**
+ * Creates a mock CedrosProvider for testing
+ *
+ * @param config - Optional configuration
+ * @returns Mock provider component
+ *
+ * @example
+ * ```typescript
+ * import { render } from '@testing-library/react';
+ * import { createMockCedrosProvider } from '@cedros/pay-react/testing';
+ *
+ * const MockProvider = createMockCedrosProvider({
+ *   stripePublicKey: 'pk_test_mock',
+ *   serverUrl: 'http://localhost:8080',
+ * });
+ *
+ * render(
+ *   <MockProvider>
+ *     <YourComponent />
+ *   </MockProvider>
+ * );
+ * ```
+ */
+export declare function createMockCedrosProvider(config?: MockCedrosProviderConfig): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Creates a minimal mock provider for simple tests
+ *
+ * @returns Minimal mock provider component
+ *
+ * @example
+ * ```typescript
+ * const MinimalProvider = createMinimalMockProvider();
+ *
+ * render(
+ *   <MinimalProvider>
+ *     <YourComponent />
+ *   </MinimalProvider>
+ * );
+ * ```
+ */
+export declare function createMinimalMockProvider(): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Wrapper for testing with Solana wallet mocks
+ *
+ * @param walletState - Mock wallet state
+ * @returns Mock wallet provider component
+ *
+ * @example
+ * ```typescript
+ * import { mockWalletProvider } from '@cedros/pay-react/testing';
+ *
+ * const WalletProvider = mockWalletProvider({
+ *   connected: true,
+ *   publicKey: 'mockWallet123',
+ * });
+ *
+ * render(
+ *   <WalletProvider>
+ *     <CryptoButton resource="test" />
+ *   </WalletProvider>
+ * );
+ * ```
+ */
+export declare function mockWalletProvider(walletState?: {
+    connected?: boolean;
+    publicKey?: string;
+    connecting?: boolean;
+}): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=providers.d.ts.map

package/dist/testing/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/testing/providers.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,OAAO,CAAC,YAAY,CAAC;IACrE,mDAAmD;IACnD,YAAY,CAAC,EAAE;QACb,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACxC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACxC,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACjD,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,wBAA6B,IAGzC,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,6CAmBzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,mBArCU;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,6CA2CzE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,GAAE;IAC9C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;CACjB,IAO+B,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,6CAKzE"}