@chipmobilesdk/rn-payment 0.5.0 → 0.7.0

package/lib/module/engine/engine.js

@@ -0,0 +1,274 @@
+"use strict";
+
+/**
+ * The engine: status, initialization, entitlement reads, and sync.
+ *
+ * Owns the concurrency guarantees that make three requirements structurally true
+ * rather than hoped for — one connection under concurrent init (FR-018), one
+ * store request under concurrent sync (FR-063), and a rate-limited foreground
+ * sync (PERF-002).
+ *
+ * It never imports a store type. The only thing it talks to is `ProviderPort`,
+ * which is what keeps the binding replaceable and iOS additive (FR-002, FR-007).
+ *
+ * This file composes (PAY-10): state and its publication live in `state.ts`, the
+ * connection in `connection.ts`, sync in `sync.ts`, and the internals tests reach
+ * for in `internals.ts`, off the public type (PAY-11).
+ */
+
+import { currentPlatform } from '@chipmobilesdk/rn-core';
+import { assertEnvironmentSafe, mayCreateRealTransaction, validateConfig } from "../config/validate.js";
+import { createExclusive, createSingleFlight } from "../core/mutex.js";
+import { PaymentError } from "../diagnostics/errors.js";
+import { createCorrelationId } from "../diagnostics/events.js";
+import { createSnapshotStore } from "../persistence/mmkv-store.js";
+import { createConnection } from "./connection.js";
+import { createFinalizer } from "./finalize.js";
+import { attachEngineInternals } from "./internals.js";
+import { createProducts } from "./products.js";
+import { createPurchaseFlow } from "./purchase.js";
+import { createEngineState } from "./state.js";
+import { createSubscriptions } from "./subscriptions.js";
+import { createSync } from "./sync.js";
+/** How many refused operations `status.blockedOperations` keeps. */
+export const MAX_BLOCKED_OPERATIONS = 20;
+export function createEngine(config, deps) {
+  // Both run before anything connects: a bad catalog or an unsafe environment
+  // must fail at configuration time, not when a user taps Buy.
+  assertEnvironmentSafe(config);
+  // rn-core's one platform source (CORE-09). Where neither OS applies, the store
+  // provider refuses everything as unsupported anyway.
+  const platform = deps.platform ?? (currentPlatform() === 'ios' ? 'ios' : 'android');
+  const resolved = validateConfig(config, platform);
+  const now = deps.now ?? (() => Date.now());
+  const provider = deps.provider;
+  const state = createEngineState(config, resolved, provider, deps.snapshotStore ?? createSnapshotStore(), now);
+  const {
+    emit,
+    commit
+  } = state;
+  const correlationCounter = {
+    next: 1
+  };
+  const nextCorrelationId = () => createCorrelationId(correlationCounter);
+  const initFlight = createSingleFlight();
+  // Exclusive rather than single-flight: a second purchase is refused, not joined
+  // onto the first, and never queued (FR-031).
+  const purchaseLock = createExclusive();
+
+  /** Written into status, not just logged, so a test can assert the block (FR-014). */
+  const recordBlockedOperation = productKey => {
+    const blocked = {
+      productKey,
+      environment: config.environment,
+      at: now()
+    };
+    // The most recent ones only: an app retrying a blocked purchase in a loop
+    // must not grow status without bound (PAY-20).
+    state.setStatus({
+      blockedOperations: [...state.status.blockedOperations, blocked].slice(-MAX_BLOCKED_OPERATIONS)
+    });
+    emit({
+      type: 'environment_blocked',
+      productKey,
+      environment: config.environment
+    });
+  };
+  const finalizer = createFinalizer({
+    provider,
+    retry: resolved.retry,
+    attemptTimeoutMs: resolved.timeouts.finalizeAttemptMs,
+    snapshot: () => state.snapshot,
+    commit,
+    emit,
+    now,
+    disposed: () => state.disposed
+  });
+  const products = createProducts({
+    resolved,
+    provider,
+    emit,
+    now
+  });
+  // Every sync also settles what an earlier session left owed, and re-asks the
+  // backend about grants it deferred (FR-039, FR-042, FR-072a).
+  const syncer = createSync(state, async () => {
+    await finalizer.drain();
+    await purchaseFlow.revalidate();
+  });
+  const purchaseFlow = createPurchaseFlow({
+    config,
+    resolved,
+    provider,
+    platform,
+    finalizer,
+    snapshot: () => state.snapshot,
+    commit,
+    emit,
+    now,
+    nextCorrelationId,
+    statusKind: () => state.status.kind,
+    mayCreateRealTransaction: () => mayCreateRealTransaction(config),
+    recordBlockedOperation,
+    // `already_owned` re-syncs rather than surfacing an error, which is how a
+    // reinstall repairs itself (FR-033); the entitlement arrives via the change
+    // signal.
+    requestSync: trigger => {
+      syncer.sync(trigger).catch(() => undefined);
+    },
+    runExclusive: operation => purchaseLock.run(operation)
+  });
+  const subscriptions = createSubscriptions({
+    resolved,
+    provider,
+    snapshot: () => state.snapshot,
+    purchase: (productKey, options) => purchaseFlow.purchase(productKey, options)
+  });
+  const connection = createConnection(state, purchase => {
+    purchaseFlow.ingest(purchase).catch(() => undefined);
+  });
+
+  /** A subscription that is a no-op once the engine is cleaned up. */
+  function subscriber(listeners) {
+    return listener => state.disposed ? () => undefined : listeners.add(listener);
+  }
+  const engine = {
+    async initialize() {
+      if (!resolved.enabled) {
+        // Selling is off, but entitlements already held stay readable (FR-012):
+        // hydration runs here too, or they would read `unknown` forever.
+        state.setStatus({
+          kind: 'disabled'
+        });
+        state.hydrate();
+        return {
+          ok: false,
+          error: new PaymentError({
+            code: 'PAYMENT_DISABLED',
+            message: 'Payments are disabled by configuration',
+            operation: 'initialize'
+          })
+        };
+      }
+      // Checked before the shortcut below: a cleaned-up engine that had been
+      // ready used to answer `ok` while nothing behind it worked any more.
+      if (state.disposed) {
+        return {
+          ok: false,
+          error: new PaymentError({
+            code: 'PAYMENT_NOT_CONFIGURED',
+            message: 'Engine has been cleaned up',
+            operation: 'initialize'
+          })
+        };
+      }
+      // Already up: answered without reconnecting, or a later sequential call
+      // would leave a second set of native listeners behind.
+      if (state.status.kind === 'ready') {
+        return {
+          ok: true
+        };
+      }
+      return initFlight.run(async () => {
+        state.setStatus({
+          kind: 'connecting'
+        });
+        // Before connecting, so a warm start answers from the last good sync
+        // while the network is still in flight (FR-053).
+        state.hydrate();
+        const connected = await connection.connect();
+        if (!connected.ok) {
+          return connected;
+        }
+        await syncer.sync('initialize');
+        // After syncing, so a transaction the store still reports owned has been
+        // re-queued first: this catches a purchase the previous session paid for
+        // but was killed before acknowledging (FR-042).
+        await finalizer.drain();
+        return {
+          ok: true
+        };
+      });
+    },
+    cleanup() {
+      state.disposed = true;
+      connection.dispose();
+      finalizer.dispose();
+      state.statusListeners.clear();
+      state.entitlementListeners.clear();
+      state.pendingListeners.clear();
+      // Disarmed last: after this nothing is emitted, and a late store callback
+      // is dropped safely (FR-082).
+      state.emitter.dispose();
+      provider.disconnect().catch(() => undefined);
+    },
+    getStatus: () => state.status,
+    subscribeStatus: subscriber(state.statusListeners),
+    /** Synchronous, in-memory, zero I/O — it is read on render paths (PERF-001). */
+    getEntitlement(key) {
+      return state.entitlements[key] ?? {
+        key,
+        status: 'unknown',
+        sources: [],
+        isStale: false
+      };
+    },
+    getAllEntitlements: () => state.entitlements,
+    subscribeEntitlements: subscriber(state.entitlementListeners),
+    getPendingPurchases: () => state.pending,
+    subscribePendingPurchases: subscriber(state.pendingListeners),
+    sync: trigger => syncer.sync(trigger),
+    async restore() {
+      const outcome = await syncer.sync('manual');
+      if (!outcome.ok) {
+        return {
+          ok: false,
+          error: outcome.error
+        };
+      }
+      const held = Object.values(state.entitlements).filter(e => e.status === 'entitled').map(e => e.key);
+      // "Nothing found" is a distinct success, so an app never claims to have
+      // restored purchases that do not exist (FR-061).
+      return held.length > 0 ? {
+        ok: true,
+        restored: true,
+        entitlements: held
+      } : {
+        ok: true,
+        restored: false
+      };
+    },
+    getLastSyncedAt: () => state.snapshot.lastSyncedAt,
+    async clearLocalData() {
+      state.forget();
+      // Prices are per account and storefront; a logout drops them too (PAY-12).
+      products.invalidate();
+    },
+    subscribeEvents: listener => state.emitter.subscribe(listener),
+    purchase: (productKey, options) => purchaseFlow.purchase(productKey, options),
+    consume: ref => finalizer.consume(ref),
+    getUnfinalized: () => finalizer.unfinalized(),
+    getProducts: productKeys => products.get(productKeys),
+    refreshProducts: productKeys => products.refresh(productKeys),
+    changePlan: (from, to, mode, options) => subscriptions.changePlan(from, to, mode, options),
+    openSubscriptionManagement: productKey => subscriptions.openManagement(productKey),
+    confirmPriceChange: productKey => subscriptions.confirmPriceChange(productKey),
+    async handleForeground() {
+      await connection.recover();
+      // Rate-limited inside sync: at most one request per interval however often
+      // the app calls this.
+      await syncer.sync('foreground');
+    }
+  };
+  attachEngineInternals(engine, {
+    resolvedConfig: () => resolved,
+    nextCorrelationId,
+    emitter: () => state.emitter,
+    snapshot: () => state.snapshot,
+    commitSnapshot: commit,
+    mayCreateRealTransaction: () => mayCreateRealTransaction(config),
+    recordBlockedOperation
+  });
+  return engine;
+}
+//# sourceMappingURL=engine.js.map

package/lib/module/engine/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["currentPlatform","assertEnvironmentSafe","mayCreateRealTransaction","validateConfig","createExclusive","createSingleFlight","PaymentError","createCorrelationId","createSnapshotStore","createConnection","createFinalizer","attachEngineInternals","createProducts","createPurchaseFlow","createEngineState","createSubscriptions","createSync","MAX_BLOCKED_OPERATIONS","createEngine","config","deps","platform","resolved","now","Date","provider","state","snapshotStore","emit","commit","correlationCounter","next","nextCorrelationId","initFlight","purchaseLock","recordBlockedOperation","productKey","blocked","environment","at","setStatus","blockedOperations","status","slice","type","finalizer","retry","attemptTimeoutMs","timeouts","finalizeAttemptMs","snapshot","disposed","products","syncer","drain","purchaseFlow","revalidate","statusKind","kind","requestSync","trigger","sync","catch","undefined","runExclusive","operation","run","subscriptions","purchase","options","connection","ingest","subscriber","listeners","listener","add","engine","initialize","enabled","hydrate","ok","error","code","message","connected","connect","cleanup","dispose","statusListeners","clear","entitlementListeners","pendingListeners","emitter","disconnect","getStatus","subscribeStatus","getEntitlement","key","entitlements","sources","isStale","getAllEntitlements","subscribeEntitlements","getPendingPurchases","pending","subscribePendingPurchases","restore","outcome","held","Object","values","filter","e","map","length","restored","getLastSyncedAt","lastSyncedAt","clearLocalData","forget","invalidate","subscribeEvents","subscribe","consume","ref","getUnfinalized","unfinalized","getProducts","productKeys","get","refreshProducts","refresh","changePlan","from","to","mode","openSubscriptionManagement","openManagement","confirmPriceChange","handleForeground","recover","resolvedConfig","commitSnapshot"],"sourceRoot":"../../../src","sources":["engine/engine.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/engine/finalize.js

@@ -0,0 +1,322 @@
+"use strict";
+
+/**
+ * The finalization queue — the package's hardest invariant (FR-041, FR-042).
+ *
+ * Google auto-refunds and revokes a purchase that is not acknowledged within
+ * **three days**. So finalization cannot be a step the app might forget, and it
+ * cannot live only in memory: the failure case FR-042 names is the app being
+ * force-killed in the instant between payment and acknowledgement.
+ *
+ * The ordering that makes this work is: **write the intent, then call the store.**
+ * A crash before the write means the purchase is still owned and the next sync
+ * re-queues it from `queryOwned`. A crash after the write means the queue has a
+ * record and the next startup drains it. There is no window where a paid
+ * transaction is forgotten.
+ *
+ * Consumption stays app-triggered (FR-043), because only the app knows whether
+ * the item was actually banked in its own data.
+ */
+
+import { backoffDelayMs } from "../core/retry.js";
+import { withTimeout } from "../core/mutex.js";
+import { PaymentError } from "../diagnostics/errors.js";
+import { pendingFinalizations } from "../persistence/snapshot.js";
+
+/** A Node `Timeout` and a browser numeric id are both valid here. */
+
+export function createFinalizer(deps) {
+  const setTimeoutFn = deps.setTimeoutFn ?? setTimeout;
+  const clearTimeoutFn = deps.clearTimeoutFn ?? clearTimeout;
+
+  /** One timer per transaction, so two transactions retry independently. */
+  const timers = new Map();
+  /** Guards against two drains racing the same transaction. */
+  const inFlight = new Set();
+  const find = transactionId => deps.snapshot().purchases.find(p => p.transactionId === transactionId);
+  const patch = (transactionId, changes) => {
+    const snapshot = deps.snapshot();
+    deps.commit({
+      ...snapshot,
+      purchases: snapshot.purchases.map(p => p.transactionId === transactionId ? {
+        ...p,
+        ...changes
+      } : p)
+    });
+  };
+
+  /**
+   * One store call under `attemptTimeoutMs`. A call that never settles used to
+   * hold this transaction's in-flight guard and, through `drain`, the sync that
+   * awaited it. Timing out counts as a failed attempt, so the retry schedule and
+   * the next-session drain both still apply.
+   */
+  const bounded = (call, operation) => withTimeout(call, deps.attemptTimeoutMs, () => new PaymentError({
+    code: 'PAYMENT_TIMEOUT',
+    message: `The store did not answer the ${operation} call in time`,
+    operation,
+    retryable: true
+  }));
+  const clearTimer = transactionId => {
+    const timer = timers.get(transactionId);
+    if (timer !== undefined) {
+      clearTimeoutFn(timer);
+      timers.delete(transactionId);
+    }
+  };
+
+  /**
+   * Attempts one finalize call.
+   *
+   * A consumable is **not** acknowledged here: it waits for the app's explicit
+   * `consume`. Acknowledging it now would tell the store the entitlement was
+   * delivered before the app has recorded the item, and a crash in between would
+   * lose a paid item with no way to recover it.
+   */
+  const attempt = async transactionId => {
+    if (deps.disposed()) {
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_NOT_CONFIGURED'
+      };
+    }
+    const record = find(transactionId);
+    if (!record) {
+      return {
+        kind: 'unknown_transaction'
+      };
+    }
+    if (record.finalizeState === 'done') {
+      // Idempotent by design: calling twice is a success, not an error (FR-044).
+      return {
+        kind: 'already_finalized'
+      };
+    }
+    if (record.productType === 'one_time_consumable') {
+      // The app owns this moment. Nothing to do until it calls consume().
+      return {
+        kind: 'already_finalized'
+      };
+    }
+    if (inFlight.has(transactionId)) {
+      return {
+        kind: 'retry_scheduled',
+        attempts: record.attempts
+      };
+    }
+    inFlight.add(transactionId);
+    patch(transactionId, {
+      finalizeState: 'in_flight'
+    });
+    let failed = false;
+    try {
+      await bounded(deps.provider.acknowledge(record.token), 'finalize');
+    } catch {
+      failed = true;
+    } finally {
+      // Released before scheduling the retry, deliberately. The guard exists to
+      // stop two concurrent store calls for one transaction, nothing more — if
+      // it were still held here, the next scheduled attempt would be refused by
+      // our own lock and the retry schedule would silently stall after one try.
+      inFlight.delete(transactionId);
+    }
+    const attempts = record.attempts + 1;
+    if (!failed) {
+      clearTimer(transactionId);
+      patch(transactionId, {
+        finalizeState: 'done',
+        state: 'purchased',
+        attempts
+      });
+      deps.emit({
+        type: 'transaction_finalized',
+        productKey: record.productKey,
+        attempts
+      });
+      return {
+        kind: 'finalized'
+      };
+    }
+    patch(transactionId, {
+      finalizeState: 'failed',
+      attempts
+    });
+    return scheduleRetry(transactionId, record.productKey, attempts, 'acknowledge');
+  };
+
+  /**
+   * One consume call for a consumable the app has banked (FR-043).
+   *
+   * Refuses anything that is not a settled consumable. Consuming a subscription
+   * or a permanent unlock would tell the store the user used it up, and a
+   * pending purchase has nothing to consume yet.
+   */
+  const consumeAttempt = async transactionId => {
+    if (deps.disposed()) {
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_NOT_CONFIGURED'
+      };
+    }
+    const record = find(transactionId);
+    if (!record) {
+      return {
+        kind: 'unknown_transaction'
+      };
+    }
+    if (record.productType !== 'one_time_consumable') {
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_NOT_CONSUMABLE'
+      };
+    }
+    if (record.state === 'pending') {
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_PENDING'
+      };
+    }
+    if (record.state === 'consumed') {
+      // Consuming twice must grant the item once (FR-044).
+      return {
+        kind: 'already_finalized'
+      };
+    }
+    if (inFlight.has(transactionId)) {
+      // Concurrent consume calls collapse to one, for the same reason.
+      return {
+        kind: 'already_finalized'
+      };
+    }
+    inFlight.add(transactionId);
+    patch(transactionId, {
+      finalizeState: 'in_flight'
+    });
+    let failed = false;
+    try {
+      await bounded(deps.provider.consume(record.token), 'consume');
+    } catch {
+      failed = true;
+    } finally {
+      // Released before scheduling, for the same reason as in `attempt`.
+      inFlight.delete(transactionId);
+    }
+    const attempts = record.attempts + 1;
+    if (failed) {
+      patch(transactionId, {
+        finalizeState: 'failed',
+        attempts
+      });
+      return scheduleRetry(transactionId, record.productKey, attempts, 'consume');
+    }
+    clearTimer(transactionId);
+    // `consumed` is what stops it being an entitlement source, so a
+    // consumable never becomes a permanent unlock.
+    patch(transactionId, {
+      state: 'consumed',
+      finalizeState: 'done',
+      attempts
+    });
+    deps.emit({
+      type: 'transaction_consumed',
+      productKey: record.productKey
+    });
+    return {
+      kind: 'finalized'
+    };
+  };
+
+  /**
+   * Schedules the next attempt inside the per-session budget.
+   *
+   * Exhausting the budget is **not** giving up. The record stays `failed`, which
+   * `pendingFinalizations` still returns, so the next startup or foreground drain
+   * picks it up again. That is what keeps the package inside Play's three-day
+   * window without hammering a store that is currently refusing.
+   */
+  const scheduleRetry = (transactionId, productKey, attempts, operation) => {
+    if (deps.disposed()) {
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_FINALIZE_FAILED'
+      };
+    }
+    if (attempts >= deps.retry.finalize.maxAttempts) {
+      // Left queued deliberately — resumed next session, never abandoned.
+      return {
+        kind: 'failed',
+        code: 'PAYMENT_FINALIZE_FAILED'
+      };
+    }
+    const delayMs = backoffDelayMs(attempts + 1, deps.retry.finalize);
+    clearTimer(transactionId);
+    timers.set(transactionId, setTimeoutFn(() => {
+      timers.delete(transactionId);
+      const retry = operation === 'consume' ? consumeAttempt : attempt;
+      retry(transactionId).catch(() => undefined);
+    }, delayMs));
+    deps.emit({
+      type: 'finalize_retry_scheduled',
+      productKey,
+      attempt: attempts + 1,
+      delayMs
+    });
+    return {
+      kind: 'retry_scheduled',
+      attempts
+    };
+  };
+  return {
+    async enqueue(transactionId) {
+      const record = find(transactionId);
+      if (!record) {
+        return {
+          kind: 'unknown_transaction'
+        };
+      }
+      if (record.finalizeState === 'done') {
+        return {
+          kind: 'already_finalized'
+        };
+      }
+
+      // The write happens BEFORE the store call. This single ordering is what
+      // makes a kill between payment and acknowledgement recoverable.
+      if (record.finalizeState !== 'in_flight') {
+        patch(transactionId, {
+          finalizeState: 'queued'
+        });
+      }
+      return attempt(transactionId);
+    },
+    async drain() {
+      // Runs regardless of whether a purchase happened this session: the record
+      // it is looking for was probably written by a session that died.
+      for (const record of pendingFinalizations(deps.snapshot())) {
+        if (deps.disposed()) {
+          return;
+        }
+        await attempt(record.transactionId).catch(() => undefined);
+      }
+    },
+    consume(ref) {
+      return consumeAttempt(ref.transactionId);
+    },
+    unfinalized() {
+      return pendingFinalizations(deps.snapshot()).map(p => ({
+        productKey: p.productKey,
+        transactionId: p.transactionId,
+        attempts: p.attempts,
+        purchasedAt: p.purchasedAt
+      }));
+    },
+    dispose() {
+      for (const timer of timers.values()) {
+        clearTimeoutFn(timer);
+      }
+      timers.clear();
+      inFlight.clear();
+    }
+  };
+}
+//# sourceMappingURL=finalize.js.map

package/lib/module/engine/finalize.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["backoffDelayMs","withTimeout","PaymentError","pendingFinalizations","createFinalizer","deps","setTimeoutFn","setTimeout","clearTimeoutFn","clearTimeout","timers","Map","inFlight","Set","find","transactionId","snapshot","purchases","p","patch","changes","commit","map","bounded","call","operation","attemptTimeoutMs","code","message","retryable","clearTimer","timer","get","undefined","delete","attempt","disposed","kind","record","finalizeState","productType","has","attempts","add","failed","provider","acknowledge","token","state","emit","type","productKey","scheduleRetry","consumeAttempt","consume","retry","finalize","maxAttempts","delayMs","set","catch","enqueue","drain","ref","unfinalized","purchasedAt","dispose","values","clear"],"sourceRoot":"../../../src","sources":["engine/finalize.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/engine/foreground.js

@@ -0,0 +1,21 @@
+"use strict";
+
+/**
+ * Opt-in foreground sync over rn-core's shared lifecycle port (PERF-07, FR-059).
+ *
+ * `handleForeground()` stays the app's to call: the engine does not decide what a
+ * foreground return is. An app that is happy with "back from the background" calls
+ * this once instead of wiring `AppState` itself, and shares the one native
+ * subscription every package uses. A trip through `inactive` alone (a biometric
+ * prompt, iOS Control Center) is not a return. On Android the Play purchase sheet
+ * does send the app to the background, so a purchase is followed by a sync; the
+ * engine's foreground rate limit keeps that to one request per interval.
+ */
+import { appLifecycle, onForeground } from '@chipmobilesdk/rn-core';
+export function syncOnForeground(engine, lifecycle = appLifecycle()) {
+  return onForeground(() => {
+    // Sync reports its own failures through status and diagnostics.
+    engine.handleForeground().catch(() => undefined);
+  }, lifecycle);
+}
+//# sourceMappingURL=foreground.js.map

package/lib/module/engine/foreground.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["appLifecycle","onForeground","syncOnForeground","engine","lifecycle","handleForeground","catch","undefined"],"sourceRoot":"../../../src","sources":["engine/foreground.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SACCA,YAAY,EACZC,YAAY,QAGN,wBAAwB;AAI/B,OAAO,SAASC,gBAAgBA,CAC/BC,MAA+C,EAC/CC,SAA2B,GAAGJ,YAAY,CAAC,CAAC,EAC9B;EACd,OAAOC,YAAY,CAAC,MAAM;IACzB;IACAE,MAAM,CAACE,gBAAgB,CAAC,CAAC,CAACC,KAAK,CAAC,MAAMC,SAAS,CAAC;EACjD,CAAC,EAAEH,SAAS,CAAC;AACd","ignoreList":[]}