@inno-isw/react-native-rtp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Quickteller
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,363 @@
-# Temporary Holding Version
+# @inno-isw/react-native-rtp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Request to Pay (RTP) SDK for React Native.
+
+`@inno-isw/react-native-rtp` owns the **business logic** of a Request to Pay flow — payload
+validation, de-duplication, expiry, recipient matching, normalized status, and
+the accept / decline / status calls. The **host app owns all UI**: it renders the
+bottom sheet, collects the PIN, and decides navigation.
+
+It is pure JS/TS with **zero native code** and **zero runtime dependencies**
+(only `react` / `react-native` peer deps). Every external effect is injected, so
+the same contract can be re-implemented on Kotlin or Swift.
+
+---
+
+## Installation
+
+```sh
+yarn add @inno-isw/react-native-rtp
+# or: npm install @inno-isw/react-native-rtp
+```
+
+Peer dependencies: `react`, `react-native`.
+
+### Publishing (maintainers)
+
+The package is consumed as a normal npm dependency — do **not** link it locally.
+
+```sh
+yarn install
+yarn prepare            # builds lib/ (bob build) via the prepare script
+npm publish             # publishes @inno-isw/react-native-rtp to the npm registry
+```
+
+Consumer (e.g. QTM) then installs it like any other package:
+
+```sh
+yarn add @inno-isw/react-native-rtp
+# or: npm install @inno-isw/react-native-rtp
+```
+
+---
+
+## The portable contract
+
+The SDK never sees a push notification. It sees a **decoded RTP payload**. Each
+platform is responsible for mapping *its* push shape (RTCP, raw FCM, APNs,
+in-house PN) into this structure.
+
+```ts
+interface RtpPayload {
+  version?: string;                 // schema version; unknown values are ignored
+  type: 'RTP';                      // discriminator
+  rtpId: string;                    // stable id — the idempotency key
+  amount: string;                   // decimal string, e.g. "5000.00"
+  currency: string;                 // ISO 4217, e.g. "NGN"
+  merchant: { name: string; accountNumber?: string; bank?: string; logoUrl?: string };
+  transactionRef?: string;
+  expiresAt: string;                // ISO 8601
+  recipient?: string;               // alias the request is addressed to
+  [key: string]: unknown;           // forward-compatible passthrough
+}
+```
+
+> Unknown fields are **ignored, not rejected**, so older SDKs keep working when
+> the backend adds fields.
+
+### `isRtp(payload)`
+
+The type guard operates on the **decoded payload**, not the notification
+envelope:
+
+```ts
+payload.type === 'RTP' && typeof payload.rtpId === 'string';
+```
+
+---
+
+## Quick start
+
+### 1. Create the client (injected seams)
+
+```ts
+import { createRtpClient } from '@inno-isw/react-native-rtp';
+import { api } from './api'; // your existing HTTP client / ky / axios instance
+
+export const rtpClient = createRtpClient({
+  // (required) minimal HTTP contract — the SDK never imports a network lib
+  transport: {
+    post: (path, body, headers) => api.post(path, { json: body, headers }),
+    get: (path, headers) => api.get(path, { headers }),
+  },
+
+  // (optional) auth headers, called per request so tokens/MACs stay fresh
+  getAuthHeaders: async () => ({ Authorization: `Bearer ${await getToken()}` }),
+
+  // (optional) drives the auth gate + recipient matching
+  getCurrentUser: () => authStore.user?.email ?? null,
+
+  // (optional) injectable clock for deterministic expiry
+  now: () => Date.now(),
+
+  // (optional) diagnostics sink
+  logger: (...args) => console.log('[rtp]', ...args),
+
+  // (optional) REST base path, default "/rtp"
+  basePath: '/rtp',
+});
+```
+
+### 2. Normalize your push notification → payload
+
+This is the **only** platform-specific input seam. Use the reference helper, or
+write your own:
+
+```ts
+import { mapPushToRtp } from '@inno-isw/react-native-rtp';
+
+// Works with RTCP/FCM shapes, including app_data JSON unwrapping:
+const payload = mapPushToRtp(notification);
+if (payload) {
+  rtpClient.receive(payload);
+}
+```
+
+For a bespoke PN system, pass your own data accessor:
+
+```ts
+const payload = mapPushToRtp(envelope, (e) => e.customKeys);
+```
+
+### 3. Mount the provider and build your UI
+
+```tsx
+import { RtpProvider, useRtp, RTP_STATUS } from '@inno-isw/react-native-rtp';
+import { rtpClient } from './rtpClient';
+
+export default function App() {
+  const isAuthenticated = useAuthStore((s) => Boolean(s.user));
+
+  return (
+    <RtpProvider
+      client={rtpClient}
+      isAuthenticated={isAuthenticated}
+      storage={persistence}          // optional — see "Cold start" below
+    >
+      <Dashboard />
+    </RtpProvider>
+  );
+}
+```
+
+Inside your screen, render your own sheet (e.g. QTM's `QTBottomSheet`):
+
+```tsx
+function Dashboard() {
+  const { request, status, isReady, accept, decline, dismiss, lastResult } =
+    useRtp();
+
+  return (
+    <>
+      <YourDashboard />
+
+      <QTBottomSheet isOpen={status !== null} onClose={dismiss}>
+        {request && (
+          <>
+            <Text>{request.merchant.name}</Text>
+            <Text>{request.currency} {request.amount}</Text>
+            <Text>{request.transactionRef}</Text>
+          </>
+        )}
+
+        {isReady && (
+          <>
+            {/* collect PIN yourself, produce an opaque credential, then: */}
+            <Button title="Accept" onPress={() => accept(credential)} />
+            <Button title="Decline" onPress={() => decline('USER_DECLINED')} />
+          </>
+        )}
+
+        {status === RTP_STATUS.ACCEPTED && <Text>Payment accepted</Text>}
+        {status === RTP_STATUS.FAILED && <Text>Something went wrong</Text>}
+        {lastResult?.error && <Text>{lastResult.error}</Text>}
+      </QTBottomSheet>
+    </>
+  );
+}
+```
+
+---
+
+## Status catalog
+
+The SDK computes status; the app only renders it.
+
+| Status | Meaning |
+| --- | --- |
+| `RECEIVED` | Payload arrived and passed validation. |
+| `AWAITING_AUTH` | Valid, but the user is logged out (auth gate). |
+| `READY` | Valid, authenticated, actionable — show Accept / Decline. |
+| `PROCESSING` | Accept/decline in flight. |
+| `ACCEPTED` | Backend confirmed acceptance. |
+| `DECLINED` | Backend confirmed (or user initiated) a decline. |
+| `EXPIRED` | Past `expiresAt`; no longer actionable. |
+| `FAILED` | Terminal failure. See `RtpError` for the reason. |
+
+`RtpError` values: `INVALID_PAYLOAD`, `RECIPIENT_MISMATCH`, `NETWORK_ERROR`,
+`BACKEND_REJECTED`, `UNKNOWN`.
+
+---
+
+## Events
+
+Subscribe via `client.on(event, handler)`. Every call returns an unsubscribe
+function.
+
+| Event | Payload | Fires when |
+| --- | --- | --- |
+| `request` | `RtpRequest` | A request becomes actionable (`READY`). |
+| `state` | `{ id, status }` | Any status transition. |
+| `result` | `RtpResult` | A terminal outcome (`ACCEPTED`/`DECLINED`/`EXPIRED`/`FAILED`). |
+
+```ts
+const off = rtpClient.on('result', (r) => {
+  if (r.status === 'ACCEPTED') showToast('Paid');
+});
+// later
+off();
+```
+
+---
+
+## Client API
+
+| Method | Description |
+| --- | --- |
+| `isRtp(payload)` | Type guard for decoded RTP payloads. |
+| `receive(payload)` | Validate, de-dupe, apply the auth gate/expiry, and emit. Returns an outcome. |
+| `accept({ id, credential })` | Authorize a request. `credential` is **opaque** — the SDK forwards it untouched. |
+| `decline({ id, reason })` | Decline a request. |
+| `getStatus(id)` | Current normalized status. |
+| `getRequest(id)` | The normalized request. |
+| `acknowledge(id)` | Forget a request (after you dismiss the UI). |
+| `resumeAuth()` | Release requests waiting on the auth gate. Usually called for you by the provider. |
+| `on(event, cb)` | Subscribe; returns an unsubscribe fn. |
+
+### The opaque credential
+
+`accept()` takes a `credential` that the SDK **never inspects** — no PIN, no
+crypto, no card-service output crosses the boundary as structured data:
+
+```ts
+const credential = await cardService.generateSecureData(pin); // stays in the app
+await accept(credential);
+```
+
+This is what makes the portability promise hold: a Kotlin or Swift host produces
+its own credential type and posts it opaquely.
+
+---
+
+## Edge cases handled for you
+
+- **Duplicate delivery** — the same `rtpId` arriving via foreground *and*
+  background (or a double tap) emits `request` exactly once.
+- **Expiry re-checked on every transition** — a request can expire while the
+  sheet is open; `accept` refuses and reports `EXPIRED`.
+- **Recipient mismatch** — if `payload.recipient` doesn't match `getCurrentUser()`,
+  the request fails with `RECIPIENT_MISMATCH` instead of being shown.
+- **Logged-out → login resume** — a request received while logged out sits in
+  `AWAITING_AUTH`; when `isAuthenticated` flips true the provider calls
+  `resumeAuth()` and emits `request`.
+
+### Cold start (killed app)
+
+Register your PN handler early (before React mounts) and persist the payload:
+
+```ts
+// index.js — before App renders
+rtcp.onNotificationTapped(async (notification) => {
+  const payload = mapPushToRtp(notification);
+  if (payload) await persistence.setItem('rtp.pendingPayload', JSON.stringify(payload));
+});
+```
+
+`RtpProvider` drains that key on mount. The storage key is
+`rtp.pendingPayload` (exported as `STORAGE_KEY` in the example).
+
+```ts
+export const persistence = {
+  getItem: (k) => AsyncStorage.getItem(k),
+  setItem: (k, v) => AsyncStorage.setItem(k, v),
+  removeItem: (k) => AsyncStorage.removeItem(k),
+};
+```
+
+---
+
+## Security notes
+
+- **Never trust the push body for money movement.** It carries an opaque
+  `rtpId`/token; `accept` is verified server-side.
+- **Recipient matching is enforced by the SDK** via `getCurrentUser()`, which
+  matters most in the logged-out flow where you have no session to lean on.
+- **Idempotency is keyed by `rtpId`**, so replays can't double-action a request.
+
+---
+
+## Cross-platform conformance
+
+This package is one of several implementations of the same spec. To keep them
+honest, `fixtures/conformance.json` holds platform-neutral test vectors with a
+**fixed clock**: valid, logged-out, expired, malformed, wrong-recipient,
+non-RTP, duplicate, and unknown-field cases.
+
+Every implementation (React Native, Kotlin, Swift) must produce the same
+outcome for each case. The vectors are the contract; the code is just one
+realization of it.
+
+> If you ever add signed payloads (HMAC), lock the canonical byte string
+> (field order, encoding, key/digest encoding, MAC placement) in these vectors
+> first — otherwise signatures silently diverge between platforms.
+
+---
+
+## Example app
+
+A runnable host app lives in [`example/`](./example). It ships a mock transport
+and a control panel to simulate incoming PNs and every edge case:
+
+```sh
+yarn example start        # then press i / a / w
+yarn example web          # or run it in a browser
+```
+
+Buttons: deliver valid / expired / duplicate requests, simulate a cold start
+(persist + remount provider), toggle authentication, and force accept failures.
+The event log shows the `request` / `state` / `result` stream live.
+
+---
+
+## Development
+
+```sh
+yarn typecheck
+yarn lint
+yarn test
+yarn prepare     # build lib/
+```
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](./CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/lib/module/client.js

@@ -0,0 +1,218 @@
+"use strict";
+
+import { RTP_ERROR, RTP_EVENT, RTP_STATUS } from "./constants.js";
+import { createEmitter, defaultNow, noopLogger } from "./emitter.js";
+import { findValidationErrors, isExpired, isRtpPayload, toRtpRequest } from "./validate.js";
+/**
+ * Create a portable Request-to-Pay client.
+ *
+ * The client owns validation, de-duplication, expiry, status computation and
+ * the accept/decline/status calls. It owns no UI, no navigation and no crypto.
+ * Every external effect is injected so the same contract can be re-implemented
+ * on other platforms.
+ */
+export function createRtpClient(options) {
+  const {
+    transport,
+    getAuthHeaders = async () => ({}),
+    getCurrentUser = () => null,
+    now = defaultNow,
+    logger = noopLogger,
+    basePath = '/rtp'
+  } = options;
+  if (!transport) {
+    throw new Error('[react-native-rtp] `transport` is required');
+  }
+  const emitter = createEmitter();
+  const entries = new Map();
+  function setStatus(id, status) {
+    const entry = entries.get(id);
+    if (entry) {
+      entry.status = status;
+    }
+    emitter.emit(RTP_EVENT.STATE, {
+      id,
+      status
+    });
+  }
+  function emitResult(result) {
+    setStatus(result.id, result.status);
+    emitter.emit(RTP_EVENT.RESULT, result);
+    return result;
+  }
+  function fail(id, error) {
+    return emitResult({
+      id,
+      status: RTP_STATUS.FAILED,
+      error
+    });
+  }
+  async function receive(payload) {
+    if (!isRtpPayload(payload)) {
+      return {
+        handled: false
+      };
+    }
+    const id = payload.rtpId;
+
+    // Idempotency: the same request can arrive twice (foreground + background,
+    // or a double tap). Never re-emit for an id we have already seen.
+    const existing = entries.get(id);
+    if (existing) {
+      return {
+        handled: true,
+        request: existing.request,
+        status: existing.status
+      };
+    }
+    const errors = findValidationErrors(payload);
+    if (errors.length > 0) {
+      logger('[react-native-rtp] invalid payload, missing:', errors.join(', '));
+      return {
+        handled: true,
+        error: RTP_ERROR.INVALID_PAYLOAD
+      };
+    }
+    const request = toRtpRequest(payload);
+    entries.set(id, {
+      request,
+      status: RTP_STATUS.RECEIVED
+    });
+    if (isExpired(request, now())) {
+      const result = emitResult({
+        id,
+        status: RTP_STATUS.EXPIRED
+      });
+      return {
+        handled: true,
+        request,
+        status: result.status
+      };
+    }
+    const currentUser = getCurrentUser();
+    if (!currentUser) {
+      setStatus(id, RTP_STATUS.AWAITING_AUTH);
+      return {
+        handled: true,
+        request,
+        status: RTP_STATUS.AWAITING_AUTH
+      };
+    }
+    if (request.recipient && currentUser !== request.recipient) {
+      const result = fail(id, RTP_ERROR.RECIPIENT_MISMATCH);
+      return {
+        handled: true,
+        request,
+        status: result.status,
+        error: result.error
+      };
+    }
+    setStatus(id, RTP_STATUS.READY);
+    emitter.emit(RTP_EVENT.REQUEST, request);
+    return {
+      handled: true,
+      request,
+      status: RTP_STATUS.READY
+    };
+  }
+
+  /**
+   * Called by the host after a successful login to release any requests that
+   * were waiting on the auth gate.
+   */
+  function resumeAuth() {
+    for (const [id, entry] of entries) {
+      if (entry.status !== RTP_STATUS.AWAITING_AUTH) {
+        continue;
+      }
+      if (isExpired(entry.request, now())) {
+        const result = emitResult({
+          id,
+          status: RTP_STATUS.EXPIRED
+        });
+        logger('[react-native-rtp] request expired while awaiting auth:', id, result.status);
+        continue;
+      }
+      const currentUser = getCurrentUser();
+      if (entry.request.recipient && currentUser && currentUser !== entry.request.recipient) {
+        fail(id, RTP_ERROR.RECIPIENT_MISMATCH);
+        continue;
+      }
+      setStatus(id, RTP_STATUS.READY);
+      emitter.emit(RTP_EVENT.REQUEST, entry.request);
+    }
+  }
+  async function accept(params) {
+    const {
+      id,
+      credential
+    } = params;
+    const entry = entries.get(id);
+    if (!entry) {
+      return fail(id, RTP_ERROR.UNKNOWN);
+    }
+    if (isExpired(entry.request, now())) {
+      return emitResult({
+        id,
+        status: RTP_STATUS.EXPIRED
+      });
+    }
+    setStatus(id, RTP_STATUS.PROCESSING);
+    try {
+      const headers = await getAuthHeaders();
+      const res = await transport.post(`${basePath}/${id}/accept`, {
+        credential
+      }, headers);
+      const backendStatus = res?.data?.status;
+      const status = backendStatus === 'DECLINED' ? RTP_STATUS.DECLINED : backendStatus === 'FAILED' ? RTP_STATUS.FAILED : RTP_STATUS.ACCEPTED;
+      return emitResult({
+        id,
+        status,
+        data: res?.data,
+        error: status === RTP_STATUS.FAILED ? RTP_ERROR.BACKEND_REJECTED : undefined
+      });
+    } catch (err) {
+      logger('[react-native-rtp] accept failed:', err);
+      return fail(id, RTP_ERROR.NETWORK_ERROR);
+    }
+  }
+  async function decline(params) {
+    const {
+      id,
+      reason
+    } = params;
+    const entry = entries.get(id);
+    if (!entry) {
+      return fail(id, RTP_ERROR.UNKNOWN);
+    }
+    setStatus(id, RTP_STATUS.PROCESSING);
+    try {
+      const headers = await getAuthHeaders();
+      const res = await transport.post(`${basePath}/${id}/decline`, {
+        reason
+      }, headers);
+      return emitResult({
+        id,
+        status: RTP_STATUS.DECLINED,
+        data: res?.data
+      });
+    } catch (err) {
+      logger('[react-native-rtp] decline failed:', err);
+      return fail(id, RTP_ERROR.NETWORK_ERROR);
+    }
+  }
+  return {
+    isRtp: isRtpPayload,
+    receive,
+    resumeAuth,
+    accept,
+    decline,
+    getStatus: id => entries.get(id)?.status,
+    getRequest: id => entries.get(id)?.request,
+    acknowledge: id => {
+      entries.delete(id);
+    },
+    on: emitter.on
+  };
+}
+//# sourceMappingURL=client.js.map

package/lib/module/client.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RTP_ERROR","RTP_EVENT","RTP_STATUS","createEmitter","defaultNow","noopLogger","findValidationErrors","isExpired","isRtpPayload","toRtpRequest","createRtpClient","options","transport","getAuthHeaders","getCurrentUser","now","logger","basePath","Error","emitter","entries","Map","setStatus","id","status","entry","get","emit","STATE","emitResult","result","RESULT","fail","error","FAILED","receive","payload","handled","rtpId","existing","request","errors","length","join","INVALID_PAYLOAD","set","RECEIVED","EXPIRED","currentUser","AWAITING_AUTH","recipient","RECIPIENT_MISMATCH","READY","REQUEST","resumeAuth","accept","params","credential","UNKNOWN","PROCESSING","headers","res","post","backendStatus","data","DECLINED","ACCEPTED","BACKEND_REJECTED","undefined","err","NETWORK_ERROR","decline","reason","isRtp","getStatus","getRequest","acknowledge","delete","on"],"sourceRoot":"../../src","sources":["client.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/constants.js

@@ -0,0 +1,44 @@
+"use strict";
+
+/**
+ * Normalized RTP status.
+ *
+ * The SDK is the single source of truth for these values so that every host
+ * platform (React Native, Kotlin, Swift) renders the same UI states.
+ */
+export const RTP_STATUS = {
+  /** Payload arrived and passed validation, but is not yet actionable. */
+  RECEIVED: 'RECEIVED',
+  /** Expired before it could be actioned. */
+  EXPIRED: 'EXPIRED',
+  /** Valid, but the user is not authenticated yet (login gate). */
+  AWAITING_AUTH: 'AWAITING_AUTH',
+  /** Valid, authenticated, and ready for the user to accept/decline. */
+  READY: 'READY',
+  /** Accept/decline in flight. */
+  PROCESSING: 'PROCESSING',
+  /** Backend confirmed acceptance. */
+  ACCEPTED: 'ACCEPTED',
+  /** Backend confirmed (or user initiated) a decline. */
+  DECLINED: 'DECLINED',
+  /** Terminal failure (network, validation, recipient mismatch, etc.). */
+  FAILED: 'FAILED'
+};
+/** Events emitted by the client. */
+export const RTP_EVENT = {
+  /** A new, actionable request is available. */
+  REQUEST: 'request',
+  /** Status transition for a request. */
+  STATE: 'state',
+  /** Terminal outcome for a request. */
+  RESULT: 'result'
+};
+/** Reasons a request can end in FAILED, exposed for UI/diagnostics. */
+export const RTP_ERROR = {
+  INVALID_PAYLOAD: 'INVALID_PAYLOAD',
+  RECIPIENT_MISMATCH: 'RECIPIENT_MISMATCH',
+  NETWORK_ERROR: 'NETWORK_ERROR',
+  BACKEND_REJECTED: 'BACKEND_REJECTED',
+  UNKNOWN: 'UNKNOWN'
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RTP_STATUS","RECEIVED","EXPIRED","AWAITING_AUTH","READY","PROCESSING","ACCEPTED","DECLINED","FAILED","RTP_EVENT","REQUEST","STATE","RESULT","RTP_ERROR","INVALID_PAYLOAD","RECIPIENT_MISMATCH","NETWORK_ERROR","BACKEND_REJECTED","UNKNOWN"],"sourceRoot":"../../src","sources":["constants.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,UAAU,GAAG;EACxB;EACAC,QAAQ,EAAE,UAAU;EACpB;EACAC,OAAO,EAAE,SAAS;EAClB;EACAC,aAAa,EAAE,eAAe;EAC9B;EACAC,KAAK,EAAE,OAAO;EACd;EACAC,UAAU,EAAE,YAAY;EACxB;EACAC,QAAQ,EAAE,UAAU;EACpB;EACAC,QAAQ,EAAE,UAAU;EACpB;EACAC,MAAM,EAAE;AACV,CAAU;AAIV;AACA,OAAO,MAAMC,SAAS,GAAG;EACvB;EACAC,OAAO,EAAE,SAAS;EAClB;EACAC,KAAK,EAAE,OAAO;EACd;EACAC,MAAM,EAAE;AACV,CAAU;AAIV;AACA,OAAO,MAAMC,SAAS,GAAG;EACvBC,eAAe,EAAE,iBAAiB;EAClCC,kBAAkB,EAAE,oBAAoB;EACxCC,aAAa,EAAE,eAAe;EAC9BC,gBAAgB,EAAE,kBAAkB;EACpCC,OAAO,EAAE;AACX,CAAU","ignoreList":[]}