@libp2p/webrtc 5.2.24 → 6.0.0-049bfa0fa

package/src/stream.ts

@@ -1,20 +1,17 @@
-import { StreamStateError, TimeoutError } from '@libp2p/interface'
-import { AbstractStream } from '@libp2p/utils/abstract-stream'
-import { anySignal } from 'any-signal'
+import { StreamResetError, StreamStateError } from '@libp2p/interface'
+import { AbstractStream } from '@libp2p/utils'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { pushable } from 'it-pushable'
-import pDefer from 'p-defer'
-import pTimeout from 'p-timeout'
-import { raceEvent } from 'race-event'
+import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
-import { BUFFERED_AMOUNT_LOW_TIMEOUT, FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, OPEN_TIMEOUT, PROTOBUF_OVERHEAD } from './constants.js'
+import { DEFAULT_FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from './constants.js'
 import { Message } from './private-to-public/pb/message.js'
+import { isFirefox } from './util.js'
 import type { DataChannelOptions } from './index.js'
-import type { AbortOptions, Direction, Logger } from '@libp2p/interface'
-import type { AbstractStreamInit } from '@libp2p/utils/abstract-stream'
+import type { AbortOptions, MessageStreamDirection, Logger } from '@libp2p/interface'
+import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
 import type { Pushable } from 'it-pushable'
-import type { DeferredPromise } from 'p-defer'
 
 export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions {
   /**
@@ -39,124 +36,40 @@ export class WebRTCStream extends AbstractStream {
    * and then the protobuf decoder.
    */
   private readonly incomingData: Pushable<Uint8Array>
-
   private readonly maxBufferedAmount: number
-
-  private readonly bufferedAmountLowEventTimeout: number
-
-  /**
-   * The maximum size of a message in bytes
-   */
-  private readonly maxMessageSize: number
-
-  /**
-   * When this promise is resolved, the remote has sent us a FIN flag
-   */
-  private readonly receiveFinAck: DeferredPromise<void>
-  private readonly finAckTimeout: number
-  private readonly openTimeout: number
-  private readonly closeController: AbortController
+  private receivedFinAck?: PromiseWithResolvers<void>
+  private finAckTimeout: number
 
   constructor (init: WebRTCStreamInit) {
-    // override onEnd to send/receive FIN_ACK before closing the stream
-    const originalOnEnd = init.onEnd
-    init.onEnd = (err?: Error): void => {
-      this.log.trace('readable and writeable ends closed with status "%s"', this.status)
-
-      void Promise.resolve(async () => {
-        if (this.timeline.abort != null || this.timeline.reset !== null) {
-          return
-        }
-
-        // wait for FIN_ACK if we haven't received it already
-        try {
-          await pTimeout(this.receiveFinAck.promise, {
-            milliseconds: this.finAckTimeout
-          })
-        } catch (err) {
-          this.log.error('error receiving FIN_ACK', err)
-        }
-      })
-        .then(() => {
-          // stop processing incoming messages
-          this.incomingData.end()
-
-          // final cleanup
-          originalOnEnd?.(err)
-        })
-        .catch(err => {
-          this.log.error('error ending stream', err)
-        })
-        .finally(() => {
-          this.channel.close()
-        })
-    }
-
-    super(init)
+    super({
+      ...init,
+      maxMessageSize: (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD
+    })
 
     this.channel = init.channel
     this.channel.binaryType = 'arraybuffer'
     this.incomingData = pushable<Uint8Array>()
-    this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT
     this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
-    this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD
-    this.receiveFinAck = pDefer()
-    this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT
-    this.openTimeout = init.openTimeout ?? OPEN_TIMEOUT
-    this.closeController = new AbortController()
-
-    // set up initial state
-    switch (this.channel.readyState) {
-      case 'open':
-        this.timeline.open = new Date().getTime()
-        break
-
-      case 'closed':
-      case 'closing':
-        if (this.timeline.close === undefined || this.timeline.close === 0) {
-          this.timeline.close = Date.now()
-        }
-        break
-      case 'connecting':
-        // noop
-        break
-
-      default:
-        this.log.error('unknown datachannel state %s', this.channel.readyState)
-        throw new StreamStateError('Unknown datachannel state')
-    }
+    this.finAckTimeout = init.finAckTimeout ?? DEFAULT_FIN_ACK_TIMEOUT
 
     // handle RTCDataChannel events
-    this.channel.onopen = (_evt) => {
-      this.timeline.open = new Date().getTime()
-    }
-
-    this.channel.onclose = (_evt) => {
-      this.log.trace('received onclose event')
+    this.channel.onclose = () => {
+      this.log.trace('received datachannel close event')
 
-      // stop any in-progress writes
-      this.closeController.abort()
-
-      // if the channel has closed we'll never receive a FIN_ACK so resolve the
-      // promise so we don't try to wait later
-      this.receiveFinAck.resolve()
-
-      void this.close().catch(err => {
-        this.log.error('error closing stream after channel closed', err)
-      })
+      this.onRemoteCloseWrite()
+      this.onTransportClosed()
     }
 
     this.channel.onerror = (evt) => {
-      this.log.trace('received onerror event')
+      const err = (evt as RTCErrorEvent).error
 
-      // stop any in-progress writes
-      this.closeController.abort()
+      this.log.trace('received datachannel error event - %e', err)
 
-      const err = (evt as RTCErrorEvent).error
       this.abort(err)
     }
 
     this.channel.onmessage = async (event: MessageEvent<ArrayBuffer>) => {
+      this.log('incoming message %d bytes', event.data.byteLength)
       const { data } = event
 
       if (data === null || data.byteLength === 0) {
@@ -166,187 +79,186 @@ export class WebRTCStream extends AbstractStream {
       this.incomingData.push(new Uint8Array(data, 0, data.byteLength))
     }
 
-    const self = this
+    // dispatch drain event when the buffered amount drops to zero
+    this.channel.bufferedAmountLowThreshold = 0
+
+    this.channel.onbufferedamountlow = () => {
+      if (this.writableNeedsDrain) {
+        this.safeDispatchEvent('drain')
+      }
+    }
+
+    if (this.channel.readyState !== 'open') {
+      this.log('channel ready state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
+      pEvent(this.channel, 'open', {
+        rejectionEvents: [
+          'close',
+          'error'
+        ]
+      })
+        .then(() => {
+          this.log('channel ready state is now "%s", dispatching drain', this.channel.readyState)
+          this.safeDispatchEvent('drain')
+        })
+        .catch(err => {
+          this.abort(err.error ?? err)
+        })
+    }
 
     // pipe framed protobuf messages through a length prefixed decoder, and
     // surface data from the `Message.message` field through a source.
     Promise.resolve().then(async () => {
       for await (const buf of lengthPrefixed.decode(this.incomingData)) {
-        const message = self.processIncomingProtobuf(buf)
-
-        if (message != null) {
-          self.sourcePush(new Uint8ArrayList(message))
-        }
+        this.processIncomingProtobuf(buf)
       }
     })
       .catch(err => {
         this.log.error('error processing incoming data channel messages', err)
       })
+
+    // close when both writable ends are closed or an error occurs
+    const cleanUpDatachannelOnClose = (): void => {
+      if (this.channel.readyState === 'open') {
+        this.log.trace('stream closed, closing underlying datachannel')
+        this.channel.close()
+      }
+    }
+    this.addEventListener('close', cleanUpDatachannelOnClose)
   }
 
   sendNewStream (): void {
     // opening new streams is handled by WebRTC so this is a noop
   }
 
-  async _sendMessage (data: Uint8ArrayList, checkBuffer: boolean = true): Promise<void> {
-    if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
+  _sendMessage (data: Uint8ArrayList): void {
+    if (this.channel.readyState !== 'open') {
       throw new StreamStateError(`Invalid datachannel state - ${this.channel.readyState}`)
     }
 
-    if (this.channel.readyState !== 'open') {
-      const timeout = AbortSignal.timeout(this.openTimeout)
-      const signal = anySignal([
-        this.closeController.signal,
-        timeout
-      ])
-
-      try {
-        this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
-        await raceEvent(this.channel, 'open', signal)
-      } finally {
-        signal.clear()
-      }
+    this.log.trace('sending message, channel state "%s"', this.channel.readyState)
 
-      this.log('channel state is now "%s", sending data', this.channel.readyState)
+    if (isFirefox) {
+      // TODO: firefox can deliver small messages out of order - remove once a
+      // browser with https://bugzilla.mozilla.org/show_bug.cgi?id=1983831 is
+      // available in playwright-test
+      this.channel.send(data.subarray())
+      return
     }
 
-    if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
-      const timeout = AbortSignal.timeout(this.bufferedAmountLowEventTimeout)
-      const signal = anySignal([
-        this.closeController.signal,
-        timeout
-      ])
-
-      try {
-        this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount)
-        await raceEvent(this.channel, 'bufferedamountlow', signal)
-      } catch (err: any) {
-        if (timeout.aborted) {
-          throw new TimeoutError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`)
-        }
-
-        throw err
-      } finally {
-        signal.clear()
-      }
+    // send message without copying data
+    for (const buf of data) {
+      this.channel.send(buf)
     }
+  }
 
-    try {
-      this.log.trace('sending message, channel state "%s"', this.channel.readyState)
-      // send message without copying data
-      this.channel.send(data.subarray())
-    } catch (err: any) {
-      this.log.error('error while sending message', err)
+  sendData (data: Uint8ArrayList): SendResult {
+    if (this.channel.readyState !== 'open') {
+      return {
+        sentBytes: 0,
+        canSendMore: false
+      }
     }
-  }
 
-  async sendData (data: Uint8ArrayList): Promise<void> {
-    const bytesTotal = data.byteLength
-    // sending messages is an async operation so use a copy of the list as it
-    // may be changed beneath us
-    data = data.sublist()
-
-    while (data.byteLength > 0) {
-      const toSend = Math.min(data.byteLength, this.maxMessageSize)
-      const buf = data.subarray(0, toSend)
-      const messageBuf = Message.encode({ message: buf })
-      const sendBuf = lengthPrefixed.encode.single(messageBuf)
-      this.log.trace('sending %d/%d bytes on channel', buf.byteLength, bytesTotal)
-      await this._sendMessage(sendBuf)
-
-      data.consume(toSend)
+    // TODO: firefox can deliver small messages out of order - remove once a
+    // browser with https://bugzilla.mozilla.org/show_bug.cgi?id=1983831 is
+    // available in playwright-test
+    // ----
+    // this is also necessary to work with rust-libp2p 0.54 though 0.53 seems ok
+    this._sendMessage(
+      lengthPrefixed.encode.single(Message.encode({
+        message: data.subarray()
+      }))
+    )
+
+    /*
+    // TODO: enable this when FF and rust-libp2p are not broken
+    // send message without copying data
+      for (const message of data) {
+        this._sendMessage(
+          lengthPrefixed.encode.single(Message.encode({
+            message
+          }))
+        )
+      }
     }
+    */
 
-    this.log.trace('finished sending data, channel state "%s"', this.channel.readyState)
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: this.channel.bufferedAmount < this.maxBufferedAmount
+    }
   }
 
-  async sendReset (): Promise<void> {
+  sendReset (err: Error): void {
     try {
-      await this._sendFlag(Message.Flag.RESET)
+      this.log.error('sending reset - %e', err)
+      this._sendFlag(Message.Flag.RESET)
+      this.receivedFinAck?.reject(err)
     } catch (err) {
       this.log.error('failed to send reset - %e', err)
-    } finally {
-      this.channel.close()
     }
   }
 
-  async sendCloseWrite (options: AbortOptions): Promise<void> {
-    if (this.channel.readyState !== 'open') {
-      this.receiveFinAck.resolve()
-      return
-    }
-
-    const sent = await this._sendFlag(Message.Flag.FIN)
-
-    if (sent) {
-      this.log.trace('awaiting FIN_ACK')
-      try {
-        await raceSignal(this.receiveFinAck.promise, options?.signal, {
-          errorMessage: 'sending close-write was aborted before FIN_ACK was received',
-          errorName: 'FinAckNotReceivedError'
-        })
-      } catch (err) {
-        this.log.error('failed to await FIN_ACK', err)
-      }
-    } else {
-      this.log.trace('sending FIN failed, not awaiting FIN_ACK')
-    }
-
-    // if we've attempted to receive a FIN_ACK, do not try again
-    this.receiveFinAck.resolve()
+  async sendCloseWrite (options?: AbortOptions): Promise<void> {
+    this._sendFlag(Message.Flag.FIN)
+    options?.signal?.throwIfAborted()
+    this.receivedFinAck = Promise.withResolvers<void>()
+
+    await Promise.any([
+      raceSignal(this.receivedFinAck.promise, options?.signal),
+      new Promise<void>(resolve => {
+        AbortSignal.timeout(this.finAckTimeout)
+          .addEventListener('abort', () => {
+            resolve()
+          })
+      })
+    ])
   }
 
-  async sendCloseRead (): Promise<void> {
-    if (this.channel.readyState !== 'open') {
-      return
-    }
-
-    await this._sendFlag(Message.Flag.STOP_SENDING)
+  async sendCloseRead (options?: AbortOptions): Promise<void> {
+    this._sendFlag(Message.Flag.STOP_SENDING)
+    options?.signal?.throwIfAborted()
   }
 
   /**
    * Handle incoming
    */
-  private processIncomingProtobuf (buffer: Uint8ArrayList): Uint8Array | undefined {
+  private processIncomingProtobuf (buffer: Uint8ArrayList): void {
     const message = Message.decode(buffer)
 
+    // ignore data messages if we've closed the readable end already
+    if (message.message != null && (this.readStatus === 'readable' || this.readStatus === 'paused')) {
+      this.onData(new Uint8ArrayList(message.message))
+    }
+
     if (message.flag !== undefined) {
       this.log.trace('incoming flag %s, write status "%s", read status "%s"', message.flag, this.writeStatus, this.readStatus)
 
       if (message.flag === Message.Flag.FIN) {
-        // We should expect no more data from the remote, stop reading
-        this.remoteCloseWrite()
-
-        this.log.trace('sending FIN_ACK')
-        void this._sendFlag(Message.Flag.FIN_ACK)
-          .catch(err => {
-            this.log.error('error sending FIN_ACK immediately', err)
-          })
+        // we should expect no more data from the remote, stop reading
+        this._sendFlag(Message.Flag.FIN_ACK)
+        this.onRemoteCloseWrite()
       }
 
       if (message.flag === Message.Flag.RESET) {
-        // Stop reading and writing to the stream immediately
-        this.reset()
+        // stop reading and writing to the stream immediately
+        this.receivedFinAck?.reject(new StreamResetError('The stream was reset'))
+        this.onRemoteReset()
       }
 
       if (message.flag === Message.Flag.STOP_SENDING) {
-        // The remote has stopped reading
-        this.remoteCloseRead()
+        // the remote has stopped reading
+        this.onRemoteCloseRead()
       }
 
       if (message.flag === Message.Flag.FIN_ACK) {
-        this.log.trace('received FIN_ACK')
-        this.receiveFinAck.resolve()
+        // remote received our FIN
+        this.receivedFinAck?.resolve()
       }
     }
-
-    // ignore data messages if we've closed the readable end already
-    if (this.readStatus === 'ready') {
-      return message.message
-    }
   }
 
-  private async _sendFlag (flag: Message.Flag): Promise<boolean> {
+  private _sendFlag (flag: Message.Flag): boolean {
     if (this.channel.readyState !== 'open') {
       // flags can be sent while we or the remote are closing the datachannel so
       // if the channel isn't open, don't try to send it but return false to let
@@ -360,7 +272,7 @@ export class WebRTCStream extends AbstractStream {
     const prefixedBuf = lengthPrefixed.encode.single(messageBuf)
 
     try {
-      await this._sendMessage(prefixedBuf, false)
+      this._sendMessage(prefixedBuf)
 
       return true
     } catch (err: any) {
@@ -369,6 +281,14 @@ export class WebRTCStream extends AbstractStream {
 
     return false
   }
+
+  sendPause (): void {
+    // TODO: read backpressure?
+  }
+
+  sendResume (): void {
+    // TODO: read backpressure?
+  }
 }
 
 export interface WebRTCStreamOptions extends DataChannelOptions {
@@ -383,12 +303,7 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
   /**
    * The stream direction
    */
-  direction: Direction
-
-  /**
-   * A callback invoked when the channel ends
-   */
-  onEnd?(err?: Error | undefined): void
+  direction: MessageStreamDirection
 
   /**
    * The logger to create a scope from
@@ -399,15 +314,16 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
    * If true the underlying datachannel is being used to perform the noise
    * handshake during connection establishment
    */
-  handshake?: boolean
+  isHandshake?: boolean
 }
 
 export function createStream (options: WebRTCStreamOptions): WebRTCStream {
-  const { channel, direction, handshake } = options
+  const { channel, direction, isHandshake } = options
 
   return new WebRTCStream({
     ...options,
     id: `${channel.id}`,
-    log: options.log.newScope(`${handshake === true ? 'handshake' : direction}:${channel.id}`)
+    log: options.log.newScope(`${isHandshake === true ? 'handshake' : direction}:${channel.id}`),
+    protocol: ''
   })
 }

package/src/util.ts

@@ -2,8 +2,9 @@ import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
 import { DATA_CHANNEL_DRAIN_TIMEOUT, DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
-import type { PeerConnection } from '@ipshipyard/node-datachannel'
 import type { LoggerOptions } from '@libp2p/interface'
+import type { Duplex, Source } from 'it-stream-types'
+import type { PeerConnection } from 'node-datachannel'
 
 const browser = detect()
 export const isFirefox = ((browser != null) && browser.name === 'firefox')
@@ -12,6 +13,26 @@ export const nopSource = async function * nop (): AsyncGenerator<Uint8Array, any
 
 export const nopSink = async (_: any): Promise<void> => {}
 
+// Duplex that does nothing. Needed to fulfill the interface
+export function inertDuplex (): Duplex<any, any, any> {
+  return {
+    source: {
+      [Symbol.asyncIterator] () {
+        return {
+          async next () {
+            // This will never resolve
+            return new Promise(() => { })
+          }
+        }
+      }
+    },
+    sink: async (source: Source<any>) => {
+      // This will never resolve
+      return new Promise(() => { })
+    }
+  }
+}
+
 export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT, options: LoggerOptions): void {
   if (channel.readyState !== 'open') {
     return

package/src/webrtc/index.ts

@@ -1 +1 @@
-export { RTCSessionDescription, RTCIceCandidate, RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
+export { RTCSessionDescription, RTCIceCandidate, RTCPeerConnection } from 'node-datachannel/polyfill'

package/dist/src/maconn.d.ts

@@ -1,58 +0,0 @@
-import type { RTCPeerConnection } from './webrtc/index.js';
-import type { ComponentLogger, Logger, MultiaddrConnection, MultiaddrConnectionTimeline, CounterGroup } from '@libp2p/interface';
-import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr';
-import type { Source, Sink } from 'it-stream-types';
-import type { Uint8ArrayList } from 'uint8arraylist';
-interface WebRTCMultiaddrConnectionInit {
-    /**
-     * WebRTC Peer Connection
-     */
-    peerConnection: RTCPeerConnection;
-    /**
-     * The multiaddr address used to communicate with the remote peer
-     */
-    remoteAddr: Multiaddr;
-    /**
-     * Holds the relevant events timestamps of the connection
-     */
-    timeline: MultiaddrConnectionTimeline;
-    /**
-     * Optional metrics counter group for this connection
-     */
-    metrics?: CounterGroup;
-}
-export interface WebRTCMultiaddrConnectionComponents {
-    logger: ComponentLogger;
-}
-export declare class WebRTCMultiaddrConnection implements MultiaddrConnection {
-    readonly log: Logger;
-    /**
-     * WebRTC Peer Connection
-     */
-    readonly peerConnection: RTCPeerConnection;
-    /**
-     * The multiaddr address used to communicate with the remote peer
-     */
-    remoteAddr: Multiaddr;
-    /**
-     * Holds the life cycle times of the connection
-     */
-    timeline: MultiaddrConnectionTimeline;
-    /**
-     * Optional metrics counter group for this connection
-     */
-    metrics?: CounterGroup;
-    /**
-     * The stream source, a no-op as the transport natively supports multiplexing
-     */
-    source: AsyncGenerator<Uint8Array, any, unknown>;
-    /**
-     * The stream destination, a no-op as the transport natively supports multiplexing
-     */
-    sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>>;
-    constructor(components: WebRTCMultiaddrConnectionComponents, init: WebRTCMultiaddrConnectionInit);
-    close(options?: AbortOptions): Promise<void>;
-    abort(err: Error): void;
-}
-export {};
-//# sourceMappingURL=maconn.d.ts.map

package/dist/src/maconn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maconn.d.ts","sourceRoot":"","sources":["../../src/maconn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChI,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,UAAU,6BAA6B;IACrC;;OAEG;IACH,cAAc,EAAE,iBAAiB,CAAA;IAEjC;;OAEG;IACH,UAAU,EAAE,SAAS,CAAA;IAErB;;OAEG;IACH,QAAQ,EAAE,2BAA2B,CAAA;IAErC;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,CAAA;CACvB;AAED,MAAM,WAAW,mCAAmC;IAClD,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,qBAAa,yBAA0B,YAAW,mBAAmB;IACnE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,iBAAiB,CAAA;IAE1C;;OAEG;IACH,UAAU,EAAE,SAAS,CAAA;IAErB;;OAEG;IACH,QAAQ,EAAE,2BAA2B,CAAA;IAErC;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,CAAA;IAEtB;;OAEG;IACH,MAAM,EAAE,cAAc,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,CAAC,CAAc;IAE9D;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,cAAc,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAU;gBAE3D,UAAU,EAAE,mCAAmC,EAAE,IAAI,EAAE,6BAA6B;IAmB3F,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAQnD,KAAK,CAAE,GAAG,EAAE,KAAK,GAAG,IAAI;CAOzB"}