@statewalker/webrun-http-browser 0.10.0 → 0.12.2

package/README.md

@@ -179,6 +179,7 @@ const stop = startRelayServiceWorker(self, {
 | `takeover` | `"last-wins"` | `"first-wins"` keeps a live holder's key; a second page gets `"<key>" is already served by another client`. A holder that reloaded is no longer live, so it can always re-register. |
 | `decorateResponse` | none | `(response, request) => Response`. Stamps headers on responses the relay makes, including its error responses. Not applied to requests the worker leaves to the network. |
 | `streamTimeout` | none | Per-stream inactivity timeout, in ms, of the links to services. |
+| `window` | `262144` | Window, in bytes, of the links to services, under which bodies are pipelined. `0` turns it off. |
 
 `UNREGISTER` is accepted only from the client that holds the key, or, once
 that client is gone, from any client `canRegister` allows: any page of the
@@ -264,13 +265,36 @@ worker's default scope covers them:
 importScripts("/path/to/@statewalker/webrun-http-browser/dist/sw-worker.js");
 ```
 
+A module worker imports the dispatcher instead (a module worker cannot
+`importScripts`), and the adapter registers it with `type: "module"`. A
+ServiceWorker resolves no bare specifiers (it has no import map): bundle it, or
+import the built `dist/sw.js` by url.
+
+```js
+// sw.js, registered with { type: "module" }
+import { startHttpDispatcher } from "@statewalker/webrun-http-browser/sw";
+startHttpDispatcher({ self });
+```
+
+A page that registers its worker itself (its own script, scope or type) passes
+the registration instead, and the adapter registers nothing (`type` is then
+not used). The worker routes under the registration's scope, whichever folder
+its script is in:
+
+```ts
+const registration = await navigator.serviceWorker.register("/sw.js", { type: "module" });
+const adapter = new SwHttpAdapter({ key: KEY, registration });
+```
+
 `SwHttpAdapter` options:
 
 | Option | Default | Meaning |
 | --- | --- | --- |
 | `key` | required | First URL segment under the scope that the worker routes to this page. |
 | `serviceWorkerUrl` | `sw-worker.js` at the scope | Resolved against `location.href`. An unresolvable value throws `Invalid serviceWorkerUrl: "<value>" (relative to <href>)`. |
-| `scope` | directory of `serviceWorkerUrl` | Registration scope. |
+| `scope` | directory of `serviceWorkerUrl`, or `registration`'s scope | Registration scope. |
+| `type` | `"classic"` | How the worker script loads: `"module"` for an ES-module worker. It must match how the script is registered elsewhere, or the update fails. |
+| `registration` | none | A registration the page made itself. The adapter registers nothing, and `stop()` leaves it registered. |
 | `timeout` | `30_000` | Upper bound, in ms, for activation, control and the adapter's handshake. Past it `start()` rejects with a `ServiceWorkerControlError`. |
 | `reloadIfUncontrolled` | `false` | Reload the page once instead of rejecting when it stays uncontrolled. |
 | `streamTimeout` | none | Per-stream inactivity timeout of the links, in ms. Unset, a slow reader is throttled, never failed. |
@@ -335,14 +359,53 @@ your own passes the options to `startHttpDispatcher({ self, ...options })`.
 
 | Option | Default | What it does |
 | --- | --- | --- |
-| `route` | `leastInflightRoute` | Picks the handler. `undefined` makes the request wait for another to attach. |
+| `key` | `scopeKey` | `(url, scope) => key \| undefined`: which key a url belongs to, for `dispatch()` (a handler's `service.fetch`), sockets, and `fetch` events of this origin. By default the first path segment under the scope; give your own for another layout (a site at the origin's root, projects under a base path). A key for another origin's url serves handlers' `service.fetch` and sockets (whoever opens them); a page's own `fetch` to that origin stays the browser's. Synchronous; must not throw. A handler registered in a page serves only urls under its own `baseUrl`. |
+| `handleFetch` | `true` | `false` leaves `fetch` events to the host's own listener, which passes what it does not answer itself to `dispatcher.handleFetch(event, request?)` (see below). Only for a dispatcher you construct: `startHttpDispatcher` refuses it. |
+| `unserved` | `fetch(request)` | The answer to a navigation under the scope whose key nobody serves (also one taken before the stored keys are read, after a restart). A host page for such urls goes here. Other requests nobody serves go to the network. |
+| `failure` | 503 / 404 / 502 | `(request, { kind, error })`: the answer to a request the dispatcher took and could not deliver: `"timeout"` (no handler `route` accepts attached in time), `"gone"` (the key's handlers are gone), `"lost"` (lost in flight). |
+| `socketHeaders` | as given | `(headers, from)`: the headers a socket's upgrade carries to `route` and its handler, by `from`: `"page"` or `"handler"`. Drop from pages' sockets what only your handlers may send. |
+| `route` | `leastInflightRoute` | Picks the handler. `undefined` makes the request wait until it accepts one that attaches, up to `attachTimeoutMs` (then `failure` `"timeout"`). |
 | `attachTimeoutMs` | `15_000` | How long a request waits for a handler during a hand-over. Past it, `503`. |
 | `relinkTimeoutMs` | `3_000` | How long a request waits for the pages to attach again after a restart. |
 | `handoverMs` | `5_000` | How long a replaced handler may finish its requests. |
 | `wsConnectTimeoutMs` | `15_000` | How long a socket waits for its handler's answer. |
 | `streamTimeout` | none | Per-stream inactivity timeout of the links. |
+| `window` | `262144` | Window, in bytes, of the links to the handlers, under which bodies are pipelined. `0` turns it off. |
 | `livenessCheckMs` | `5_000` | Period of the backup liveness check (`navigator.locks.query()`); `0` turns it off. |
 
+A host whose worker has its own `fetch` handling (routes of its own, cookies
+it adds before dispatching, a page for urls no tab serves) constructs the
+dispatcher with `handleFetch: false`. Its own listener answers its routes and
+passes the rest to `handleFetch(event, request?)`, which returns whether it
+called `respondWith`:
+
+```js
+// a module ServiceWorker of your own
+import { SwHttpDispatcher } from "@statewalker/webrun-http-browser/sw";
+const dispatcher = new SwHttpDispatcher({
+  self,
+  handleFetch: false,
+  unserved: (request) => hostPage(request), // what no handler serves
+});
+dispatcher.start();
+self.addEventListener("fetch", (event) => {
+  if (isMine(event.request)) return event.respondWith(answer(event.request));
+  if (!dispatcher.handleFetch(event, withCookies(event.request))) {
+    // not the dispatcher's: answer it, or leave it to the network
+  }
+});
+```
+
+While `route` declines every handler of a key (it waits for one in particular, a shard
+say), a request waits for attaches until it accepts one, up to `attachTimeoutMs`.
+`dispatcher.ready` settles once the keys served before a restart are read back.
+
+`handleFetch` takes every request with a key before the worker has read which
+keys it serves (the first requests after a restart), and every navigation
+under the scope, so whether a url is served cannot be decided before calling
+it: a page for urls nobody serves belongs in `unserved`. The `install` and
+`activate` handlers (`skipWaiting`, `clients.claim`) stay on.
+
 `link.drain({ ms })` hands a slot over: no new requests reach the handler (they
 wait for the next owner of the key, up to `attachTimeoutMs`), and those in
 flight may finish for up to `ms`. Then the link is closed. A drain or detach
@@ -415,18 +478,45 @@ const WS = serviceWorkerWebSocketClass();                     // any controlled
 const WS2 = service.WebSocket;                                // in a worker, via the router
 ```
 
+A socket that needs headers (what a `route` function picks the handler by, a
+shard, an origin) opens through `connectWebSocket(url, protocols, headers)`,
+from a page's adapter or a worker's service; the handler sees them on the
+upgrade request. They are the caller's word: nothing checks them, so a handler
+trusts a `cookie` or an `authorization` there no more than its caller. An
+older ServiceWorker (still active while a newer one waits) drops them, so a
+handler that needs one should refuse an upgrade without it:
+
+```ts
+const WS3 = createWebSocketClass((url, protocols) =>
+  service.connectWebSocket(url, protocols, { "x-shard": "7" }),
+);
+```
+
 The ServiceWorker only brokers the port: it routes the url like a fetch, asks
 the handler, and hands the accepted port to the caller. The socket then runs
 between the two directly, so it survives a ServiceWorker restart. A socket to
 a handler in the same page needs no ServiceWorker at all.
 
+- **A server end of your own.** `webSocketUpgradeResponse(port, protocol)` is
+  the 101 for a socket whose server end the handler runs itself on the other
+  end of `port`; the host hands `port` to the caller as for `upgradeWebSocket`.
 - **Upgrade request.** A browser drops `Upgrade` and `Sec-*` headers from every
   `new Request()`, so the upgrade request carries them as its own `headers`
   property. `requestedProtocols(request)` reads the subprotocols.
 - **Server end.** `ServerWebSocket` delivers events only after `accept()`
   (frames that arrive earlier are queued), answers pings before it, and has
   `send`, `close`, `bufferedAmount` and `whenDrained(limit)` for
-  backpressure.
+  backpressure. It closes with 1006 once the client's pings stop; with
+  `upgradeWebSocket(request, { watch: "first-ping" })` it starts watching only
+  at the first ping, for a peer that never pings (two ends kept in one realm).
+  Other platforms' server ends (workerd's `WebSocketPair`) build on it with
+  `heartbeatPeriod: "first"` (keep the first ping's period: a closing tab
+  turns hidden, and announces a longer one, on its way out),
+  `sendBeforeAccept`, `deliverWhileClosing`, `defaultCloseCode: 1005`,
+  `closeTimeoutMs: Infinity`, a
+  `binaryType` of `"blob"`, an overridden `checkClose(code, reason)`, and
+  `detach()`, which hands an unaccepted end's port, with the frames that
+  reached it, to another holder.
 - **Client.** `createWebSocketClass(connect, options)` validates as the
   standard does (url, scheme, fragment, subprotocol tokens, close codes and
   reasons), has `binaryType`, the `on*` handlers and the close handshake.
@@ -495,8 +585,8 @@ new WebSocket(...)         ──WS_CONNECT──► same-origin worker ──ct
 Every link is one `MessagePort` (`down`: requests a handler serves; `up`:
 requests a worker sends; `ctl`: socket hand-over). Calls on a link are
 multiplexed by `@statewalker/webrun-rpc` (`connect` / `serve` over `overPipe`),
-each a stream with a one-chunk window in both directions, and HTTP runs over
-them with `fetchOverDuplex` / `serveFetchOverDuplex` from
+each a stream with backpressure in both directions (see below for the window
+its bodies are pipelined under), and HTTP runs over them with `fetchOverDuplex` / `serveFetchOverDuplex` from
 `@statewalker/webrun-http-streams`. The relay uses the same links, one per
 `CONNECT`. Every hand-shake carries `HTTP_LINK_PROTOCOL`: a peer of version 1
 (this package's own stream transport) is still served over that transport, and
@@ -644,21 +734,65 @@ answered by the worker and can load uncontrolled in Firefox; call
 - `incompatible`: answered the handshake but runs an older version of this
   package (reload the page once the updated worker is active).
 
+### A link pipelines its bodies under a 256 KiB window
+
+The calling end of every link asks each request's port for a flow-control
+window of 256 KiB (`HttpLinkOptions.window`, webrun-rpc's `window`). Under it,
+request and response bodies are pipelined: chunks leave without waiting for a
+confirmation each, and only the window holds the sender back. On a
+`MessageChannel` a body in 256 B chunks moved 2.0-2.6x as fast as one
+confirmed chunk at a time over 9 runs of `pnpm bench` on an idle machine (each
+the median ratio of 7 pairs), and one in 4 KiB chunks 1.8-2.3x. On a loaded
+machine, where both modes ran slower, runs gave as little as 1.83x at 256 B
+and 1.56x at 4 KiB.
+The larger the chunk, the more of its time goes to the link's own cost per
+chunk (`ReadableStream`, request framing, the copy on receipt), which no
+window removes. The answering end needs no option: it applies whatever window
+each port asks for.
+
+The size is a trade. The window belongs to each request's port, not to the
+link: a reader that stops holds about one window of its body in flight, per
+direction, on each link (each hop) the body crosses. N stalled requests on one
+link hold about N × the window per direction, up to the link's `maxPorts`
+ceiling on requests in flight (by default 1024 × 256 KiB, 256 MiB per
+direction). On page → ServiceWorker → worker, each of the two hops holds its
+own. What that looks like: ServiceWorker or page memory that grows with the
+number of stalled downloads: bodies a page or worker stopped reading without
+cancelling them. Lower `window` (or `maxPorts`) where many readers can stall at
+once. 64 KiB gave the same throughput on a `MessageChannel`, and 1 MiB gained
+at most 5% for four times the memory.
+
+`window: 0` turns it off: the link then puts exactly the envelopes of a link
+with no window on the wire, one confirmed chunk at a time. Every link that
+calls takes the option, so it can be set on each of them: the ServiceWorkers'
+links to their handlers (`startHttpDispatcher` / `SwHttpDispatcher`,
+`startRelayServiceWorker`), and the links a page or worker opens itself
+(`callHttpService`, `sendOverConnection`, and the `up` link of
+`serveHttpInWorker` and `HandlerEndpoint`). Each link's calling end decides
+its window, so turning it off everywhere means `window: 0` on the ServiceWorker
+and on the pages and workers that call through it.
+
+An end of an older version is safe on either side. One that does not answer
+the pipelining handshake gets confirmed chunks, and one with no window at all
+is never waited on. Nothing changes in `HTTP_LINK_PROTOCOL`.
+
 ### Backpressure, and where the browser buffers
 
 Both modes move requests over webrun-rpc links: a handler producing a body is
-never more than a few chunks ahead of whoever reads it through this package's
-links, and a reader that stops (an aborted `fetch`, a cancelled body) releases
+never more than about one window (256 KiB) per hop ahead of whoever reads it
+through this package's links (one window per stalled request, per direction,
+per hop: see above), and a reader that stops (an aborted `fetch`, a cancelled body) releases
 the producer. Between a ServiceWorker's `respondWith` and the page, though,
 Chromium buffers by itself, tens of megabytes of a fast stream: a page reading
 slowly sees the handler run that far ahead before backpressure reaches it
 (about 55 MiB, the same for a plain ServiceWorker with no library). Firefox
 sets no such bound: it keeps reading a ServiceWorker's response while the page
 does not, so there a handler streaming to a page that stopped reading keeps
-producing (this package still holds only a few chunks of it). A worker
+producing (this package still holds only about one window of it). A worker
 reading through `service.fetch` has no such buffer. `links.browser.ts` pins
-the split: once a page stops reading, the handler is never more than a few
-chunks ahead of what the ServiceWorker handed to Chromium, and stops.
+the split: once a page stops reading, the handler is never more than about one
+window (plus a few chunks: 256 KiB + 3 × 64 KiB) ahead of what the ServiceWorker
+handed to Chromium, and stops.
 
 `sendStream` / `handleStreams`, and the `sendHttpRequest` /
 `handleHttpRequests` pair built on them, are version 1's transport, kept for
@@ -769,6 +903,17 @@ All four runtime dependencies are bundled into `dist/`:
 ### Tests
 
 - `pnpm test`: unit tests under Node, against the source.
+- `pnpm bench`: the throughput benchmark, kept out of `pnpm test` so that a
+  loaded machine cannot fail the suite. It compares the default window with
+  `window: 0` in one run (median of 7 pairs after a warm-up pair) and fails
+  below 2x at 256 B chunks and below 1.5x at 4 KiB chunks. The 4 KiB bar is the lower one
+  because the link's own cost per chunk caps the gain there. Each pair runs
+  both modes back to back, alternating which goes first, and the bar is held
+  against the median of the pairs' ratios. The 256 B bar sits at the bottom of
+  the run-to-run spread (above), so a busy machine can fail a run of a sound
+  build (`AssertionError: expected <ratio> to be greater than or equal to 2`): rerun on an idle
+  one before reading a failure as a regression. The 4 KiB bar sits below
+  every run measured, but a loaded machine came within 5% of it.
 - `pnpm run test:browser`: builds, then runs `tests/browser/` in Chromium and
   Firefox through Playwright against the built bundles, plus
   `tests/packaging/`, which checks the published exports map. Needs the

package/dist/core/index.d.ts

@@ -4,4 +4,5 @@ export * from "./data-channels.js";
 export * from "./message-target.js";
 export * from "./registry.js";
 export * from "./service-worker-control.js";
+export type { FetchEventLike, ServiceWorkerClientLike, ServiceWorkerScope } from "./sw-scope.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAGA,cAAc,6BAA6B,CAAC;AAE5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAGA,cAAc,6BAA6B,CAAC;AAE5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/service-worker-control.d.ts

@@ -1,3 +1,4 @@
+import type { ServiceWorkerScope } from "./sw-scope.js";
 /**
  * How long, by default, the page waits for its ServiceWorker to activate and
  * to take control before giving up. Generous: a first install downloads and
@@ -70,5 +71,5 @@ export declare function awaitServiceWorkerControl(registration: ServiceWorkerReg
  * `clients.claim()`, which takes over every uncontrolled client in scope.
  * Returns a function that stops answering.
  */
-export declare function handleClaimRequests(self: ServiceWorkerGlobalScope): () => void;
+export declare function handleClaimRequests(self: ServiceWorkerScope): () => void;
 //# sourceMappingURL=service-worker-control.d.ts.map

package/dist/core/service-worker-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-worker-control.d.ts","sourceRoot":"","sources":["../../src/core/service-worker-control.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAUrD,kFAAkF;AAClF,eAAO,MAAM,UAAU,UAAU,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,GACnC,oBAAoB,GACpB,cAAc,GACd,cAAc,GACd,cAAc,CAAC;AAEnB;;;;GAIG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,YAAY,MAAM,EAAE,2BAA2B,EAAE,OAAO,EAAE,MAAM,EAI/D;CACF;AAED,MAAM,WAAW,yBAAyB;IACxC,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gCAAiC,SAAQ,yBAAyB;IACjF;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,oDAAoD;IACpD,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,yBAAyB,EACvC,EAAE,OAAwC,EAAE,GAAE,yBAA8B,GAC3E,OAAO,CAAC,aAAa,CAAC,CAaxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,yBAAyB,EACvC,EACE,OAAwC,EACxC,oBAA4B,EAC5B,SAAmC,GACpC,GAAE,gCAAqC,GACvC,OAAO,CAAC,aAAa,CAAC,CA6CxB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM,IAAI,CAM9E"}
+{"version":3,"file":"service-worker-control.d.ts","sourceRoot":"","sources":["../../src/core/service-worker-control.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAUrD,kFAAkF;AAClF,eAAO,MAAM,UAAU,UAAU,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,GACnC,oBAAoB,GACpB,cAAc,GACd,cAAc,GACd,cAAc,CAAC;AAEnB;;;;GAIG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,YAAY,MAAM,EAAE,2BAA2B,EAAE,OAAO,EAAE,MAAM,EAI/D;CACF;AAED,MAAM,WAAW,yBAAyB;IACxC,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gCAAiC,SAAQ,yBAAyB;IACjF;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,oDAAoD;IACpD,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,yBAAyB,EACvC,EAAE,OAAwC,EAAE,GAAE,yBAA8B,GAC3E,OAAO,CAAC,aAAa,CAAC,CAaxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,yBAAyB,EACvC,EACE,OAAwC,EACxC,oBAA4B,EAC5B,SAAmC,GACpC,GAAE,gCAAqC,GACvC,OAAO,CAAC,aAAa,CAAC,CA6CxB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAOxE"}

package/dist/core/sw-scope.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A ServiceWorker's global scope, as this package's API takes it: structurally, so that code
+ * importing the package's declarations compiles with the DOM lib alone. TypeScript's
+ * `ServiceWorkerGlobalScope` is in the WebWorker lib, which a page's or a library's
+ * compilation does not load. A ServiceWorker's `self` is one.
+ */
+export interface ServiceWorkerScope extends EventTarget {
+    readonly location: {
+        readonly href: string;
+        readonly origin: string;
+    };
+    readonly registration?: {
+        readonly scope: string;
+    };
+    readonly clients: unknown;
+    skipWaiting(): Promise<void>;
+}
+/** A ServiceWorker's `fetch` event, structurally (see `ServiceWorkerScope`). */
+export interface FetchEventLike extends Event {
+    readonly request: Request;
+    respondWith(response: Response | PromiseLike<Response>): void;
+}
+/**
+ * A ServiceWorker's client (a page or a worker it controls), structurally (see
+ * `ServiceWorkerScope`). A `Client` is one.
+ */
+export interface ServiceWorkerClientLike {
+    readonly id: string;
+    readonly url: string;
+}
+//# sourceMappingURL=sw-scope.d.ts.map

package/dist/core/sw-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sw-scope.d.ts","sourceRoot":"","sources":["../../src/core/sw-scope.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,QAAQ,CAAC,YAAY,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAe,SAAQ,KAAK;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB"}