nostr-double-ratchet 0.0.37 → 0.0.48

package/src/StorageAdapter.ts

@@ -58,8 +58,7 @@ export class LocalStorageAdapter implements StorageAdapter {
     try {
       const item = localStorage.getItem(this.getFullKey(key))
       return item ? JSON.parse(item) : undefined
-    } catch (e) {
-      console.warn(`Failed to get key ${key} from localStorage:`, e)
+    } catch {
       return undefined
     }
   }
@@ -76,8 +75,8 @@ export class LocalStorageAdapter implements StorageAdapter {
   async del(key: string): Promise<void> {
     try {
       localStorage.removeItem(this.getFullKey(key))
-    } catch (e) {
-      console.warn(`Failed to delete key ${key} from localStorage:`, e)
+    } catch {
+      // Ignore deletion failures
     }
   }
 
@@ -93,8 +92,8 @@ export class LocalStorageAdapter implements StorageAdapter {
           keys.push(key.substring(this.keyPrefix.length))
         }
       }
-    } catch (e) {
-      console.warn("Failed to list keys from localStorage:", e)
+    } catch {
+      // Ignore list failures
     }
 
     return keys

package/src/index.ts

@@ -1,6 +1,9 @@
 export * from "./Session"
 export * from "./Invite"
+export * from "./AppKeys"
+export * from "./inviteUtils"
 export * from "./types"
 export * from "./utils"
 export * from "./SessionManager"
-export * from "./StorageAdapter"
+export * from "./AppKeysManager"
+export * from "./StorageAdapter"

package/src/inviteUtils.ts

@@ -0,0 +1,271 @@
+import { generateSecretKey, getPublicKey, nip44 } from 'nostr-tools'
+import { getConversationKey } from 'nostr-tools/nip44'
+import { hexToBytes, bytesToHex } from '@noble/hashes/utils'
+import { Session } from './Session'
+import { NostrSubscribe, INVITE_RESPONSE_KIND, EncryptFunction, DecryptFunction, KeyPair } from './types'
+
+/**
+ * Device payload for QR code / text code sharing.
+ */
+export interface DevicePayload {
+  /** Ephemeral public key (64 hex chars) */
+  ephemeralPubkey: string
+  /** Shared secret (64 hex chars) */
+  sharedSecret: string
+  /** Device ID (16 hex chars) */
+  deviceId: string
+  /** Human-readable device label */
+  deviceLabel: string
+  /** Identity public key for this device (64 hex chars) */
+  identityPubkey: string
+}
+
+/**
+ * Generates a new ephemeral keypair for invites.
+ * @returns A keypair with publicKey (hex string) and privateKey (Uint8Array)
+ */
+export function generateEphemeralKeypair(): KeyPair {
+  const privateKey = generateSecretKey()
+  const publicKey = getPublicKey(privateKey)
+  return { publicKey, privateKey }
+}
+
+/**
+ * Generates a new shared secret for invite handshakes.
+ * @returns A 64-character hex string (32 bytes)
+ */
+export function generateSharedSecret(): string {
+  return bytesToHex(generateSecretKey())
+}
+
+/**
+ * Generates a unique device ID.
+ * @returns A random device ID string
+ */
+export function generateDeviceId(): string {
+  return bytesToHex(generateSecretKey()).slice(0, 16)
+}
+
+export interface EncryptInviteResponseParams {
+  /** The invitee's session public key */
+  inviteeSessionPublicKey: string
+  /** The invitee's identity public key (also serves as device ID) */
+  inviteePublicKey: string
+  /** The invitee's identity private key (optional if encrypt function provided) */
+  inviteePrivateKey?: Uint8Array
+  /** The inviter's identity public key */
+  inviterPublicKey: string
+  /** The inviter's ephemeral public key */
+  inviterEphemeralPublicKey: string
+  /** The shared secret for the invite */
+  sharedSecret: string
+  /** The invitee's owner/Nostr identity public key (optional for single-device users) */
+  ownerPublicKey?: string
+  /** Optional custom encrypt function */
+  encrypt?: EncryptFunction
+}
+
+export interface EncryptedInviteResponse {
+  /** The inner event containing the encrypted payload */
+  innerEvent: {
+    pubkey: string
+    content: string
+    created_at: number
+  }
+  /** The outer envelope event */
+  envelope: {
+    kind: number
+    pubkey: string
+    content: string
+    created_at: number
+    tags: string[][]
+  }
+  /** The random sender's public key used for the envelope */
+  randomSenderPublicKey: string
+  /** The random sender's private key used for the envelope */
+  randomSenderPrivateKey: Uint8Array
+}
+
+const TWO_DAYS = 2 * 24 * 60 * 60
+const now = () => Math.round(Date.now() / 1000)
+const randomNow = () => Math.round(now() - Math.random() * TWO_DAYS)
+
+/**
+ * Encrypts an invite response with two-layer encryption.
+ *
+ * Layer 1 (inner): Payload encrypted with DH key, then encrypted with shared secret.
+ * Layer 2 (outer): Envelope encrypted with random key -> inviter ephemeral key.
+ */
+export async function encryptInviteResponse(params: EncryptInviteResponseParams): Promise<EncryptedInviteResponse> {
+  const {
+    inviteeSessionPublicKey,
+    inviteePublicKey,
+    inviteePrivateKey,
+    inviterPublicKey,
+    inviterEphemeralPublicKey,
+    sharedSecret,
+    ownerPublicKey,
+    encrypt,
+  } = params
+
+  const sharedSecretBytes = hexToBytes(sharedSecret)
+
+  // Create the encrypt function
+  const encryptFn = encrypt ?? (async (plaintext: string, pubkey: string) => {
+    if (!inviteePrivateKey) {
+      throw new Error('inviteePrivateKey is required when encrypt function is not provided')
+    }
+    return nip44.encrypt(plaintext, getConversationKey(inviteePrivateKey, pubkey))
+  })
+
+  // Create the payload
+  // Note: deviceId is no longer needed - inviteePublicKey (identity) serves as device ID
+  const payload = JSON.stringify({
+    sessionKey: inviteeSessionPublicKey,
+    ...(ownerPublicKey && { ownerPublicKey }),
+  })
+
+  // Encrypt with DH key (invitee -> inviter)
+  const dhEncrypted = await encryptFn(payload, inviterPublicKey)
+
+  // Encrypt with shared secret
+  const innerEvent = {
+    pubkey: inviteePublicKey,
+    content: nip44.encrypt(dhEncrypted, sharedSecretBytes),
+    created_at: now(),
+  }
+
+  // Create a random keypair for the envelope sender
+  const randomSenderPrivateKey = generateSecretKey()
+  const randomSenderPublicKey = getPublicKey(randomSenderPrivateKey)
+
+  // Encrypt the inner event with the random key -> inviter ephemeral key
+  const innerJson = JSON.stringify(innerEvent)
+  const envelope = {
+    kind: INVITE_RESPONSE_KIND,
+    pubkey: randomSenderPublicKey,
+    content: nip44.encrypt(innerJson, getConversationKey(randomSenderPrivateKey, inviterEphemeralPublicKey)),
+    created_at: randomNow(),
+    tags: [['p', inviterEphemeralPublicKey]],
+  }
+
+  return {
+    innerEvent,
+    envelope,
+    randomSenderPublicKey,
+    randomSenderPrivateKey,
+  }
+}
+
+export interface DecryptInviteResponseParams {
+  /** The encrypted envelope content */
+  envelopeContent: string
+  /** The envelope sender's public key */
+  envelopeSenderPubkey: string
+  /** The inviter's ephemeral private key */
+  inviterEphemeralPrivateKey: Uint8Array
+  /** The inviter's identity private key (optional if decrypt function provided) */
+  inviterPrivateKey?: Uint8Array
+  /** The shared secret for the invite */
+  sharedSecret: string
+  /** Optional custom decrypt function */
+  decrypt?: DecryptFunction
+}
+
+export interface DecryptedInviteResponse {
+  /** The invitee's identity public key (also serves as device ID) */
+  inviteeIdentity: string
+  /** The invitee's session public key */
+  inviteeSessionPublicKey: string
+  /** The invitee's owner/Nostr identity public key (optional for backward compat) */
+  ownerPublicKey?: string
+}
+
+/**
+ * Decrypts an invite response.
+ */
+export async function decryptInviteResponse(params: DecryptInviteResponseParams): Promise<DecryptedInviteResponse> {
+  const {
+    envelopeContent,
+    envelopeSenderPubkey,
+    inviterEphemeralPrivateKey,
+    inviterPrivateKey,
+    sharedSecret,
+    decrypt,
+  } = params
+
+  const sharedSecretBytes = hexToBytes(sharedSecret)
+
+  // Decrypt the outer envelope
+  const decrypted = nip44.decrypt(
+    envelopeContent,
+    getConversationKey(inviterEphemeralPrivateKey, envelopeSenderPubkey)
+  )
+  const innerEvent = JSON.parse(decrypted)
+
+  const inviteeIdentity = innerEvent.pubkey
+
+  // Decrypt the inner content using shared secret
+  const dhEncrypted = nip44.decrypt(innerEvent.content, sharedSecretBytes)
+
+  // Create the decrypt function
+  const decryptFn = decrypt ?? (async (ciphertext: string, pubkey: string) => {
+    if (!inviterPrivateKey) {
+      throw new Error('inviterPrivateKey is required when decrypt function is not provided')
+    }
+    return nip44.decrypt(ciphertext, getConversationKey(inviterPrivateKey, pubkey))
+  })
+
+  // Decrypt using DH key
+  const decryptedPayload = await decryptFn(dhEncrypted, inviteeIdentity)
+
+  let inviteeSessionPublicKey: string
+  let ownerPublicKey: string | undefined
+
+  try {
+    const parsed = JSON.parse(decryptedPayload)
+    inviteeSessionPublicKey = parsed.sessionKey
+    ownerPublicKey = parsed.ownerPublicKey
+  } catch {
+    // Backward compatibility: plain session key
+    inviteeSessionPublicKey = decryptedPayload
+  }
+
+  return {
+    inviteeIdentity,
+    inviteeSessionPublicKey,
+    ownerPublicKey,
+  }
+}
+
+export interface CreateSessionFromAcceptParams {
+  /** Nostr subscription function */
+  nostrSubscribe: NostrSubscribe
+  /** The other party's public key */
+  theirPublicKey: string
+  /** Our session private key */
+  ourSessionPrivateKey: Uint8Array
+  /** The shared secret (hex string) */
+  sharedSecret: string
+  /** Whether we are the sender (initiator) */
+  isSender: boolean
+  /** Optional session name */
+  name?: string
+}
+
+/**
+ * Creates a Session from invite acceptance parameters.
+ */
+export function createSessionFromAccept(params: CreateSessionFromAcceptParams): Session {
+  const {
+    nostrSubscribe,
+    theirPublicKey,
+    ourSessionPrivateKey,
+    sharedSecret,
+    isSender,
+    name,
+  } = params
+
+  const sharedSecretBytes = hexToBytes(sharedSecret)
+  return Session.init(nostrSubscribe, theirPublicKey, ourSessionPrivateKey, isSender, sharedSecretBytes, name)
+}

package/src/types.ts

@@ -68,11 +68,18 @@ export type Unsubscribe = () => void;
 export type NostrSubscribe = (_filter: Filter, _onEvent: (_e: VerifiedEvent) => void) => Unsubscribe;
 export type EncryptFunction = (_plaintext: string, _pubkey: string) => Promise<string>;
 export type DecryptFunction = (_ciphertext: string, _pubkey: string) => Promise<string>;
+
+/**
+ * Identity key for cryptographic operations.
+ * Either a raw private key (Uint8Array) or encrypt/decrypt functions for extension login (NIP-07).
+ */
+export type IdentityKey = Uint8Array | { encrypt: EncryptFunction; decrypt: DecryptFunction };
+
 export type NostrPublish = (_event: UnsignedEvent) => Promise<VerifiedEvent>;
 
 export type Rumor = UnsignedEvent & { id: string }
 
-/** 
+/**
  * Callback function for handling decrypted messages
  * @param _event - The decrypted message object (Rumor)
  * @param _outerEvent - The outer Nostr event (VerifiedEvent)
@@ -91,9 +98,10 @@ export const INVITE_EVENT_KIND = 30078;
 
 export const INVITE_RESPONSE_KIND = 1059;
 
+export const APP_KEYS_EVENT_KIND = 30078;
+
 export const CHAT_MESSAGE_KIND = 14;
 
-export const MAX_SKIP = 100;
 
 export type NostrEvent = {
   id: string;
@@ -104,3 +112,30 @@ export type NostrEvent = {
   content: string;
   sig: string;
 }
+
+/**
+ * Payload for reaction messages sent through NDR.
+ * Reactions are regular messages with a JSON payload indicating they're a reaction.
+ */
+export interface ReactionPayload {
+  type: 'reaction';
+  /** ID of the message being reacted to */
+  messageId: string;
+  /** Emoji or reaction content */
+  emoji: string;
+}
+
+/**
+ * Kind constant for reaction inner events
+ */
+export const REACTION_KIND = 7;
+
+/**
+ * Kind constant for read/delivery receipt inner events
+ */
+export const RECEIPT_KIND = 15;
+
+/**
+ * Kind constant for typing indicator inner events
+ */
+export const TYPING_KIND = 25;

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils";
-import { Rumor, SessionState } from "./types";
+import { Rumor, SessionState, ReactionPayload } from "./types";
 import { Session } from "./Session.ts";
 import { extract as hkdf_extract, expand as hkdf_expand } from '@noble/hashes/hkdf';
 import { sha256 } from '@noble/hashes/sha256';
@@ -136,12 +136,12 @@ export function deepCopyState(s: SessionState): SessionState {
     receivingChainMessageNumber: s.receivingChainMessageNumber,
     previousSendingChainMessageCount: s.previousSendingChainMessageCount,
     skippedKeys: Object.fromEntries(
-      Object.entries(s.skippedKeys).map(([author, entry]: any) => [
+      Object.entries(s.skippedKeys).map(([author, entry]) => [
         author,
         {
-          headerKeys: entry.headerKeys.map((hk: Uint8Array) => new Uint8Array(hk)),
+          headerKeys: entry.headerKeys.map((hk) => new Uint8Array(hk)),
           messageKeys: Object.fromEntries(
-            Object.entries(entry.messageKeys).map(([n, mk]: any) => [n, new Uint8Array(mk)])
+            Object.entries(entry.messageKeys).map(([n, mk]) => [n, new Uint8Array(mk)])
           ),
         },
       ])
@@ -188,10 +188,6 @@ export function kdf(input1: Uint8Array, input2: Uint8Array = new Uint8Array(32),
   return outputs;
 }
 
-export function skippedMessageIndexKey(_nostrSender: string, _number: number): string {
-  return `${_nostrSender}:${_number}`;
-}
-
 export function getMillisecondTimestamp(event: Rumor) {
   const msTag = event.tags?.find((tag: string[]) => tag[0] === "ms");
   if (msTag) {
@@ -199,3 +195,44 @@ export function getMillisecondTimestamp(event: Rumor) {
   }
   return event.created_at * 1000;
 }
+
+/**
+ * Check if a message content is a reaction payload.
+ * @param content The message content to check
+ * @returns The parsed ReactionPayload if valid, null otherwise
+ */
+export function parseReaction(content: string): ReactionPayload | null {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.type === 'reaction' && typeof parsed.messageId === 'string' && typeof parsed.emoji === 'string') {
+      return parsed as ReactionPayload;
+    }
+  } catch {
+    // Not JSON or invalid structure
+  }
+  return null;
+}
+
+/**
+ * Check if a message content is a reaction.
+ * @param content The message content to check
+ * @returns true if the content is a reaction payload
+ */
+export function isReaction(content: string): boolean {
+  return parseReaction(content) !== null;
+}
+
+/**
+ * Create a reaction payload JSON string.
+ * @param messageId The ID of the message being reacted to
+ * @param emoji The emoji or reaction content
+ * @returns JSON string of the reaction payload
+ */
+export function createReactionPayload(messageId: string, emoji: string): string {
+  const payload: ReactionPayload = {
+    type: 'reaction',
+    messageId,
+    emoji
+  };
+  return JSON.stringify(payload);
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Martti Malmi
-
-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/dist/UserRecord.d.ts

@@ -1,117 +0,0 @@
-import { Session } from './Session';
-import { NostrSubscribe } from './types';
-interface DeviceRecord {
-    deviceId: string;
-    publicKey: string;
-    activeSession?: Session;
-    inactiveSessions: Session[];
-    isStale: boolean;
-    staleTimestamp?: number;
-    lastActivity?: number;
-}
-/**
- * Manages sessions for a single user across multiple devices
- * Structure: UserRecord → DeviceRecord → Sessions
- */
-export declare class UserRecord {
-    readonly userId: string;
-    private readonly nostrSubscribe;
-    private deviceRecords;
-    private isStale;
-    private staleTimestamp?;
-    constructor(userId: string, nostrSubscribe: NostrSubscribe);
-    /**
-     * Creates or updates a device record for this user
-     */
-    upsertDevice(deviceId: string, publicKey: string): DeviceRecord;
-    /**
-     * Gets a device record by deviceId
-     */
-    getDevice(deviceId: string): DeviceRecord | undefined;
-    /**
-     * Gets all device records for this user
-     */
-    getAllDevices(): DeviceRecord[];
-    /**
-     * Gets all active (non-stale) device records
-     */
-    getActiveDevices(): DeviceRecord[];
-    /**
-     * Removes a device record and closes all its sessions
-     */
-    removeDevice(deviceId: string): boolean;
-    /**
-     * Adds or updates a session for a specific device
-     */
-    upsertSession(deviceId: string, session: Session, publicKey?: string): void;
-    /**
-     * Gets the active session for a specific device
-     */
-    getActiveSession(deviceId: string): Session | undefined;
-    /**
-     * Gets all sessions (active + inactive) for a specific device
-     */
-    getDeviceSessions(deviceId: string): Session[];
-    /**
-     * Gets all active sessions across all devices for this user
-     */
-    getActiveSessions(): Session[];
-    /**
-     * Gets all sessions (active + inactive) across all devices
-     */
-    getAllSessions(): Session[];
-    /**
-     * Gets sessions that are ready to send messages
-     */
-    getSendableSessions(): Session[];
-    /**
-     * Marks a specific device as stale
-     */
-    markDeviceStale(deviceId: string): void;
-    /**
-     * Marks the entire user record as stale
-     */
-    markUserStale(): void;
-    /**
-     * Removes stale devices and sessions older than maxLatency
-     */
-    pruneStaleRecords(maxLatency: number): void;
-    /**
-     * Gets the most recently active device
-     */
-    getMostActiveDevice(): DeviceRecord | undefined;
-    /**
-     * Gets the preferred session (from most active device)
-     */
-    getPreferredSession(): Session | undefined;
-    /**
-     * Checks if this user has any active sessions
-     */
-    hasActiveSessions(): boolean;
-    /**
-     * Gets total count of devices
-     */
-    getDeviceCount(): number;
-    /**
-     * Gets total count of active sessions
-     */
-    getActiveSessionCount(): number;
-    /**
-     * Cleanup when destroying the user record
-     */
-    close(): void;
-    /**
-     * @deprecated Use upsertDevice instead
-     */
-    conditionalUpdate(deviceId: string, publicKey: string): void;
-    /**
-     * @deprecated Use upsertSession instead
-     */
-    insertSession(deviceId: string, session: Session): void;
-    /**
-     * Creates a new session for a device
-     */
-    createSession(deviceId: string, sharedSecret: Uint8Array, ourCurrentPrivateKey: Uint8Array, isInitiator: boolean, name?: string): Session;
-}
-export {};
-//# sourceMappingURL=UserRecord.d.ts.map

package/dist/UserRecord.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UserRecord.d.ts","sourceRoot":"","sources":["../src/UserRecord.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,UAAU,YAAY;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,OAAO,EAAE,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,qBAAa,UAAU;aAMH,MAAM,EAAE,MAAM;IAC9B,OAAO,CAAC,QAAQ,CAAC,cAAc;IANjC,OAAO,CAAC,aAAa,CAAwC;IAC7D,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,cAAc,CAAC,CAAS;gBAGd,MAAM,EAAE,MAAM,EACb,cAAc,EAAE,cAAc;IAQjD;;OAEG;IACI,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY;IAyBtE;;OAEG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI5D;;OAEG;IACI,aAAa,IAAI,YAAY,EAAE;IAItC;;OAEG;IACI,gBAAgB,IAAI,YAAY,EAAE;IAKzC;;OAEG;IACI,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAe9C;;OAEG;IACI,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAclF;;OAEG;IACI,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAK9D;;OAEG;IACI,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,EAAE;IAYrD;;OAEG;IACI,iBAAiB,IAAI,OAAO,EAAE;IAsBrC;;OAEG;IACI,cAAc,IAAI,OAAO,EAAE;IAalC;;OAEG;IACI,mBAAmB,IAAI,OAAO,EAAE;IAUvC;;OAEG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQ9C;;OAEG;IACI,aAAa,IAAI,IAAI;IAK5B;;OAEG;IACI,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAsBlD;;OAEG;IACI,mBAAmB,IAAI,YAAY,GAAG,SAAS;IAWtD;;OAEG;IACI,mBAAmB,IAAI,OAAO,GAAG,SAAS;IAKjD;;OAEG;IACI,iBAAiB,IAAI,OAAO;IAInC;;OAEG;IACI,cAAc,IAAI,MAAM;IAI/B;;OAEG;IACI,qBAAqB,IAAI,MAAM;IAItC;;OAEG;IACI,KAAK,IAAI,IAAI;IAYpB;;OAEG;IACI,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAInE;;OAEG;IACI,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAI9D;;OAEG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,UAAU,EACxB,oBAAoB,EAAE,UAAU,EAChC,WAAW,EAAE,OAAO,EACpB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO;CAkBX"}