@yume-chan/scrcpy 0.0.16 → 0.0.18

package/CHANGELOG.json

@@ -1,6 +1,39 @@
 {
   "name": "@yume-chan/scrcpy",
   "entries": [
+    {
+      "version": "0.0.18",
+      "tag": "@yume-chan/scrcpy_v0.0.18",
+      "date": "Wed, 25 Jan 2023 21:33:49 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Move `@yume-chan/adb` to `peerDependencies`"
+          },
+          {
+            "comment": "Add support for Scrcpy server version 1.25"
+          },
+          {
+            "comment": "Add support for `SetClipboard` control message and `AckClipboard` device message"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.17",
+      "tag": "@yume-chan/scrcpy_v0.0.17",
+      "date": "Tue, 18 Oct 2022 09:32:30 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Add standalone types for serializing/deserializing Scrcpy packets"
+          },
+          {
+            "comment": "Separate decoders to own packages so they don't need optional peer dependencies."
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.16",
       "tag": "@yume-chan/scrcpy_v0.0.16",
@@ -41,7 +74,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for new option of 1.24"
+            "comment": "Add support for Scrcpy server version 1.24"
           }
         ]
       }
@@ -53,7 +86,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for 1.23"
+            "comment": "Add support for Scrcpy server version 1.23"
           }
         ]
       }
@@ -71,7 +104,7 @@
       "comments": {
         "none": [
           {
-            "comment": "Add support for 1.22 new server options"
+            "comment": "Add support for Scrcpy server version 1.22"
           },
           {
             "comment": "Update to use Web Streams API"

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Change Log - @yume-chan/scrcpy
 
-This log was last generated on Sat, 28 May 2022 03:56:37 GMT and should not be manually modified.
+This log was last generated on Wed, 25 Jan 2023 21:33:49 GMT and should not be manually modified.
+
+## 0.0.18
+Wed, 25 Jan 2023 21:33:49 GMT
+
+### Updates
+
+- Move `@yume-chan/adb` to `peerDependencies`
+- Add support for Scrcpy server version 1.25
+- Add support for `SetClipboard` control message and `AckClipboard` device message
+
+## 0.0.17
+Tue, 18 Oct 2022 09:32:30 GMT
+
+### Updates
+
+- Add standalone types for serializing/deserializing Scrcpy packets
+- Separate decoders to own packages so they don't need optional peer dependencies.
 
 ## 0.0.16
 Sat, 28 May 2022 03:56:37 GMT
@@ -24,14 +41,14 @@ Sat, 30 Apr 2022 14:05:48 GMT
 
 ### Updates
 
-- Add support for new option of 1.24
+- Add support for Scrcpy server version 1.24
 
 ## 0.0.13
 Thu, 28 Apr 2022 01:23:53 GMT
 
 ### Updates
 
-- Add support for 1.23
+- Add support for Scrcpy server version 1.23
 
 ## 0.0.12
 Sun, 03 Apr 2022 11:18:47 GMT
@@ -43,7 +60,7 @@ Sun, 03 Apr 2022 10:54:15 GMT
 
 ### Updates
 
-- Add support for 1.22 new server options
+- Add support for Scrcpy server version 1.22
 - Update to use Web Streams API
 - Improve compatibility with Node.js 12 ESM format
 - Workaround a issue with server crash on Samsung ROM (https://github.com/Genymobile/scrcpy/issues/2841)

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2022 Simon Chan
+Copyright (c) 2020-2023 Simon Chan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,16 +2,57 @@
 
 TypeScript implementation of [Scrcpy](https://github.com/Genymobile/scrcpy) client.
 
-It uses the official Scrcpy server releases.
+It's compatible with the official Scrcpy server binaries.
 
 **WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
 
-## Download Server Binary
+- [Basic information](#basic-information)
+- [Prepare server binary](#prepare-server-binary)
+  - [`fetch-scrcpy-server`](#fetch-scrcpy-server)
+  - [Use the server binary](#use-the-server-binary)
+    - [Node.js CommonJS](#nodejs-commonjs)
+    - [Node.js ES module](#nodejs-es-module)
+    - [Webpack 4](#webpack-4)
+    - [Webpack 5](#webpack-5)
+  - [Read the server version](#read-the-server-version)
+- [Server versions](#server-versions)
+- [Use with `@yume-chan/adb`](#use-with-yume-chanadb)
+  - [Push server binary](#push-server-binary)
+  - [Start server on device](#start-server-on-device)
+- [Using other transportation](#using-other-transportation)
+  - [Parsing video packets](#parsing-video-packets)
+  - [Sending control messages](#sending-control-messages)
+  - [Reading device messages](#reading-device-messages)
+- [Always read the streams](#always-read-the-streams)
+- [Video stream](#video-stream)
+- [Decode video stream](#decode-video-stream)
 
-This package has a script `fetch-scrcpy-server` to help you download the official server binary.
+## Basic information
+
+Although Scrcpy doesn't install any App on the device, it does have a server binary executable to be run on the device.
+
+With the official Scrcpy client and server, the client uses ADB to transfer the server binary file to the device, run it, and communicate with it via ADB tunnel (the bootstrap process).
+
+This package provides types that can serialize and deserialize Scrcpy protocol messages, but it generally requires you to do the bootstrapping and provide the data stream to the server.
+
+If you are also using `@yume-chan/adb`, this package has a helper class that can complete the bootstrap process using it, doing what the official client does.
+
+**NOTE:** `@yume-chan/adb` is a peer dependency, you need to install it yourself. Only those types whose names begin with `Adb` requires `@yume-chan/adb`.
+
+## Prepare server binary
+
+This package doesn't include the server binary. It's compatible with many versions of the official server binary, but may not work with future versions due to protocol changes.
+
+You can download the server binary from official releases (https://github.com/Genymobile/scrcpy/releases), or use the built-in `fetch-scrcpy-server` script to automate the process.
 
 The server binary is subject to [Apache License 2.0](https://github.com/Genymobile/scrcpy/blob/master/LICENSE).
 
+### `fetch-scrcpy-server`
+
+This package includes a script that downloads the server binary from official releases for you.
+
+The `gh-release-fetch@3` package is a peer dependency for this script, thus requires separated installation.
+
 Usage:
 
 ```
@@ -21,30 +62,86 @@ $ npx fetch-scrcpy-server <version>
 For example:
 
 ```
-$ npx fetch-scrcpy-server 1.21
+$ npx fetch-scrcpy-server 1.25
 ```
 
-You can also add it to the `postinstall` script of your `package.json` so it will run automatically when you do `npm install`:
+It can also be added to the `postinstall` script in `package.json`, so running `npm install` will automatically invoke the script:
 
 ```json
 "scripts": {
-    "postinstall": "fetch-scrcpy-server 1.21",
+    "postinstall": "fetch-scrcpy-server 1.25",
 },
 ```
 
-It will download the binary to `bin/scrcpy` and write the version string to `bin/version.js`. You can import the version string with
+The server binary will be named `bin/scrcpy-server` in this package's installation directory (usually in `node_modules`).
+
+### Use the server binary
+
+The server binary file needs to be embedded into your application, the exact method depends on the bundler and runtime.
+
+To name a few:
+
+#### Node.js CommonJS
+
+```ts
+const fs = require('fs');
+const path: string = require.resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const buffer: Buffer = fs.readFileSync(path);
+```
+
+#### Node.js ES module
+
+```ts
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+
+const path: string = createRequire(import.meta.url).resolve('@yume-chan/scrcpy/bin/scrcpy-server'); // Or your own server binary path
+const buffer: Buffer = await fs.readFile(path);
+```
+
+Currently, ES Module doesn't have a `resolve` function like `require.resolve` in CommonJS, so `createRequire` is used to create a CommonJS resolver.
+
+`import.meta.resolve` (https://github.com/whatwg/html/pull/5572) is a proposal that fills this gap. Node.js already has experimental support for it behind a flag. See https://nodejs.org/api/esm.html#importmetaresolvespecifier-parent for more information.
+
+```ts
+const path: string = import.meta.resolve('@yume-chan/scrcpy/bin/scrcpy-server');
+```
+
+#### Webpack 4
+
+Requires installing and configuring file-loader (https://v4.webpack.js.org/loaders/file-loader/)
+
+```ts
+import SCRCPY_SERVER_URL from '@yume-chan/scrcpy/bin/scrcpy-server'; // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+```
+
+#### Webpack 5
+
+Requires configuring Asset Modules (https://webpack.js.org/guides/asset-modules/)
+
+```ts
+const SCRCPY_SERVER_URL = new URL('@yume-chan/scrcpy/bin/scrcpy-server', import.meta.url); // Or your own server binary path
+const buffer: ArrayBuffer = await fetch(SCRCPY_SERVER_URL).then(res => res.arrayBuffer());
+```
+
+### Read the server version
+
+The correct version number is required to launch the server, so `fetch-scrcpy-server` also writes the version number to `bin/version.js`.
 
 ```js
-import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version';
+import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
+
+console.log(SCRCPY_SERVER_VERSION); // "1.25"
 ```
 
-And import the server binary with [file-loader](https://v4.webpack.js.org/loaders/file-loader/) (Webpack 4) or [Asset Modules](https://webpack.js.org/guides/asset-modules/) (Webpack 5).
+## Server versions
 
-## Option versions
+Scrcpy protocol change over time, and are usually not backwards compatible. This package supports multiple server versions (or ranges), and uses different option types to choose different behaviors. Using incorrect option version usually results in errors.
 
-Scrcpy server has no backward compatibility on options input format. Currently the following versions are supported:
+The latest one may continue to work for future server versions, but there is no guarantee.
 
-| versions  | type                |
+| Version   | Type                |
 | --------- | ------------------- |
 | 1.16~1.17 | `ScrcpyOptions1_16` |
 | 1.18~1.20 | `ScrcpyOptions1_18` |
@@ -52,39 +149,196 @@ Scrcpy server has no backward compatibility on options input format. Currently t
 | 1.22      | `ScrcpyOptions1_22` |
 | 1.23      | `ScrcpyOptions1_23` |
 | 1.24      | `ScrcpyOptions1_24` |
+| 1.25      | `ScrcpyOptions1_25` |
 
-You must use the correct type according to the server version.
+When using `AdbScrcpyClient`, there are `AdbScrcpyOptions` containing `@yume-chan/adb` specific options:
 
-## Video stream
+| Version   | Type                   |
+| --------- | ---------------------- |
+| 1.16~1.21 | `AdbScrcpyOptions1_16` |
+| 1.22~1.25 | `AdbScrcpyOptions1_22` |
+
+## Use with `@yume-chan/adb`
+
+`@yume-chan/adb` is a TypeScript ADB implementation that can run on Web browser. It can be used to bootstrap the server on a device.
+
+### Push server binary
+
+The `Adb#sync()#write()` method can be used to push files to the device. Read more at `@yume-chan/adb`'s documentation (https://github.com/yume-chan/ya-webadb/tree/main/libraries/adb#readme).
+
+This package also provides the `AdbScrcpyClient.pushServer()` static method as a shortcut, plus it will automatically close the `AdbSync` object on completion.
+
+Example using `write()`:
+
+```ts
+import { AdbScrcpyClient } from '@yume-chan/scrcpy';
+
+const stream: WritableStream<Uint8Array> = AdbScrcpyClient.pushServer(adb);
+const writer = stream.getWriter();
+await writer.write(new Uint8Array(buffer));
+await writer.close();
+```
 
-The data from `onVideoData` event is a raw H.264 stream. You can process it as you want, or use the following built-in decoders to render it in browsers:
+Example using `pipeTo()`:
 
-* WebCodecs decoder: Uses the [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API). The video stream will be decoded into `VideoFrame`s and drawn on a 2D canvas.
-* TinyH264 decoder: TinyH264 compiles the old Android H.264 software decoder (now deprecated and removed) into WebAssembly, and wrap it in Web Worker to prevent blocking the main thread. The video stream will be decoded into YUV frames, then converted to RGB using a WebGL shader.
+```ts
+import { WrapReadableStream } from '@yume-chan/adb';
+import { AdbScrcpyClient } from '@yume-chan/scrcpy';
+
+await fetch(SCRCPY_SERVER_URL)
+    // `WrapReadableStream` is required because native `ReadableStream` (from `fetch`)
+    // doesn't support `pipeTo()` non-native `WritableStream`s
+    // (`@yume-chan/adb` is using `web-streams-polyfill`)
+    .then(response => new WrapReadableStream(response.body))
+    .then(stream => stream.pipeTo(AdbScrcpyClient.pushServer(adb)));
+```
+
+### Start server on device
+
+To start the server, use the `AdbScrcpyClient.start()` method. It automatically sets up port forwarding, launches the server, and connects to it.
+
+```js
+import { AdbScrcpyClient, AdbScrcpyOptions1_22, DEFAULT_SERVER_PATH, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+import SCRCPY_SERVER_VERSION from '@yume-chan/scrcpy/bin/version.js';
+
+const client: AdbScrcpyClient = await AdbScrcpyClient.start(
+    adb,
+    DEFAULT_SERVER_PATH,
+    SCRCPY_SERVER_VERSION, // If server binary was downloaded manually, must provide the correct version
+    new AdbScrcpyOptions1_22(ScrcpyOptions1_24({
+        // options
+    }))
+);
+
+const stdout: ReadableStream<string> = client.stdout;
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = client.videoStream;
+const controlMessageSerializer: ScrcpyControlMessageSerializer | undefined = client.controlMessageSerializer;
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined = client.deviceMessageStream;
+
+// to stop the server
+client.close();
+```
+
+## Using other transportation
+
+If you push, start and connect to the server yourself, you can still use this package to serialize/deserialize packets.
+
+### Parsing video packets
+
+Requires a `ReadableStream<Uint8Array>` that reads from the video socket, preserving packet boundaries.
+
+**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
+
+```ts
+import { ScrcpyOptions1_24, ScrcpyVideoStreamPacket } from '@yume-chan/scrcpy';
+
+const videoStream: ReadableStream<Uint8Array>; // get the stream yourself
+
+const options = new ScrcpyOptions1_24({
+    // use the same version and options
+});
+
+const videoPacketStream: ReadableStream<ScrcpyVideoStreamPacket> = videoStream.pipeThrough(options.createVideoStreamTransformer());
+// Read from `videoPacketStream`
+```
+
+### Sending control messages
+
+Requires a `WritableStream<Uint8Array>` that writes to the control socket.
+
+Control socket is optional if control is not enabled. Video socket and control socket can run completely separately.
+
+```ts
+import { ScrcpyControlMessageSerializer, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+
+const options = new ScrcpyOptions1_24({
+    // use the same version and options
+});
+
+const controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
+// Call methods on `controlMessageSerializer`
+controlMessageSerializer.injectText("Hello World!");
+```
+
+### Reading device messages
+
+Requires a `ReadableStream<Uint8Array>` that reads from the control socket.
+
+**NOTE:** Because this package uses `web-streams-polyfill` NPM package's Web Streams API implementation, the provided `ReadableStream` must also be from `web-streams-polyfill` (or another polyfill that doesn't check object prototype when piping).
+
+```ts
+import { ScrcpyDeviceMessageDeserializeStream, ScrcpyOptions1_24 } from '@yume-chan/scrcpy';
+
+const controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined // get the stream yourself
+
+const deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+```
 
-| Name              | Chrome | Firefox | Safari | Performance                     | Supported H.264 profile/level |
-| ----------------- | ------ | ------- | ------ | ------------------------------- | ----------------------------- |
-| WebCodecs decoder | 94     | No      | No     | High with Hardware acceleration | High level 5                  |
-| TinyH264 decoder  | 57     | 52      | 11     | Poor                            | Baseline level 4              |
+## Always read the streams
 
-TinyH264 decoder needs some extra setup:
+In Web Streams API, `ReadableStream` will block its upstream when too many chunks are kept not read. If multiple streams are from the same upstream source, block one stream means blocking all of them.
 
-1. `tinyh264`, `yuv-buffer` and `yuv-canvas` packages are peer dependencies. You must install them separately.
-2. The bundler you use must support the `new Worker(new URL('./worker.js', import.meta.url))` syntax. It's known to work with Webpack 5.
+For Scrcpy, usually all streams are originated from the same ADB connection (either USB or TCP), so it's important to always read from all streams, even if you don't care about their data.
 
-Example usage:
+```ts
+// when using `AdbScrcpyClient`
+stdout
+    .pipeTo(
+        new WritableStream<string>({
+            write: (line) => {
+                // Handle or ignore the stdout line
+            },
+        }),
+    )
+    .catch(() => {})
+    .then(() => {
+        // Handle server exit
+    });
+
+videoPacketStream
+    .pipeTo(new WritableStream<ScrcpyVideoStreamPacket>({
+        write: (packet) => {
+            // Handle or ignore the video packet
+        },
+    }))
+    .catch(() => {});
+
+deviceMessageStream
+    .pipeTo(new WritableStream<ScrcpyDeviceMessage>({
+        write: (message) => {
+            // Handle or ignore the device message
+        },
+    }))
+    .catch(() => {});
+```
+
+## Video stream
+
+The data from `videoPacketStream` has two types: `configuration` and `frame`. Some fields may not be populated depending on the server version and options.
 
 ```ts
-const client = new ScrcpyClient(adb);
-const decoder = new WebCodecsDecoder(); // Or `new TinyH264Decoder()`
-client.onSizeChanged(size => decoder.setSize(size));
-client.onVideoData(data => decoder.feed(data));
-client.start(serverPath, serverVersion, new ScrcpyOptionsX_XX({
-    ...options,
-    codecOptions: new CodecOptions({
-        profile: decoder.maxProfile,
-        level: decoder.maxLevel,
-    }),
-}));
-document.body.appendChild(decoder.element);
+export interface ScrcpyVideoStreamConfigurationPacket {
+    type: 'configuration';
+    data: H264Configuration;
+}
+
+export interface ScrcpyVideoStreamFramePacket {
+    type: 'frame';
+    keyframe?: boolean | undefined;
+    pts?: bigint | undefined;
+    data: Uint8Array;
+}
 ```
+
+When `sendFrameMeta: false` is set, `videoPacketStream` only contains `frame` packets, and only the `data` field in it is available. It's commonly used when feeding into decoders like FFmpeg that can parse the H.264 stream itself, or saving to disk directly.
+
+Otherwise, both `configuration` and `frame` packets are available.
+
+* `configuration` packets contain the parsed SPS data, and can be used to initialize a video decoder.
+* `pts` (and `keyframe` field from server version 1.23) fields in `frame` packets are available to help decode the video.
+
+## Decode video stream
+
+`@yume-chan/scrcpy-decoder-tinyh264` and `@yume-chan/scrcpy-decoder-webcodecs` can be used to decode and render the video stream in Browser environments. Refer to their README files for compatibility and usage information.

package/bin/version.d.ts

@@ -1 +1 @@
-export default '1.24';
+export default '1.25';

package/bin/version.js

@@ -1 +1 @@
-export default '1.24';
+export default '1.25';

package/esm/adb/client.d.ts

@@ -0,0 +1,41 @@
+import { type Adb, type AdbSubprocessProtocol } from "@yume-chan/adb";
+import { ReadableStream, WrapWritableStream, type ReadableWritablePair } from "@yume-chan/stream-extra";
+import { ScrcpyControlMessageSerializer } from "../control/index.js";
+import { type ScrcpyDeviceMessage } from "../device-message/index.js";
+import { type ScrcpyVideoStreamPacket } from "../options/index.js";
+import { type AdbScrcpyOptions } from "./options/index.js";
+export declare class ScrcpyExitedError extends Error {
+    output: string[];
+    constructor(output: string[]);
+}
+export declare class AdbScrcpyClient {
+    static pushServer(adb: Adb, path?: string): WrapWritableStream<Uint8Array>;
+    static start(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<object>): Promise<AdbScrcpyClient>;
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static getEncoders(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<object>): Promise<string[]>;
+    /**
+     * This method will modify the given `options`,
+     * so don't reuse it elsewhere.
+     */
+    static getDisplays(adb: Adb, path: string, version: string, options: AdbScrcpyOptions<object>): Promise<number[]>;
+    private process;
+    private _stdout;
+    get stdout(): ReadableStream<string>;
+    get exit(): Promise<number>;
+    private _screenWidth;
+    get screenWidth(): number | undefined;
+    private _screenHeight;
+    get screenHeight(): number | undefined;
+    private _videoStream;
+    get videoStream(): ReadableStream<ScrcpyVideoStreamPacket>;
+    private _controlMessageSerializer;
+    get controlMessageSerializer(): ScrcpyControlMessageSerializer | undefined;
+    private _deviceMessageStream;
+    get deviceMessageStream(): ReadableStream<ScrcpyDeviceMessage> | undefined;
+    constructor(options: AdbScrcpyOptions<object>, process: AdbSubprocessProtocol, stdout: ReadableStream<string>, videoStream: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined);
+    close(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/esm/adb/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/adb/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,GAAG,EACR,KAAK,qBAAqB,EAE7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAIH,cAAc,EAEd,kBAAkB,EAIlB,KAAK,oBAAoB,EAC5B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEH,KAAK,uBAAuB,EAC/B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AA0D3D,qBAAa,iBAAkB,SAAQ,KAAK;IACjC,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEL,MAAM,EAAE,MAAM,EAAE;CAItC;AAED,qBAAa,eAAe;WACV,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,SAAsB;WAazC,KAAK,CACrB,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC;IA4ErC;;;OAGG;WACiB,WAAW,CAC3B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC;IA+BpB;;;OAGG;WACiB,WAAW,CAC3B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC;IA8BpB,OAAO,CAAC,OAAO,CAAwB;IAEvC,OAAO,CAAC,OAAO,CAAyB;IACxC,IAAW,MAAM,2BAEhB;IAED,IAAW,IAAI,oBAEd;IAED,OAAO,CAAC,YAAY,CAAqB;IACzC,IAAW,WAAW,uBAErB;IAED,OAAO,CAAC,aAAa,CAAqB;IAC1C,IAAW,YAAY,uBAEtB;IAED,OAAO,CAAC,YAAY,CAA0C;IAC9D,IAAW,WAAW,4CAErB;IAED,OAAO,CAAC,yBAAyB,CAEjB;IAChB,IAAW,wBAAwB,+CAElC;IAED,OAAO,CAAC,oBAAoB,CAEZ;IAChB,IAAW,mBAAmB,oDAE7B;gBAGG,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,EACjC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,EAC9B,WAAW,EAAE,cAAc,CAAC,UAAU,CAAC,EACvC,aAAa,EAAE,oBAAoB,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,SAAS;IA2B9D,KAAK;CAGrB"}