@mediabunny/dts 1.55.0

package/dist/mediabunny-dts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Registers a DTS audio decoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any decoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+export declare const registerDtsDecoder: () => void;
+
+/**
+ * Registers a DTS audio encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+export declare const registerDtsEncoder: () => void;
+
+export { }
+export as namespace MediabunnyDts;

package/dist/modules/build/dts.d.ts

@@ -0,0 +1,3 @@
+export default Module;
+declare function Module(moduleArg?: {}): Promise<{}>;
+//# sourceMappingURL=dts.d.ts.map

package/dist/modules/build/dts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dts.d.ts","sourceRoot":"","sources":["../../../build/dts.js"],"names":[],"mappings":";AAAA,qDACkB"}

package/dist/modules/src/codec.worker.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * 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/.
+ */
+export {};
+//# sourceMappingURL=codec.worker.d.ts.map

package/dist/modules/src/codec.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.worker.d.ts","sourceRoot":"","sources":["../../../src/codec.worker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/modules/src/codec.worker.js

@@ -0,0 +1,271 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dts_1 = __importDefault(require("../build/dts"));
+let module;
+let modulePromise = null;
+let initDecoderFn;
+let configureDecodePacket;
+let decodePacket;
+let getDecodedFormat;
+let getDecodedPlanePtr;
+let getDecodedChannels;
+let getDecodedSampleRate;
+let getDecodedSampleCount;
+let getDecodedPts;
+let flushDecoderFn;
+let closeDecoderFn;
+let initEncoderFn;
+let getEncoderFrameSize;
+let getEncodeInputPtr;
+let encodeFrameFn;
+let flushEncoderFn;
+let getEncodedData;
+let getEncodedPts;
+let getEncodedDuration;
+let closeEncoderFn;
+const ensureModule = async () => {
+    if (!module) {
+        if (modulePromise) {
+            // If we don't do this we can have a race condition
+            return modulePromise;
+        }
+        modulePromise = (0, dts_1.default)();
+        module = await modulePromise;
+        modulePromise = null;
+        initDecoderFn = module.cwrap('init_decoder', 'number', []);
+        configureDecodePacket = module.cwrap('configure_decode_packet', 'number', ['number', 'number']);
+        decodePacket = module.cwrap('decode_packet', 'number', ['number', 'number']);
+        getDecodedFormat = module.cwrap('get_decoded_format', 'number', ['number']);
+        getDecodedPlanePtr = module.cwrap('get_decoded_plane_ptr', 'number', ['number', 'number']);
+        getDecodedChannels = module.cwrap('get_decoded_channels', 'number', ['number']);
+        getDecodedSampleRate = module.cwrap('get_decoded_sample_rate', 'number', ['number']);
+        getDecodedSampleCount = module.cwrap('get_decoded_sample_count', 'number', ['number']);
+        getDecodedPts = module.cwrap('get_decoded_pts', 'number', ['number']);
+        flushDecoderFn = module.cwrap('flush_decoder', null, ['number']);
+        closeDecoderFn = module.cwrap('close_decoder', null, ['number']);
+        initEncoderFn = module.cwrap('init_encoder', 'number', ['number', 'number', 'number']);
+        getEncoderFrameSize = module.cwrap('get_encoder_frame_size', 'number', ['number']);
+        getEncodeInputPtr = module.cwrap('get_encode_input_ptr', 'number', ['number', 'number']);
+        encodeFrameFn = module.cwrap('encode_frame', 'number', ['number', 'number']);
+        flushEncoderFn = module.cwrap('flush_encoder', null, ['number']);
+        getEncodedData = module.cwrap('get_encoded_data', 'number', ['number']);
+        getEncodedPts = module.cwrap('get_encoded_pts', 'number', ['number']);
+        getEncodedDuration = module.cwrap('get_encoded_duration', 'number', ['number']);
+        closeEncoderFn = module.cwrap('close_encoder', null, ['number']);
+    }
+};
+const initDecoder = async () => {
+    await ensureModule();
+    const ctx = initDecoderFn();
+    if (ctx === 0) {
+        throw new Error('Failed to initialize DTS decoder.');
+    }
+    return { ctx, frameSize: 0 };
+};
+// Keys are AVSampleFormat enum values
+const AV_FORMAT_MAP = {
+    0: { format: 'u8', bytesPerSample: 1, planar: false },
+    1: { format: 's16', bytesPerSample: 2, planar: false },
+    2: { format: 's32', bytesPerSample: 4, planar: false },
+    3: { format: 'f32', bytesPerSample: 4, planar: false },
+    5: { format: 'u8-planar', bytesPerSample: 1, planar: true },
+    6: { format: 's16-planar', bytesPerSample: 2, planar: true },
+    7: { format: 's32-planar', bytesPerSample: 4, planar: true },
+    8: { format: 'f32-planar', bytesPerSample: 4, planar: true },
+};
+const decode = (ctx, encodedData, timestamp) => {
+    const bytes = new Uint8Array(encodedData);
+    const dataPtr = configureDecodePacket(ctx, bytes.length);
+    if (dataPtr === 0) {
+        throw new Error('Failed to configure decode packet.');
+    }
+    module.HEAPU8.set(bytes, dataPtr);
+    const ret = decodePacket(ctx, BigInt(timestamp));
+    if (ret < 0) {
+        throw new Error(`Decode failed with error code ${ret}.`);
+    }
+    const avFormat = getDecodedFormat(ctx);
+    const info = AV_FORMAT_MAP[avFormat];
+    if (!info) {
+        throw new Error(`Unsupported AVSampleFormat: ${avFormat}`);
+    }
+    const channels = getDecodedChannels(ctx);
+    const sampleRate = getDecodedSampleRate(ctx);
+    const sampleCount = getDecodedSampleCount(ctx);
+    const pts = Number(getDecodedPts(ctx));
+    let pcmData;
+    if (info.planar) {
+        const planeSize = sampleCount * info.bytesPerSample;
+        const buffer = new Uint8Array(planeSize * channels);
+        for (let ch = 0; ch < channels; ch++) {
+            const ptr = getDecodedPlanePtr(ctx, ch);
+            buffer.set(module.HEAPU8.subarray(ptr, ptr + planeSize), ch * planeSize);
+        }
+        pcmData = buffer.buffer;
+    }
+    else {
+        const totalSize = sampleCount * channels * info.bytesPerSample;
+        const ptr = getDecodedPlanePtr(ctx, 0);
+        pcmData = module.HEAPU8.slice(ptr, ptr + totalSize).buffer;
+    }
+    return { pcmData, format: info.format, channels, sampleRate, sampleCount, pts };
+};
+const initEncoder = async (numberOfChannels, sampleRate, bitrate) => {
+    await ensureModule();
+    const ctx = initEncoderFn(numberOfChannels, sampleRate, bitrate);
+    if (ctx === 0) {
+        throw new Error('Failed to initialize DTS encoder.');
+    }
+    return { ctx, frameSize: getEncoderFrameSize(ctx) };
+};
+const encode = (ctx, audioData, timestamp) => {
+    const audioBytes = new Uint8Array(audioData);
+    const inputPtr = getEncodeInputPtr(ctx, audioBytes.length);
+    if (inputPtr === 0) {
+        throw new Error('Failed to allocate encoder input buffer.');
+    }
+    module.HEAPU8.set(audioBytes, inputPtr);
+    const bytesWritten = encodeFrameFn(ctx, BigInt(timestamp));
+    if (bytesWritten < 0) {
+        throw new Error(`Encode failed with error code ${bytesWritten}.`);
+    }
+    const ptr = getEncodedData(ctx);
+    const encodedData = module.HEAPU8.slice(ptr, ptr + bytesWritten).buffer;
+    const pts = Number(getEncodedPts(ctx));
+    const duration = getEncodedDuration(ctx);
+    return { encodedData, pts, duration };
+};
+const flushEncoder = (ctx) => {
+    flushEncoderFn(ctx);
+};
+const onMessage = (data) => {
+    const { id, command } = data;
+    const handleCommand = async () => {
+        try {
+            let result;
+            const transferables = [];
+            switch (command.type) {
+                case 'init-decoder':
+                    {
+                        const { ctx, frameSize } = await initDecoder();
+                        result = { type: command.type, ctx, frameSize };
+                    }
+                    ;
+                    break;
+                case 'decode':
+                    {
+                        const decoded = decode(command.data.ctx, command.data.encodedData, command.data.timestamp);
+                        result = {
+                            type: command.type,
+                            pcmData: decoded.pcmData,
+                            format: decoded.format,
+                            channels: decoded.channels,
+                            sampleRate: decoded.sampleRate,
+                            sampleCount: decoded.sampleCount,
+                            pts: decoded.pts,
+                        };
+                        transferables.push(decoded.pcmData);
+                    }
+                    ;
+                    break;
+                case 'flush-decoder':
+                    {
+                        flushDecoderFn(command.data.ctx);
+                        result = { type: command.type };
+                    }
+                    ;
+                    break;
+                case 'close-decoder':
+                    {
+                        closeDecoderFn(command.data.ctx);
+                        result = { type: command.type };
+                    }
+                    ;
+                    break;
+                case 'init-encoder':
+                    {
+                        const { ctx, frameSize } = await initEncoder(command.data.numberOfChannels, command.data.sampleRate, command.data.bitrate);
+                        result = { type: command.type, ctx, frameSize };
+                    }
+                    ;
+                    break;
+                case 'encode':
+                    {
+                        const encoded = encode(command.data.ctx, command.data.audioData, command.data.timestamp);
+                        result = {
+                            type: command.type,
+                            encodedData: encoded.encodedData,
+                            pts: encoded.pts,
+                            duration: encoded.duration,
+                        };
+                        transferables.push(encoded.encodedData);
+                    }
+                    ;
+                    break;
+                case 'flush-encoder':
+                    {
+                        flushEncoder(command.data.ctx);
+                        result = { type: command.type };
+                    }
+                    ;
+                    break;
+                case 'close-encoder':
+                    {
+                        closeEncoderFn(command.data.ctx);
+                        result = { type: command.type };
+                    }
+                    ;
+                    break;
+            }
+            const response = {
+                id,
+                success: true,
+                data: result,
+            };
+            sendMessage(response, transferables);
+        }
+        catch (error) {
+            const response = {
+                id,
+                success: false,
+                error,
+            };
+            sendMessage(response);
+        }
+    };
+    void handleCommand();
+};
+const sendMessage = (data, transferables) => {
+    if (parentPort) {
+        parentPort.postMessage(data, transferables ?? []);
+    }
+    else {
+        self.postMessage(data, { transfer: transferables ?? [] });
+    }
+};
+let parentPort = null;
+if (typeof self === 'undefined') {
+    const workerModule = 'worker_threads';
+    // eslint-disable-next-line @stylistic/max-len
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-member-access
+    parentPort = require(workerModule).parentPort;
+}
+if (parentPort) {
+    parentPort.on('message', onMessage);
+}
+else {
+    self.addEventListener('message', event => onMessage(event.data));
+}
+// Prevents the worker for being randomly closed by Firefox
+// https://github.com/Vanilagy/mediabunny/issues/435
+setInterval(() => { }, 1000);

package/dist/modules/src/decoder.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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/.
+ */
+/**
+ * Registers a DTS audio decoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any decoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+export declare const registerDtsDecoder: () => void;
+//# sourceMappingURL=decoder.d.ts.map

package/dist/modules/src/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../src/decoder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA2DH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,YAO9B,CAAC"}

package/dist/modules/src/decoder.js

@@ -0,0 +1,68 @@
+"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/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDtsDecoder = void 0;
+const mediabunny_1 = require("mediabunny");
+const worker_client_1 = require("./worker-client");
+class DtsDecoder extends mediabunny_1.CustomAudioDecoder {
+    constructor() {
+        super(...arguments);
+        this.ctx = 0;
+    }
+    static supports(codec) {
+        return codec === 'dts';
+    }
+    async init() {
+        await (0, worker_client_1.refWorker)();
+        const result = await (0, worker_client_1.sendCommand)({
+            type: 'init-decoder',
+            data: {},
+        });
+        this.ctx = result.ctx;
+    }
+    async decode(packet) {
+        const encodedData = packet.data.slice().buffer;
+        const timestamp = Math.round(packet.timestamp * this.config.sampleRate);
+        const result = await (0, worker_client_1.sendCommand)({
+            type: 'decode',
+            data: { ctx: this.ctx, encodedData, timestamp },
+        }, [encodedData]);
+        const sample = new mediabunny_1.AudioSample({
+            data: result.pcmData,
+            format: result.format,
+            numberOfChannels: result.channels,
+            sampleRate: result.sampleRate,
+            timestamp: result.pts / result.sampleRate,
+        });
+        this.onSample(sample);
+    }
+    async flush() {
+        await (0, worker_client_1.sendCommand)({ type: 'flush-decoder', data: { ctx: this.ctx } });
+    }
+    async close() {
+        void (0, worker_client_1.sendCommand)({ type: 'close-decoder', data: { ctx: this.ctx } });
+        await (0, worker_client_1.unrefWorker)();
+    }
+}
+let registered = false;
+/**
+ * Registers a DTS audio decoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any decoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+const registerDtsDecoder = () => {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    (0, mediabunny_1.registerDecoder)(DtsDecoder);
+};
+exports.registerDtsDecoder = registerDtsDecoder;

package/dist/modules/src/encoder.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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/.
+ */
+/**
+ * Registers a DTS audio encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+export declare const registerDtsEncoder: () => void;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/modules/src/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgLH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,YAO9B,CAAC"}

package/dist/modules/src/encoder.js

@@ -0,0 +1,155 @@
+"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/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDtsEncoder = void 0;
+const mediabunny_1 = require("mediabunny");
+const worker_client_1 = require("./worker-client");
+const shared_1 = require("./shared");
+const dts_misc_1 = require("../../../shared/dts-misc");
+class DtsEncoder extends mediabunny_1.CustomAudioEncoder {
+    constructor() {
+        super(...arguments);
+        this.ctx = 0;
+        this.encoderFrameSize = 0;
+        this.sampleRate = 0;
+        this.numberOfChannels = 0;
+        this.chunkMetadata = {};
+        // Accumulate interleaved f32 samples until we have a full frame
+        this.pendingBuffer = new Float32Array(2 ** 16);
+        this.pendingFrames = 0;
+        this.nextSampleTimestampInSamples = null;
+        this.nextPacketTimestampInSamples = null;
+    }
+    static supports(codec, config) {
+        return codec === 'dts'
+            && dts_misc_1.DTS_CHANNEL_COUNTS.includes(config.numberOfChannels)
+            && dts_misc_1.DTS_SAMPLE_RATES.includes(config.sampleRate)
+            && config.bitrate !== undefined
+            && (0, dts_misc_1.dtsBitrateFits)(config.bitrate, config.sampleRate, config.numberOfChannels);
+    }
+    async init() {
+        await (0, worker_client_1.refWorker)();
+        (0, shared_1.assert)(this.config.bitrate !== undefined);
+        this.sampleRate = this.config.sampleRate;
+        this.numberOfChannels = this.config.numberOfChannels;
+        const result = await (0, worker_client_1.sendCommand)({
+            type: 'init-encoder',
+            data: {
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+                bitrate: this.config.bitrate,
+            },
+        });
+        this.ctx = result.ctx;
+        this.encoderFrameSize = result.frameSize;
+        this.resetInternalState();
+    }
+    resetInternalState() {
+        this.pendingFrames = 0;
+        this.nextSampleTimestampInSamples = null;
+        this.nextPacketTimestampInSamples = null;
+        this.chunkMetadata = {
+            decoderConfig: {
+                codec: 'dtsc',
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+            },
+        };
+    }
+    async encode(audioSample) {
+        if (this.nextSampleTimestampInSamples === null) {
+            this.nextSampleTimestampInSamples = Math.round(audioSample.timestamp * this.sampleRate);
+            this.nextPacketTimestampInSamples = this.nextSampleTimestampInSamples;
+        }
+        const channels = this.numberOfChannels;
+        const incomingFrames = audioSample.numberOfFrames;
+        // Extract interleaved f32 data
+        const totalBytes = audioSample.allocationSize({ format: 'f32', planeIndex: 0 });
+        const audioBytes = new Uint8Array(totalBytes);
+        audioSample.copyTo(audioBytes, { format: 'f32', planeIndex: 0 });
+        const incomingData = new Float32Array(audioBytes.buffer);
+        const requiredSamples = (this.pendingFrames + incomingFrames) * channels;
+        if (requiredSamples > this.pendingBuffer.length) {
+            let newSize = this.pendingBuffer.length;
+            while (newSize < requiredSamples) {
+                newSize *= 2;
+            }
+            const newBuffer = new Float32Array(newSize);
+            newBuffer.set(this.pendingBuffer.subarray(0, this.pendingFrames * channels));
+            this.pendingBuffer = newBuffer;
+        }
+        this.pendingBuffer.set(incomingData, this.pendingFrames * channels);
+        this.pendingFrames += incomingFrames;
+        while (this.pendingFrames >= this.encoderFrameSize) {
+            await this.encodeOneFrame();
+        }
+    }
+    async flush() {
+        // Pad remaining samples with silence to fill a full frame
+        if (this.pendingFrames > 0) {
+            const channels = this.numberOfChannels;
+            const frameSize = this.encoderFrameSize;
+            const usedSamples = this.pendingFrames * channels;
+            const frameSamples = frameSize * channels;
+            this.pendingBuffer.fill(0, usedSamples, frameSamples);
+            this.pendingFrames = frameSize;
+            await this.encodeOneFrame();
+        }
+        await (0, worker_client_1.sendCommand)({ type: 'flush-encoder', data: { ctx: this.ctx } });
+        this.resetInternalState();
+    }
+    close() {
+        void (0, worker_client_1.sendCommand)({ type: 'close-encoder', data: { ctx: this.ctx } });
+        void (0, worker_client_1.unrefWorker)();
+    }
+    async encodeOneFrame() {
+        (0, shared_1.assert)(this.nextSampleTimestampInSamples !== null);
+        (0, shared_1.assert)(this.nextPacketTimestampInSamples !== null);
+        const channels = this.numberOfChannels;
+        const frameSize = this.encoderFrameSize;
+        const frameSamples = frameSize * channels;
+        const frameData = this.pendingBuffer.slice(0, frameSamples);
+        // Shift remaining using copyWithin
+        this.pendingFrames -= frameSize;
+        if (this.pendingFrames > 0) {
+            this.pendingBuffer.copyWithin(0, frameSamples, frameSamples + this.pendingFrames * channels);
+        }
+        const audioData = frameData.buffer;
+        const result = await (0, worker_client_1.sendCommand)({
+            type: 'encode',
+            data: {
+                ctx: this.ctx,
+                audioData,
+                timestamp: this.nextSampleTimestampInSamples,
+            },
+        }, [audioData]);
+        this.nextSampleTimestampInSamples += frameSize;
+        // We always get exactly one packet because we encode the correct frame size
+        const packet = new mediabunny_1.EncodedPacket(new Uint8Array(result.encodedData), 'key', this.nextPacketTimestampInSamples / this.sampleRate, result.duration / this.sampleRate);
+        this.nextPacketTimestampInSamples += result.duration;
+        this.onPacket(packet, this.chunkMetadata);
+        this.chunkMetadata = {};
+    }
+}
+let registered = false;
+/**
+ * Registers a DTS audio encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * @group \@mediabunny/dts
+ * @public
+ */
+const registerDtsEncoder = () => {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    (0, mediabunny_1.registerEncoder)(DtsEncoder);
+};
+exports.registerDtsEncoder = registerDtsEncoder;

package/dist/modules/src/index.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * 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/.
+ */
+export { registerDtsDecoder } from './decoder';
+export { registerDtsEncoder } from './encoder';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}

package/dist/modules/src/index.js

@@ -0,0 +1,23 @@
+"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/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDtsEncoder = exports.registerDtsDecoder = void 0;
+const mediabunny_1 = require("mediabunny");
+const DTS_LOADED_SYMBOL = Symbol.for('@mediabunny/dts loaded');
+if (globalThis[DTS_LOADED_SYMBOL]) {
+    mediabunny_1.Logging._error('[WARNING]\n@mediabunny/dts was loaded twice.'
+        + ' This will likely cause the encoder/decoder not to work correctly.'
+        + ' Check if multiple dependencies are importing different versions of @mediabunny/dts,'
+        + ' or if something is being bundled incorrectly.');
+}
+globalThis[DTS_LOADED_SYMBOL] = true;
+var decoder_1 = require("./decoder");
+Object.defineProperty(exports, "registerDtsDecoder", { enumerable: true, get: function () { return decoder_1.registerDtsDecoder; } });
+var encoder_1 = require("./encoder");
+Object.defineProperty(exports, "registerDtsEncoder", { enumerable: true, get: function () { return encoder_1.registerDtsEncoder; } });