@dragon708/docmind-markdown 1.2.5 → 1.2.7

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

@@ -1,27 +1,23 @@
-import { BasicParser } from '../common/BasicParser.js';
-declare const OggContentError_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 OggContentError extends OggContentError_base {
+import { IGetToken } from 'strtok3/lib/core';
+import { BasicParser } from '../common/BasicParser';
+import * as Ogg from './Ogg';
+export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {
+    private static sum;
+    len: number;
+    constructor(header: Ogg.IPageHeader);
+    get(buf: any, off: any): Ogg.ISegmentTable;
 }
 /**
  * Parser for Ogg logical bitstream framing
  */
 export declare class OggParser extends BasicParser {
-    private streams;
+    private static Header;
+    private header;
+    private pageNumber;
+    private pageConsumer;
     /**
      * Parse page
      * @returns {Promise<void>}
      */
     parse(): Promise<void>;
 }
-export {};

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

@@ -1,125 +1,126 @@
-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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OggParser = exports.SegmentTable = void 0;
+const Token = require("token-types");
+const core_1 = require("strtok3/lib/core");
+const debug_1 = require("debug");
+const util = require("../common/Util");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const VorbisParser_1 = require("./vorbis/VorbisParser");
+const OpusParser_1 = require("./opus/OpusParser");
+const SpeexParser_1 = require("./speex/SpeexParser");
+const TheoraParser_1 = require("./theora/TheoraParser");
+const debug = (0, debug_1.default)('music-metadata:parser:ogg');
+class SegmentTable {
+    static sum(buf, off, len) {
+        let s = 0;
+        for (let i = off; i < off + len; ++i) {
+            s += buf[i];
         }
-        if (this.pageConsumer) {
-            await this.pageConsumer.parsePage(header, pageData);
-        }
-        else
-            throw new Error('pageConsumer should be initialized');
+        return s;
+    }
+    constructor(header) {
+        this.len = header.page_segments;
+    }
+    get(buf, off) {
+        return {
+            totalPageSize: SegmentTable.sum(buf, off, this.len)
+        };
     }
 }
+exports.SegmentTable = SegmentTable;
 /**
  * Parser for Ogg logical bitstream framing
  */
-export class OggParser extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.streams = new Map();
-    }
+class OggParser extends BasicParser_1.BasicParser {
     /**
      * Parse page
      * @returns {Promise<void>}
      */
     async parse() {
-        this.streams = new Map();
-        let enfOfStream = false;
-        let header;
+        debug('pos=%s, parsePage()', this.tokenizer.position);
         try {
+            let header;
             do {
-                header = await this.tokenizer.readToken(PageHeader);
+                header = await this.tokenizer.readToken(OggParser.Header);
                 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;
+                    throw new Error('Invalid Ogg capture pattern');
+                this.metadata.setFormat('container', 'Ogg');
+                this.header = header;
+                this.pageNumber = header.pageSequenceNo;
+                debug('page#=%s, Ogg.id=%s', header.pageSequenceNo, header.capturePattern);
+                const segmentTable = await this.tokenizer.readToken(new SegmentTable(header));
+                debug('totalPageSize=%s', segmentTable.totalPageSize);
+                const pageData = await this.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) {
+                    const id = new Token.StringType(7, 'ascii').get(Buffer.from(pageData), 0);
+                    switch (id) {
+                        case '\x01vorbis': // Ogg/Vorbis
+                            debug('Set page consumer to Ogg/Vorbis');
+                            this.pageConsumer = new VorbisParser_1.VorbisParser(this.metadata, this.options);
+                            break;
+                        case 'OpusHea': // Ogg/Opus
+                            debug('Set page consumer to Ogg/Opus');
+                            this.pageConsumer = new OpusParser_1.OpusParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        case 'Speex  ': // Ogg/Speex
+                            debug('Set page consumer to Ogg/Speex');
+                            this.pageConsumer = new SpeexParser_1.SpeexParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        case 'fishead':
+                        case '\x00theora': // Ogg/Theora
+                            debug('Set page consumer to Ogg/Theora');
+                            this.pageConsumer = new TheoraParser_1.TheoraParser(this.metadata, this.options, this.tokenizer);
+                            break;
+                        default:
+                            throw new Error('gg audio-codec not recognized (id=' + id + ')');
+                    }
                 }
-            } while (![...this.streams.values()].every(item => item.closed));
+                this.pageConsumer.parsePage(header, pageData);
+            } while (!header.headerType.lastPage);
         }
         catch (err) {
-            if (err instanceof EndOfStreamError) {
-                debug("Reached end-of-stream");
-                enfOfStream = true;
+            if (err instanceof core_1.EndOfStreamError) {
+                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
+                debug(`End-of-stream`);
+                this.metadata.addWarning('Last OGG-page is not marked with last-page flag');
+                if (this.header) {
+                    this.pageConsumer.calculateDuration(this.header);
+                }
             }
-            else if (err instanceof OggContentError) {
-                this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
+            else if (err.message.startsWith('FourCC')) {
+                if (this.pageNumber > 0) {
+                    // ignore this error: work-around if last OGG-page is not marked with last-page flag
+                    this.metadata.addWarning('Invalid FourCC ID, maybe last OGG-page is not marked with last-page flag');
+                    this.pageConsumer.flush();
+                }
             }
-            else
+            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);
         }
     }
 }
+OggParser.Header = {
+    len: 27,
+    get: (buf, off) => {
+        return {
+            capturePattern: FourCC_1.FourCcToken.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: buf.readUInt8(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)
+        };
+    }
+};
+exports.OggParser = OggParser;

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

@@ -1,4 +1,4 @@
-import type { IGetToken } from 'strtok3';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * Opus ID Header interface
  * Ref: https://wiki.xiph.org/OggOpus#ID_Header
@@ -37,20 +37,6 @@ export interface IIdHeader {
      */
     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
@@ -58,6 +44,5 @@ export declare class OpusContentError extends OpusContentError_base {
 export declare class IdHeader implements IGetToken<IIdHeader> {
     len: number;
     constructor(len: number);
-    get(buf: Uint8Array, off: number): IIdHeader;
+    get(buf: any, off: any): IIdHeader;
 }
-export {};

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

@@ -1,27 +1,28 @@
-import * as Token from 'token-types';
-import { makeUnexpectedFileContentError } from '../../ParseError.js';
-export class OpusContentError extends makeUnexpectedFileContentError('Opus') {
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdHeader = void 0;
+const Token = require("token-types");
 /**
  * Opus ID Header parser
  * Ref: https://wiki.xiph.org/OggOpus#ID_Header
  */
-export class IdHeader {
+class IdHeader {
     constructor(len) {
+        this.len = len;
         if (len < 19) {
-            throw new OpusContentError('ID-header-page 0 should be at least 19 bytes long');
+            throw new Error("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)
+            version: buf.readUInt8(off + 8),
+            channelCount: buf.readUInt8(off + 9),
+            preSkip: buf.readInt16LE(off + 10),
+            inputSampleRate: buf.readInt32LE(off + 12),
+            outputGain: buf.readInt16LE(off + 16),
+            channelMapping: buf.readUInt8(off + 18)
         };
     }
 }
+exports.IdHeader = IdHeader;

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { ITokenizer } from 'strtok3/lib/core';
+import { IPageHeader } from '../Ogg';
+import { VorbisParser } from '../vorbis/VorbisParser';
+import { IOptions } from '../../type';
+import { INativeMetadataCollector } from '../../common/MetadataCollector';
+/**
+ * Opus parser
+ * Internet Engineering Task Force (IETF) - RFC 6716
+ * Used by OggParser
+ */
+export declare class OpusParser extends VorbisParser {
+    private tokenizer;
+    private idHeader;
+    private lastPos;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Parse first Opus Ogg page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+    protected parseFullPage(pageData: Buffer): void;
+    calculateDuration(header: IPageHeader): void;
+}

package/node_modules/music-metadata/lib/ogg/opus/{OpusStream.js → OpusParser.js}

@@ -1,50 +1,49 @@
-import * as Token from 'token-types';
-import { VorbisStream } from '../vorbis/VorbisStream.js';
-import * as Opus from './Opus.js';
-import { OpusContentError } from './Opus.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpusParser = void 0;
+const Token = require("token-types");
+const VorbisParser_1 = require("../vorbis/VorbisParser");
+const Opus = require("./Opus");
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
- * Used by OggStream
+ * Used by OggParser
  */
-export class OpusStream extends VorbisStream {
+class OpusParser extends VorbisParser_1.VorbisParser {
     constructor(metadata, options, tokenizer) {
         super(metadata, options);
-        this.idHeader = null;
-        this.lastPos = -1;
         this.tokenizer = tokenizer;
-        this.durationOnLastPage = true;
+        this.lastPos = -1;
     }
     /**
      * Parse first Opus Ogg page
      * @param {IPageHeader} header
-     * @param {Uint8Array} pageData
+     * @param {Buffer} pageData
      */
-    parseFirstPage(_header, 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");
+            throw new Error("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) {
+    parseFullPage(pageData) {
         const magicSignature = new Token.StringType(8, 'ascii').get(pageData, 0);
         switch (magicSignature) {
             case 'OpusTags':
-                await this.parseUserCommentList(pageData, 8);
+                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) {
+    calculateDuration(header) {
+        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
             // Calculate duration
-            const pos_48bit = this.lastPageHeader.absoluteGranulePosition - this.idHeader.preSkip;
+            const pos_48bit = header.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) {
@@ -54,3 +53,4 @@ export class OpusStream extends VorbisStream {
         }
     }
 }
+exports.OpusParser = OpusParser;

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

@@ -1,4 +1,4 @@
-import type { IGetToken } from 'strtok3';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * Speex Header Packet
  * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000

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

@@ -1,28 +1,31 @@
-import * as Token from 'token-types';
-import * as util from '../../common/Util.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Header = void 0;
+const Token = require("token-types");
+const util = require("../../common/Util");
 /**
  * Speex Header Packet
  * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000
  */
-export const Header = {
+exports.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)
+            version_id: buf.readInt32LE(off + 28),
+            header_size: buf.readInt32LE(off + 32),
+            rate: buf.readInt32LE(off + 36),
+            mode: buf.readInt32LE(off + 40),
+            mode_bitstream_version: buf.readInt32LE(off + 44),
+            nb_channels: buf.readInt32LE(off + 48),
+            bitrate: buf.readInt32LE(off + 52),
+            frame_size: buf.readInt32LE(off + 56),
+            vbr: buf.readInt32LE(off + 60),
+            frames_per_packet: buf.readInt32LE(off + 64),
+            extra_headers: buf.readInt32LE(off + 68),
+            reserved1: buf.readInt32LE(off + 72),
+            reserved2: buf.readInt32LE(off + 76)
         };
     }
 };

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { ITokenizer } from 'strtok3/lib/core';
+import { IPageHeader } from '../Ogg';
+import { VorbisParser } from '../vorbis/VorbisParser';
+import { IOptions } from '../../type';
+import { INativeMetadataCollector } from '../../common/MetadataCollector';
+/**
+ * Speex, RFC 5574
+ * Ref:
+ * - https://www.speex.org/docs/manual/speex-manual/
+ * - https://tools.ietf.org/html/rfc5574
+ */
+export declare class SpeexParser extends VorbisParser {
+    private tokenizer;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Parse first Speex Ogg page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+}

package/node_modules/music-metadata/lib/ogg/speex/{SpeexStream.js → SpeexParser.js}

@@ -1,23 +1,27 @@
-import initDebug from 'debug';
-import { VorbisStream } from '../vorbis/VorbisStream.js';
-import * as Speex from './Speex.js';
-const debug = initDebug('music-metadata:parser:ogg:speex');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeexParser = void 0;
+const debug_1 = require("debug");
+const VorbisParser_1 = require("../vorbis/VorbisParser");
+const Speex = require("./Speex");
+const debug = (0, debug_1.default)('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) {
+class SpeexParser extends VorbisParser_1.VorbisParser {
+    constructor(metadata, options, tokenizer) {
         super(metadata, options);
+        this.tokenizer = tokenizer;
     }
     /**
      * Parse first Speex Ogg page
      * @param {IPageHeader} header
-     * @param {Uint8Array} pageData
+     * @param {Buffer} pageData
      */
-    parseFirstPage(_header, pageData) {
+    parseFirstPage(header, pageData) {
         debug('First Ogg/Speex page');
         const speexHeader = Speex.Header.get(pageData, 0);
         this.metadata.setFormat('codec', `Speex ${speexHeader.version}`);
@@ -26,6 +30,6 @@ export class SpeexStream extends VorbisStream {
         if (speexHeader.bitrate !== -1) {
             this.metadata.setFormat('bitrate', speexHeader.bitrate);
         }
-        this.metadata.setAudioOnly();
     }
 }
+exports.SpeexParser = SpeexParser;

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

@@ -1,4 +1,4 @@
-import type { IGetToken } from 'strtok3';
+import { IGetToken } from 'strtok3/lib/core';
 /**
  * 6.2 Identification Header
  * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode

package/node_modules/music-metadata/lib/ogg/theora/Theora.js

@@ -1,20 +1,23 @@
-import * as Token from 'token-types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentificationHeader = void 0;
+const Token = require("token-types");
 /**
  * 6.2 Identification Header
  * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
  */
-export const IdentificationHeader = {
+exports.IdentificationHeader = {
     len: 42,
     get: (buf, off) => {
         return {
             id: new Token.StringType(7, 'ascii').get(buf, off),
-            vmaj: Token.UINT8.get(buf, off + 7),
-            vmin: Token.UINT8.get(buf, off + 8),
-            vrev: Token.UINT8.get(buf, off + 9),
-            vmbw: Token.UINT16_BE.get(buf, off + 10),
-            vmbh: Token.UINT16_BE.get(buf, off + 17),
+            vmaj: buf.readUInt8(off + 7),
+            vmin: buf.readUInt8(off + 8),
+            vrev: buf.readUInt8(off + 9),
+            vmbw: buf.readUInt16BE(off + 10),
+            vmbh: buf.readUInt16BE(off + 17),
             nombr: Token.UINT24_BE.get(buf, off + 37),
-            nqual: Token.UINT8.get(buf, off + 40)
+            nqual: buf.readUInt8(off + 40)
         };
     }
 };

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { ITokenizer } from 'strtok3/lib/core';
+import { IOptions } from '../../type';
+import { INativeMetadataCollector } from '../../common/MetadataCollector';
+import * as Ogg from '../Ogg';
+/**
+ * Ref:
+ * - https://theora.org/doc/Theora.pdf
+ */
+export declare class TheoraParser implements Ogg.IPageConsumer {
+    private metadata;
+    private tokenizer;
+    constructor(metadata: INativeMetadataCollector, options: IOptions, tokenizer: ITokenizer);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Buffer): void;
+    flush(): void;
+    calculateDuration(header: Ogg.IPageHeader): void;
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Buffer): void;
+}