@statewalker/webrun-streams-signaling 0.2.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -37,15 +37,18 @@ pass an `rtc` factory from a WebRTC implementation.
37
37
  | Export | Purpose |
38
38
  | --- | --- |
39
39
  | `new PeerManager(signaling, options?)` | WebRTC connections keyed by peer id over a `SignalingTransport`. `connect(peerId): Promise<ByteChannel>`, `onConnection((peerId, ch) => void): () => void`, `close()`. |
40
- | `PeerManagerOptions` | Same as `WebRtcConnectionOptions`. |
40
+ | `PeerManagerOptions` | `WebRtcConnectionOptions` plus `onError?: (error, peerId) => void`, called when a connection fails with no caller to tell (a signal it rejects, an inbound channel that never opens). |
41
41
  | `new QrSignaling(options?)` | Serverless pairing. `offer(): Promise<{ qr, accept(answerQr): Promise<ByteChannel> }>`, `answer(offerQr): Promise<{ qr, channel }>`, `getSessionId()`. |
42
42
  | `QrSignalingOptions` | `{ sessionId?: string; connection?: WebRtcConnectionOptions }`. |
43
- | `new RoomManager(options: RoomManagerOptions)` | Room membership. `join(room)`, `participants(): AsyncIterable<string>`, `channelTo(peerId): Promise<ByteChannel>`, `leave()`. |
44
- | `new PeerConnection(role, options?)` | One WebRTC connection's lifecycle, which `PeerManager` and `QrSignaling` build on. `connect()`, `handleSignal(msg)`, `open(): Promise<ByteChannel>`, `waitForIceGathering()`, `getLocalDescription()`, `getCollectedCandidates()`, `getState()`, `getRole()`, `getDataChannel()`, `on` / `off`, `close()`. |
45
- | `byteChannelFromDataChannel(dc)` | Wrap an `RTCDataChannel` as a `ByteChannel`. |
46
- | `byteChannelFromRoom(room, peerId)` | A `ByteChannel` to one participant of a `RoomLike`. It closes when the room disconnects, the participant leaves, or a reliable publish fails, so whatever runs on it learns the other end is gone. |
47
- | `messageTargetOverByteChannel(channel, options?)` | A `ByteChannel` as `{ target, signal, maxMessageSize }` for `webrun-rpc`'s `overPipe`: a `MessageTarget` of bytes, a signal aborted when the channel closes, and the payload ceiling (`DEFAULT_MAX_MESSAGE_SIZE`, 16 KiB − 256, what every browser pair delivers over a data channel; pass `maxMessageSize: 12 * 1024` for a `byteChannelFromRoom` channel). It must be the channel's only reader. |
48
- | `ByteChannel` | The channel type. It used to come from `@statewalker/webrun-streams`; it is declared here since `emulateMux` was removed. |
43
+ | `new RoomManager(options: RoomManagerOptions)` | Room membership. `join(room)`, `participants(): AsyncIterable<string>`, `channelTo(peerId, options?): Promise<ByteChannel>` (a `byteChannelFromRoom` channel), `leave()`. |
44
+ | `new PeerConnection(role, options?)` | One WebRTC connection's lifecycle, which `PeerManager` and `QrSignaling` build on. `connect()`, `handleSignal(msg)`, `open(): Promise<ByteChannel>`, `waitForIceGathering()`, `getLocalDescription()`, `getCollectedCandidates()`, `getState()`, `getRole()`, `hasRemoteDescription()`, `getDataChannel()`, `on` / `off`, `close()`. |
45
+ | `byteChannelFromDataChannel(dc)` | Wrap an `RTCDataChannel` as a `ByteChannel`, with the data channel's `bufferedAmount` and a `whenDrained()` that waits for `bufferedamountlow`. |
46
+ | `byteChannelFromRoom(room, peerId, options?)` | A `ByteChannel` to one participant of a `RoomLike`, on its own data topic (`options.topic`, default `DEFAULT_ROOM_TOPIC`). It closes when the room disconnects, the participant leaves, the peer's channel closes, a reliable publish fails, or a `send` exceeds `options.maxFrameBytes` (default `DEFAULT_ROOM_MAX_FRAME_BYTES`), so whatever runs on it learns the other end is gone. Packets and goodbye follow `webrun-streams-livekit`'s conventions. |
47
+ | `ByteChannelFromRoomOptions` | `{ topic?: string; maxFrameBytes?: number }`. |
48
+ | `DEFAULT_ROOM_TOPIC`, `DEFAULT_ROOM_MAX_FRAME_BYTES` | `"webrun/port-stack"` and `64_000`, the same defaults as `webrun-streams-livekit`. |
49
+ | `messageTargetOverByteChannel(channel, options?)` | A `ByteChannel` as `{ target, signal, maxMessageSize }` for `webrun-rpc`'s `overPipe`: a `MessageTarget` of bytes, a signal aborted when the channel closes, and the payload ceiling (`DEFAULT_MAX_MESSAGE_SIZE`, 16 KiB − 256, what every browser pair delivers over a data channel; pass `maxMessageSize: 12 * 1024` for a `byteChannelFromRoom` channel). `target` also has the channel's `bufferedAmount` and `whenDrained()`, so `overPipe` with `frameSize` paces its frames by the transport. It must be the channel's only reader. |
50
+ | `DRAIN_LOW_WATER` | `256 * 1024`. The channels' `whenDrained()` resolves once `bufferedAmount` is at most this. |
51
+ | `ByteChannel` | The channel type: `send`, `recv`, `closed`, `close`, and optional `bufferedAmount` / `whenDrained()`. It used to come from `@statewalker/webrun-streams`; it is declared here since `emulateMux` was removed. |
49
52
  | `generateSessionId()`, `createCompressedSignal(...)`, `parseCompressedSignal(signal)`, `encodeSignal(signal)`, `decodeSignal(text)` | The pure QR payload functions. |
50
53
 
51
54
  Types and constants: `SignalingTransport` (`localId`, `send(to, msg)`,
@@ -54,7 +57,7 @@ Types and constants: `SignalingTransport` (`localId`, `send(to, msg)`,
54
57
  `PeerConnectionEvents` (`stateChange`, `signal`, `open`, `close`, `error`),
55
58
  `WebRtcConnectionOptions`, `RtcPeerConnectionFactory`, `DEFAULT_ICE_SERVERS` (two Google STUN
56
59
  servers), `CompressedSignal`, `RoomLike`, `RoomParticipantLike`, `RoomLocalParticipantLike`,
57
- `RoomManagerOptions` (`url`, `getToken(room)`, `roomFactory`), `ROOM_EVENT` (the three LiveKit
60
+ `RoomManagerOptions` (`url`, `getToken(room)`, `roomFactory`), `ROOM_EVENT` (the four LiveKit
58
61
  event names used), `ParticipantInfo` (exported, not used by any API here).
59
62
 
60
63
  `WebRtcConnectionOptions`:
@@ -62,7 +65,7 @@ event names used), `ParticipantInfo` (exported, not used by any API here).
62
65
  | option | default | meaning |
63
66
  | --- | --- | --- |
64
67
  | `iceServers` | `DEFAULT_ICE_SERVERS` | ICE servers. |
65
- | `connectionTimeout` | 30000 ms | How long `open()` waits for the data channel. |
68
+ | `connectionTimeout` | 30000 ms | How long `open()` waits for the data channel (for `QrSignaling`'s initiator, from `accept`). |
66
69
  | `iceGatheringTimeout` | 5000 ms | How long `QrSignaling` waits for ICE gathering before using what it has. |
67
70
  | `channelLabel` | `"webrun-data"` | Data channel label. |
68
71
  | `ordered` | `true` | Ordered delivery. |
@@ -192,7 +195,15 @@ data channel and offer, and resolves when the channel opens. An inbound `offer`
192
195
  peer creates a responder; `onConnection` handlers are called when its channel opens. Answers and
193
196
  candidates from unknown peers are ignored. Candidates that arrive before the remote description
194
197
  is set are queued and applied after it. When ICE gathering completes, a `{ type: "ready" }`
195
- signal is sent; receivers ignore it. A connection is forgotten when its data channel closes.
198
+ signal is sent; receivers ignore it. A connection is closed and forgotten when its data channel
199
+ closes, when its state becomes `failed` or `closed`, when its channel does not open, or when it
200
+ rejects a signal; the peer's next offer then starts a new responder. A connection makes one
201
+ offer, so a new offer from a peer means it started over (for example it reloaded before ICE
202
+ reported a failure here): if this side answered that peer before, or dialed it and already applied
203
+ its answer, the old connection is closed and the offer starts a new responder at once. An offer
204
+ to a connection that is still waiting for its answer is glare: both dials fail (reported through
205
+ `onError` on this side) and must be retried. `connect(peerId)` replaces any existing connection to
206
+ that peer.
196
207
 
197
208
  ### What `answer()` waits for
198
209
 
@@ -205,16 +216,19 @@ the initiator has applied the answer, which needs the answer QR. So `answer()` r
205
216
  above does not complete. The test suite uses a mock `RTCPeerConnection` that opens the channel as
206
217
  soon as both descriptions are set on one side, so it does not exercise this ordering.
207
218
 
208
- `offer()` starts waiting for its channel immediately. If `accept` is never called, that wait
209
- rejects after `connectionTimeout` with nothing attached to it: an unhandled rejection, which
210
- terminates a Node process.
219
+ `offer()` does not wait for its channel: `accept` does, so `connectionTimeout` counts from
220
+ `accept`, not from the offer, and the people scanning the codes can take as long as they need.
221
+ If applying the answer fails, `accept` closes the connection and rejects.
211
222
 
212
223
  ### How QR payloads stay small
213
224
 
214
225
  `createCompressedSignal` keeps only the SDP lines needed to connect (`v=`, `o=`, `s=`, `t=`,
215
226
  `m=`, `c=`, `a=group:`, `a=ice-ufrag:`, `a=ice-pwd:`, `a=fingerprint:`, `a=setup:`, `a=mid:`,
216
- `a=sctp-port:`, `a=max-message-size:`) and packs each candidate into a `|`-separated string
217
- (unparseable candidates are kept raw, prefixed `R:`). `encodeSignal` is URL-safe base64 of the
227
+ `a=sctp-port:`, `a=max-message-size:`) and packs each candidate into a `|`-separated string,
228
+ dropping the attributes after `typ`. A candidate that carries `raddr`, `rport` or `tcptype` (a
229
+ srflx, relay or TCP candidate) is kept raw instead, prefixed `R:`, with only those attributes, and
230
+ so is a candidate that does not parse. A null `sdpMLineIndex` travels as an empty field, so 0
231
+ stays 0. `encodeSignal` is URL-safe base64 of the
218
232
  JSON, without padding. `parseCompressedSignal` throws `Unsupported protocol version: <v>` for any
219
233
  version other than 1, and a malformed packed candidate throws
220
234
  `Invalid compressed candidate: <text>`.
@@ -224,13 +238,25 @@ version other than 1, and a malformed packed candidate throws
224
238
  - Both channels buffer inbound bytes from the moment they are created, so data that arrives
225
239
  before your `for await` starts is not lost.
226
240
  - `byteChannelFromDataChannel` sets `binaryType = "arraybuffer"` and copies every inbound payload.
227
- A non-byte message (a string) throws `TypeError: byte channel received a non-byte payload`
228
- inside the channel's `message` listener. `closed` resolves on the data channel's `close` event
229
- or on `close()`. A `send` on a closed channel is swallowed.
230
- - `byteChannelFromRoom` publishes with `reliable: true` to `destinationIdentities: [peerId]` and
231
- accepts `dataReceived` events from that participant (or with no participant). Its `closed`
232
- resolves only when you call `close()`; it does not watch for the participant leaving or the
233
- room disconnecting.
241
+ A non-byte message (a string) ends the channel, as does a `send` that throws (a closed channel,
242
+ or Chrome's full 16 MiB send queue): either way the stream above lost a message. `closed`
243
+ resolves on the data channel's `close` event or on `close()`; a `send` after that is ignored.
244
+ It sets `bufferedAmountLowThreshold` to `DRAIN_LOW_WATER`; `whenDrained()` resolves on
245
+ `bufferedamountlow` or when the channel ends.
246
+ - `messageTargetOverByteChannel`'s `whenDrained()` is the channel's, and resolves at once over a
247
+ channel without one or once the pipe has ended.
248
+ - `byteChannelFromRoom` publishes with `reliable: true` to `destinationIdentities: [peerId]` on
249
+ its topic, and accepts `dataReceived` events from that participant on that topic only; packets
250
+ with no participant, from anyone else, or on another topic are ignored, so several channels to
251
+ one participant can share a room on different topics. It ends when the room disconnects, the
252
+ participant leaves, a reliable publish fails, a `send` exceeds `maxFrameBytes` (that `send`
253
+ throws `RangeError`), or the peer's goodbye arrives. When it ends on this side (`close()`, an
254
+ oversized `send`, a failed publish) it publishes an empty goodbye on `<topic>/close`, the same
255
+ convention as `webrun-streams-livekit`'s `CLOSE_TOPIC`, so the peer's channel ends although the
256
+ room stays connected. The topic, goodbye and frame ceiling match `messageTargetOverLiveKit`'s
257
+ defaults, so the port stack over this channel talks to one over that adapter. `bufferedAmount`
258
+ counts bytes whose publish has not settled; `whenDrained()` resolves once that is at most
259
+ `DRAIN_LOW_WATER`.
234
260
 
235
261
  ### What `RoomManager` tracks
236
262
 
@@ -246,14 +272,21 @@ that joins, and ends at `leave()`. Departures are not reported. Only the most re
246
272
  - `connect()` on a responder throws `connect() should only be called by initiator`; an offer to an
247
273
  initiator throws `Received offer but not in responder role`; an answer to a responder throws
248
274
  `Received answer but not in initiator role`.
249
- - On the `PeerManager` responder side, a connection that never opens is never reported to
250
- `onConnection`; its `open()` rejection has no handler attached and surfaces as an unhandled
251
- rejection.
275
+ - `PeerManager`: a failed `connect()` rejects and forgets the connection. A failure with no caller
276
+ (an offer during glare, malformed SDP or candidates, an inbound channel that never opens) closes
277
+ and forgets the connection and goes to `onError`; without `onError` it is dropped. Either way
278
+ `onConnection` is not called for it.
279
+ - `PeerConnection.open()` also rejects with `Connection closed before the data channel opened`
280
+ when the connection is closed first.
252
281
 
253
282
  ### Dependencies
254
283
 
255
- Zero runtime dependencies: the bundle imports nothing, and `ByteChannel` is declared here.
256
- `@statewalker/webrun-rpc`, `-msgpack` and `-streams` are dev dependencies of the tests. `livekit-client` is an optional peer, used only through the
284
+ One runtime dependency, `@statewalker/webrun-streams` at runtime, for `newMessagePipe`: the pipe module every transport adapter shares (listeners, delivery, life, the byte check, the frame ceiling, drain, close), so a pipe rule is fixed once for all of them (#151). The target is a `MessageTarget` by shape and carries its own `closeSignal` and `maxMessageSize`, so `overPipe(target, { codec, side })` needs nothing else. `ByteChannel` is declared here, and `messageTargetOverByteChannel`
285
+ takes an optional `maxFrameBytes`.
286
+ `@statewalker/webrun-rpc`, `-msgpack` and `-streams-conformance` are dev dependencies of the tests:
287
+ `tests/conformance.test.ts` runs the conformance suite over `messageTargetOverByteChannel` and the
288
+ port stack, on `byteChannelFromDataChannel` and on `byteChannelFromRoom` (in-process stand-ins for
289
+ the data channel and the room). `livekit-client` is an optional peer, used only through the
257
290
  `RoomLike` shape you inject. A neutrality test (`tests/neutrality.test.ts`) keeps the source from
258
291
  importing anything else.
259
292
 
@@ -7,16 +7,57 @@
7
7
  * multiplexing (`webrun-rpc`'s port stack, via `messageTargetOverByteChannel`) can run on top.
8
8
  */
9
9
  import type { ByteChannel, RoomLike } from "./types.js";
10
+ /**
11
+ * `whenDrained` resolves once the bytes sent and not yet written out are at
12
+ * most this: the transport can take more. The same mark the ws, peerjs,
13
+ * livekit and webrtc adapters use.
14
+ */
15
+ export declare const DRAIN_LOW_WATER: number;
10
16
  /**
11
17
  * Wrap an established `RTCDataChannel` as a {@link ByteChannel}. Outbound bytes
12
- * go through `channel.send`; inbound `message` events feed `recv`.
18
+ * go through `channel.send`; inbound `message` events feed `recv`. A message
19
+ * that is not bytes, or a `send` that fails (a closed channel, Chrome's full
20
+ * send queue), ends the channel: the stream above it lost a message.
21
+ * `bufferedAmount` is the data channel's; `whenDrained` waits for its
22
+ * `bufferedamountlow`.
13
23
  */
14
24
  export declare function byteChannelFromDataChannel(channel: RTCDataChannel): ByteChannel;
25
+ /**
26
+ * The topic a {@link byteChannelFromRoom} channel's packets carry, the same
27
+ * default as `webrun-streams-livekit`'s `messageTargetOverLiveKit`; packets on
28
+ * other topics are someone else's. The goodbye goes on this topic with
29
+ * `/close` appended, as there.
30
+ */
31
+ export declare const DEFAULT_ROOM_TOPIC = "webrun/port-stack";
32
+ /**
33
+ * The largest packet a {@link byteChannelFromRoom} channel publishes, as in
34
+ * `webrun-streams-livekit`: livekit-client (2.x) refuses a larger one.
35
+ */
36
+ export declare const DEFAULT_ROOM_MAX_FRAME_BYTES = 64000;
37
+ /** Options for {@link byteChannelFromRoom}. */
38
+ export interface ByteChannelFromRoomOptions {
39
+ /**
40
+ * The data topic, default {@link DEFAULT_ROOM_TOPIC}; the goodbye uses it
41
+ * with `/close` appended. Both ends must agree. Use another to run two
42
+ * channels to the same participant.
43
+ */
44
+ topic?: string;
45
+ /** The largest packet sent; past it `send` ends the channel and throws `RangeError`. Default {@link DEFAULT_ROOM_MAX_FRAME_BYTES}. */
46
+ maxFrameBytes?: number;
47
+ }
15
48
  /**
16
49
  * Build a {@link ByteChannel} to a single room participant over a LiveKit-style
17
- * `Room`. Outbound bytes are published to `peerId`; inbound `dataReceived`
18
- * events from `peerId` feed `recv`. This is the per-participant filtering the
19
- * retired `vcs-port-livekit` `livekit-port` performed, adapted to ByteChannel.
50
+ * `Room`. Outbound bytes are published reliably to `peerId` on the channel's
51
+ * topic; inbound `dataReceived` events from `peerId` on that topic feed
52
+ * `recv`. The packets and the goodbye follow `webrun-streams-livekit`'s
53
+ * conventions, so the port stack over this channel talks to one over
54
+ * `messageTargetOverLiveKit` with the same topic.
55
+ *
56
+ * The channel ends when the room disconnects, the participant leaves, the
57
+ * peer's goodbye arrives, a reliable publish fails, or a `send` exceeds
58
+ * `maxFrameBytes`. When it ends on this side, a goodbye on the close topic
59
+ * ends the peer's channel too: the room stays connected, so nothing else would.
60
+ * `bufferedAmount` counts bytes whose publish has not settled.
20
61
  */
21
- export declare function byteChannelFromRoom(room: RoomLike, peerId: string): ByteChannel;
62
+ export declare function byteChannelFromRoom(room: RoomLike, peerId: string, options?: ByteChannelFromRoomOptions): ByteChannel;
22
63
  //# sourceMappingURL=byte-channel.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"byte-channel.d.ts","sourceRoot":"","sources":["../src/byte-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGxD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAyC/E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CA8C/E"}
1
+ {"version":3,"file":"byte-channel.d.ts","sourceRoot":"","sources":["../src/byte-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAa,CAAC;AAE1C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAuE/E;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,sBAAsB,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAEnD,+CAA+C;AAC/C,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sIAAsI;IACtI,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,0BAA+B,GACvC,WAAW,CA0Gb"}
package/dist/index.d.ts CHANGED
@@ -13,7 +13,7 @@
13
13
  *
14
14
  * @packageDocumentation
15
15
  */
16
- export { byteChannelFromDataChannel, byteChannelFromRoom } from "./byte-channel.js";
16
+ export { type ByteChannelFromRoomOptions, byteChannelFromDataChannel, byteChannelFromRoom, DEFAULT_ROOM_MAX_FRAME_BYTES, DEFAULT_ROOM_TOPIC, DRAIN_LOW_WATER, } from "./byte-channel.js";
17
17
  export * from "./message-target.js";
18
18
  export { PeerConnection } from "./peer-connection.js";
19
19
  export { PeerManager, type PeerManagerOptions } from "./peer-manager.js";
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACpF,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,cAAc,YAAY,CAAC"}
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,KAAK,0BAA0B,EAC/B,0BAA0B,EAC1B,mBAAmB,EACnB,4BAA4B,EAC5B,kBAAkB,EAClB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,cAAc,YAAY,CAAC"}