@boruto_vk7/opus-ogg 1.2.0

package/dist/cjs/src/oggDemuxer.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OggDemuxer = void 0;
+const node_stream_1 = require("node:stream");
+// Constants for Ogg parsing
+const OGG_CAPTURE_PATTERN = 0x4f676753; // 'OggS'
+const OGG_HEADER_SIZE = 27; // Fixed size of Ogg page header
+// Opus header types
+const OPUS_HEAD_SIGNATURE = Buffer.from('OpusHead');
+const OPUS_TAGS_SIGNATURE = Buffer.from('OpusTags');
+/**
+ * A Transform stream that demuxes Ogg Opus streams, extracting raw Opus packets.
+ * It parses Ogg pages and emits individual Opus packets as Buffers.
+ */
+class OggDemuxer extends node_stream_1.Transform {
+    buffer;
+    currentGranulePosition;
+    bitstreamSerialNumber;
+    pageSequenceNumber;
+    opusHeadParsed;
+    opusTagsParsed;
+    constructor() {
+        super({ readableObjectMode: true }); // Emits Opus packets as objects (Buffers)
+        this.buffer = Buffer.alloc(0);
+        this.currentGranulePosition = 0n;
+        this.bitstreamSerialNumber = null;
+        this.pageSequenceNumber = 0;
+        this.opusHeadParsed = false;
+        this.opusTagsParsed = false;
+    }
+    _transform(chunk, encoding, callback) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.parseBuffer();
+        callback();
+    }
+    _flush(callback) {
+        // Attempt to parse any remaining data in the buffer
+        this.parseBuffer();
+        if (this.buffer.length > 0) {
+            this.emit('warn', `OggDemuxer: Remaining unparsed data in buffer: ${this.buffer.length} bytes`);
+        }
+        callback();
+    }
+    parseBuffer() {
+        while (this.buffer.length >= OGG_HEADER_SIZE) {
+            const header = this.parsePageHeader(this.buffer);
+            if (!header) {
+                // No valid OggS pattern found at current position, try to resync
+                const nextOggS = this.buffer.indexOf(Buffer.from("OggS"), 1); // Search from next byte
+                if (nextOggS === -1) {
+                    // No more OggS patterns, clear buffer and wait for more data
+                    this.buffer = Buffer.alloc(0);
+                    break;
+                }
+                else {
+                    // Resync: discard data until next OggS
+                    this.emit("debug", `OggDemuxer: Resyncing, discarding ${nextOggS} bytes.`);
+                    this.buffer = this.buffer.subarray(nextOggS);
+                    continue;
+                }
+            }
+            const pageLength = OGG_HEADER_SIZE + header.pageSegments + header.segmentTable.reduce((a, b) => a + b, 0);
+            if (this.buffer.length < pageLength) {
+                // Not enough data for the full page, wait for more
+                break;
+            }
+            // Validate bitstream serial number for logical stream continuity
+            if (this.bitstreamSerialNumber === null) {
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+            }
+            else if (this.bitstreamSerialNumber !== header.bitstreamSerialNumber) {
+                // This indicates a new logical bitstream, which is fine for concatenated Ogg files
+                // For simplicity, we'll just reset state for the new stream
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+                this.opusHeadParsed = false;
+                this.opusTagsParsed = false;
+                this.pageSequenceNumber = 0;
+                this.currentGranulePosition = 0n;
+                this.emit('warn', `OggDemuxer: Detected new logical bitstream (serial: ${header.bitstreamSerialNumber})`);
+            }
+            // Check page sequence number for continuity (optional, but good for error detection)
+            if (!(header.headerTypeFlag & 0x02) && header.pageSequenceNumber !== this.pageSequenceNumber) {
+                this.emit("warn", `OggDemuxer: Page sequence discontinuity detected. Expected ${this.pageSequenceNumber}, got ${header.pageSequenceNumber}.`);
+                // We can still try to process, but this might indicate corruption
+            }
+            this.pageSequenceNumber = header.pageSequenceNumber + 1;
+            this.currentGranulePosition = header.granulePosition;
+            // Extract packet data
+            let packetOffset = OGG_HEADER_SIZE + header.pageSegments;
+            let currentPacketBuffer = Buffer.alloc(0);
+            for (let i = 0; i < header.segmentTable.length; i++) {
+                const segmentLength = header.segmentTable[i];
+                const segmentData = this.buffer.subarray(packetOffset, packetOffset + segmentLength);
+                currentPacketBuffer = Buffer.concat([currentPacketBuffer, segmentData]);
+                packetOffset += segmentLength;
+                // If segment is less than 255, it's the end of a packet
+                if (segmentLength < 255 || i === header.segmentTable.length - 1) {
+                    this.processPacket(currentPacketBuffer);
+                    currentPacketBuffer = Buffer.alloc(0);
+                }
+            }
+            // Remove processed page from buffer
+            this.buffer = this.buffer.subarray(pageLength);
+        }
+    }
+    parsePageHeader(buffer) {
+        // Check capture pattern 'OggS'
+        // OGG_CAPTURE_PATTERN is 0x4f676753. buffer.readUInt32LE(0) reads 0x5367674f on little-endian systems.
+        // So we need to compare with Buffer.from("OggS").readUInt32LE(0)
+        if (buffer.readUInt32LE(0) !== Buffer.from("OggS").readUInt32LE(0)) {
+            return null;
+        }
+        const header = {
+            capturePattern: buffer.readUInt32LE(0),
+            streamStructureVersion: buffer.readUInt8(4),
+            headerTypeFlag: buffer.readUInt8(5),
+            granulePosition: buffer.readBigInt64LE(6),
+            bitstreamSerialNumber: buffer.readUInt32LE(14),
+            pageSequenceNumber: buffer.readUInt32LE(18),
+            pageChecksum: buffer.readUInt32LE(22),
+            pageSegments: buffer.readUInt8(26),
+            segmentTable: [],
+        };
+        // Read segment table
+        const segmentTableOffset = OGG_HEADER_SIZE;
+        for (let i = 0; i < header.pageSegments; i++) {
+            header.segmentTable.push(buffer.readUInt8(segmentTableOffset + i));
+        }
+        return header;
+    }
+    processPacket(packet) {
+        // The first two packets in an Ogg Opus stream are OpusHead and OpusTags
+        if (!this.opusHeadParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_HEAD_SIGNATURE)) {
+                // This is the OpusHead packet (identification header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusHeadParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusHead packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusHead packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        if (!this.opusTagsParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_TAGS_SIGNATURE)) {
+                // This is the OpusTags packet (comment header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusTagsParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusTags packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusTags packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        // After OpusHead and OpusTags, all subsequent packets are raw Opus frames
+        if (this.opusHeadParsed && this.opusTagsParsed) {
+            this.emit("debug", `OggDemuxer: Emitting Opus packet. Length: ${packet.length}`);
+            this.push(packet);
+        }
+        else {
+            this.emit("debug", `OggDemuxer: Skipping non-Opus data before headers. Length: ${packet.length}`);
+        }
+    }
+}
+exports.OggDemuxer = OggDemuxer;

package/dist/esm/index.js

@@ -0,0 +1,139 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as https from 'node:https';
+import * as http from 'node:http';
+import { spawn } from 'node:child_process';
+import { Readable, PassThrough } from 'node:stream';
+import * as os from 'node:os';
+import { OggDemuxer } from './oggDemuxer'; // Import the new demuxer
+// Fallback to system ffmpeg if local bin is not found
+let ffmpegPath = 'ffmpeg';
+/**
+ * Resolves the path to the FFmpeg binary.
+ * Priority:
+ * 1. Local bin/ folder (downloaded via postinstall)
+ * 2. System PATH
+ */
+function resolveFFmpeg() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg'),
+        path.join(__dirname, '..', 'bin', os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg')
+    ];
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p))
+                return p;
+        }
+        catch { /* ignore */ }
+    }
+    return 'ffmpeg';
+}
+try {
+    ffmpegPath = resolveFFmpeg();
+}
+catch {
+    ffmpegPath = 'ffmpeg';
+}
+/**
+ * Converts audio to OGG Opus compatible with WhatsApp (iPhone) and Discord.
+ * Optimized for ultra-low latency and minimal CPU stress using streaming.
+ */
+export function EngineOgg(input, options = {}) {
+    const outputStream = new PassThrough({ highWaterMark: 128 * 1024 });
+    const channels = options.forceStereo ? 2 : 1;
+    const profile = options.profile || 'voip';
+    const bitrate = options.bitrate || (profile === 'audio' ? '128k' : '64k');
+    const bin = options.ffmpegPath || ffmpegPath;
+    const args = [
+        '-hide_banner',
+        '-loglevel', 'error',
+        '-probesize', '32',
+        '-analyzeduration', '0',
+        '-i', 'pipe:0',
+        '-vn',
+        '-c:a', 'libopus',
+        '-ac', channels.toString(),
+        '-ar', '48000',
+        '-b:a', bitrate,
+        '-application', profile,
+        '-vbr', 'on',
+        '-compression_level', '0',
+        '-frame_duration', '20',
+        '-map_metadata', '-1',
+        '-f', 'opus',
+        'pipe:1'
+    ];
+    const ffmpeg = spawn(bin, args);
+    // Handle Input
+    if (typeof input === 'string') {
+        if (/^https?:\/\//.test(input)) {
+            const lib = input.startsWith('https') ? https : http;
+            lib.get(input, { headers: { 'User-Agent': 'Mozilla/5.0' } }, (res) => {
+                if (res.statusCode !== 200) {
+                    outputStream.emit('error', new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                res.pipe(ffmpeg.stdin);
+            }).on('error', (err) => {
+                outputStream.emit('error', err);
+            });
+        }
+        else {
+            if (!fs.existsSync(input)) {
+                outputStream.emit('error', new Error(`File not found: ${input}`));
+            }
+            else {
+                fs.createReadStream(input).pipe(ffmpeg.stdin);
+            }
+        }
+    }
+    else if (input instanceof Readable) {
+        input.pipe(ffmpeg.stdin);
+    }
+    // Handle Output
+    ffmpeg.stdout.pipe(outputStream);
+    // Error Handling
+    ffmpeg.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            const msg = `FFmpeg not found at "${bin}". Please ensure it is installed.`;
+            outputStream.emit('error', new Error(msg));
+        }
+        else {
+            outputStream.emit('error', err);
+        }
+    });
+    ffmpeg.stdin.on('error', () => { });
+    return outputStream;
+}
+/**
+ * Converts an Ogg Opus stream into a stream of raw Opus packets,
+ * suitable for `@discordjs/voice` with `StreamType.Opus`.
+ *
+ * @param oggInput A Readable stream containing Ogg Opus data.
+ * @returns A Readable stream emitting raw Opus packets (Buffers).
+ */
+export function OggToOpusStream(oggInput) {
+    const demuxer = new OggDemuxer();
+    oggInput.pipe(demuxer);
+    return demuxer;
+}
+/**
+ * Legacy support for file-based conversion (Async)
+ */
+export async function EngineOggFile(id, input, options = {}) {
+    const TEMP_DIR = path.resolve(process.cwd(), 'temp_audio');
+    if (!fs.existsSync(TEMP_DIR))
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+    const ts = Date.now();
+    const outputFile = path.join(TEMP_DIR, `out_${id}_${ts}.ogg`);
+    const stream = EngineOgg(input, options);
+    const writeStream = fs.createWriteStream(outputFile);
+    return new Promise((resolve, reject) => {
+        stream.pipe(writeStream);
+        writeStream.on('finish', () => resolve(outputFile));
+        writeStream.on('error', reject);
+        stream.on('error', reject);
+    });
+}
+export default EngineOgg;

package/dist/esm/oggDemuxer.js

@@ -0,0 +1,165 @@
+import { Transform } from 'node:stream';
+// Constants for Ogg parsing
+const OGG_CAPTURE_PATTERN = 0x4f676753; // 'OggS'
+const OGG_HEADER_SIZE = 27; // Fixed size of Ogg page header
+// Opus header types
+const OPUS_HEAD_SIGNATURE = Buffer.from('OpusHead');
+const OPUS_TAGS_SIGNATURE = Buffer.from('OpusTags');
+/**
+ * A Transform stream that demuxes Ogg Opus streams, extracting raw Opus packets.
+ * It parses Ogg pages and emits individual Opus packets as Buffers.
+ */
+export class OggDemuxer extends Transform {
+    buffer;
+    currentGranulePosition;
+    bitstreamSerialNumber;
+    pageSequenceNumber;
+    opusHeadParsed;
+    opusTagsParsed;
+    constructor() {
+        super({ readableObjectMode: true }); // Emits Opus packets as objects (Buffers)
+        this.buffer = Buffer.alloc(0);
+        this.currentGranulePosition = 0n;
+        this.bitstreamSerialNumber = null;
+        this.pageSequenceNumber = 0;
+        this.opusHeadParsed = false;
+        this.opusTagsParsed = false;
+    }
+    _transform(chunk, encoding, callback) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.parseBuffer();
+        callback();
+    }
+    _flush(callback) {
+        // Attempt to parse any remaining data in the buffer
+        this.parseBuffer();
+        if (this.buffer.length > 0) {
+            this.emit('warn', `OggDemuxer: Remaining unparsed data in buffer: ${this.buffer.length} bytes`);
+        }
+        callback();
+    }
+    parseBuffer() {
+        while (this.buffer.length >= OGG_HEADER_SIZE) {
+            const header = this.parsePageHeader(this.buffer);
+            if (!header) {
+                // No valid OggS pattern found at current position, try to resync
+                const nextOggS = this.buffer.indexOf(Buffer.from("OggS"), 1); // Search from next byte
+                if (nextOggS === -1) {
+                    // No more OggS patterns, clear buffer and wait for more data
+                    this.buffer = Buffer.alloc(0);
+                    break;
+                }
+                else {
+                    // Resync: discard data until next OggS
+                    this.emit("debug", `OggDemuxer: Resyncing, discarding ${nextOggS} bytes.`);
+                    this.buffer = this.buffer.subarray(nextOggS);
+                    continue;
+                }
+            }
+            const pageLength = OGG_HEADER_SIZE + header.pageSegments + header.segmentTable.reduce((a, b) => a + b, 0);
+            if (this.buffer.length < pageLength) {
+                // Not enough data for the full page, wait for more
+                break;
+            }
+            // Validate bitstream serial number for logical stream continuity
+            if (this.bitstreamSerialNumber === null) {
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+            }
+            else if (this.bitstreamSerialNumber !== header.bitstreamSerialNumber) {
+                // This indicates a new logical bitstream, which is fine for concatenated Ogg files
+                // For simplicity, we'll just reset state for the new stream
+                this.bitstreamSerialNumber = header.bitstreamSerialNumber;
+                this.opusHeadParsed = false;
+                this.opusTagsParsed = false;
+                this.pageSequenceNumber = 0;
+                this.currentGranulePosition = 0n;
+                this.emit('warn', `OggDemuxer: Detected new logical bitstream (serial: ${header.bitstreamSerialNumber})`);
+            }
+            // Check page sequence number for continuity (optional, but good for error detection)
+            if (!(header.headerTypeFlag & 0x02) && header.pageSequenceNumber !== this.pageSequenceNumber) {
+                this.emit("warn", `OggDemuxer: Page sequence discontinuity detected. Expected ${this.pageSequenceNumber}, got ${header.pageSequenceNumber}.`);
+                // We can still try to process, but this might indicate corruption
+            }
+            this.pageSequenceNumber = header.pageSequenceNumber + 1;
+            this.currentGranulePosition = header.granulePosition;
+            // Extract packet data
+            let packetOffset = OGG_HEADER_SIZE + header.pageSegments;
+            let currentPacketBuffer = Buffer.alloc(0);
+            for (let i = 0; i < header.segmentTable.length; i++) {
+                const segmentLength = header.segmentTable[i];
+                const segmentData = this.buffer.subarray(packetOffset, packetOffset + segmentLength);
+                currentPacketBuffer = Buffer.concat([currentPacketBuffer, segmentData]);
+                packetOffset += segmentLength;
+                // If segment is less than 255, it's the end of a packet
+                if (segmentLength < 255 || i === header.segmentTable.length - 1) {
+                    this.processPacket(currentPacketBuffer);
+                    currentPacketBuffer = Buffer.alloc(0);
+                }
+            }
+            // Remove processed page from buffer
+            this.buffer = this.buffer.subarray(pageLength);
+        }
+    }
+    parsePageHeader(buffer) {
+        // Check capture pattern 'OggS'
+        // OGG_CAPTURE_PATTERN is 0x4f676753. buffer.readUInt32LE(0) reads 0x5367674f on little-endian systems.
+        // So we need to compare with Buffer.from("OggS").readUInt32LE(0)
+        if (buffer.readUInt32LE(0) !== Buffer.from("OggS").readUInt32LE(0)) {
+            return null;
+        }
+        const header = {
+            capturePattern: buffer.readUInt32LE(0),
+            streamStructureVersion: buffer.readUInt8(4),
+            headerTypeFlag: buffer.readUInt8(5),
+            granulePosition: buffer.readBigInt64LE(6),
+            bitstreamSerialNumber: buffer.readUInt32LE(14),
+            pageSequenceNumber: buffer.readUInt32LE(18),
+            pageChecksum: buffer.readUInt32LE(22),
+            pageSegments: buffer.readUInt8(26),
+            segmentTable: [],
+        };
+        // Read segment table
+        const segmentTableOffset = OGG_HEADER_SIZE;
+        for (let i = 0; i < header.pageSegments; i++) {
+            header.segmentTable.push(buffer.readUInt8(segmentTableOffset + i));
+        }
+        return header;
+    }
+    processPacket(packet) {
+        // The first two packets in an Ogg Opus stream are OpusHead and OpusTags
+        if (!this.opusHeadParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_HEAD_SIGNATURE)) {
+                // This is the OpusHead packet (identification header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusHeadParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusHead packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusHead packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        if (!this.opusTagsParsed) {
+            if (packet.subarray(0, 8).equals(OPUS_TAGS_SIGNATURE)) {
+                // This is the OpusTags packet (comment header)
+                // We don't need to emit it as a raw Opus frame for @discordjs/voice
+                this.opusTagsParsed = true;
+                this.emit("debug", `OggDemuxer: Parsed OpusTags packet. Length: ${packet.length}`);
+            }
+            else {
+                this.emit("warn", `OggDemuxer: Expected OpusTags packet but got something else. Packet length: ${packet.length}, first 8 bytes: ${packet.subarray(0, 8).toString()}`);
+                // Potentially a malformed stream or not an Opus stream
+            }
+            return;
+        }
+        // After OpusHead and OpusTags, all subsequent packets are raw Opus frames
+        if (this.opusHeadParsed && this.opusTagsParsed) {
+            this.emit("debug", `OggDemuxer: Emitting Opus packet. Length: ${packet.length}`);
+            this.push(packet);
+        }
+        else {
+            this.emit("debug", `OggDemuxer: Skipping non-Opus data before headers. Length: ${packet.length}`);
+        }
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+import { Readable } from 'node:stream';
+/**
+ * EngineOgg Configuration Options
+ */
+export interface EngineOggOptions {
+    profile?: 'voip' | 'audio';
+    forceStereo?: boolean;
+    bitrate?: string;
+    preset?: string;
+    ffmpegPath?: string;
+}
+/**
+ * Converts audio to OGG Opus compatible with WhatsApp (iPhone) and Discord.
+ * Optimized for ultra-low latency and minimal CPU stress using streaming.
+ */
+export declare function EngineOgg(input: string | Readable, options?: EngineOggOptions): Readable;
+/**
+ * Converts an Ogg Opus stream into a stream of raw Opus packets,
+ * suitable for `@discordjs/voice` with `StreamType.Opus`.
+ *
+ * @param oggInput A Readable stream containing Ogg Opus data.
+ * @returns A Readable stream emitting raw Opus packets (Buffers).
+ */
+export declare function OggToOpusStream(oggInput: Readable): Readable;
+/**
+ * Legacy support for file-based conversion (Async)
+ */
+export declare function EngineOggFile(id: string | number, input: string | Readable, options?: EngineOggOptions): Promise<string>;
+export default EngineOgg;

package/dist/types/oggDemuxer.d.ts

@@ -0,0 +1,19 @@
+import { Transform, TransformCallback } from 'node:stream';
+/**
+ * A Transform stream that demuxes Ogg Opus streams, extracting raw Opus packets.
+ * It parses Ogg pages and emits individual Opus packets as Buffers.
+ */
+export declare class OggDemuxer extends Transform {
+    private buffer;
+    private currentGranulePosition;
+    private bitstreamSerialNumber;
+    private pageSequenceNumber;
+    private opusHeadParsed;
+    private opusTagsParsed;
+    constructor();
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private parseBuffer;
+    private parsePageHeader;
+    private processPacket;
+}

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

@@ -0,0 +1,29 @@
+import { Readable } from 'node:stream';
+/**
+ * EngineOgg Configuration Options
+ */
+export interface EngineOggOptions {
+    profile?: 'voip' | 'audio';
+    forceStereo?: boolean;
+    bitrate?: string;
+    preset?: string;
+    ffmpegPath?: string;
+}
+/**
+ * Converts audio to OGG Opus compatible with WhatsApp (iPhone) and Discord.
+ * Optimized for ultra-low latency and minimal CPU stress using streaming.
+ */
+export declare function EngineOgg(input: string | Readable, options?: EngineOggOptions): Readable;
+/**
+ * Converts an Ogg Opus stream into a stream of raw Opus packets,
+ * suitable for `@discordjs/voice` with `StreamType.Opus`.
+ *
+ * @param oggInput A Readable stream containing Ogg Opus data.
+ * @returns A Readable stream emitting raw Opus packets (Buffers).
+ */
+export declare function OggToOpusStream(oggInput: Readable): Readable;
+/**
+ * Legacy support for file-based conversion (Async)
+ */
+export declare function EngineOggFile(id: string | number, input: string | Readable, options?: EngineOggOptions): Promise<string>;
+export default EngineOgg;

package/dist/types/src/oggDemuxer.d.ts

@@ -0,0 +1,19 @@
+import { Transform, TransformCallback } from 'node:stream';
+/**
+ * A Transform stream that demuxes Ogg Opus streams, extracting raw Opus packets.
+ * It parses Ogg pages and emits individual Opus packets as Buffers.
+ */
+export declare class OggDemuxer extends Transform {
+    private buffer;
+    private currentGranulePosition;
+    private bitstreamSerialNumber;
+    private pageSequenceNumber;
+    private opusHeadParsed;
+    private opusTagsParsed;
+    constructor();
+    _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private parseBuffer;
+    private parsePageHeader;
+    private processPacket;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@boruto_vk7/opus-ogg",
+  "version": "1.2.0",
+  "description": "Ultra-fast Audio to OGG Opus converter for WhatsApp (iPhone) and Discord",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "author": "eduh_dev021 (Borutovk7)",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "bin",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Borutovk7/opus-ogg.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json && node -e \"const fs = require('fs'); if (!fs.existsSync('dist/cjs')) fs.mkdirSync('dist/cjs', {recursive:true}); if (!fs.existsSync('dist/esm')) fs.mkdirSync('dist/esm', {recursive:true}); fs.writeFileSync('dist/cjs/package.json', JSON.stringify({type:'commonjs'})); fs.writeFileSync('dist/esm/package.json', JSON.stringify({type:'module'}));\"",
+    "test": "node test.mjs",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/install-ffmpeg.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}