@mediabunny/server 1.45.0

package/dist/modules/src/video-encoder.js

@@ -0,0 +1,474 @@
+"use strict";
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeAvVideoEncoder = void 0;
+const mediabunny_1 = require("mediabunny");
+const NodeAv = __importStar(require("node-av"));
+const misc_1 = require("./misc");
+const video_sample_1 = require("./video-sample");
+const codec_data_1 = require("../../../src/codec-data");
+const codec_1 = require("../../../src/codec");
+const misc_2 = require("../../../src/misc");
+class NodeAvVideoEncoder extends mediabunny_1.CustomVideoEncoder {
+    constructor() {
+        super(...arguments);
+        this.codecContext = null;
+        this.lastBuffer = null;
+        this.packetEmitted = false;
+        this.scaler = null;
+        this.lastScalerKey = null;
+        this.dstFrame = null;
+        // Bookkeeping to restore the original timing information
+        this.preciseTimings = [];
+    }
+    static supports(codec, config) {
+        return (codec === 'avc' || codec === 'hevc' || codec === 'vp8' || codec === 'vp9' || codec === 'av1')
+            && config.bitrateMode !== 'quantizer';
+    }
+    async init() {
+        this.frame = new NodeAv.Frame();
+        this.frame.alloc();
+        this.frame.timeBase = new NodeAv.Rational(1, 1e6);
+        this.packet = new NodeAv.Packet();
+        this.packet.alloc();
+        const codecId = misc_1.CODEC_TO_CODEC_ID[this.codec];
+        (0, misc_2.assert)(codecId !== undefined);
+        let codec = null;
+        if (this.codec === 'vp9' && this.config.alpha === 'keep') {
+            codec = NodeAv.Codec.findEncoderByName(misc_1.LIBVPX_VP9) ?? NodeAv.Codec.findEncoder(codecId);
+        }
+        else if (this.config.hardwareAcceleration === 'prefer-software') {
+            codec = NodeAv.Codec.findEncoder(codecId);
+        }
+        else {
+            codec = (0, misc_1.getHardwareEncoderCodec)(codecId) ?? NodeAv.Codec.findEncoder(codecId);
+        }
+        if (!codec) {
+            throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
+        }
+        this.avCodec = codec;
+        await this.createCodecContext();
+    }
+    async createCodecContext() {
+        (0, misc_2.assert)(this.codecContext === null);
+        const codecContext = new NodeAv.CodecContext();
+        codecContext.allocContext3(this.avCodec);
+        let pixelFormat = NodeAv.AV_PIX_FMT_YUV420P;
+        if (this.avCodec.pixelFormats) {
+            if (!this.avCodec.pixelFormats.includes(NodeAv.AV_PIX_FMT_YUV420P)) {
+                pixelFormat = this.avCodec.pixelFormats[0];
+            }
+            if (this.config.alpha === 'keep' && this.avCodec.pixelFormats.includes(NodeAv.AV_PIX_FMT_YUVA420P)) {
+                pixelFormat = NodeAv.AV_PIX_FMT_YUVA420P;
+            }
+        }
+        const pixelAspectRatio = (0, misc_2.simplifyRational)({
+            num: (this.config.displayWidth ?? this.config.width) * this.config.height,
+            den: (this.config.displayHeight ?? this.config.height) * this.config.width,
+        });
+        codecContext.width = this.config.width;
+        codecContext.height = this.config.height;
+        codecContext.pixelFormat = pixelFormat;
+        codecContext.timeBase = new NodeAv.Rational(1, 1e6);
+        codecContext.gopSize = 60;
+        codecContext.framerate = new NodeAv.Rational(Math.round(this.config.framerate ?? 0) || 30, 1);
+        codecContext.bitRate = BigInt(this.config.bitrate ?? mediabunny_1.QUALITY_MEDIUM._toVideoBitrate(this.codec, this.config.width, this.config.height));
+        codecContext.sampleAspectRatio = new NodeAv.Rational(pixelAspectRatio.num, pixelAspectRatio.den);
+        if (this.config.bitrateMode === 'constant') {
+            codecContext.rcMinRate = codecContext.bitRate;
+            codecContext.rcMaxRate = codecContext.bitRate;
+        }
+        const isRealtime = this.config.latencyMode === 'realtime';
+        if (this.avCodec.name === 'libx264') {
+            if (isRealtime) {
+                codecContext.setOption('tune', 'zerolatency');
+                codecContext.setOption('preset', 'ultrafast');
+            }
+        }
+        else if (this.avCodec.name === 'libx265') {
+            codecContext.setOption('x265-params', 'log-level=error');
+            if (isRealtime) {
+                codecContext.setOption('tune', 'zerolatency');
+                codecContext.setOption('preset', 'ultrafast');
+            }
+        }
+        else if (this.avCodec.name === 'libvpx') {
+            if (isRealtime) {
+                codecContext.setOption('deadline', 'realtime');
+                codecContext.setOption('cpu-used', '8');
+            }
+            else {
+                codecContext.setOption('cpu-used', '8');
+            }
+        }
+        else if (this.avCodec.name === 'libvpx-vp9') {
+            codecContext.setOption('deadline', 'realtime');
+            if (isRealtime) {
+                codecContext.setOption('cpu-used', '8');
+            }
+            else {
+                codecContext.setOption('cpu-used', '5');
+            }
+        }
+        else if (this.avCodec.name === 'libsvtav1') {
+            // SVTAV1 can be silenced by setting an environment variable:
+            // https://superuser.com/questions/1775236/how-to-remove-svt-av1-information-from-ffmpeg-output
+            process.env['SVT_LOG'] = '1';
+            if (isRealtime) {
+                codecContext.setOption('preset', '12');
+            }
+        }
+        const ret = await codecContext.open2();
+        NodeAv.FFmpegError.throwIfError(ret, 'Open codec context');
+        this.codecContext = codecContext;
+    }
+    async encode(videoSample, options) {
+        if (this.codecContext === null) {
+            await this.createCodecContext();
+            (0, misc_2.assert)(this.codecContext);
+        }
+        if (videoSample._data instanceof video_sample_1.AvFrameVideoSampleResource) {
+            this.frame.ref(videoSample._data.frame);
+        }
+        else {
+            if (videoSample.format === null) {
+                throw new Error('Cannot encode foreign VideoSample with unknown (null) format.');
+            }
+            this.lastBuffer = await (0, video_sample_1.copyVideoSampleToAvFrame)(videoSample, this.frame, this.lastBuffer);
+        }
+        let frameToEncode = this.frame;
+        const requiresScaler = this.codecContext.pixelFormat !== this.frame.format
+            || this.codecContext.width !== this.frame.width
+            || this.codecContext.height !== this.frame.height;
+        if (requiresScaler) {
+            if (!this.scaler) {
+                this.scaler = new NodeAv.SoftwareScaleContext();
+            }
+            const key = `${this.frame.width}x${this.frame.height}:${this.frame.format}`;
+            const needsConfigure = key !== this.lastScalerKey;
+            if (needsConfigure) {
+                this.scaler.getContext(this.frame.width, this.frame.height, this.frame.format, this.codecContext.width, this.codecContext.height, this.codecContext.pixelFormat, NodeAv.SWS_FAST_BILINEAR);
+                this.lastScalerKey = key;
+                const ret = this.scaler.initContext();
+                NodeAv.FFmpegError.throwIfError(ret, 'initContext');
+            }
+            if (!this.dstFrame) {
+                this.dstFrame = new NodeAv.Frame();
+                this.dstFrame.alloc();
+                this.dstFrame.width = this.codecContext.width;
+                this.dstFrame.height = this.codecContext.height;
+                this.dstFrame.format = this.codecContext.pixelFormat;
+                this.dstFrame.allocBuffer();
+            }
+            await this.scaler.scaleFrame(this.dstFrame, this.frame);
+            this.dstFrame.copyProps(this.frame);
+            frameToEncode = this.dstFrame;
+        }
+        frameToEncode.pts = BigInt(videoSample.microsecondTimestamp);
+        frameToEncode.duration = BigInt(videoSample.microsecondDuration);
+        frameToEncode.timeBase = new NodeAv.Rational(1, 1e6);
+        // Let's just set both for good measure
+        frameToEncode.pictType = options?.keyFrame
+            ? NodeAv.AV_PICTURE_TYPE_I
+            : NodeAv.AV_PICTURE_TYPE_NONE;
+        frameToEncode.keyFrame = options?.keyFrame
+            ? 1
+            : 0;
+        const preciseTimingIndex = (0, misc_2.binarySearchLessOrEqual)(this.preciseTimings, videoSample.microsecondTimestamp, x => x.microsecondTimestamp);
+        const existingEntry = preciseTimingIndex !== -1
+            ? this.preciseTimings[preciseTimingIndex]
+            : null;
+        if (existingEntry && existingEntry.microsecondTimestamp === videoSample.microsecondTimestamp) {
+            if (existingEntry.timestamp !== videoSample.timestamp) {
+                // Mapping isn't unique, can't use the timestamp
+                existingEntry.timestampIsValid = false;
+            }
+            if (existingEntry.duration !== videoSample.duration) {
+                // Mapping isn't unique, can't use the duration
+                existingEntry.durationIsValid = false;
+            }
+        }
+        else {
+            this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+                microsecondTimestamp: videoSample.microsecondTimestamp,
+                timestamp: videoSample.timestamp,
+                duration: videoSample.duration,
+                timestampIsValid: true,
+                durationIsValid: true,
+            });
+            // Make sure it doesn't grow indefinitely
+            if (this.preciseTimings.length > 128) {
+                this.preciseTimings.shift();
+            }
+        }
+        const ret = await this.codecContext.sendFrame(frameToEncode);
+        NodeAv.FFmpegError.throwIfError(ret, 'Send frame');
+        // Keep receiving packets until no more are available for this frame
+        while (true) {
+            const receiveRet = await this.codecContext.receivePacket(this.packet);
+            if (receiveRet === NodeAv.AVERROR_EAGAIN || receiveRet === NodeAv.AVERROR_EOF) {
+                break;
+            }
+            this.receivePacket(receiveRet);
+        }
+    }
+    receivePacket(ret) {
+        (0, misc_2.assert)(this.codecContext);
+        NodeAv.FFmpegError.throwIfError(ret, 'Receive packet');
+        if (!this.packet.data) {
+            return;
+        }
+        let packetData = (0, misc_2.toUint8Array)(this.packet.data);
+        let timestamp = Number(this.packet.pts) / 1e6;
+        let duration = Number(this.packet.duration) / 1e6;
+        const preciseTimingIndex = (0, misc_2.binarySearchLessOrEqual)(this.preciseTimings, Number(this.packet.pts), x => x.microsecondTimestamp);
+        const entry = preciseTimingIndex !== -1
+            ? this.preciseTimings[preciseTimingIndex]
+            : null;
+        // If there's a relevant timing entry, refine the packet's timing data to get better accuracy than
+        // microseconds
+        if (entry && entry.microsecondTimestamp === Number(this.packet.pts)) {
+            if (entry.timestampIsValid) {
+                timestamp = entry.timestamp;
+            }
+            if (entry.durationIsValid) {
+                duration = entry.duration;
+            }
+        }
+        const metadata = {};
+        let decoderConfigCodecString = null;
+        let decoderConfigDescription = null;
+        if (this.codec === 'avc' || this.codec === 'hevc') {
+            let expectsAnnexB = false;
+            if (this.codec === 'avc') {
+                expectsAnnexB = this.config.avc?.format === 'annexb';
+            }
+            else {
+                // eslint-disable-next-line @stylistic/max-len
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+                expectsAnnexB = this.config.hevc?.format === 'annexb';
+            }
+            if (!this.packetEmitted) {
+                let serializedRecord;
+                if (this.codec === 'avc') {
+                    const record = (0, codec_data_1.extractAvcDecoderConfigurationRecord)(this.packet.data);
+                    if (!record) {
+                        throw new Error('Invalid AVC data, could not extract decoder configuration record.');
+                    }
+                    serializedRecord = (0, codec_data_1.serializeAvcDecoderConfigurationRecord)(record);
+                }
+                else {
+                    const record = (0, codec_data_1.extractHevcDecoderConfigurationRecord)(this.packet.data);
+                    if (!record) {
+                        throw new Error('Invalid HEVC data, could not extract decoder configuration record.');
+                    }
+                    serializedRecord = (0, codec_data_1.serializeHevcDecoderConfigurationRecord)(record);
+                }
+                decoderConfigCodecString = (0, codec_1.extractVideoCodecString)({
+                    width: this.config.width,
+                    height: this.config.height,
+                    codec: this.codec,
+                    codecDescription: serializedRecord,
+                    colorSpace: null,
+                    avcType: 1,
+                    avcCodecInfo: null,
+                    hevcCodecInfo: null,
+                    vp9CodecInfo: null,
+                    av1CodecInfo: null,
+                });
+                if (!expectsAnnexB) {
+                    decoderConfigDescription = serializedRecord;
+                }
+            }
+            if (!expectsAnnexB) {
+                const NAL_UNIT_LENGTH_SIZE = 4;
+                const nalUnits = [];
+                for (const loc of (0, codec_data_1.iterateNalUnitsInAnnexB)(packetData)) {
+                    if (this.codec === 'avc') {
+                        const naluType = (0, codec_data_1.extractNalUnitTypeForAvc)(packetData[loc.offset]);
+                        // Certain NALUs get stripped
+                        if (naluType !== codec_data_1.AvcNalUnitType.SPS
+                            && naluType !== codec_data_1.AvcNalUnitType.PPS
+                            && naluType !== codec_data_1.AvcNalUnitType.SPS_EXT) {
+                            nalUnits.push(loc);
+                        }
+                    }
+                    else {
+                        const naluType = (0, codec_data_1.extractNalUnitTypeForHevc)(packetData[loc.offset]);
+                        // Certain NALUs get stripped
+                        if (naluType !== codec_data_1.HevcNalUnitType.SPS_NUT
+                            && naluType !== codec_data_1.HevcNalUnitType.PPS_NUT
+                            && naluType !== codec_data_1.HevcNalUnitType.VPS_NUT) {
+                            nalUnits.push(loc);
+                        }
+                    }
+                }
+                let totalSize = 0;
+                for (const nalUnit of nalUnits) {
+                    totalSize += NAL_UNIT_LENGTH_SIZE + nalUnit.length;
+                }
+                const lengthPrefixedData = new Uint8Array(totalSize);
+                const dataView = new DataView(lengthPrefixedData.buffer);
+                let offset = 0;
+                // Write each NAL unit with its length prefix
+                for (const nalUnit of nalUnits) {
+                    const length = nalUnit.length;
+                    dataView.setUint32(offset, length, false);
+                    offset += 4;
+                    lengthPrefixedData.set(packetData.subarray(nalUnit.offset, nalUnit.offset + nalUnit.length), offset);
+                    offset += nalUnit.length;
+                }
+                packetData = lengthPrefixedData;
+            }
+        }
+        else if (this.codec === 'vp8') {
+            if (!this.packetEmitted) {
+                decoderConfigCodecString = (0, codec_1.extractVideoCodecString)({
+                    width: this.config.width,
+                    height: this.config.height,
+                    codec: 'vp8',
+                    codecDescription: null,
+                    colorSpace: null,
+                    avcType: null,
+                    avcCodecInfo: null,
+                    hevcCodecInfo: null,
+                    vp9CodecInfo: null,
+                    av1CodecInfo: null,
+                });
+            }
+        }
+        else if (this.codec === 'vp9') {
+            if (!this.packetEmitted) {
+                const vp9CodecInfo = (0, codec_data_1.extractVp9CodecInfoFromPacket)(packetData);
+                decoderConfigCodecString = (0, codec_1.extractVideoCodecString)({
+                    width: this.config.width,
+                    height: this.config.height,
+                    codec: 'vp9',
+                    codecDescription: null,
+                    colorSpace: null,
+                    avcType: null,
+                    avcCodecInfo: null,
+                    hevcCodecInfo: null,
+                    vp9CodecInfo,
+                    av1CodecInfo: null,
+                });
+            }
+        }
+        else if (this.codec === 'av1') {
+            if (!this.packetEmitted) {
+                const av1CodecInfo = (0, codec_data_1.extractAv1CodecInfoFromPacket)(packetData);
+                decoderConfigCodecString = (0, codec_1.extractVideoCodecString)({
+                    width: this.config.width,
+                    height: this.config.height,
+                    codec: 'av1',
+                    codecDescription: null,
+                    colorSpace: null,
+                    avcType: null,
+                    avcCodecInfo: null,
+                    hevcCodecInfo: null,
+                    vp9CodecInfo: null,
+                    av1CodecInfo,
+                });
+            }
+        }
+        else {
+            throw new Error('Unreachable.');
+        }
+        const sideData = {};
+        const matroskaBlockAdditional = this.packet.getSideData(NodeAv.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL);
+        if (matroskaBlockAdditional) {
+            sideData.alpha = (0, misc_2.toUint8Array)(matroskaBlockAdditional).subarray(8); // Skip the BlockAddId
+        }
+        const packet = new mediabunny_1.EncodedPacket(packetData, this.packet.isKeyframe ? 'key' : 'delta', timestamp, duration, undefined, undefined, sideData);
+        if (decoderConfigCodecString !== null) {
+            // Create the decoder config
+            metadata.decoderConfig = {
+                codec: decoderConfigCodecString,
+                codedWidth: this.codecContext.width,
+                codedHeight: this.codecContext.height,
+                displayAspectWidth: this.config.displayWidth ?? this.codecContext.width,
+                displayAspectHeight: this.config.displayHeight ?? this.codecContext.height,
+                description: decoderConfigDescription ?? undefined,
+                colorSpace: {
+                    primaries: (0, misc_1.unmapColorPrimaries)(this.codecContext.colorPrimaries),
+                    matrix: (0, misc_1.unmapMatrixCoefficients)(this.codecContext.colorSpace),
+                    transfer: (0, misc_1.unmapTransferCharacteristics)(this.codecContext.colorTrc),
+                    fullRange: this.codecContext.colorRange === NodeAv.AVCOL_RANGE_JPEG
+                        ? true
+                        : this.codecContext.colorRange === NodeAv.AVCOL_RANGE_MPEG
+                            ? false
+                            : undefined,
+                },
+            };
+        }
+        this.packetEmitted = true;
+        this.onPacket(packet, metadata);
+    }
+    async flush() {
+        if (this.codecContext) {
+            // Send null frame to signal flush
+            const ret = await this.codecContext.sendFrame(null);
+            NodeAv.FFmpegError.throwIfError(ret, 'Send frame');
+            // Keep receiving packets until no more are available
+            while (true) {
+                const receiveRet = await this.codecContext.receivePacket(this.packet);
+                if (receiveRet === NodeAv.AVERROR_EAGAIN || receiveRet === NodeAv.AVERROR_EOF) {
+                    break;
+                }
+                this.receivePacket(receiveRet);
+            }
+            this.codecContext.freeContext();
+            this.codecContext = null;
+            // The codec is done now and can't be reused. Any subsequent encode call will first need to recreate a
+            // codec context.
+        }
+        this.packetEmitted = false;
+    }
+    close() {
+        this.codecContext?.freeContext();
+        this.frame.free();
+        this.packet.free();
+        this.scaler?.freeContext();
+        this.dstFrame?.free();
+    }
+}
+exports.NodeAvVideoEncoder = NodeAvVideoEncoder;

package/dist/modules/src/video-sample.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { type MaybePromise, VideoSamplePixelFormat, VideoSampleResource, VideoSampleColorSpace, SetRequired, VideoSampleInit, VideoSample, VideoDataPlane, VideoSampleTransformationDescription } from 'mediabunny';
+import * as NodeAv from 'node-av';
+/**
+ * A custom `VideoSampleResource` backed by NodeAV's
+ * [`Frame`](https://seydx.github.io/node-av/api/lib/classes/Frame.html), which in turn is backed by FFmpeg's
+ * [`AVFrame`](https://ffmpeg.org/doxygen/2.7/structAVFrame.html). You can use this resource to create `VideoSample`
+ * instances that are directly backed by FFmpeg's `AVFrame` without data having to be copied. Since `AVFrame`s can
+ * themselves be backed by data on the GPU, this enables zero-copy hardware-accelerated decode and encode paths.
+ *
+ * When using Electron, you can directly create `Frame` instances without the data having to leave the GPU. For more,
+ * see [NodeAV's docs](https://seydx.github.io/node-av/api/lib/classes/Frame.html).
+ *
+ * When passed, the `Frame` is now owned by resource, meaning it takes care of closing the frame later. If you want to
+ * keep a copy for your own use, clone the frame first.
+ *
+ * @group \@mediabunny/server
+ * @public
+ */
+export declare class AvFrameVideoSampleResource extends VideoSampleResource {
+    /**
+     * The NodeAV [`Frame`](https://seydx.github.io/node-av/api/lib/classes/Frame.html) instance backing this resource.
+     * Access throws if the resource has already been closed.
+     */
+    get frame(): NodeAv.Frame;
+    constructor(frame: NodeAv.Frame);
+    getFormat(): VideoSamplePixelFormat | null;
+    getCodedWidth(): number;
+    getCodedHeight(): number;
+    getSquarePixelWidth(): number;
+    getSquarePixelHeight(): number;
+    getColorSpace(): VideoSampleColorSpace;
+    close(): void;
+    getDataPlanes(): MaybePromise<VideoDataPlane[]>;
+    toRgbSample(init: SetRequired<VideoSampleInit, 'timestamp'>, colorSpace: PredefinedColorSpace): Promise<VideoSample>;
+}
+export declare const copyVideoSampleToAvFrame: (sample: VideoSample, frame: NodeAv.Frame, lastBuffer: Buffer | null) => Promise<Buffer<ArrayBufferLike>>;
+export declare const transformVideoSample: (sample: VideoSample, description: VideoSampleTransformationDescription) => Promise<VideoSample | null>;
+//# sourceMappingURL=video-sample.d.ts.map

package/dist/modules/src/video-sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-sample.d.ts","sourceRoot":"","sources":["../../../src/video-sample.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACN,KAAK,YAAY,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,WAAW,EACX,cAAc,EACd,oCAAoC,EACpC,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,MAAM,MAAM,SAAS,CAAC;AAqBlC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;IAIlE;;;OAGG;IACH,IAAI,KAAK,iBAMR;gBAEW,KAAK,EAAE,MAAM,CAAC,KAAK;IAU/B,SAAS,IAAI,sBAAsB,GAAG,IAAI;IAI1C,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAIxB,mBAAmB,IAAI,MAAM;IAQ7B,oBAAoB,IAAI,MAAM;IAQ9B,aAAa,IAAI,qBAAqB;IActC,KAAK,IAAI,IAAI;IAKb,aAAa,IAAI,YAAY,CAAC,cAAc,EAAE,CAAC;IASzC,WAAW,CAChB,IAAI,EAAE,WAAW,CAAC,eAAe,EAAE,WAAW,CAAC,EAG/C,UAAU,EAAE,oBAAoB,GAC9B,OAAO,CAAC,WAAW,CAAC;CAiCvB;AAED,eAAO,MAAM,wBAAwB,GAAU,QAAQ,WAAW,EAAE,OAAO,MAAM,CAAC,KAAK,EAAE,YAAY,MAAM,GAAG,IAAI,qCA+BjH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAChC,QAAQ,WAAW,EACnB,aAAa,oCAAoC,KAC/C,OAAO,CAAC,WAAW,GAAG,IAAI,CAkG5B,CAAC"}