node-av-light 0.0.0 → 7.1.0-beta.1

package/dist/lib/hardware-frames-context.js

@@ -0,0 +1,471 @@
+import { bindings } from './binding.js';
+import { HardwareDeviceContext } from './hardware-device-context.js';
+/**
+ * Hardware frames context for GPU memory management.
+ *
+ * Manages pools of hardware frames (textures/surfaces) on the GPU.
+ * Essential for zero-copy hardware acceleration, allowing frames to stay
+ * in GPU memory throughout the processing pipeline. Provides frame allocation,
+ * format conversion, and data transfer between hardware and system memory.
+ *
+ * Direct mapping to FFmpeg's AVHWFramesContext.
+ *
+ * @example
+ * ```typescript
+ * import { HardwareFramesContext, HardwareDeviceContext, Frame, FFmpegError } from 'node-av';
+ * import { AV_PIX_FMT_NV12, AV_PIX_FMT_CUDA, AV_HWDEVICE_TYPE_CUDA } from 'node-av/constants';
+ *
+ * // Create hardware frames context
+ * const device = new HardwareDeviceContext();
+ * device.create(AV_HWDEVICE_TYPE_CUDA);
+ *
+ * const frames = new HardwareFramesContext();
+ * frames.format = AV_PIX_FMT_CUDA;     // Hardware format
+ * frames.swFormat = AV_PIX_FMT_NV12;   // Software format
+ * frames.width = 1920;
+ * frames.height = 1080;
+ * frames.initialPoolSize = 20;         // Pre-allocate 20 frames
+ *
+ * frames.alloc(device);
+ * const ret = frames.init();
+ * FFmpegError.throwIfError(ret, 'init');
+ *
+ * // Allocate hardware frame
+ * const hwFrame = new Frame();
+ * const ret2 = frames.getBuffer(hwFrame, 0);
+ * FFmpegError.throwIfError(ret2, 'getBuffer');
+ *
+ * // Transfer from CPU to GPU
+ * const cpuFrame = new Frame();
+ * // ... fill cpuFrame with data ...
+ * await frames.transferData(hwFrame, cpuFrame);
+ *
+ * // Map hardware frame to CPU for access
+ * const mappedFrame = new Frame();
+ * const ret3 = frames.map(mappedFrame, hwFrame, AV_HWFRAME_MAP_READ);
+ * FFmpegError.throwIfError(ret3, 'map');
+ * ```
+ *
+ * @see [AVHWFramesContext](https://ffmpeg.org/doxygen/trunk/structAVHWFramesContext.html) - FFmpeg Doxygen
+ * @see {@link HardwareDeviceContext} For device management
+ * @see {@link Frame} For frame operations
+ */
+export class HardwareFramesContext {
+    native;
+    constructor() {
+        this.native = new bindings.HardwareFramesContext();
+    }
+    /**
+     * Hardware pixel format.
+     *
+     * The pixel format used for frames in GPU memory.
+     * Hardware-specific format like AV_PIX_FMT_CUDA or AV_PIX_FMT_VAAPI.
+     *
+     * Direct mapping to AVHWFramesContext->format.
+     */
+    get format() {
+        return this.native.format;
+    }
+    set format(value) {
+        this.native.format = value;
+    }
+    /**
+     * Software pixel format.
+     *
+     * The pixel format frames are converted to when transferred
+     * to system memory. Standard format like AV_PIX_FMT_YUV420P.
+     *
+     * Direct mapping to AVHWFramesContext->sw_format.
+     */
+    get swFormat() {
+        return this.native.swFormat;
+    }
+    set swFormat(value) {
+        this.native.swFormat = value;
+    }
+    /**
+     * Frame width.
+     *
+     * Width of frames in pixels.
+     *
+     * Direct mapping to AVHWFramesContext->width.
+     */
+    get width() {
+        return this.native.width;
+    }
+    set width(value) {
+        this.native.width = value;
+    }
+    /**
+     * Frame height.
+     *
+     * Height of frames in pixels.
+     *
+     * Direct mapping to AVHWFramesContext->height.
+     */
+    get height() {
+        return this.native.height;
+    }
+    set height(value) {
+        this.native.height = value;
+    }
+    /**
+     * Initial pool size.
+     *
+     * Number of frames to pre-allocate in the pool.
+     * Set before calling init() for optimal performance.
+     *
+     * Direct mapping to AVHWFramesContext->initial_pool_size.
+     */
+    get initialPoolSize() {
+        return this.native.initialPoolSize;
+    }
+    set initialPoolSize(value) {
+        this.native.initialPoolSize = value;
+    }
+    /**
+     * Associated hardware device.
+     *
+     * Reference to the device context this frames context belongs to.
+     * Automatically set when calling alloc().
+     *
+     * Direct mapping to AVHWFramesContext->device_ref.
+     */
+    get deviceRef() {
+        // Not cached: device_ref is unset before alloc(), and the native wrapper holds
+        // its own AVBufferRef, so a fresh wrapper per access is safe
+        const native = this.native.deviceRef;
+        if (!native) {
+            return null;
+        }
+        const device = Object.create(HardwareDeviceContext.prototype);
+        device.native = native;
+        return device;
+    }
+    /**
+     * Allocate hardware frames context.
+     *
+     * Allocates the frames context and associates it with a device.
+     * Must be called before init().
+     *
+     * Direct mapping to av_hwframe_ctx_alloc().
+     *
+     * @param device - Hardware device context to use
+     *
+     * @throws {Error} If allocation fails (ENOMEM)
+     *
+     * @example
+     * ```typescript
+     * import { AV_PIX_FMT_CUDA, AV_PIX_FMT_NV12 } from 'node-av/constants';
+     *
+     * const frames = new HardwareFramesContext();
+     * frames.format = AV_PIX_FMT_CUDA;
+     * frames.swFormat = AV_PIX_FMT_NV12;
+     * frames.width = 1920;
+     * frames.height = 1080;
+     * frames.alloc(device);
+     * ```
+     *
+     * @see {@link init} To initialize after allocation
+     */
+    alloc(device) {
+        this.native.alloc(device.getNative());
+    }
+    /**
+     * Initialize hardware frames context.
+     *
+     * Initializes the frame pool after configuration.
+     * Must be called after alloc() and property setup.
+     *
+     * Direct mapping to av_hwframe_ctx_init().
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *   - AVERROR_ENOSYS: Operation not supported
+     *   - Hardware-specific errors
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * frames.alloc(device);
+     * const ret = frames.init();
+     * FFmpegError.throwIfError(ret, 'init');
+     * ```
+     *
+     * @see {@link alloc} Must be called first
+     */
+    init() {
+        return this.native.init();
+    }
+    /**
+     * Free hardware frames context.
+     *
+     * Releases all frames and resources associated with the context.
+     * The context becomes invalid after calling this.
+     *
+     * Direct mapping to av_buffer_unref() on frames context.
+     *
+     * @example
+     * ```typescript
+     * frames.free();
+     * // Frames context is now invalid
+     * ```
+     *
+     * @see {@link Symbol.dispose} For automatic cleanup
+     */
+    free() {
+        this.native.free();
+    }
+    /**
+     * Allocate hardware frame from pool.
+     *
+     * Gets a frame from the hardware frame pool.
+     * The frame will have hardware-backed storage.
+     *
+     * Direct mapping to av_hwframe_get_buffer().
+     *
+     * @param frame - Frame to allocate buffer for
+     *
+     * @param flags - Allocation flags (usually 0)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_ENOMEM: No frames available in pool
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { Frame, FFmpegError } from 'node-av';
+     *
+     * const hwFrame = new Frame();
+     * const ret = frames.getBuffer(hwFrame, 0);
+     * FFmpegError.throwIfError(ret, 'getBuffer');
+     * // hwFrame now has GPU memory allocated
+     * ```
+     *
+     * @see {@link transferData} To upload data to hardware frame
+     */
+    getBuffer(frame, flags) {
+        return this.native.getBuffer(frame.getNative(), flags ?? 0);
+    }
+    /**
+     * Transfer data between hardware and system memory.
+     *
+     * Copies frame data between GPU and CPU memory.
+     * Direction is determined by frame types.
+     *
+     * Direct mapping to av_hwframe_transfer_data().
+     *
+     * @param dst - Destination frame
+     *
+     * @param src - Source frame
+     *
+     * @param flags - Transfer flags (usually 0)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOSYS: Transfer not supported
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Upload: CPU -> GPU
+     * const cpuFrame = new Frame();
+     * // ... fill cpuFrame with data ...
+     * const hwFrame = new Frame();
+     * frames.getBuffer(hwFrame, 0);
+     * const ret = await frames.transferData(hwFrame, cpuFrame);
+     * FFmpegError.throwIfError(ret, 'transferData');
+     *
+     * // Download: GPU -> CPU
+     * const downloadFrame = new Frame();
+     * const ret2 = await frames.transferData(downloadFrame, hwFrame);
+     * FFmpegError.throwIfError(ret2, 'transferData');
+     * ```
+     *
+     * @see {@link getBuffer} To allocate hardware frame
+     * @see {@link map} For zero-copy access
+     */
+    async transferData(dst, src, flags) {
+        return await this.native.transferData(dst.getNative(), src.getNative(), flags ?? 0);
+    }
+    /**
+     * Transfer frame between hardware and system memory synchronously.
+     * Synchronous version of transferData.
+     *
+     * Copies frame data between GPU and CPU memory.
+     * Direction depends on frame types (hardware vs software).
+     *
+     * Direct mapping to av_hwframe_transfer_data().
+     *
+     * @param dst - Destination frame
+     *
+     * @param src - Source frame
+     *
+     * @param flags - Transfer flags (currently unused, pass 0)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid frames
+     *   - AVERROR_ENOSYS: Operation not supported
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { Frame, FFmpegError } from 'node-av';
+     *
+     * // Download from GPU to CPU
+     * const cpuFrame = new Frame();
+     * cpuFrame.format = frames.swFormat;
+     * cpuFrame.width = frames.width;
+     * cpuFrame.height = frames.height;
+     * cpuFrame.allocBuffer();
+     *
+     * const ret = frames.transferDataSync(cpuFrame, hwFrame);
+     * FFmpegError.throwIfError(ret, 'transferDataSync');
+     *
+     * // Upload from CPU to GPU
+     * const ret2 = frames.transferDataSync(hwFrame, cpuFrame);
+     * FFmpegError.throwIfError(ret2, 'transferDataSync');
+     * ```
+     *
+     * @see {@link transferData} For async version
+     */
+    transferDataSync(dst, src, flags) {
+        return this.native.transferDataSync(dst.getNative(), src.getNative(), flags ?? 0);
+    }
+    /**
+     * Get supported transfer formats.
+     *
+     * Returns pixel formats supported for frame transfer
+     * in the specified direction.
+     *
+     * Direct mapping to av_hwframe_transfer_get_formats().
+     *
+     * @param direction - Transfer direction (FROM/TO hardware)
+     *
+     * @returns Array of supported formats, or error code:
+     *   - AVERROR_ENOSYS: Query not supported
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { AV_HWFRAME_TRANSFER_DIRECTION_FROM } from 'node-av/constants';
+     *
+     * const formats = frames.transferGetFormats(AV_HWFRAME_TRANSFER_DIRECTION_FROM);
+     * if (Array.isArray(formats)) {
+     *   console.log('Supported download formats:', formats);
+     * } else {
+     *   console.error('Error querying formats:', formats);
+     * }
+     * ```
+     */
+    transferGetFormats(direction) {
+        return this.native.transferGetFormats(direction);
+    }
+    /**
+     * Map hardware frame to system memory.
+     *
+     * Creates a mapping of hardware frame data accessible from CPU.
+     * More efficient than transferData() for read-only access.
+     *
+     * Direct mapping to av_hwframe_map().
+     *
+     * @param dst - Destination frame for mapped data
+     *
+     * @param src - Hardware frame to map
+     *
+     * @param flags - Mapping flags (AV_HWFRAME_MAP_*)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOSYS: Mapping not supported
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AV_HWFRAME_MAP_READ } from 'node-av/constants';
+     *
+     * const mappedFrame = new Frame();
+     * const ret = frames.map(mappedFrame, hwFrame, AV_HWFRAME_MAP_READ);
+     * FFmpegError.throwIfError(ret, 'map');
+     * // Can now read hwFrame data through mappedFrame
+     * ```
+     *
+     * @see {@link transferData} For full data copy
+     */
+    map(dst, src, flags) {
+        return this.native.map(dst.getNative(), src.getNative(), flags ?? 0);
+    }
+    /**
+     * Create derived frames context.
+     *
+     * Creates a new frames context derived from another,
+     * potentially on a different device.
+     *
+     * Direct mapping to av_hwframe_ctx_create_derived().
+     *
+     * @param format - Pixel format for derived frames
+     *
+     * @param derivedDevice - Target device context
+     *
+     * @param source - Source frames context
+     *
+     * @param flags - Creation flags
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOSYS: Derivation not supported
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AV_PIX_FMT_VULKAN } from 'node-av/constants';
+     *
+     * const derivedFrames = new HardwareFramesContext();
+     * const ret = derivedFrames.createDerived(
+     *   AV_PIX_FMT_VULKAN,
+     *   vulkanDevice,
+     *   cudaFrames,
+     *   0
+     * );
+     * FFmpegError.throwIfError(ret, 'createDerived');
+     * ```
+     */
+    createDerived(format, derivedDevice, source, flags) {
+        return this.native.createDerived(format, derivedDevice.getNative(), source.native, flags ?? 0);
+    }
+    /**
+     * Get the underlying native HardwareFramesContext object.
+     *
+     * @returns The native HardwareFramesContext binding object
+     *
+     * @internal
+     */
+    getNative() {
+        return this.native;
+    }
+    /**
+     * Dispose of the hardware frames context.
+     *
+     * Implements the Disposable interface for automatic cleanup.
+     * Equivalent to calling free().
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using frames = new HardwareFramesContext();
+     *   frames.alloc(device);
+     *   frames.init();
+     *   // Use frames...
+     * } // Automatically freed when leaving scope
+     * ```
+     */
+    [Symbol.dispose]() {
+        this.native[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=hardware-frames-context.js.map

package/dist/lib/hardware-frames-context.js.map

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

package/dist/lib/index.d.ts

@@ -0,0 +1,35 @@
+export type * from './types.js';
+export { FormatContext, type RTSPStreamInfo } from './format-context.js';
+export { CodecContext } from './codec-context.js';
+export { CodecParameters } from './codec-parameters.js';
+export { Codec, type CodecProfile } from './codec.js';
+export { CodecParser } from './codec-parser.js';
+export { Packet } from './packet.js';
+export { Frame, type AudioFrame, type D3D11TextureFrame, type DmaBufFrame, type DmaBufPlanes, type IOSurfaceFrame, type NSImageFrame, type VideoFrame } from './frame.js';
+export { Stream } from './stream.js';
+export { InputFormat } from './input-format.js';
+export { OutputFormat } from './output-format.js';
+export { HardwareDeviceContext } from './hardware-device-context.js';
+export { HardwareFramesContext } from './hardware-frames-context.js';
+export { SoftwareScaleContext } from './software-scale-context.js';
+export { SoftwareResampleContext } from './software-resample-context.js';
+export { AudioFifo } from './audio-fifo.js';
+export { Fifo } from './fifo.js';
+export { FrameUtils, type ImageCrop, type ImageFormat, type ImageOptions, type ImageOutputFormat, type ImageResize } from './frame-utils.js';
+export { IOContext } from './io-context.js';
+export { Dictionary } from './dictionary.js';
+export { Option, OptionInfo, type OptionMember } from './option.js';
+export { SyncQueue, SyncQueueType } from './sync-queue.js';
+export { FilterContext } from './filter-context.js';
+export { FilterGraphSegment } from './filter-graph-segment.js';
+export { FilterGraph } from './filter-graph.js';
+export { FilterInOut } from './filter-inout.js';
+export { Filter, type FilterPad } from './filter.js';
+export { BitStreamFilterContext } from './bitstream-filter-context.js';
+export { BitStreamFilter } from './bitstream-filter.js';
+export { Rational } from './rational.js';
+export { Log, type LogOptions } from './log.js';
+export { Device, type AudioDeviceInfo, type AudioDeviceMode, type BaseDeviceInfo, type DeviceInfo, type DeviceMode, type ScreenBounds, type ScreenDeviceInfo, type VideoDeviceInfo, } from './device.js';
+export { FFmpegError, PosixError } from './error.js';
+export * from './utilities.js';
+export type { OptionCapableObject } from './binding.js';

package/dist/lib/index.js

@@ -0,0 +1,60 @@
+// Format Context
+export { FormatContext } from './format-context.js';
+// Codec Context
+export { CodecContext } from './codec-context.js';
+// Codec Parameters
+export { CodecParameters } from './codec-parameters.js';
+// Codec
+export { Codec } from './codec.js';
+// Codec Parser
+export { CodecParser } from './codec-parser.js';
+// Packet
+export { Packet } from './packet.js';
+// Frame
+export { Frame } from './frame.js';
+// Stream
+export { Stream } from './stream.js';
+// Input/Output Format
+export { InputFormat } from './input-format.js';
+export { OutputFormat } from './output-format.js';
+// Hardware related classes
+export { HardwareDeviceContext } from './hardware-device-context.js';
+export { HardwareFramesContext } from './hardware-frames-context.js';
+// Software Scale
+export { SoftwareScaleContext } from './software-scale-context.js';
+// Software Resample
+export { SoftwareResampleContext } from './software-resample-context.js';
+// Audio FIFO
+export { AudioFifo } from './audio-fifo.js';
+// Generic FIFO
+export { Fifo } from './fifo.js';
+// Frame Utils
+export { FrameUtils } from './frame-utils.js';
+// I/O Context
+export { IOContext } from './io-context.js';
+// Dictionary
+export { Dictionary } from './dictionary.js';
+// Option
+export { Option, OptionInfo } from './option.js';
+// Sync Queue
+export { SyncQueue, SyncQueueType } from './sync-queue.js';
+// Filter related classes
+export { FilterContext } from './filter-context.js';
+export { FilterGraphSegment } from './filter-graph-segment.js';
+export { FilterGraph } from './filter-graph.js';
+export { FilterInOut } from './filter-inout.js';
+export { Filter } from './filter.js';
+// Bitstream Filter related classes
+export { BitStreamFilterContext } from './bitstream-filter-context.js';
+export { BitStreamFilter } from './bitstream-filter.js';
+// Utils
+export { Rational } from './rational.js';
+// Logging
+export { Log } from './log.js';
+// Device
+export { Device, } from './device.js';
+// Error handling
+export { FFmpegError, PosixError } from './error.js';
+// Utilities
+export * from './utilities.js';
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAEA,iBAAiB;AACjB,OAAO,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AAEzE,gBAAgB;AAChB,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,mBAAmB;AACnB,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,QAAQ;AACR,OAAO,EAAE,KAAK,EAAqB,MAAM,YAAY,CAAC;AAEtD,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,SAAS;AACT,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,QAAQ;AACR,OAAO,EAAE,KAAK,EAAyI,MAAM,YAAY,CAAC;AAE1K,SAAS;AACT,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,sBAAsB;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,iBAAiB;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,oBAAoB;AACpB,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEzE,aAAa;AACb,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,eAAe;AACf,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,cAAc;AACd,OAAO,EAAE,UAAU,EAAiG,MAAM,kBAAkB,CAAC;AAE7I,cAAc;AACd,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,aAAa;AACb,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,SAAS;AACT,OAAO,EAAE,MAAM,EAAE,UAAU,EAAqB,MAAM,aAAa,CAAC;AAEpE,aAAa;AACb,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE3D,yBAAyB;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAkB,MAAM,aAAa,CAAC;AAErD,mCAAmC;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,QAAQ;AACR,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,UAAU;AACV,OAAO,EAAE,GAAG,EAAmB,MAAM,UAAU,CAAC;AAEhD,SAAS;AACT,OAAO,EACL,MAAM,GASP,MAAM,aAAa,CAAC;AAErB,iBAAiB;AACjB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY;AACZ,cAAc,gBAAgB,CAAC"}