homebridge-plugin-utils 1.15.2 → 1.16.0

package/dist/ffmpeg/rtp.d.ts

@@ -0,0 +1,205 @@
+/**
+ * RTP and RTCP packet demultiplexer and UDP port management for FFmpeg-based HomeKit livestreaming.
+ *
+ * This module supplies classes and helpers to support realtime streaming via FFmpeg in Homebridge and similar HomeKit environments. It enables the demultiplexing of RTP
+ * and RTCP packets on a single UDP port, as required by HomeKit and RFC 5761, working around FFmpeg’s lack of native support for RTP/RTCP multiplexing. It also manages
+ * the allocation and tracking of UDP ports for RTP and RTCP, helping prevent conflicts in dynamic, multi-session streaming scenarios.
+ *
+ * Key features:
+ *
+ * - Demultiplexes RTP and RTCP packets received on a single UDP port, forwarding them to the correct FFmpeg destinations for HomeKit livestream compatibility.
+ * - Injects periodic heartbeat messages to keep two-way audio streams alive with FFmpeg’s strict timeout requirements.
+ * - Dynamically allocates and reserves UDP ports for RTP/RTCP, supporting consecutive port pairing for correct FFmpeg operation.
+ * - Event-driven architecture for integration with plugin or automation logic.
+ *
+ * Designed for plugin developers and advanced users implementing HomeKit livestreaming, audio/video bridging, or similar applications requiring precise RTP/RTCP handling
+ * with FFmpeg.
+ *
+ * @module
+ */
+import { EventEmitter } from "node:events";
+import type { HomebridgePluginLogging } from "../util.js";
+/**
+ * Utility for demultiplexing RTP and RTCP packets on a single UDP port for HomeKit compatibility.
+ *
+ * FFmpeg does not support multiplexing RTP and RTCP data on a single UDP port (RFC 5761) and HomeKit requires this for livestreaming. This class listens on a UDP port
+ * and demultiplexes RTP and RTCP traffic, forwarding them to separate RTP and RTCP ports as required by FFmpeg.
+ *
+ * Credit to [dgreif](https://github.com/dgreif), [brandawg93](https://github.com/brandawg93), and [Sunoo](https://github.com/Sunoo) for foundational ideas and
+ * collaboration.
+ *
+ * @example
+ *
+ * ```ts
+ * // Create an RtpDemuxer to split packets for FFmpeg compatibility.
+ * const demuxer = new RtpDemuxer("ipv4", 50000, 50002, 50004, log);
+ *
+ * // Close the demuxer when finished.
+ * demuxer.close();
+ * ```
+ *
+ * @see {@link https://tools.ietf.org/html/rfc5761 | RFC 5761}
+ * @see {@link https://github.com/homebridge/homebridge-camera-ffmpeg | homebridge-camera-ffmpeg}
+ *
+ * @category FFmpeg
+ */
+export declare class RtpDemuxer extends EventEmitter {
+    private heartbeatTimer;
+    private heartbeatMsg;
+    private _isRunning;
+    private log?;
+    private inputPort;
+    readonly socket: import("dgram").Socket;
+    /**
+     * Constructs a new RtpDemuxer for a specified IP family and port set.
+     *
+     * @param ipFamily         - The IP family: "ipv4" or "ipv6".
+     * @param inputPort        - The UDP port to listen on for incoming packets.
+     * @param rtcpPort         - The UDP port to forward RTCP packets to.
+     * @param rtpPort          - The UDP port to forward RTP packets to.
+     * @param log              - Logger instance for debug and error messages.
+     *
+     * @example
+     *
+     * ```ts
+     * const demuxer = new RtpDemuxer("ipv4", 50000, 50002, 50004, log);
+     * ```
+     */
+    constructor(ipFamily: ("ipv4" | "ipv6"), inputPort: number, rtcpPort: number, rtpPort: number, log: HomebridgePluginLogging);
+    /**
+     * Sends periodic heartbeat messages to the RTP port to keep the FFmpeg process alive.
+     *
+     * This is necessary because FFmpeg times out input streams if it does not receive data for more than five seconds.
+     *
+     * @param port - The RTP port to send the heartbeat to.
+     */
+    private heartbeat;
+    /**
+     * Closes the demuxer, its socket, and any heartbeat timers.
+     *
+     * @example
+     *
+     * ```ts
+     * demuxer.close();
+     * ```
+     */
+    close(): void;
+    /**
+     * Extracts the RTP payload type from a UDP packet.
+     *
+     * Used internally to distinguish RTP from RTCP messages.
+     *
+     * @param message - The UDP packet buffer.
+     *
+     * @returns The RTP payload type as a number.
+     */
+    private getPayloadType;
+    /**
+     * Determines if the provided UDP packet is an RTP message.
+     *
+     * @param message - The UDP packet buffer.
+     *
+     * @returns `true` if the packet is RTP, `false` if RTCP.
+     */
+    private isRtpMessage;
+    /**
+     * Indicates if the demuxer is running and accepting packets.
+     *
+     * @returns `true` if running, otherwise `false`.
+     *
+     * @example
+     *
+     * ```ts
+     * if(demuxer.isRunning) {
+     *   // Demuxer is active.
+     * }
+     * ```
+     */
+    get isRunning(): boolean;
+}
+/**
+ * Allocates and tracks UDP ports for RTP and RTCP to avoid port conflicts in environments with high network activity.
+ *
+ * This utility class is used to find and reserve available UDP ports for demuxing FFmpeg streams or other network activities.
+ *
+ * @example
+ *
+ * ```ts
+ * const allocator = new RtpPortAllocator();
+ *
+ * // Reserve two consecutive ports for RTP and RTCP.
+ * const rtpPort = await allocator.reserve("ipv4", 2);
+ *
+ * // Cancel reservation if not needed.
+ * allocator.cancel(rtpPort);
+ * ```
+ *
+ * @category FFmpeg
+ */
+export declare class RtpPortAllocator {
+    private portsInUse;
+    /**
+     * Instantiates a new RTP port allocator and tracker.
+     */
+    constructor();
+    /**
+     * Finds an available UDP port by attempting to bind a new socket.
+     *
+     * Loops until an available port not already marked as in use is found.
+     *
+     * @param ipFamily         - "ipv4" or "ipv6".
+     * @param port             - Optional. The port to try to bind to. If 0, selects a random port.
+     *
+     * @returns A promise resolving to the available port number, or `-1` on error.
+     */
+    private getPort;
+    /**
+     * Internal method to reserve one or two consecutive UDP ports for FFmpeg or network use.
+     *
+     * If two ports are reserved, ensures they are consecutive for RTP and RTCP usage. Returns the first port in the sequence, or `-1` if we're unable to allocate.
+     *
+     * @param ipFamily         - Optional. "ipv4" or "ipv6". Defaults to "ipv4".
+     * @param portCount        - Optional. The number of consecutive ports to reserve (1 or 2). Defaults to 1.
+     * @param attempts         - Internal. The number of allocation attempts. Used for recursion.
+     *
+     * @returns A promise resolving to the first reserved port, or `-1` if unavailable.
+     */
+    private _reserve;
+    /**
+     * Reserves one or two consecutive UDP ports for FFmpeg or network use.
+     *
+     * If two ports are reserved, ensures they are consecutive for RTP and RTCP usage. Returns the first port in the sequence, or `-1` if we're unable to allocate.
+     *
+     * @param ipFamily         - Optional. "ipv4" or "ipv6". Defaults to "ipv4".
+     * @param portCount        - Optional. The number of consecutive ports to reserve (1 or 2). Defaults to 1.
+     *
+     * @returns A promise resolving to the first reserved port, or `-1` if unavailable.
+     *
+     * @remarks FFmpeg currently lacks the ability to specify both the RTP and RTCP ports. FFmpeg always assumes, by convention, that when you specify an RTP port, the RTCP
+     * port is the RTP port + 1. In order to work around that challenge, we need to always ensure that when we reserve multiple ports for RTP (primarily for two-way audio
+     * use cases) that we we are reserving consecutive ports only.
+     *
+     * @example
+     *
+     * ```ts
+     * // Reserve a single port.
+     * const port = await allocator.reserve();
+     *
+     * // Reserve two consecutive ports for RTP/RTCP.
+     * const rtpPort = await allocator.reserve("ipv4", 2);
+     * ```
+     */
+    reserve(ipFamily?: ("ipv4" | "ipv6"), portCount?: (1 | 2)): Promise<number>;
+    /**
+     * Cancels and releases a previously reserved port, making it available for future use.
+     *
+     * @param port - The port number to release.
+     *
+     * @example
+     *
+     * ```ts
+     * allocator.cancel(50000);
+     * ```
+     */
+    cancel(port: number): void;
+}

package/dist/ffmpeg/rtp.js

@@ -0,0 +1,335 @@
+/* Copyright(C) 2017-2025, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * ffmpeg/rtp.ts: RTP-related utilities to slice and dice RTP streams.
+ *
+ * This module is heavily inspired by the homebridge and homebridge-camera-ffmpeg source code and borrows from both. Thank you for your contributions to the community.
+ */
+/**
+ * RTP and RTCP packet demultiplexer and UDP port management for FFmpeg-based HomeKit livestreaming.
+ *
+ * This module supplies classes and helpers to support realtime streaming via FFmpeg in Homebridge and similar HomeKit environments. It enables the demultiplexing of RTP
+ * and RTCP packets on a single UDP port, as required by HomeKit and RFC 5761, working around FFmpeg’s lack of native support for RTP/RTCP multiplexing. It also manages
+ * the allocation and tracking of UDP ports for RTP and RTCP, helping prevent conflicts in dynamic, multi-session streaming scenarios.
+ *
+ * Key features:
+ *
+ * - Demultiplexes RTP and RTCP packets received on a single UDP port, forwarding them to the correct FFmpeg destinations for HomeKit livestream compatibility.
+ * - Injects periodic heartbeat messages to keep two-way audio streams alive with FFmpeg’s strict timeout requirements.
+ * - Dynamically allocates and reserves UDP ports for RTP/RTCP, supporting consecutive port pairing for correct FFmpeg operation.
+ * - Event-driven architecture for integration with plugin or automation logic.
+ *
+ * Designed for plugin developers and advanced users implementing HomeKit livestreaming, audio/video bridging, or similar applications requiring precise RTP/RTCP handling
+ * with FFmpeg.
+ *
+ * @module
+ */
+import { EventEmitter, once } from "node:events";
+import { createSocket } from "node:dgram";
+// How often, in seconds, should we heartbeat FFmpeg in two-way audio sessions. This should be less than 5 seconds, which is FFmpeg's input timeout interval.
+const TWOWAY_HEARTBEAT_INTERVAL = 3;
+/**
+ * Utility for demultiplexing RTP and RTCP packets on a single UDP port for HomeKit compatibility.
+ *
+ * FFmpeg does not support multiplexing RTP and RTCP data on a single UDP port (RFC 5761) and HomeKit requires this for livestreaming. This class listens on a UDP port
+ * and demultiplexes RTP and RTCP traffic, forwarding them to separate RTP and RTCP ports as required by FFmpeg.
+ *
+ * Credit to [dgreif](https://github.com/dgreif), [brandawg93](https://github.com/brandawg93), and [Sunoo](https://github.com/Sunoo) for foundational ideas and
+ * collaboration.
+ *
+ * @example
+ *
+ * ```ts
+ * // Create an RtpDemuxer to split packets for FFmpeg compatibility.
+ * const demuxer = new RtpDemuxer("ipv4", 50000, 50002, 50004, log);
+ *
+ * // Close the demuxer when finished.
+ * demuxer.close();
+ * ```
+ *
+ * @see {@link https://tools.ietf.org/html/rfc5761 | RFC 5761}
+ * @see {@link https://github.com/homebridge/homebridge-camera-ffmpeg | homebridge-camera-ffmpeg}
+ *
+ * @category FFmpeg
+ */
+export class RtpDemuxer extends EventEmitter {
+    heartbeatTimer;
+    heartbeatMsg;
+    _isRunning;
+    log;
+    inputPort;
+    socket;
+    /**
+     * Constructs a new RtpDemuxer for a specified IP family and port set.
+     *
+     * @param ipFamily         - The IP family: "ipv4" or "ipv6".
+     * @param inputPort        - The UDP port to listen on for incoming packets.
+     * @param rtcpPort         - The UDP port to forward RTCP packets to.
+     * @param rtpPort          - The UDP port to forward RTP packets to.
+     * @param log              - Logger instance for debug and error messages.
+     *
+     * @example
+     *
+     * ```ts
+     * const demuxer = new RtpDemuxer("ipv4", 50000, 50002, 50004, log);
+     * ```
+     */
+    constructor(ipFamily, inputPort, rtcpPort, rtpPort, log) {
+        super();
+        this._isRunning = false;
+        this.log = log;
+        this.inputPort = inputPort;
+        this.socket = createSocket(ipFamily === "ipv6" ? "udp6" : "udp4");
+        // Catch errors when they happen on our demuxer.
+        this.socket.on("error", (error) => {
+            this.log?.error("RtpDemuxer Error: %s", error);
+            this.socket.close();
+        });
+        // Split the message into RTP and RTCP packets.
+        this.socket.on("message", (msg) => {
+            // Send RTP packets to the RTP port.
+            if (this.isRtpMessage(msg)) {
+                this.emit("rtp");
+                this.socket.send(msg, rtpPort);
+            }
+            else {
+                // Save this RTCP message for heartbeat purposes for the RTP port. This works because RTCP packets will be ignored by ffmpeg on the RTP port, effectively
+                // providing a heartbeat to ensure FFmpeg doesn't timeout if there's an extended delay between data transmission.
+                this.heartbeatMsg = Buffer.from(msg);
+                // Clear the old heartbeat timer.
+                clearTimeout(this.heartbeatTimer);
+                this.heartbeat(rtpPort);
+                // RTCP control packets should go to the RTCP port.
+                this.socket.send(msg, rtcpPort);
+            }
+        });
+        this.log?.debug("Creating an RtpDemuxer instance - inbound port: %s, RTCP port: %s, RTP port: %s.", this.inputPort, rtcpPort, rtpPort);
+        // Take the socket live.
+        this.socket.bind(this.inputPort);
+        this._isRunning = true;
+    }
+    /**
+     * Sends periodic heartbeat messages to the RTP port to keep the FFmpeg process alive.
+     *
+     * This is necessary because FFmpeg times out input streams if it does not receive data for more than five seconds.
+     *
+     * @param port - The RTP port to send the heartbeat to.
+     */
+    heartbeat(port) {
+        // Clear the old heartbeat timer.
+        clearTimeout(this.heartbeatTimer);
+        // Send a heartbeat to FFmpeg every few seconds to keep things open. FFmpeg has a five-second timeout in reading input, and we want to be comfortably within the
+        // margin for error to ensure the process continues to run.
+        this.heartbeatTimer = setTimeout(() => {
+            this.log?.debug("Sending ffmpeg a heartbeat.");
+            this.socket.send(this.heartbeatMsg, port);
+            this.heartbeat(port);
+        }, TWOWAY_HEARTBEAT_INTERVAL * 1000);
+    }
+    /**
+     * Closes the demuxer, its socket, and any heartbeat timers.
+     *
+     * @example
+     *
+     * ```ts
+     * demuxer.close();
+     * ```
+     */
+    close() {
+        this.log?.debug("Closing the RtpDemuxer instance on port %s.", this.inputPort);
+        clearTimeout(this.heartbeatTimer);
+        this.socket.close();
+        this._isRunning = false;
+        this.emit("rtp");
+    }
+    /**
+     * Extracts the RTP payload type from a UDP packet.
+     *
+     * Used internally to distinguish RTP from RTCP messages.
+     *
+     * @param message - The UDP packet buffer.
+     *
+     * @returns The RTP payload type as a number.
+     */
+    getPayloadType(message) {
+        return message.readUInt8(1) & 0x7f;
+    }
+    /**
+     * Determines if the provided UDP packet is an RTP message.
+     *
+     * @param message - The UDP packet buffer.
+     *
+     * @returns `true` if the packet is RTP, `false` if RTCP.
+     */
+    isRtpMessage(message) {
+        const payloadType = this.getPayloadType(message);
+        return (payloadType > 90) || (payloadType === 0);
+    }
+    /**
+     * Indicates if the demuxer is running and accepting packets.
+     *
+     * @returns `true` if running, otherwise `false`.
+     *
+     * @example
+     *
+     * ```ts
+     * if(demuxer.isRunning) {
+     *   // Demuxer is active.
+     * }
+     * ```
+     */
+    get isRunning() {
+        return this._isRunning;
+    }
+}
+/**
+ * Allocates and tracks UDP ports for RTP and RTCP to avoid port conflicts in environments with high network activity.
+ *
+ * This utility class is used to find and reserve available UDP ports for demuxing FFmpeg streams or other network activities.
+ *
+ * @example
+ *
+ * ```ts
+ * const allocator = new RtpPortAllocator();
+ *
+ * // Reserve two consecutive ports for RTP and RTCP.
+ * const rtpPort = await allocator.reserve("ipv4", 2);
+ *
+ * // Cancel reservation if not needed.
+ * allocator.cancel(rtpPort);
+ * ```
+ *
+ * @category FFmpeg
+ */
+export class RtpPortAllocator {
+    portsInUse;
+    /**
+     * Instantiates a new RTP port allocator and tracker.
+     */
+    constructor() {
+        // Initialize our in use tracker.
+        this.portsInUse = {};
+    }
+    /**
+     * Finds an available UDP port by attempting to bind a new socket.
+     *
+     * Loops until an available port not already marked as in use is found.
+     *
+     * @param ipFamily         - "ipv4" or "ipv6".
+     * @param port             - Optional. The port to try to bind to. If 0, selects a random port.
+     *
+     * @returns A promise resolving to the available port number, or `-1` on error.
+     */
+    async getPort(ipFamily, port = 0) {
+        try {
+            // Keep looping until we find what we're looking for: local UDP ports that are unspoken for.
+            for (;;) {
+                // Create a datagram socket, so we can use it to find a port.
+                const socket = createSocket(ipFamily === "ipv6" ? "udp6" : "udp4");
+                // Exclude this socket from Node's reference counting so we don't have issues later.
+                socket.unref();
+                // Listen for the bind event.
+                const eventListener = once(socket, "listening");
+                // Bind to the port in question. If port is set to 0, we'll get a randomly generated port generated for us.
+                socket.bind(port);
+                // Ensure we wait for the socket to be bound.
+                // eslint-disable-next-line no-await-in-loop
+                await eventListener;
+                // Retrieve the port number we've gotten from the bind request.
+                const assignedPort = socket.address().port;
+                // We're done with the socket, let's cleanup.
+                socket.close();
+                // Check to see if the port is one we're already using. If it is, try again.
+                if (this.portsInUse[assignedPort]) {
+                    continue;
+                }
+                // Now let's mark the port in use.
+                this.portsInUse[assignedPort] = true;
+                // Return the port.
+                return assignedPort;
+            }
+        }
+        catch (error) {
+            return -1;
+        }
+    }
+    /**
+     * Internal method to reserve one or two consecutive UDP ports for FFmpeg or network use.
+     *
+     * If two ports are reserved, ensures they are consecutive for RTP and RTCP usage. Returns the first port in the sequence, or `-1` if we're unable to allocate.
+     *
+     * @param ipFamily         - Optional. "ipv4" or "ipv6". Defaults to "ipv4".
+     * @param portCount        - Optional. The number of consecutive ports to reserve (1 or 2). Defaults to 1.
+     * @param attempts         - Internal. The number of allocation attempts. Used for recursion.
+     *
+     * @returns A promise resolving to the first reserved port, or `-1` if unavailable.
+     */
+    async _reserve(ipFamily = "ipv4", portCount = 1, attempts = 0) {
+        // Sanity check and make sure we're not requesting any more than two ports at a time, or if we've exceeded our attempt limit.
+        if (![1, 2].includes(portCount) || (attempts > 10)) {
+            return -1;
+        }
+        let firstPort = 0;
+        // Find the appropriate number of ports being requested.
+        for (let i = 0; i < portCount; i++) {
+            // eslint-disable-next-line no-await-in-loop
+            const assignedPort = await this.getPort(ipFamily, firstPort ? firstPort + 1 : 0);
+            // We haven't gotten a port, let's try again.
+            if (assignedPort === -1) {
+                // If we've gotten the first port of a pair of ports, make sure we release it here.
+                if (firstPort) {
+                    this.cancel(firstPort);
+                }
+                // We still haven't found what we're looking for...keep looking.
+                return this._reserve(ipFamily, portCount, attempts++);
+            }
+            // We've seen the first port we may be looking for, let's save it.
+            if (!firstPort) {
+                firstPort = assignedPort;
+            }
+        }
+        // Return the first port we've found.
+        return firstPort;
+    }
+    /**
+     * Reserves one or two consecutive UDP ports for FFmpeg or network use.
+     *
+     * If two ports are reserved, ensures they are consecutive for RTP and RTCP usage. Returns the first port in the sequence, or `-1` if we're unable to allocate.
+     *
+     * @param ipFamily         - Optional. "ipv4" or "ipv6". Defaults to "ipv4".
+     * @param portCount        - Optional. The number of consecutive ports to reserve (1 or 2). Defaults to 1.
+     *
+     * @returns A promise resolving to the first reserved port, or `-1` if unavailable.
+     *
+     * @remarks FFmpeg currently lacks the ability to specify both the RTP and RTCP ports. FFmpeg always assumes, by convention, that when you specify an RTP port, the RTCP
+     * port is the RTP port + 1. In order to work around that challenge, we need to always ensure that when we reserve multiple ports for RTP (primarily for two-way audio
+     * use cases) that we we are reserving consecutive ports only.
+     *
+     * @example
+     *
+     * ```ts
+     * // Reserve a single port.
+     * const port = await allocator.reserve();
+     *
+     * // Reserve two consecutive ports for RTP/RTCP.
+     * const rtpPort = await allocator.reserve("ipv4", 2);
+     * ```
+     */
+    async reserve(ipFamily = "ipv4", portCount = 1) {
+        return this._reserve(ipFamily, portCount);
+    }
+    /**
+     * Cancels and releases a previously reserved port, making it available for future use.
+     *
+     * @param port - The port number to release.
+     *
+     * @example
+     *
+     * ```ts
+     * allocator.cancel(50000);
+     * ```
+     */
+    cancel(port) {
+        delete this.portsInUse[port];
+    }
+}
+//# sourceMappingURL=rtp.js.map

package/dist/ffmpeg/rtp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtp.js","sourceRoot":"","sources":["../../src/ffmpeg/rtp.ts"],"names":[],"mappings":"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"}

package/dist/ffmpeg/settings.d.ts

@@ -0,0 +1,6 @@
+export declare const HOMEKIT_IDR_INTERVAL = 5;
+export declare const HOMEKIT_STREAMING_HEADROOM = 64;
+export declare const HKSV_FRAGMENT_LENGTH = 4000;
+export declare const HKSV_IDR_INTERVAL = 4;
+export declare const HKSV_TIMEOUT = 4500;
+export declare const RPI_GPU_MINIMUM = 128;

package/dist/ffmpeg/settings.js

@@ -0,0 +1,17 @@
+/* Copyright(C) 2022-2025, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * ffmpeg/settings.ts: Settings and constants for HomeKit FFmpeg utilities.
+ */
+// HomeKit prefers an I-frame interval of 5 seconds when livestreaming.
+export const HOMEKIT_IDR_INTERVAL = 5;
+// Additional headroom for bitrates beyond what HomeKit is requesting when streaming to improve quality with a minor additional bandwidth cost.
+export const HOMEKIT_STREAMING_HEADROOM = 64;
+// HomeKit Secure Video fragment length, in milliseconds. HomeKit only supports this value currently.
+export const HKSV_FRAGMENT_LENGTH = 4000;
+// HomeKit prefers a default I-frame interval of 4 seconds for HKSV event recordings.
+export const HKSV_IDR_INTERVAL = 4;
+// HomeKit Secure Video communication timeout threshold, in milliseconds. HKSV has a strict 5 second threshold for communication, so we set this a little below that.
+export const HKSV_TIMEOUT = 4500;
+// Minimum required GPU memory on a Raspberry Pi to enable hardware acceleration.
+export const RPI_GPU_MINIMUM = 128;
+//# sourceMappingURL=settings.js.map

package/dist/ffmpeg/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../src/ffmpeg/settings.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,uEAAuE;AACvE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC,+IAA+I;AAC/I,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAE7C,qGAAqG;AACrG,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAEzC,qFAAqF;AACrF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC,qKAAqK;AACrK,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC;AAEjC,iFAAiF;AACjF,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC"}