@openclaw/matrix 2026.10.2 → 2026.10.5-beta.2

package/node_modules/music-metadata/lib/mpeg/MpegParser.js

@@ -1,10 +1,10 @@
-import * as Token from 'token-types';
-import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
+import { EndOfStreamError } from 'strtok3';
+import * as Token from 'token-types';
 import * as common from '../common/Util.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
 const debug = initDebug('music-metadata:parser:mpeg');
 export class MpegContentError extends makeUnexpectedFileContentError('MPEG') {
 }
@@ -31,7 +31,22 @@ const MPEG4 = {
      * https://wiki.multimedia.cx/index.php/MPEG-4_Audio#Sampling_Frequencies
      */
     SamplingFrequencies: [
-        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, null, null, null
+        96000,
+        88200,
+        64000,
+        48000,
+        44100,
+        32000,
+        24000,
+        22050,
+        16000,
+        12000,
+        11025,
+        8000,
+        7350,
+        null,
+        null,
+        null
     ]
     /**
      * Channel Configurations
@@ -87,14 +102,15 @@ class MpegFrameHeader {
         this.isProtectedByCRC = !common.isBitSet(buf, off + 1, 7);
     }
     calcDuration(numFrames) {
-        return this.samplingRate == null ? null : (numFrames * this.calcSamplesPerFrame() / this.samplingRate);
+        return this.samplingRate == null ? null : (numFrames * this.calcSamplesPerFrame()) / this.samplingRate;
     }
     calcSamplesPerFrame() {
         return MpegFrameHeader.samplesInFrameTable[this.version === 1 ? 0 : 1][this.layer];
     }
     calculateSideInfoLength() {
-        if (this.layer !== 3)
+        if (this.layer !== 3) {
             return 2;
+        }
         if (this.channelModeIndex === 3) {
             // mono
             if (this.version === 1) {
@@ -153,7 +169,7 @@ class MpegFrameHeader {
         }
     }
     parseAdtsHeader(buf, off) {
-        debug("layer=0 => ADTS");
+        debug('layer=0 => ADTS');
         this.version = this.versionIndex === 2 ? 4 : 2;
         this.container = `ADTS/MPEG-${this.version}`;
         const profileIndex = common.getBitAllignedNumber(buf, off + 2, 0, 2);
@@ -170,7 +186,8 @@ class MpegFrameHeader {
     }
     calcBitrate() {
         if (this.bitrateIndex === 0x00 || // free
-            this.bitrateIndex === 0x0F) { // reserved
+            this.bitrateIndex === 0x0f) {
+            // reserved
             return null;
         }
         if (this.version && this.bitrateIndex) {
@@ -180,13 +197,14 @@ class MpegFrameHeader {
         return null;
     }
     calcSamplingRate() {
-        if (this.sampRateFreqIndex === 0x03 || this.version === null || this.sampRateFreqIndex == null)
+        if (this.sampRateFreqIndex === 0x03 || this.version === null || this.sampRateFreqIndex == null) {
             return null; // 'reserved'
+        }
         return MpegFrameHeader.sampling_rate_freq_index[this.version][this.sampRateFreqIndex];
     }
 }
-MpegFrameHeader.SyncByte1 = 0xFF;
-MpegFrameHeader.SyncByte2 = 0xE0;
+MpegFrameHeader.SyncByte1 = 0xff;
+MpegFrameHeader.SyncByte2 = 0xe0;
 MpegFrameHeader.VersionID = [2.5, null, 2, 1];
 MpegFrameHeader.LayerDescription = [0, 3, 2, 1];
 MpegFrameHeader.ChannelMode = ['stereo', 'joint_stereo', 'dual_channel', 'mono'];
@@ -264,7 +282,7 @@ export class MpegParser extends AbstractID3Parser {
         }
         catch (err) {
             if (err instanceof EndOfStreamError) {
-                debug("End-of-stream");
+                debug('End-of-stream');
                 if (this.calculateEofDuration) {
                     if (this.samplesPerFrame !== null) {
                         const numberOfSamples = this.frameCount * this.samplesPerFrame;
@@ -292,7 +310,7 @@ export class MpegParser extends AbstractID3Parser {
             if (format.duration && this.tokenizer.fileInfo.size) {
                 const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
                 if (format.codecProfile && format.codecProfile[0] === 'V') {
-                    this.metadata.setFormat('bitrate', mpegSize * 8 / format.duration);
+                    this.metadata.setFormat('bitrate', (mpegSize * 8) / format.duration);
                 }
             }
             if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
@@ -302,7 +320,7 @@ export class MpegParser extends AbstractID3Parser {
                     this.metadata.setFormat('numberOfSamples', numberOfSamples);
                     if (format.sampleRate && !format.duration) {
                         const duration = numberOfSamples / format.sampleRate;
-                        debug("Calculate CBR duration based on file size: %s", duration);
+                        debug('Calculate CBR duration based on file size: %s', duration);
                         this.metadata.setFormat('duration', duration);
                     }
                 }
@@ -318,7 +336,7 @@ export class MpegParser extends AbstractID3Parser {
                 throw new EndOfStreamError();
             }
             while (true) {
-                if (gotFirstSync && (this.syncPeek.buf[bo] & 0xE0) === 0xE0) {
+                if (gotFirstSync && (this.syncPeek.buf[bo] & 0xe0) === 0xe0) {
                     this.buf_frame_header[0] = MpegFrameHeader.SyncByte1;
                     this.buf_frame_header[1] = this.syncPeek.buf[bo];
                     await this.tokenizer.ignore(bo);
@@ -372,7 +390,9 @@ export class MpegParser extends AbstractID3Parser {
         this.metadata.setFormat('lossless', false);
         this.metadata.setFormat('sampleRate', header.samplingRate);
         this.frameCount++;
-        return header.version !== null && header.version >= 2 && header.layer === 0 ? this.parseAdts(header) : this.parseAudioFrameHeader(header);
+        return header.version !== null && header.version >= 2 && header.layer === 0
+            ? this.parseAdts(header)
+            : this.parseAudioFrameHeader(header);
     }
     /**
      * @return {Promise<boolean>} true if parser should quit
@@ -391,7 +411,7 @@ export class MpegParser extends AbstractID3Parser {
         debug(`samples_per_frame=${samples_per_frame}`);
         const bps = samples_per_frame / 8.0;
         if (header.bitrate !== null && header.samplingRate != null) {
-            const fsize = (bps * header.bitrate / header.samplingRate) + ((header.padding) ? slot_size : 0);
+            const fsize = (bps * header.bitrate) / header.samplingRate + (header.padding ? slot_size : 0);
             this.frame_size = Math.floor(fsize);
         }
         this.audioFrameHeader = header;
@@ -410,8 +430,9 @@ export class MpegParser extends AbstractID3Parser {
                 // Actual calculation will be done in finalize
                 this.samplesPerFrame = samples_per_frame;
                 this.metadata.setFormat('codecProfile', 'CBR');
-                if (this.tokenizer.fileInfo.size)
+                if (this.tokenizer.fileInfo.size) {
                     return true; // Will calculate duration based on the file size
+                }
             }
             else if (this.metadata.format.duration) {
                 return true; // We already got the duration, stop processing MPEG stream any further
@@ -556,8 +577,9 @@ export class MpegParser extends AbstractID3Parser {
         return infoTag;
     }
     async skipFrameData(frameDataLeft) {
-        if (frameDataLeft < 0)
+        if (frameDataLeft < 0) {
             throw new MpegContentError('frame-data-left cannot be negative');
+        }
         await this.tokenizer.ignore(frameDataLeft);
     }
     areAllSame(array) {

package/node_modules/music-metadata/lib/mpeg/ReplayGainDataFormat.d.ts

@@ -21,7 +21,7 @@ declare const NameCode: {
      */
     audiophile: number;
 };
-type NameCode = typeof NameCode[keyof typeof NameCode];
+type NameCode = (typeof NameCode)[keyof typeof NameCode];
 /**
  * https://github.com/Borewit/music-metadata/wiki/Replay-Gain-Data-Format#originator-code
  */
@@ -47,7 +47,7 @@ declare const ReplayGainOriginator: {
      */
     rms_average: number;
 };
-type ReplayGainOriginator = typeof ReplayGainOriginator[keyof typeof ReplayGainOriginator];
+type ReplayGainOriginator = (typeof ReplayGainOriginator)[keyof typeof ReplayGainOriginator];
 /**
  * Replay Gain Data Format
  *

package/node_modules/music-metadata/lib/mpeg/ReplayGainDataFormat.js

@@ -56,7 +56,7 @@ export const ReplayGain = {
             return {
                 type: common.getBitAllignedNumber(buf, off, 0, 3),
                 origin: common.getBitAllignedNumber(buf, off, 3, 3),
-                adjustment: (sign ? -gain_adj : gain_adj)
+                adjustment: sign ? -gain_adj : gain_adj
             };
         }
         return undefined;

package/node_modules/music-metadata/lib/mpeg/XingTag.d.ts

@@ -1,5 +1,5 @@
-import * as Token from 'token-types';
 import type { IGetToken, ITokenizer } from 'strtok3';
+import * as Token from 'token-types';
 import { type IExtendedLameHeader } from './ExtendedLameHeader.js';
 export interface IXingHeaderFlags {
     frames: boolean;

package/node_modules/music-metadata/lib/musepack/MusepackParser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
 import * as Token from 'token-types';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
-import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
 import { MusepackContentError } from './MusepackConentError.js';
+import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
+import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MusepackParser extends AbstractID3Parser {
     async postId3v2Parse() {

package/node_modules/music-metadata/lib/musepack/sv7/BitReader.js

@@ -16,7 +16,7 @@ export class BitReader {
         let out = this.dword;
         this.pos += bits;
         if (this.pos < 32) {
-            out >>>= (32 - this.pos);
+            out >>>= 32 - this.pos;
             return out & ((1 << bits) - 1);
         }
         this.pos -= 32;

package/node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
-import { BasicParser } from '../../common/BasicParser.js';
 import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
+import { BasicParser } from '../../common/BasicParser.js';
+import { MusepackContentError } from '../MusepackConentError.js';
 import { BitReader } from './BitReader.js';
 import * as SV7 from './StreamVersion7.js';
-import { MusepackContentError } from '../MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MpcSv7Parser extends BasicParser {
     constructor() {
@@ -14,8 +14,9 @@ export class MpcSv7Parser extends BasicParser {
     }
     async parse() {
         const header = await this.tokenizer.readToken(SV7.Header);
-        if (header.signature !== 'MP+')
+        if (header.signature !== 'MP+') {
             throw new MusepackContentError('Unexpected magic number');
+        }
         debug(`stream-version=${header.streamMajorVersion}.${header.streamMinorVersion}`);
         this.metadata.setFormat('container', 'Musepack, SV7');
         this.metadata.setFormat('sampleRate', header.sampleFrequency);

package/node_modules/music-metadata/lib/musepack/sv7/StreamVersion7.js

@@ -1,6 +1,6 @@
+import { textDecode } from '@borewit/text-codec';
 import * as Token from 'token-types';
 import * as util from '../../common/Util.js';
-import { textDecode } from '@borewit/text-codec';
 /**
  * BASIC STRUCTURE
  */
@@ -30,10 +30,10 @@ export const Header = {
             albumPeak: Token.UINT16_LE.get(buf, off + 16),
             albumGain: Token.UINT16_LE.get(buf, off + 18),
             // word
-            lastFrameLength: (Token.UINT32_LE.get(buf, off + 20) >>> 20) & 0x7FF,
+            lastFrameLength: (Token.UINT32_LE.get(buf, off + 20) >>> 20) & 0x7ff,
             trueGapless: util.isBitSet(buf, off + 23, 0)
         };
-        header.lastFrameLength = header.trueGapless ? (Token.UINT32_LE.get(buf, 20) >>> 20) & 0x7FF : 0;
+        header.lastFrameLength = header.trueGapless ? (Token.UINT32_LE.get(buf, 20) >>> 20) & 0x7ff : 0;
         return header;
     }
 };

package/node_modules/music-metadata/lib/musepack/sv8/MpcSv8Parser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
-import { BasicParser } from '../../common/BasicParser.js';
 import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
+import { BasicParser } from '../../common/BasicParser.js';
 import { FourCcToken } from '../../common/FourCC.js';
-import * as SV8 from './StreamVersion8.js';
 import { MusepackContentError } from '../MusepackConentError.js';
+import * as SV8 from './StreamVersion8.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MpcSv8Parser extends BasicParser {
     constructor() {
@@ -12,8 +12,9 @@ export class MpcSv8Parser extends BasicParser {
     }
     async parse() {
         const signature = await this.tokenizer.readToken(FourCcToken);
-        if (signature !== 'MPCK')
+        if (signature !== 'MPCK') {
             throw new MusepackContentError('Invalid Magic number');
+        }
         this.metadata.setFormat('container', 'Musepack, SV8');
         return this.parsePacket();
     }
@@ -23,7 +24,8 @@ export class MpcSv8Parser extends BasicParser {
             const header = await sv8reader.readPacketHeader();
             debug(`packet-header key=${header.key}, payloadLength=${header.payloadLength}`);
             switch (header.key) {
-                case 'SH': { // Stream Header
+                case 'SH': {
+                    // Stream Header
                     const sh = await sv8reader.readStreamHeader(header.payloadLength);
                     this.metadata.setFormat('numberOfSamples', sh.sampleCount);
                     this.metadata.setFormat('sampleRate', sh.sampleFrequency);
@@ -44,7 +46,7 @@ export class MpcSv8Parser extends BasicParser {
                     break;
                 case 'SE': // Stream End
                     if (this.metadata.format.duration) {
-                        this.metadata.setFormat('bitrate', this.audioLength * 8 / this.metadata.format.duration);
+                        this.metadata.setFormat('bitrate', (this.audioLength * 8) / this.metadata.format.duration);
                     }
                     return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
                 default:

package/node_modules/music-metadata/lib/musepack/sv8/StreamVersion8.js

@@ -1,5 +1,5 @@
-import * as Token from 'token-types';
 import initDebug from 'debug';
+import * as Token from 'token-types';
 import * as util from '../../common/Util.js';
 const debug = initDebug('music-metadata:parser:musepack:sv8');
 const PacketKey = new Token.StringType(2, 'latin1');
@@ -75,7 +75,7 @@ export class StreamReader {
         if ((n & 0x80) === 0) {
             return { len, value: hb + n };
         }
-        n &= 0x7F;
+        n &= 0x7f;
         n += hb;
         return this.readVariableSizeField(len + 1, n << 7);
     }

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

@@ -1,14 +1,14 @@
-import * as Token from 'token-types';
-import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
+import { EndOfStreamError } from 'strtok3';
+import * as Token from 'token-types';
 import { BasicParser } from '../common/BasicParser.js';
-import { VorbisStream } from './vorbis/VorbisStream.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { FlacStream } from './flac/FlacStream.js';
+import { PageHeader, SegmentTable } from './OggToken.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';
+import { VorbisStream } from './vorbis/VorbisStream.js';
 export class OggContentError extends makeUnexpectedFileContentError('Ogg') {
 }
 const debug = initDebug('music-metadata:parser:ogg');
@@ -66,8 +66,9 @@ class OggStream {
         if (this.pageConsumer) {
             await this.pageConsumer.parsePage(header, pageData);
         }
-        else
+        else {
             throw new Error('pageConsumer should be initialized');
+        }
     }
 }
 /**
@@ -85,38 +86,47 @@ export class OggParser extends BasicParser {
     async parse() {
         this.streams = new Map();
         let enfOfStream = false;
+        let stoppedEarly = false;
         let header;
         try {
             do {
                 header = await this.tokenizer.readToken(PageHeader);
-                if (header.capturePattern !== 'OggS')
+                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");
+                if (stream.pageNumber > 12 &&
+                    // A comment (including its cover art) may span more than 13 pages.
+                    [...this.streams.values()].every(stream => stream.pageConsumer?.isMetadataComplete !== false) &&
+                    !(this.options.duration && [...this.streams.values()].find(stream => stream.pageConsumer?.durationOnLastPage))) {
+                    stoppedEarly = true;
+                    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");
+                debug('Reached end-of-stream');
                 enfOfStream = true;
             }
             else if (err instanceof OggContentError) {
                 this.metadata.addWarning(`Corrupt Ogg content at ${this.tokenizer.position}`);
             }
-            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}`);
+                if (!stoppedEarly) {
+                    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

@@ -62,6 +62,8 @@ export declare class SegmentTable implements IGetToken<ISegmentTable> {
     get(buf: Uint8Array, off: number): ISegmentTable;
 }
 export interface IPageConsumer {
+    /** False while required metadata is still being read; undefined if not tracked. */
+    isMetadataComplete?: boolean;
     /**
      * Need to parse to end to be able to calculate the duration
      */

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

@@ -1,6 +1,6 @@
 import * as Token from 'token-types';
-import * as util from '../common/Util.js';
 import { StringType } from 'token-types';
+import * as util from '../common/Util.js';
 export const PageHeader = {
     len: 27,
     get: (buf, off) => {

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

@@ -1,7 +1,7 @@
 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';
+import type { IOptions } from '../../type.js';
+import type * as Ogg from '../OggToken.js';
 /**
  * Ref:
  * - https://xiph.org/flac/ogg_mapping.html

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

@@ -1,7 +1,7 @@
 import initDebug from 'debug';
-import * as Flac from '../../flac/FlacToken.js';
-import { FlacParser } from '../../flac/FlacParser.js';
 import { FourCcToken } from '../../common/FourCC.js';
+import { FlacParser } from '../../flac/FlacParser.js';
+import * as Flac from '../../flac/FlacToken.js';
 import { VorbisPictureToken } from '../vorbis/Vorbis.js';
 const debug = initDebug('music-metadata:parser:ogg:theora');
 /**

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

@@ -1,8 +1,8 @@
 import type { ITokenizer } from 'strtok3';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+import type { IOptions } from '../../type.js';
 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

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

@@ -24,8 +24,9 @@ export class OpusStream extends VorbisStream {
         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");
+        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();
@@ -42,14 +43,17 @@ export class OpusStream extends VorbisStream {
         }
     }
     calculateDuration(enfOfStream) {
-        if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+        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);
+                this.metadata.setFormat('bitrate', (8 * dataSize) / this.metadata.format.duration);
             }
         }
     }

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

@@ -1,8 +1,8 @@
 import type { ITokenizer } from 'strtok3';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+import type { IOptions } from '../../type.js';
 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:

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

@@ -35,8 +35,9 @@ export class SpeexStream extends VorbisStream {
      * Ref: https://tools.ietf.org/html/rfc5574#section-3
      */
     async parseFullPage(pageData) {
-        if (this.commentHeaderParsed)
+        if (this.commentHeaderParsed) {
             return;
+        }
         this.commentHeaderParsed = true;
         debug('Parse Ogg/Speex comment header');
         await this.parseUserCommentList(pageData, 0);

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

@@ -1,7 +1,7 @@
 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';
+import type { IOptions } from '../../type.js';
+import type * as Ogg from '../OggToken.js';
 /**
  * Ref:
  * - https://theora.org/doc/Theora.pdf

package/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.d.ts

@@ -1,5 +1,5 @@
-import type { IPicture } from '../../type.js';
 import type { IGetToken } from 'strtok3';
+import type { IPicture } from '../../type.js';
 /**
  * Interface to parsed result of METADATA_BLOCK_PICTURE
  * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.js

@@ -1,5 +1,5 @@
-import * as Token from 'token-types';
 import { textDecode } from '@borewit/text-codec';
+import * as Token from 'token-types';
 export class VorbisDecoder {
     constructor(data, offset) {
         this.data = data;

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.d.ts

@@ -1,7 +1,7 @@
-import { type IVorbisPicture } from './Vorbis.js';
-import type { IPageConsumer, IPageHeader } from '../OggToken.js';
-import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+import type { IOptions } from '../../type.js';
+import type { IPageConsumer, IPageHeader } from '../OggToken.js';
+import { type IVorbisPicture } from './Vorbis.js';
 declare const VorbisContentError_base: {
     new (message: string): {
         readonly fileType: string;
@@ -26,6 +26,7 @@ export declare class VorbisStream implements IPageConsumer {
     protected options: IOptions;
     protected lastPageHeader?: IPageHeader;
     durationOnLastPage: boolean;
+    isMetadataComplete: boolean;
     constructor(metadata: INativeMetadataCollector, options: IOptions);
     /**
      * Vorbis 1 parser

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.js

@@ -1,8 +1,8 @@
-import * as Token from 'token-types';
 import debugInit from 'debug';
-import { VorbisDecoder } from './VorbisDecoder.js';
-import { CommonHeader, IdentificationHeader, VorbisPictureToken } from './Vorbis.js';
+import * as Token from 'token-types';
 import { makeUnexpectedFileContentError } from '../../ParseError.js';
+import { CommonHeader, IdentificationHeader, VorbisPictureToken } from './Vorbis.js';
+import { VorbisDecoder } from './VorbisDecoder.js';
 const debug = debugInit('music-metadata:parser:ogg:vorbis1');
 export class VorbisContentError extends makeUnexpectedFileContentError('Vorbis') {
 }
@@ -14,6 +14,7 @@ export class VorbisStream {
     constructor(metadata, options) {
         this.pageSegments = [];
         this.durationOnLastPage = true;
+        this.isMetadataComplete = false;
         this.metadata = metadata;
         this.options = options;
     }
@@ -64,9 +65,9 @@ export class VorbisStream {
         return tag.len;
     }
     async addTag(id, value) {
-        if (id === 'METADATA_BLOCK_PICTURE' && (typeof value === 'string')) {
+        if (id === 'METADATA_BLOCK_PICTURE' && typeof value === 'string') {
             if (this.options.skipCovers) {
-                debug("Ignore picture");
+                debug('Ignore picture');
                 return;
             }
             value = VorbisPictureToken.fromBase64(value);
@@ -78,7 +79,10 @@ export class VorbisStream {
         await this.metadata.addTag('vorbis', id, value);
     }
     calculateDuration(enfOfStream) {
-        if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+        if (this.lastPageHeader &&
+            (enfOfStream || this.lastPageHeader.headerType.lastPage) &&
+            this.metadata.format.sampleRate &&
+            this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
             this.metadata.setFormat('numberOfSamples', this.lastPageHeader.absoluteGranulePosition);
             this.metadata.setFormat('duration', this.lastPageHeader.absoluteGranulePosition / this.metadata.format.sampleRate);
@@ -95,8 +99,9 @@ export class VorbisStream {
         debug('Parse first page');
         // Parse  Vorbis common header
         const commonHeader = CommonHeader.get(pageData, 0);
-        if (commonHeader.vorbis !== 'vorbis')
+        if (commonHeader.vorbis !== 'vorbis') {
             throw new VorbisContentError('Metadata does not look like Vorbis');
+        }
         if (commonHeader.packetType === 1) {
             const idHeader = IdentificationHeader.get(pageData, CommonHeader.len);
             this.metadata.setFormat('sampleRate', idHeader.sampleRate);
@@ -104,8 +109,9 @@ export class VorbisStream {
             this.metadata.setFormat('numberOfChannels', idHeader.channelMode);
             debug('sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s', idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
         }
-        else
+        else {
             throw new VorbisContentError('First Ogg page should be type 1: the identification header');
+        }
     }
     async parseFullPage(pageData) {
         // New page
@@ -130,7 +136,8 @@ export class VorbisStream {
         let userCommentListLength = Token.UINT32_LE.get(pageData, offset);
         offset += 4;
         while (userCommentListLength-- > 0) {
-            offset += (await this.parseUserComment(pageData, offset));
+            offset += await this.parseUserComment(pageData, offset);
         }
+        this.isMetadataComplete = true;
     }
 }