@yume-chan/scrcpy 0.0.20 → 0.0.21

package/src/control/writer.ts

@@ -16,72 +16,70 @@ import { ScrcpyControlMessageSerializer } from "./serializer.js";
 import type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
 
 export class ScrcpyControlMessageWriter {
-    private _writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
-    private _serializer: ScrcpyControlMessageSerializer;
+    #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    #serializer: ScrcpyControlMessageSerializer;
 
-    public constructor(
+    constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
-        options: ScrcpyOptions<object>
+        options: ScrcpyOptions<object>,
     ) {
-        this._writer = writer;
-        this._serializer = new ScrcpyControlMessageSerializer(options);
+        this.#writer = writer;
+        this.#serializer = new ScrcpyControlMessageSerializer(options);
     }
 
-    private async write(message: Uint8Array) {
-        await ConsumableWritableStream.write(this._writer, message);
+    async #write(message: Uint8Array) {
+        await ConsumableWritableStream.write(this.#writer, message);
     }
 
-    public async injectKeyCode(
-        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    async injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">,
     ) {
-        await this.write(this._serializer.injectKeyCode(message));
+        await this.#write(this.#serializer.injectKeyCode(message));
     }
 
-    public async injectText(text: string) {
-        await this.write(this._serializer.injectText(text));
+    async injectText(text: string) {
+        await this.#write(this.#serializer.injectText(text));
     }
 
     /**
      * `pressure` is a float value between 0 and 1.
      */
-    public async injectTouch(
-        message: Omit<ScrcpyInjectTouchControlMessage, "type">
-    ) {
-        await this.write(this._serializer.injectTouch(message));
+    async injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        await this.#write(this.#serializer.injectTouch(message));
     }
 
     /**
      * `scrollX` and `scrollY` are float values between 0 and 1.
      */
-    public async injectScroll(
-        message: Omit<ScrcpyInjectScrollControlMessage, "type">
+    async injectScroll(
+        message: Omit<ScrcpyInjectScrollControlMessage, "type">,
     ) {
-        const data = this._serializer.injectScroll(message);
+        const data = this.#serializer.injectScroll(message);
         if (data) {
-            await this.write(data);
+            await this.#write(data);
         }
     }
 
-    public async backOrScreenOn(action: AndroidKeyEventAction) {
-        const data = this._serializer.backOrScreenOn(action);
+    async backOrScreenOn(action: AndroidKeyEventAction) {
+        const data = this.#serializer.backOrScreenOn(action);
         if (data) {
-            await this.write(data);
+            await this.#write(data);
         }
     }
 
-    public async setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        await this.write(this._serializer.setScreenPowerMode(mode));
+    async setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        await this.#write(this.#serializer.setScreenPowerMode(mode));
     }
 
-    public async rotateDevice() {
-        await this.write(this._serializer.rotateDevice());
+    async rotateDevice() {
+        await this.#write(this.#serializer.rotateDevice());
     }
 
-    public releaseLock() {
-        this._writer.releaseLock();
+    releaseLock() {
+        this.#writer.releaseLock();
     }
 
-    public async close() {
-        await this._writer.close();
+    async close() {
+        await this.#writer.close();
     }
 }

package/src/device-message/stream.ts

@@ -21,11 +21,11 @@ export class ScrcpyDeviceMessageDeserializeStream extends BufferedTransformStrea
                 switch (type[0]) {
                     case ScrcpyDeviceMessageType.Clipboard:
                         return await ScrcpyClipboardDeviceMessage.deserialize(
-                            stream
+                            stream,
                         );
                     case ScrcpyDeviceMessageType.AckClipboard:
                         return await ScrcpyAckClipboardDeviceMessage.deserialize(
-                            stream
+                            stream,
                         );
                     default:
                         throw new Error("Unsupported control message type");

package/src/options/1_16/codec-options.ts

@@ -27,15 +27,15 @@ const CODEC_OPTION_TYPES: Partial<
 };
 
 export class CodecOptions implements ScrcpyOptionValue {
-    public value: Partial<CodecOptionsInit>;
+    value: Partial<CodecOptionsInit>;
 
-    public constructor(value: Partial<CodecOptionsInit> = {}) {
+    constructor(value: Partial<CodecOptionsInit> = {}) {
         this.value = value;
     }
 
-    public toOptionValue(): string | undefined {
+    toOptionValue(): string | undefined {
         const entries = Object.entries(this.value).filter(
-            ([, value]) => value !== undefined
+            ([, value]) => value !== undefined,
         );
 
         if (entries.length === 0) {

package/src/options/1_16/float-to-uint16.ts

@@ -29,5 +29,5 @@ export const ScrcpyFloatToUint16NumberType: NumberFieldType = {
 };
 
 export const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
-    ScrcpyFloatToUint16NumberType
+    ScrcpyFloatToUint16NumberType,
 );

package/src/options/1_16/options.ts

@@ -38,7 +38,7 @@ import type { ScrcpyScrollController } from "./scroll.js";
 import { ScrcpyScrollController1_16 } from "./scroll.js";
 
 export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         logLevel: ScrcpyLogLevel1_16.Debug,
         maxSize: 0,
         bitRate: 8_000_000,
@@ -54,7 +54,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         codecOptions: new CodecOptions(),
     } as const satisfies Required<ScrcpyOptionsInit1_16>;
 
-    public static readonly SERIALIZE_ORDER = [
+    static readonly SERIALIZE_ORDER = [
         "logLevel",
         "maxSize",
         "bitRate",
@@ -70,68 +70,64 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         "codecOptions",
     ] as const satisfies readonly (keyof ScrcpyOptionsInit1_16)[];
 
-    public static serialize<T>(options: T, order: readonly (keyof T)[]) {
+    static serialize<T>(options: T, order: readonly (keyof T)[]) {
         return order.map((key) => toScrcpyOptionValue(options[key], "-"));
     }
 
-    public static async parseCString(
+    static async parseCString(
         stream: AsyncExactReadable,
-        maxLength: number
+        maxLength: number,
     ): Promise<string> {
         let result = decodeUtf8(await stream.readExactly(maxLength));
         result = result.substring(0, result.indexOf("\0"));
         return result;
     }
 
-    public static async parseUint16BE(
-        stream: AsyncExactReadable
-    ): Promise<number> {
+    static async parseUint16BE(stream: AsyncExactReadable): Promise<number> {
         const buffer = await stream.readExactly(NumberFieldType.Uint16.size);
         return NumberFieldType.Uint16.deserialize(buffer, false);
     }
 
-    public static async parseUint32BE(
-        stream: AsyncExactReadable
-    ): Promise<number> {
+    static async parseUint32BE(stream: AsyncExactReadable): Promise<number> {
         const buffer = await stream.readExactly(NumberFieldType.Uint32.size);
         return NumberFieldType.Uint32.deserialize(buffer, false);
     }
 
-    public value: Required<ScrcpyOptionsInit1_16>;
+    value: Required<ScrcpyOptionsInit1_16>;
 
-    public readonly defaults: Required<ScrcpyOptionsInit1_16> =
+    readonly defaults: Required<ScrcpyOptionsInit1_16> =
         ScrcpyOptions1_16.DEFAULTS;
 
-    public readonly controlMessageTypes: readonly ScrcpyControlMessageType[] =
+    readonly controlMessageTypes: readonly ScrcpyControlMessageType[] =
         SCRCPY_CONTROL_MESSAGE_TYPES_1_16;
 
-    public constructor(init: ScrcpyOptionsInit1_16) {
+    constructor(init: ScrcpyOptionsInit1_16) {
         this.value = { ...ScrcpyOptions1_16.DEFAULTS, ...init };
     }
 
-    public serialize(): string[] {
+    serialize(): string[] {
         return ScrcpyOptions1_16.serialize(
             this.value,
-            ScrcpyOptions1_16.SERIALIZE_ORDER
+            ScrcpyOptions1_16.SERIALIZE_ORDER,
         );
     }
 
-    public setListEncoders(): void {
+    setListEncoders(): void {
         throw new Error("Not supported");
     }
 
-    public setListDisplays(): void {
+    setListDisplays(): void {
         // Set to an invalid value
         // Server will print valid values before crashing
         // (server will crash before opening sockets)
         this.value.displayId = -1;
     }
 
-    public parseEncoder(): ScrcpyEncoder | undefined {
+    parseEncoder(): ScrcpyEncoder | undefined {
         throw new Error("Not supported");
     }
 
-    public parseDisplay(line: string): ScrcpyDisplay | undefined {
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
         const displayIdRegex = /\s+scrcpy --display (\d+)/;
         const match = line.match(displayIdRegex);
         if (match) {
@@ -142,8 +138,8 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         return undefined;
     }
 
-    public parseVideoStreamMetadata(
-        stream: ReadableStream<Uint8Array>
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
     ): ValueOrPromise<ScrcpyVideoStream> {
         return (async () => {
             const buffered = new BufferedReadableStream(stream);
@@ -152,7 +148,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
             };
             metadata.deviceName = await ScrcpyOptions1_16.parseCString(
                 buffered,
-                64
+                64,
             );
             metadata.width = await ScrcpyOptions1_16.parseUint16BE(buffered);
             metadata.height = await ScrcpyOptions1_16.parseUint16BE(buffered);
@@ -160,11 +156,11 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         })();
     }
 
-    public parseAudioStreamMetadata(): never {
+    parseAudioStreamMetadata(): never {
         throw new Error("Not supported");
     }
 
-    public createMediaStreamTransformer(): TransformStream<
+    createMediaStreamTransformer(): TransformStream<
         Uint8Array,
         ScrcpyMediaStreamPacket
     > {
@@ -181,7 +177,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         }
 
         const deserializeStream = new StructDeserializeStream(
-            ScrcpyMediaStreamRawPacket
+            ScrcpyMediaStreamRawPacket,
         );
         return {
             writable: deserializeStream.writable,
@@ -202,19 +198,19 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
                             data: packet.data,
                         });
                     },
-                })
+                }),
             ),
         };
     }
 
-    public serializeInjectTouchControlMessage(
-        message: ScrcpyInjectTouchControlMessage
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
     ): Uint8Array {
         return ScrcpyInjectTouchControlMessage1_16.serialize(message);
     }
 
-    public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
     ) {
         if (message.action === AndroidKeyEventAction.Down) {
             return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
@@ -223,13 +219,13 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         return undefined;
     }
 
-    public serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
     ): Uint8Array {
         return ScrcpySetClipboardControlMessage1_15.serialize(message);
     }
 
-    public createScrollController(): ScrcpyScrollController {
+    createScrollController(): ScrcpyScrollController {
         return new ScrcpyScrollController1_16();
     }
 }

package/src/options/1_16/scroll.ts

@@ -4,7 +4,7 @@ import type { ScrcpyInjectScrollControlMessage } from "../../control/index.js";
 
 export interface ScrcpyScrollController {
     serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined;
 }
 
@@ -24,31 +24,31 @@ export const ScrcpyInjectScrollControlMessage1_16 = new Struct()
  * reaches 1 or -1.
  */
 export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
-    private accumulatedX = 0;
-    private accumulatedY = 0;
+    #accumulatedX = 0;
+    #accumulatedY = 0;
 
     protected processMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): ScrcpyInjectScrollControlMessage | undefined {
-        this.accumulatedX += message.scrollX;
-        this.accumulatedY += message.scrollY;
+        this.#accumulatedX += message.scrollX;
+        this.#accumulatedY += message.scrollY;
 
         let scrollX = 0;
         let scrollY = 0;
-        if (this.accumulatedX >= 1) {
+        if (this.#accumulatedX >= 1) {
             scrollX = 1;
-            this.accumulatedX = 0;
-        } else if (this.accumulatedX <= -1) {
+            this.#accumulatedX = 0;
+        } else if (this.#accumulatedX <= -1) {
             scrollX = -1;
-            this.accumulatedX = 0;
+            this.#accumulatedX = 0;
         }
 
-        if (this.accumulatedY >= 1) {
+        if (this.#accumulatedY >= 1) {
             scrollY = 1;
-            this.accumulatedY = 0;
-        } else if (this.accumulatedY <= -1) {
+            this.#accumulatedY = 0;
+        } else if (this.#accumulatedY <= -1) {
             scrollY = -1;
-            this.accumulatedY = 0;
+            this.#accumulatedY = 0;
         }
 
         if (scrollX === 0 && scrollY === 0) {
@@ -60,8 +60,8 @@ export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
         return message;
     }
 
-    public serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+    serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined {
         const processed = this.processMessage(message);
         if (!processed) {

package/src/options/1_17.ts

@@ -11,19 +11,19 @@ export class ScrcpyOptions1_17 extends ScrcpyOptionsBase<
     ScrcpyOptionsInit1_17,
     ScrcpyOptions1_16
 > {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         ...ScrcpyOptions1_16.DEFAULTS,
         encoderName: undefined,
     } as const satisfies Required<ScrcpyOptionsInit1_17>;
 
-    public static readonly SERIALIZE_ORDER = [
+    static readonly SERIALIZE_ORDER = [
         ...ScrcpyOptions1_16.SERIALIZE_ORDER,
         "encoderName",
     ] as const satisfies readonly (keyof ScrcpyOptionsInit1_17)[];
 
-    public static parseEncoder(
+    static parseEncoder(
         line: string,
-        encoderNameRegex: RegExp
+        encoderNameRegex: RegExp,
     ): ScrcpyEncoder | undefined {
         const match = line.match(encoderNameRegex);
         if (match) {
@@ -32,35 +32,35 @@ export class ScrcpyOptions1_17 extends ScrcpyOptionsBase<
         return undefined;
     }
 
-    public override get defaults(): Required<ScrcpyOptionsInit1_17> {
+    override get defaults(): Required<ScrcpyOptionsInit1_17> {
         return ScrcpyOptions1_17.DEFAULTS;
     }
 
-    public constructor(init: ScrcpyOptionsInit1_17) {
+    constructor(init: ScrcpyOptionsInit1_17) {
         super(new ScrcpyOptions1_16(init), {
             ...ScrcpyOptions1_17.DEFAULTS,
             ...init,
         });
     }
 
-    public override serialize(): string[] {
+    override serialize(): string[] {
         return ScrcpyOptions1_16.serialize(
             this.value,
-            ScrcpyOptions1_17.SERIALIZE_ORDER
+            ScrcpyOptions1_17.SERIALIZE_ORDER,
         );
     }
 
-    public override setListEncoders() {
+    override setListEncoders() {
         // Set to an invalid value
         // Server will print valid values before crashing
         // (server will crash after opening video and control sockets)
         this.value.encoderName = "_";
     }
 
-    public override parseEncoder(line: string): ScrcpyEncoder | undefined {
+    override parseEncoder(line: string): ScrcpyEncoder | undefined {
         return ScrcpyOptions1_17.parseEncoder(
             line,
-            /\s+scrcpy --encoder-name '(.*?)'/
+            /\s+scrcpy --encoder-name '(.*?)'/,
         );
     }
 }

package/src/options/1_18.ts

@@ -56,7 +56,7 @@ export const SCRCPY_CONTROL_MESSAGE_TYPES_1_18 =
 SCRCPY_CONTROL_MESSAGE_TYPES_1_18.splice(
     6,
     0,
-    ScrcpyControlMessageType.ExpandSettingPanel
+    ScrcpyControlMessageType.ExpandSettingPanel,
 );
 
 const LOG_LEVEL_MAP = {
@@ -82,23 +82,23 @@ export class ScrcpyOptions1_18 extends ScrcpyOptionsBase<
     ScrcpyOptionsInit1_18,
     ScrcpyOptions1_17
 > {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         ...ScrcpyOptions1_17.DEFAULTS,
         logLevel: ScrcpyLogLevel1_18.Debug,
         lockVideoOrientation: ScrcpyVideoOrientation1_18.Unlocked,
         powerOffOnClose: false,
     } as const satisfies Required<ScrcpyOptionsInit1_18>;
 
-    public static readonly SERIALIZE_ORDER = [
+    static readonly SERIALIZE_ORDER = [
         ...ScrcpyOptions1_17.SERIALIZE_ORDER,
         "powerOffOnClose",
     ] as const satisfies readonly (keyof ScrcpyOptionsInit1_18)[];
 
-    public override get defaults(): Required<ScrcpyOptionsInit1_18> {
+    override get defaults(): Required<ScrcpyOptionsInit1_18> {
         return ScrcpyOptions1_18.DEFAULTS;
     }
 
-    public override get controlMessageTypes() {
+    override get controlMessageTypes() {
         return SCRCPY_CONTROL_MESSAGE_TYPES_1_18;
     }
 
@@ -111,26 +111,26 @@ export class ScrcpyOptions1_18 extends ScrcpyOptionsBase<
                 lockVideoOrientation:
                     VIDEO_ORIENTATION_MAP[value.lockVideoOrientation],
             }),
-            value
+            value,
         );
     }
 
-    public serialize(): string[] {
+    override serialize(): string[] {
         return ScrcpyOptions1_16.serialize(
             this.value,
-            ScrcpyOptions1_18.SERIALIZE_ORDER
+            ScrcpyOptions1_18.SERIALIZE_ORDER,
         );
     }
 
-    public override parseEncoder(line: string): ScrcpyEncoder | undefined {
+    override parseEncoder(line: string): ScrcpyEncoder | undefined {
         return ScrcpyOptions1_17.parseEncoder(
             line,
-            /\s+scrcpy --encoder '(.*?)'/
+            /\s+scrcpy --encoder '(.*?)'/,
         );
     }
 
-    public override serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage
+    override serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
     ) {
         return ScrcpyBackOrScreenOnControlMessage1_18.serialize(message);
     }

package/src/options/1_21.ts

@@ -30,14 +30,14 @@ export class ScrcpyOptions1_21 extends ScrcpyOptionsBase<
     ScrcpyOptionsInit1_21,
     ScrcpyOptions1_18
 > {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         ...ScrcpyOptions1_18.DEFAULTS,
         clipboardAutosync: true,
     } as const satisfies Required<ScrcpyOptionsInit1_21>;
 
-    public static serialize<T extends object>(
+    static serialize<T extends object>(
         options: T,
-        defaults: Required<T>
+        defaults: Required<T>,
     ): string[] {
         // 1.21 changed the format of arguments
         const result: string[] = [];
@@ -49,7 +49,7 @@ export class ScrcpyOptions1_21 extends ScrcpyOptionsBase<
 
             const defaultValue = toScrcpyOptionValue(
                 defaults[key as keyof T],
-                undefined
+                undefined,
             );
             if (serializedValue == defaultValue) {
                 continue;
@@ -60,23 +60,23 @@ export class ScrcpyOptions1_21 extends ScrcpyOptionsBase<
         return result;
     }
 
-    public override get defaults(): Required<ScrcpyOptionsInit1_21> {
+    override get defaults(): Required<ScrcpyOptionsInit1_21> {
         return ScrcpyOptions1_21.DEFAULTS;
     }
 
-    public constructor(init: ScrcpyOptionsInit1_21) {
+    constructor(init: ScrcpyOptionsInit1_21) {
         super(new ScrcpyOptions1_18(init), {
             ...ScrcpyOptions1_21.DEFAULTS,
             ...init,
         });
     }
 
-    public override serialize(): string[] {
+    override serialize(): string[] {
         return ScrcpyOptions1_21.serialize(this.value, this.defaults);
     }
 
-    public override serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
+    override serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
     ): Uint8Array {
         return ScrcpySetClipboardControlMessage1_21.serialize(message);
     }

package/src/options/1_22/options.ts

@@ -14,26 +14,26 @@ export class ScrcpyOptions1_22 extends ScrcpyOptionsBase<
     ScrcpyOptionsInit1_22,
     ScrcpyOptions1_21
 > {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         ...ScrcpyOptions1_21.DEFAULTS,
         downsizeOnError: true,
         sendDeviceMeta: true,
         sendDummyByte: true,
     } as const satisfies Required<ScrcpyOptionsInit1_22>;
 
-    public override get defaults(): Required<ScrcpyOptionsInit1_22> {
+    override get defaults(): Required<ScrcpyOptionsInit1_22> {
         return ScrcpyOptions1_22.DEFAULTS;
     }
 
-    public constructor(init: ScrcpyOptionsInit1_22) {
+    constructor(init: ScrcpyOptionsInit1_22) {
         super(new ScrcpyOptions1_21(init), {
             ...ScrcpyOptions1_22.DEFAULTS,
             ...init,
         });
     }
 
-    public override parseVideoStreamMetadata(
-        stream: ReadableStream<Uint8Array>
+    override parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
     ): ValueOrPromise<ScrcpyVideoStream> {
         if (!this.value.sendDeviceMeta) {
             return { stream, metadata: { codec: ScrcpyVideoCodecId.H264 } };
@@ -42,11 +42,11 @@ export class ScrcpyOptions1_22 extends ScrcpyOptionsBase<
         }
     }
 
-    public override serialize(): string[] {
+    override serialize(): string[] {
         return ScrcpyOptions1_21.serialize(this.value, this.defaults);
     }
 
-    public override createScrollController(): ScrcpyScrollController {
+    override createScrollController(): ScrcpyScrollController {
         return new ScrcpyScrollController1_22();
     }
 }

package/src/options/1_22/scroll.ts

@@ -13,8 +13,8 @@ export type ScrcpyInjectScrollControlMessage1_22 =
     (typeof ScrcpyInjectScrollControlMessage1_22)["TInit"];
 
 export class ScrcpyScrollController1_22 extends ScrcpyScrollController1_16 {
-    public override serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage1_22
+    override serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage1_22,
     ): Uint8Array | undefined {
         const processed = this.processMessage(message);
         if (!processed) {