valley-baileys 1.0.0

package/node_modules/music-metadata/lib/ogg/OggParser.js

@@ -0,0 +1,125 @@
+import * as Token from 'token-types';
+import { EndOfStreamError } from 'strtok3';
+import initDebug from 'debug';
+import { BasicParser } from '../common/BasicParser.js';
+import { VorbisStream } from './vorbis/VorbisStream.js';
+import { OpusStream } from './opus/OpusStream.js';
+import { SpeexStream } from './speex/SpeexStream.js';
+import { TheoraStream } from './theora/TheoraStream.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { PageHeader, SegmentTable } from './OggToken.js';
+import { FlacStream } from './flac/FlacStream.js';
+export class OggContentError extends makeUnexpectedFileContentError('Ogg') {
+}
+const debug = initDebug('music-metadata:parser:ogg');
+class OggStream {
+    constructor(metadata, streamSerial, options) {
+        this.pageNumber = 0;
+        this.closed = false;
+        this.metadata = metadata;
+        this.streamSerial = streamSerial;
+        this.options = options;
+    }
+    async parsePage(tokenizer, header) {
+        this.pageNumber = header.pageSequenceNo;
+        debug('serial=%s page#=%s, Ogg.id=%s', header.streamSerialNumber, header.pageSequenceNo, header.capturePattern);
+        const segmentTable = await tokenizer.readToken(new SegmentTable(header));
+        debug('totalPageSize=%s', segmentTable.totalPageSize);
+        const pageData = await tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
+        debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
+        if (header.headerType.firstPage) {
+            this.metadata.setFormat('container', 'Ogg');
+            const idData = pageData.subarray(0, 7); // Copy this portion
+            const asciiId = Array.from(idData)
+                .filter(b => b >= 32 && b <= 126) // Keep only printable ASCII
+                .map(b => String.fromCharCode(b))
+                .join('');
+            switch (asciiId) {
+                case 'vorbis': // Ogg/Vorbis
+                    debug(`Set Ogg stream serial ${header.streamSerialNumber}, codec=Vorbis`);
+                    this.pageConsumer = new VorbisStream(this.metadata, this.options);
+                    break;
+                case 'OpusHea': // Ogg/Opus
+                    debug('Set page consumer to Ogg/Opus');
+                    this.pageConsumer = new OpusStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'Speex  ': // Ogg/Speex
+                    debug('Set page consumer to Ogg/Speex');
+                    this.pageConsumer = new SpeexStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'fishead':
+                case 'theora': // Ogg/Theora
+                    debug('Set page consumer to Ogg/Theora');
+                    this.pageConsumer = new TheoraStream(this.metadata, this.options, tokenizer);
+                    break;
+                case 'FLAC': // Ogg/Theora
+                    debug('Set page consumer to Vorbis');
+                    this.pageConsumer = new FlacStream(this.metadata, this.options, tokenizer);
+                    break;
+                default:
+                    throw new OggContentError(`Ogg codec not recognized (id=${asciiId}`);
+            }
+        }
+        if (header.headerType.lastPage) {
+            this.closed = true;
+        }
+        if (this.pageConsumer) {
+            await this.pageConsumer.parsePage(header, pageData);
+        }
+        else
+            throw new Error('pageConsumer should be initialized');
+    }
+}
+/**
+ * Parser for Ogg logical bitstream framing
+ */
+export class OggParser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.streams = new Map();
+    }
+    /**
+     * Parse page
+     * @returns {Promise<void>}
+     */
+    async parse() {
+        this.streams = new Map();
+        let enfOfStream = false;
+        let header;
+        try {
+            do {
+                header = await this.tokenizer.readToken(PageHeader);
+                if (header.capturePattern !== 'OggS')
+                    throw new OggContentError('Invalid Ogg capture pattern');
+                let stream = this.streams.get(header.streamSerialNumber);
+                if (!stream) {
+                    stream = new OggStream(this.metadata, header.streamSerialNumber, this.options);
+                    this.streams.set(header.streamSerialNumber, stream);
+                }
+                await stream.parsePage(this.tokenizer, header);
+                if (stream.pageNumber > 12 && !(this.options.duration && [...this.streams.values()].find(stream => stream.pageConsumer?.durationOnLastPage))) {
+                    debug("Stop processing Ogg stream");
+                    break;
+                }
+            } while (![...this.streams.values()].every(item => item.closed));
+        }
+        catch (err) {
+            if (err instanceof EndOfStreamError) {
+                debug("Reached end-of-stream");
+                enfOfStream = true;
+            }
+            else if (err instanceof OggContentError) {
+                this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
+            }
+            else
+                throw err;
+        }
+        for (const stream of this.streams.values()) {
+            if (!stream.closed) {
+                this.metadata.addWarning(`End-of-stream reached before reaching last page in Ogg stream serial=${stream.streamSerial}`);
+                await stream.pageConsumer?.flush();
+            }
+            stream.pageConsumer?.calculateDuration(enfOfStream);
+        }
+    }
+}

package/node_modules/music-metadata/lib/ogg/OggToken.d.ts

@@ -0,0 +1,83 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * Page header
+ * Ref: https://www.xiph.org/ogg/doc/framing.html#page_header
+ */
+export interface IPageHeader {
+    /**
+     * capture_pattern
+     * A header begins with a capture pattern that simplifies identifying pages;
+     * once the decoder has found the capture pattern it can do a more intensive job of verifying that it has in fact found a page boundary (as opposed to an inadvertent coincidence in the byte stream).
+     */
+    capturePattern: string;
+    /**
+     * stream_structure_version
+     */
+    version: number;
+    /**
+     * header_type_flag
+     */
+    headerType: {
+        /**
+         * True: continued packet;
+         * False: fresh packet
+         */
+        continued: boolean;
+        /**
+         * True: first page of logical bitstream (bos)
+         * False: not first page of logical bitstream
+         */
+        firstPage: boolean;
+        /**
+         * True: last page of logical bitstream (eos)
+         * False: not last page of logical bitstream
+         */
+        lastPage: boolean;
+    };
+    /**
+     * The total samples encoded after including all packets finished on this page
+     * The position specified in the frame header of the last page tells how long the data coded by the bitstream is.
+     */
+    absoluteGranulePosition: number;
+    streamSerialNumber: number;
+    pageSequenceNo: number;
+    pageChecksum: number;
+    /**
+     * The number of segment entries to appear in the segment table.
+     * The maximum number of 255 segments (255 bytes each) sets the maximum possible physical page size at 65307 bytes or
+     * just under 64kB (thus we know that a header corrupted so as destroy sizing/alignment information will not cause a
+     * runaway bitstream. We'll read in the page according to the corrupted size information that's guaranteed to be a
+     * reasonable size regardless, notice the checksum mismatch, drop sync and then look for recapture).
+     */
+    page_segments: number;
+}
+export declare const PageHeader: IGetToken<IPageHeader>;
+export interface ISegmentTable {
+    totalPageSize: number;
+}
+export declare class SegmentTable implements IGetToken<ISegmentTable> {
+    private static sum;
+    len: number;
+    constructor(header: IPageHeader);
+    get(buf: Uint8Array, off: number): ISegmentTable;
+}
+export interface IPageConsumer {
+    /**
+     * Need to parse to end to be able to calculate the duration
+     */
+    durationOnLastPage: boolean;
+    /**
+     * Parse Ogg page
+     * @param header Ogg page header
+     * @param pageData Ogg page data
+     */
+    parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
+    /**
+     * Calculate duration of provided header
+     */
+    calculateDuration(enfOfStream: boolean): void;
+    /**
+     * Force to parse pending segments
+     */
+    flush(): Promise<void>;
+}

package/node_modules/music-metadata/lib/ogg/OggToken.js

@@ -0,0 +1,41 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import { StringType } from 'token-types';
+export const PageHeader = {
+    len: 27,
+    get: (buf, off) => {
+        return {
+            capturePattern: new StringType(4, 'latin1').get(buf, off),
+            version: Token.UINT8.get(buf, off + 4),
+            headerType: {
+                continued: util.getBit(buf, off + 5, 0),
+                firstPage: util.getBit(buf, off + 5, 1),
+                lastPage: util.getBit(buf, off + 5, 2)
+            },
+            // packet_flag: Token.UINT8.get(buf, off + 5),
+            absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
+            streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
+            pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),
+            pageChecksum: Token.UINT32_LE.get(buf, off + 22),
+            page_segments: Token.UINT8.get(buf, off + 26)
+        };
+    }
+};
+export class SegmentTable {
+    static sum(buf, off, len) {
+        const dv = new DataView(buf.buffer, 0);
+        let s = 0;
+        for (let i = off; i < off + len; ++i) {
+            s += dv.getUint8(i);
+        }
+        return s;
+    }
+    constructor(header) {
+        this.len = header.page_segments;
+    }
+    get(buf, off) {
+        return {
+            totalPageSize: SegmentTable.sum(buf, off, this.len)
+        };
+    }
+}

package/node_modules/music-metadata/lib/ogg/flac/FlacStream.d.ts

@@ -0,0 +1,29 @@
+import type { ITokenizer } from 'strtok3';
+import type * as Ogg from '../OggToken.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Ref:
+ * - https://xiph.org/flac/ogg_mapping.html
+ */
+export declare class FlacStream implements Ogg.IPageConsumer {
+    private metadata;
+    private options;
+    private tokenizer;
+    private flacParser;
+    durationOnLastPage: boolean;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    calculateDuration(): void;
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    private parseDataBlock;
+    flush(): Promise<void>;
+}

package/node_modules/music-metadata/lib/ogg/flac/FlacStream.js

@@ -0,0 +1,74 @@
+import initDebug from 'debug';
+import * as Flac from '../../flac/FlacToken.js';
+import { FlacParser } from '../../flac/FlacParser.js';
+import { FourCcToken } from '../../common/FourCC.js';
+import { VorbisPictureToken } from '../vorbis/Vorbis.js';
+const debug = initDebug('music-metadata:parser:ogg:theora');
+/**
+ * Ref:
+ * - https://xiph.org/flac/ogg_mapping.html
+ */
+export class FlacStream {
+    constructor(metadata, options, tokenizer) {
+        this.durationOnLastPage = false;
+        this.metadata = metadata;
+        this.options = options;
+        this.tokenizer = tokenizer;
+        this.flacParser = new FlacParser(this.metadata, this.tokenizer, options);
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    async parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            await this.parseFirstPage(header, pageData);
+        }
+    }
+    calculateDuration() {
+        debug('duration calculation not implemented');
+    }
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    async parseFirstPage(_header, pageData) {
+        debug('First Ogg/FLAC page');
+        const fourCC = await FourCcToken.get(pageData, 9);
+        if (fourCC.toString() !== 'fLaC') {
+            throw new Error('Invalid FLAC preamble');
+        }
+        const blockHeader = await Flac.BlockHeader.get(pageData, 13);
+        await this.parseDataBlock(blockHeader, pageData.subarray(13 + Flac.BlockHeader.len));
+    }
+    async parseDataBlock(blockHeader, pageData) {
+        debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
+        switch (blockHeader.type) {
+            case Flac.BlockType.STREAMINFO: {
+                const streamInfo = Flac.BlockStreamInfo.get(pageData, 0);
+                return this.flacParser.processsStreamInfo(streamInfo);
+            }
+            case Flac.BlockType.PADDING:
+                break;
+            case Flac.BlockType.APPLICATION:
+                break;
+            case Flac.BlockType.SEEKTABLE:
+                break;
+            case Flac.BlockType.VORBIS_COMMENT:
+                return this.flacParser.parseComment(pageData);
+            case Flac.BlockType.PICTURE:
+                if (!this.options.skipCovers) {
+                    const picture = new VorbisPictureToken(pageData.length).get(pageData, 0);
+                    return this.flacParser.addPictureTag(picture);
+                }
+                break;
+            default:
+                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+        }
+        // Ignore data block
+        return this.tokenizer.ignore(blockHeader.length).then();
+    }
+    flush() {
+        return Promise.resolve();
+    }
+}

package/node_modules/music-metadata/lib/ogg/opus/Opus.d.ts

@@ -0,0 +1,63 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * Opus ID Header interface
+ * Ref: https://wiki.xiph.org/OggOpus#ID_Header
+ */
+export interface IIdHeader {
+    /**
+     * Magic signature: "OpusHead" (64 bits)
+     */
+    magicSignature: string;
+    /**
+     * Version number (8 bits unsigned): 0x01 for this spec
+     */
+    version: number;
+    /**
+     * Channel count 'c' (8 bits unsigned): MUST be > 0
+     */
+    channelCount: number;
+    /**
+     * Pre-skip (16 bits unsigned, little endian)
+     */
+    preSkip: number;
+    /**
+     * Input sample rate (32 bits unsigned, little endian): informational only
+     */
+    inputSampleRate: number;
+    /**
+     * Output gain (16 bits, little endian, signed Q7.8 in dB) to apply when decoding
+     */
+    outputGain: number;
+    /**
+     * Channel mapping family (8 bits unsigned)
+     * -  0 = one stream: mono or L,R stereo
+     * -  1 = channels in vorbis spec order: mono or L,R stereo or ... or FL,C,FR,RL,RR,LFE, ...
+     * -  2..254 = reserved (treat as 255)
+     * -  255 = no defined channel meaning
+     */
+    channelMapping: number;
+}
+declare const OpusContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class OpusContentError extends OpusContentError_base {
+}
+/**
+ * Opus ID Header parser
+ * Ref: https://wiki.xiph.org/OggOpus#ID_Header
+ */
+export declare class IdHeader implements IGetToken<IIdHeader> {
+    len: number;
+    constructor(len: number);
+    get(buf: Uint8Array, off: number): IIdHeader;
+}
+export {};

package/node_modules/music-metadata/lib/ogg/opus/Opus.js

@@ -0,0 +1,27 @@
+import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../../ParseError.js';
+export class OpusContentError extends makeUnexpectedFileContentError('Opus') {
+}
+/**
+ * Opus ID Header parser
+ * Ref: https://wiki.xiph.org/OggOpus#ID_Header
+ */
+export class IdHeader {
+    constructor(len) {
+        if (len < 19) {
+            throw new OpusContentError('ID-header-page 0 should be at least 19 bytes long');
+        }
+        this.len = len;
+    }
+    get(buf, off) {
+        return {
+            magicSignature: new Token.StringType(8, 'ascii').get(buf, off + 0),
+            version: Token.UINT8.get(buf, off + 8),
+            channelCount: Token.UINT8.get(buf, off + 9),
+            preSkip: Token.UINT16_LE.get(buf, off + 10),
+            inputSampleRate: Token.UINT32_LE.get(buf, off + 12),
+            outputGain: Token.UINT16_LE.get(buf, off + 16),
+            channelMapping: Token.UINT8.get(buf, off + 18)
+        };
+    }
+}

package/node_modules/music-metadata/lib/ogg/opus/OpusStream.d.ts

@@ -0,0 +1,24 @@
+import type { ITokenizer } from 'strtok3';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Opus parser
+ * Internet Engineering Task Force (IETF) - RFC 6716
+ * Used by OggStream
+ */
+export declare class OpusStream extends VorbisStream {
+    private idHeader;
+    private lastPos;
+    private tokenizer;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Parse first Opus Ogg page
+     * @param {IPageHeader} header
+     * @param {Uint8Array} pageData
+     */
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFullPage(pageData: Uint8Array): Promise<void>;
+    calculateDuration(enfOfStream: boolean): void;
+}

package/node_modules/music-metadata/lib/ogg/opus/OpusStream.js

@@ -0,0 +1,56 @@
+import * as Token from 'token-types';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
+import * as Opus from './Opus.js';
+import { OpusContentError } from './Opus.js';
+/**
+ * Opus parser
+ * Internet Engineering Task Force (IETF) - RFC 6716
+ * Used by OggStream
+ */
+export class OpusStream extends VorbisStream {
+    constructor(metadata, options, tokenizer) {
+        super(metadata, options);
+        this.idHeader = null;
+        this.lastPos = -1;
+        this.tokenizer = tokenizer;
+        this.durationOnLastPage = true;
+    }
+    /**
+     * Parse first Opus Ogg page
+     * @param {IPageHeader} header
+     * @param {Uint8Array} pageData
+     */
+    parseFirstPage(_header, pageData) {
+        this.metadata.setFormat('codec', 'Opus');
+        // Parse Opus ID Header
+        this.idHeader = new Opus.IdHeader(pageData.length).get(pageData, 0);
+        if (this.idHeader.magicSignature !== "OpusHead")
+            throw new OpusContentError("Illegal ogg/Opus magic-signature");
+        this.metadata.setFormat('sampleRate', this.idHeader.inputSampleRate);
+        this.metadata.setFormat('numberOfChannels', this.idHeader.channelCount);
+        this.metadata.setAudioOnly();
+    }
+    async parseFullPage(pageData) {
+        const magicSignature = new Token.StringType(8, 'ascii').get(pageData, 0);
+        switch (magicSignature) {
+            case 'OpusTags':
+                await this.parseUserCommentList(pageData, 8);
+                this.lastPos = this.tokenizer.position - pageData.length;
+                break;
+            default:
+                break;
+        }
+    }
+    calculateDuration(enfOfStream) {
+        if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+            // Calculate duration
+            const pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
+            this.metadata.setFormat('numberOfSamples', pos_48bit);
+            this.metadata.setFormat('duration', pos_48bit / 48000);
+            if (this.lastPos !== -1 && this.tokenizer.fileInfo.size && this.metadata.format.duration) {
+                const dataSize = this.tokenizer.fileInfo.size - this.lastPos;
+                this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
+            }
+        }
+    }
+}

package/node_modules/music-metadata/lib/ogg/speex/Speex.d.ts

@@ -0,0 +1,36 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * Speex Header Packet
+ * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
+ */
+export interface IHeader {
+    /**
+     * speex_string, char[] 8
+     */
+    speex: string;
+    /**
+     * speex_version, char[] 20
+     */
+    version: string;
+    /**
+     * Version id
+     */
+    version_id: number;
+    header_size: number;
+    rate: number;
+    mode: number;
+    mode_bitstream_version: number;
+    nb_channels: number;
+    bitrate: number;
+    frame_size: number;
+    vbr: number;
+    frames_per_packet: number;
+    extra_headers: number;
+    reserved1: number;
+    reserved2: number;
+}
+/**
+ * Speex Header Packet
+ * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
+ */
+export declare const Header: IGetToken<IHeader>;

package/node_modules/music-metadata/lib/ogg/speex/Speex.js

@@ -0,0 +1,28 @@
+import * as Token from 'token-types';
+import * as util from '../../common/Util.js';
+/**
+ * Speex Header Packet
+ * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
+ */
+export const Header = {
+    len: 80,
+    get: (buf, off) => {
+        return {
+            speex: new Token.StringType(8, 'ascii').get(buf, off + 0),
+            version: util.trimRightNull(new Token.StringType(20, 'ascii').get(buf, off + 8)),
+            version_id: Token.INT32_LE.get(buf, off + 28),
+            header_size: Token.INT32_LE.get(buf, off + 32),
+            rate: Token.INT32_LE.get(buf, off + 36),
+            mode: Token.INT32_LE.get(buf, off + 40),
+            mode_bitstream_version: Token.INT32_LE.get(buf, off + 44),
+            nb_channels: Token.INT32_LE.get(buf, off + 48),
+            bitrate: Token.INT32_LE.get(buf, off + 52),
+            frame_size: Token.INT32_LE.get(buf, off + 56),
+            vbr: Token.INT32_LE.get(buf, off + 60),
+            frames_per_packet: Token.INT32_LE.get(buf, off + 64),
+            extra_headers: Token.INT32_LE.get(buf, off + 68),
+            reserved1: Token.INT32_LE.get(buf, off + 72),
+            reserved2: Token.INT32_LE.get(buf, off + 76)
+        };
+    }
+};

package/node_modules/music-metadata/lib/ogg/speex/SpeexStream.d.ts

@@ -0,0 +1,20 @@
+import type { ITokenizer } from 'strtok3';
+import type { IPageHeader } from '../OggToken.js';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Speex, RFC 5574
+ * Ref:
+ * - https://www.speex.org/docs/manual/speex-manual/
+ * - https://tools.ietf.org/html/rfc5574
+ */
+export declare class SpeexStream extends VorbisStream {
+    constructor(metadata: INativeMetadataCollector, options: IOptions, _tokenizer: ITokenizer);
+    /**
+     * Parse first Speex Ogg page
+     * @param {IPageHeader} header
+     * @param {Uint8Array} pageData
+     */
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
+}

package/node_modules/music-metadata/lib/ogg/speex/SpeexStream.js

@@ -0,0 +1,31 @@
+import initDebug from 'debug';
+import { VorbisStream } from '../vorbis/VorbisStream.js';
+import * as Speex from './Speex.js';
+const debug = initDebug('music-metadata:parser:ogg:speex');
+/**
+ * Speex, RFC 5574
+ * Ref:
+ * - https://www.speex.org/docs/manual/speex-manual/
+ * - https://tools.ietf.org/html/rfc5574
+ */
+export class SpeexStream extends VorbisStream {
+    constructor(metadata, options, _tokenizer) {
+        super(metadata, options);
+    }
+    /**
+     * Parse first Speex Ogg page
+     * @param {IPageHeader} header
+     * @param {Uint8Array} pageData
+     */
+    parseFirstPage(_header, pageData) {
+        debug('First Ogg/Speex page');
+        const speexHeader = Speex.Header.get(pageData, 0);
+        this.metadata.setFormat('codec', `Speex ${speexHeader.version}`);
+        this.metadata.setFormat('numberOfChannels', speexHeader.nb_channels);
+        this.metadata.setFormat('sampleRate', speexHeader.rate);
+        if (speexHeader.bitrate !== -1) {
+            this.metadata.setFormat('bitrate', speexHeader.bitrate);
+        }
+        this.metadata.setAudioOnly();
+    }
+}

package/node_modules/music-metadata/lib/ogg/theora/Theora.d.ts

@@ -0,0 +1,20 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * 6.2 Identification Header
+ * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
+ */
+export interface IIdentificationHeader {
+    id: string;
+    vmaj: number;
+    vmin: number;
+    vrev: number;
+    vmbw: number;
+    vmbh: number;
+    nombr: number;
+    nqual: number;
+}
+/**
+ * 6.2 Identification Header
+ * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
+ */
+export declare const IdentificationHeader: IGetToken<IIdentificationHeader>;