@mediabunny/aac-encoder 1.35.1

package/dist/mediabunny-aac-encoder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Registers the AAC encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * Preferably, wrap the call in a condition to avoid overriding any native AAC encoder:
+ *
+ * ```ts
+ * import { canEncodeAudio } from 'mediabunny';
+ * import { registerAacEncoder } from '@mediabunny/aac-encoder';
+ *
+ * if (!(await canEncodeAudio('aac'))) {
+ *     registerAacEncoder();
+ * }
+ * ```
+ *
+ * @group \@mediabunny/aac-encoder
+ * @public
+ */
+export declare const registerAacEncoder: () => void;
+
+export { }
+export as namespace MediabunnyAacEncoder;

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

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

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

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

package/dist/modules/src/encode.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=encode.worker.d.ts.map

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

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

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

@@ -0,0 +1,172 @@
+"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 aac_1 = __importDefault(require("../build/aac"));
+let module;
+let modulePromise = null;
+let initEncoderFn;
+let getEncoderFrameSize;
+let getEncoderExtradata;
+let getEncoderExtradataSize;
+let getEncodeInputPtr;
+let sendFrameFn;
+let receivePacketFn;
+let flushEncoderStartFn;
+let resetEncoderFn;
+let getEncodedData;
+let getEncodedPts;
+let getEncodedDuration;
+let closeEncoderFn;
+const ensureModule = async () => {
+    if (!module) {
+        if (modulePromise) {
+            return modulePromise;
+        }
+        modulePromise = (0, aac_1.default)();
+        module = await modulePromise;
+        modulePromise = null;
+        initEncoderFn = module.cwrap('init_encoder', 'number', ['number', 'number', 'number']);
+        getEncoderFrameSize = module.cwrap('get_encoder_frame_size', 'number', ['number']);
+        getEncoderExtradata = module.cwrap('get_encoder_extradata', 'number', ['number']);
+        getEncoderExtradataSize = module.cwrap('get_encoder_extradata_size', 'number', ['number']);
+        getEncodeInputPtr = module.cwrap('get_encode_input_ptr', 'number', ['number', 'number']);
+        sendFrameFn = module.cwrap('send_frame', 'number', ['number', 'number']);
+        receivePacketFn = module.cwrap('receive_packet', 'number', ['number']);
+        flushEncoderStartFn = module.cwrap('flush_encoder_start', null, ['number']);
+        resetEncoderFn = module.cwrap('reset_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 initEncoder = async (numberOfChannels, sampleRate, bitrate) => {
+    await ensureModule();
+    const ctx = initEncoderFn(numberOfChannels, sampleRate, bitrate);
+    if (ctx === 0) {
+        throw new Error('Failed to initialize AAC encoder.');
+    }
+    const frameSize = getEncoderFrameSize(ctx);
+    const extradataPtr = getEncoderExtradata(ctx);
+    const extradataSize = getEncoderExtradataSize(ctx);
+    const extradata = module.HEAPU8.slice(extradataPtr, extradataPtr + extradataSize).buffer;
+    return { ctx, frameSize, extradata };
+};
+const drainPackets = (ctx) => {
+    const packets = [];
+    let size;
+    while ((size = receivePacketFn(ctx)) > 0) {
+        const ptr = getEncodedData(ctx);
+        const encodedData = module.HEAPU8.slice(ptr, ptr + size).buffer;
+        const pts = getEncodedPts(ctx);
+        const duration = getEncodedDuration(ctx);
+        packets.push({ encodedData, pts, duration });
+    }
+    return packets;
+};
+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 ret = sendFrameFn(ctx, timestamp);
+    if (ret < 0) {
+        throw new Error(`Encode failed with error code ${ret}.`);
+    }
+    return drainPackets(ctx);
+};
+const onMessage = (data) => {
+    const { id, command } = data;
+    const handleCommand = async () => {
+        try {
+            let result;
+            const transferables = [];
+            switch (command.type) {
+                case 'init':
+                    {
+                        const { ctx, frameSize, extradata } = await initEncoder(command.data.numberOfChannels, command.data.sampleRate, command.data.bitrate);
+                        result = { type: command.type, ctx, frameSize, extradata };
+                        transferables.push(extradata);
+                    }
+                    ;
+                    break;
+                case 'encode':
+                    {
+                        const packets = encode(command.data.ctx, command.data.audioData, command.data.timestamp);
+                        for (const p of packets) {
+                            transferables.push(p.encodedData);
+                        }
+                        result = { type: command.type, packets };
+                    }
+                    ;
+                    break;
+                case 'flush':
+                    {
+                        flushEncoderStartFn(command.data.ctx);
+                        const packets = drainPackets(command.data.ctx);
+                        for (const p of packets) {
+                            transferables.push(p.encodedData);
+                        }
+                        resetEncoderFn(command.data.ctx);
+                        result = { type: command.type, packets };
+                    }
+                    ;
+                    break;
+                case 'close':
+                    {
+                        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));
+}

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

@@ -0,0 +1,27 @@
+/*!
+ * 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 the AAC encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * Preferably, wrap the call in a condition to avoid overriding any native AAC encoder:
+ *
+ * ```ts
+ * import { canEncodeAudio } from 'mediabunny';
+ * import { registerAacEncoder } from '@mediabunny/aac-encoder';
+ *
+ * if (!(await canEncodeAudio('aac'))) {
+ *     registerAacEncoder();
+ * }
+ * ```
+ *
+ * @group \@mediabunny/aac-encoder
+ * @public
+ */
+export declare const registerAacEncoder: () => 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;AAiRH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,YAE9B,CAAC"}

package/dist/modules/src/encoder.js

@@ -0,0 +1,241 @@
+"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 });
+exports.registerAacEncoder = void 0;
+const aac_misc_1 = require("../../../shared/aac-misc");
+const mediabunny_1 = require("mediabunny");
+// @ts-expect-error An esbuild plugin handles this, TypeScript doesn't need to understand
+const encode_worker_1 = __importDefault(require("./encode.worker"));
+const AAC_SAMPLE_RATES = [
+    96000, 88200, 64000, 48000, 44100, 32000,
+    24000, 22050, 16000, 12000, 11025, 8000, 7350,
+];
+class AacEncoder extends mediabunny_1.CustomAudioEncoder {
+    constructor() {
+        super(...arguments);
+        this.worker = null;
+        this.nextMessageId = 0;
+        this.pendingMessages = new Map();
+        this.ctx = 0;
+        this.encoderFrameSize = 0;
+        this.sampleRate = 0;
+        this.numberOfChannels = 0;
+        this.chunkMetadata = {};
+        this.useAdts = false;
+        this.adtsHeaderTemplate = null;
+        this.description = null;
+        // 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 === 'aac'
+            && config.numberOfChannels >= 1
+            && config.numberOfChannels <= 8
+            && AAC_SAMPLE_RATES.includes(config.sampleRate)
+            && config.bitrate !== undefined;
+    }
+    async init() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        this.worker = (await (0, encode_worker_1.default)());
+        const onMessage = (data) => {
+            const pending = this.pendingMessages.get(data.id);
+            assert(pending !== undefined);
+            this.pendingMessages.delete(data.id);
+            if (data.success) {
+                pending.resolve(data.data);
+            }
+            else {
+                pending.reject(data.error);
+            }
+        };
+        if (this.worker.addEventListener) {
+            this.worker.addEventListener('message', event => onMessage(event.data));
+        }
+        else {
+            const nodeWorker = this.worker;
+            nodeWorker.on('message', onMessage);
+        }
+        assert(this.config.bitrate !== undefined);
+        this.sampleRate = this.config.sampleRate;
+        this.numberOfChannels = this.config.numberOfChannels;
+        const result = await this.sendCommand({
+            type: 'init',
+            data: {
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+                bitrate: this.config.bitrate,
+            },
+        });
+        this.ctx = result.ctx;
+        this.encoderFrameSize = result.frameSize;
+        // The ffmpeg encoder provides an AudioSpecificConfig as extradata after init
+        const description = new Uint8Array(result.extradata);
+        const aacConfig = this.config.aac;
+        this.useAdts = aacConfig?.format === 'adts';
+        if (this.useAdts) {
+            const audioSpecificConfig = (0, aac_misc_1.parseAacAudioSpecificConfig)(description);
+            this.adtsHeaderTemplate = (0, aac_misc_1.buildAdtsHeaderTemplate)(audioSpecificConfig);
+        }
+        this.description = this.useAdts ? null : description;
+        this.resetInternalState();
+    }
+    resetInternalState() {
+        this.pendingFrames = 0;
+        this.nextSampleTimestampInSamples = null;
+        this.nextPacketTimestampInSamples = null;
+        this.chunkMetadata = {
+            decoderConfig: {
+                codec: 'mp4a.40.2',
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+                ...(this.description ? { description: this.description } : {}),
+            },
+        };
+    }
+    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();
+        }
+        const result = await this.sendCommand({ type: 'flush', data: { ctx: this.ctx } });
+        this.emitPackets(result.packets);
+        this.resetInternalState();
+    }
+    close() {
+        void this.sendCommand({ type: 'close', data: { ctx: this.ctx } });
+        this.worker?.terminate();
+    }
+    async encodeOneFrame() {
+        assert(this.nextSampleTimestampInSamples !== null);
+        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 this.sendCommand({
+            type: 'encode',
+            data: {
+                ctx: this.ctx,
+                audioData,
+                timestamp: this.nextSampleTimestampInSamples,
+            },
+        }, [audioData]);
+        this.nextSampleTimestampInSamples += frameSize;
+        this.emitPackets(result.packets);
+    }
+    emitPackets(packets) {
+        assert(this.nextPacketTimestampInSamples !== null);
+        for (const p of packets) {
+            let data = new Uint8Array(p.encodedData);
+            if (this.useAdts) {
+                assert(this.adtsHeaderTemplate !== null);
+                const { header, bitstream } = this.adtsHeaderTemplate;
+                const frameLength = header.byteLength + data.byteLength;
+                (0, aac_misc_1.writeAdtsFrameLength)(bitstream, frameLength);
+                const adtsFrame = new Uint8Array(frameLength);
+                adtsFrame.set(header, 0);
+                adtsFrame.set(data, header.byteLength);
+                data = adtsFrame;
+            }
+            const packet = new mediabunny_1.EncodedPacket(data, 'key', this.nextPacketTimestampInSamples / this.sampleRate, p.duration / this.sampleRate);
+            this.nextPacketTimestampInSamples += p.duration;
+            this.onPacket(packet, this.chunkMetadata);
+            this.chunkMetadata = {};
+        }
+    }
+    sendCommand(command, transferables) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextMessageId++;
+            this.pendingMessages.set(id, {
+                resolve: resolve,
+                reject,
+            });
+            assert(this.worker);
+            if (transferables) {
+                this.worker.postMessage({ id, command }, transferables);
+            }
+            else {
+                this.worker.postMessage({ id, command });
+            }
+        });
+    }
+}
+/**
+ * Registers the AAC encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * Preferably, wrap the call in a condition to avoid overriding any native AAC encoder:
+ *
+ * ```ts
+ * import { canEncodeAudio } from 'mediabunny';
+ * import { registerAacEncoder } from '@mediabunny/aac-encoder';
+ *
+ * if (!(await canEncodeAudio('aac'))) {
+ *     registerAacEncoder();
+ * }
+ * ```
+ *
+ * @group \@mediabunny/aac-encoder
+ * @public
+ */
+const registerAacEncoder = () => {
+    (0, mediabunny_1.registerEncoder)(AacEncoder);
+};
+exports.registerAacEncoder = registerAacEncoder;
+function assert(x) {
+    if (!x) {
+        throw new Error('Assertion failed.');
+    }
+}

package/dist/modules/src/index.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 { registerAacEncoder } 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;AAaH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}

package/dist/modules/src/index.js

@@ -0,0 +1,20 @@
+"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.registerAacEncoder = void 0;
+const AAC_ENCODER_LOADED_SYMBOL = Symbol.for('@mediabunny/aac-encoder loaded');
+if (globalThis[AAC_ENCODER_LOADED_SYMBOL]) {
+    console.error('[WARNING]\n@mediabunny/aac-encoder was loaded twice.'
+        + ' This will likely cause the encoder not to work correctly.'
+        + ' Check if multiple dependencies are importing different versions of @mediabunny/aac-encoder,'
+        + ' or if something is being bundled incorrectly.');
+}
+globalThis[AAC_ENCODER_LOADED_SYMBOL] = true;
+var encoder_1 = require("./encoder");
+Object.defineProperty(exports, "registerAacEncoder", { enumerable: true, get: function () { return encoder_1.registerAacEncoder; } });

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

@@ -0,0 +1,64 @@
+/*!
+ * 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 type WorkerCommand = {
+    type: 'init';
+    data: {
+        numberOfChannels: number;
+        sampleRate: number;
+        bitrate: number;
+    };
+} | {
+    type: 'encode';
+    data: {
+        ctx: number;
+        audioData: ArrayBuffer;
+        timestamp: number;
+    };
+} | {
+    type: 'flush';
+    data: {
+        ctx: number;
+    };
+} | {
+    type: 'close';
+    data: {
+        ctx: number;
+    };
+};
+export type WorkerResponseData = {
+    type: 'init';
+    ctx: number;
+    frameSize: number;
+    extradata: ArrayBuffer;
+} | {
+    type: 'encode';
+    packets: Array<{
+        encodedData: ArrayBuffer;
+        pts: number;
+        duration: number;
+    }>;
+} | {
+    type: 'flush';
+    packets: Array<{
+        encodedData: ArrayBuffer;
+        pts: number;
+        duration: number;
+    }>;
+} | {
+    type: 'close';
+};
+export type WorkerResponse = {
+    id: number;
+} & ({
+    success: true;
+    data: WorkerResponseData;
+} | {
+    success: false;
+    error: unknown;
+});
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QACL,gBAAgB,EAAE,MAAM,CAAC;QACzB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;KAChB,CAAC;CACF,GAAG;IACH,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,WAAW,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC;CACF,GAAG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;KACZ,CAAC;CACF,GAAG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;KACZ,CAAC;CACF,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,WAAW,CAAC;CACvB,GAAG;IACH,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;QACd,WAAW,EAAE,WAAW,CAAC;QACzB,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACH,GAAG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;QACd,WAAW,EAAE,WAAW,CAAC;QACzB,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACH,GAAG;IACH,IAAI,EAAE,OAAO,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;CACX,GAAG,CAAC;IACJ,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,kBAAkB,CAAC;CACzB,GAAG;IACH,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CACf,CAAC,CAAC"}

package/dist/modules/src/shared.js

@@ -0,0 +1,9 @@
+"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 });