@dragon708/docmind-markdown 1.2.5 → 1.2.6

package/node_modules/music-metadata/lib/dsf/DsfParser.js

@@ -1,43 +1,42 @@
-import initDebug from 'debug';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
-import { ID3v2Parser } from "../id3v2/ID3v2Parser.js";
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-const debug = initDebug('music-metadata:parser:DSF');
-export class DsdContentParseError extends makeUnexpectedFileContentError('DSD') {
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DsfParser = void 0;
+const debug_1 = require("debug");
+const AbstractID3Parser_1 = require("../id3v2/AbstractID3Parser");
+const DsfChunk_1 = require("./DsfChunk");
+const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
+const debug = (0, debug_1.default)('music-metadata:parser:DSF');
 /**
  * DSF (dsd stream file) File Parser
  * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
  */
-export class DsfParser extends AbstractID3Parser {
+class DsfParser extends AbstractID3Parser_1.AbstractID3Parser {
     async postId3v2Parse() {
         const p0 = this.tokenizer.position; // mark start position, normally 0
-        const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+        const chunkHeader = await this.tokenizer.readToken(DsfChunk_1.ChunkHeader);
         if (chunkHeader.id !== 'DSD ')
-            throw new DsdContentParseError('Invalid chunk signature');
+            throw new Error('Invalid chunk signature');
         this.metadata.setFormat('container', 'DSF');
         this.metadata.setFormat('lossless', true);
-        this.metadata.setAudioOnly();
-        const dsdChunk = await this.tokenizer.readToken(DsdChunk);
+        const dsdChunk = await this.tokenizer.readToken(DsfChunk_1.DsdChunk);
         if (dsdChunk.metadataPointer === BigInt(0)) {
-            debug("No ID3v2 tag present");
+            debug(`No ID3v2 tag present`);
         }
         else {
             debug(`expect ID3v2 at offset=${dsdChunk.metadataPointer}`);
             await this.parseChunks(dsdChunk.fileSize - chunkHeader.size);
             // Jump to ID3 header
             await this.tokenizer.ignore(Number(dsdChunk.metadataPointer) - this.tokenizer.position - p0);
-            return new ID3v2Parser().parse(this.metadata, this.tokenizer, this.options);
+            return new ID3v2Parser_1.ID3v2Parser().parse(this.metadata, this.tokenizer, this.options);
         }
     }
     async parseChunks(bytesRemaining) {
-        while (bytesRemaining >= ChunkHeader.len) {
-            const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+        while (bytesRemaining >= DsfChunk_1.ChunkHeader.len) {
+            const chunkHeader = await this.tokenizer.readToken(DsfChunk_1.ChunkHeader);
             debug(`Parsing chunk name=${chunkHeader.id} size=${chunkHeader.size}`);
             switch (chunkHeader.id) {
-                case 'fmt ': {
-                    const formatChunk = await this.tokenizer.readToken(FormatChunk);
+                case 'fmt ':
+                    const formatChunk = await this.tokenizer.readToken(DsfChunk_1.FormatChunk);
                     this.metadata.setFormat('numberOfChannels', formatChunk.channelNum);
                     this.metadata.setFormat('sampleRate', formatChunk.samplingFrequency);
                     this.metadata.setFormat('bitsPerSample', formatChunk.bitsPerSample);
@@ -46,12 +45,12 @@ export class DsfParser extends AbstractID3Parser {
                     const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
                     this.metadata.setFormat('bitrate', bitrate);
                     return; // We got what we want, stop further processing of chunks
-                }
                 default:
-                    this.tokenizer.ignore(Number(chunkHeader.size) - ChunkHeader.len);
+                    this.tokenizer.ignore(Number(chunkHeader.size) - DsfChunk_1.ChunkHeader.len);
                     break;
             }
             bytesRemaining -= chunkHeader.size;
         }
     }
 }
+exports.DsfParser = DsfParser;

package/node_modules/music-metadata/lib/flac/FlacParser.d.ts

@@ -1,29 +1,28 @@
-import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import type { IBlockStreamInfo } from './FlacToken.js';
+import { ITokenizer } from 'strtok3/lib/core';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser';
+import { INativeMetadataCollector } from '../common/MetadataCollector';
+import { IOptions } from '../type';
+import { ITokenParser } from '../ParserFactory';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;
-    postId3v2Parse(): Promise<void>;
-    private parseDataBlock;
+    private padding;
     /**
-     * Parse STREAMINFO
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param {INativeMetadataCollector} metadata Output
+     * @param {ITokenizer} tokenizer Input
+     * @param {IOptions} options Parsing options
      */
-    private readBlockStreamInfo;
+    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    postId3v2Parse(): Promise<void>;
+    private parseDataBlock;
     /**
      * Parse STREAMINFO
      */
-    processsStreamInfo(streamInfo: IBlockStreamInfo): void;
-    /**
-     * Read VORBIS_COMMENT from tokenizer
-     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
-     */
-    private readComment;
+    private parseBlockStreamInfo;
     /**
      * Parse VORBIS_COMMENT
      * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
      */
-    parseComment(data: Uint8Array): Promise<void>;
+    private parseComment;
     private parsePicture;
-    addPictureTag(picture: IVorbisPicture): Promise<void>;
-    private addTag;
 }

package/node_modules/music-metadata/lib/flac/FlacParser.js

@@ -1,29 +1,54 @@
-import initDebug from 'debug';
-import { Uint8ArrayType } from 'token-types';
-import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { FourCcToken } from '../common/FourCC.js';
-import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
-import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-import * as Flac from './FlacToken.js';
-const debug = initDebug('music-metadata:parser:FLAC');
-class FlacContentError extends makeUnexpectedFileContentError('FLAC') {
-}
-export class FlacParser extends AbstractID3Parser {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlacParser = void 0;
+const token_types_1 = require("token-types");
+const debug_1 = require("debug");
+const util = require("../common/Util");
+const Vorbis_1 = require("../ogg/vorbis/Vorbis");
+const AbstractID3Parser_1 = require("../id3v2/AbstractID3Parser");
+const FourCC_1 = require("../common/FourCC");
+const VorbisParser_1 = require("../ogg/vorbis/VorbisParser");
+const VorbisDecoder_1 = require("../ogg/vorbis/VorbisDecoder");
+const debug = (0, debug_1.default)('music-metadata:parser:FLAC');
+/**
+ * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
+ * ref: https://xiph.org/flac/format.html#metadata_block
+ */
+var BlockType;
+(function (BlockType) {
+    BlockType[BlockType["STREAMINFO"] = 0] = "STREAMINFO";
+    BlockType[BlockType["PADDING"] = 1] = "PADDING";
+    BlockType[BlockType["APPLICATION"] = 2] = "APPLICATION";
+    BlockType[BlockType["SEEKTABLE"] = 3] = "SEEKTABLE";
+    BlockType[BlockType["VORBIS_COMMENT"] = 4] = "VORBIS_COMMENT";
+    BlockType[BlockType["CUESHEET"] = 5] = "CUESHEET";
+    BlockType[BlockType["PICTURE"] = 6] = "PICTURE";
+})(BlockType || (BlockType = {}));
+class FlacParser extends AbstractID3Parser_1.AbstractID3Parser {
     constructor() {
         super(...arguments);
-        this.vorbisParser = new VorbisStream(this.metadata, this.options);
+        this.padding = 0;
+    }
+    /**
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param {INativeMetadataCollector} metadata Output
+     * @param {ITokenizer} tokenizer Input
+     * @param {IOptions} options Parsing options
+     */
+    init(metadata, tokenizer, options) {
+        super.init(metadata, tokenizer, options);
+        this.vorbisParser = new VorbisParser_1.VorbisParser(metadata, options);
+        return this;
     }
     async postId3v2Parse() {
-        const fourCC = await this.tokenizer.readToken(FourCcToken);
+        const fourCC = await this.tokenizer.readToken(FourCC_1.FourCcToken);
         if (fourCC.toString() !== 'fLaC') {
-            throw new FlacContentError('Invalid FLAC preamble');
+            throw new Error('Invalid FLAC preamble');
         }
         let blockHeader;
         do {
             // Read block header
-            blockHeader = await this.tokenizer.readToken(Flac.BlockHeader);
+            blockHeader = await this.tokenizer.readToken(Metadata.BlockHeader);
             // Parse block data
             await this.parseDataBlock(blockHeader);
         } while (!blockHeader.lastBlock);
@@ -32,26 +57,26 @@ export class FlacParser extends AbstractID3Parser {
             this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
         }
     }
-    async parseDataBlock(blockHeader) {
+    parseDataBlock(blockHeader) {
         debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
         switch (blockHeader.type) {
-            case Flac.BlockType.STREAMINFO:
-                return this.readBlockStreamInfo(blockHeader.length);
-            case Flac.BlockType.PADDING:
+            case BlockType.STREAMINFO:
+                return this.parseBlockStreamInfo(blockHeader.length);
+            case BlockType.PADDING:
+                this.padding += blockHeader.length;
                 break;
-            case Flac.BlockType.APPLICATION:
+            case BlockType.APPLICATION:
                 break;
-            case Flac.BlockType.SEEKTABLE:
+            case BlockType.SEEKTABLE:
                 break;
-            case Flac.BlockType.VORBIS_COMMENT:
-                return this.readComment(blockHeader.length);
-            case Flac.BlockType.CUESHEET:
+            case BlockType.VORBIS_COMMENT:
+                return this.parseComment(blockHeader.length);
+            case BlockType.CUESHEET:
                 break;
-            case Flac.BlockType.PICTURE:
-                await this.parsePicture(blockHeader.length);
-                return;
+            case BlockType.PICTURE:
+                return this.parsePicture(blockHeader.length).then();
             default:
-                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+                this.metadata.addWarning('Unknown block type: ' + blockHeader.type);
         }
         // Ignore data block
         return this.tokenizer.ignore(blockHeader.length).then();
@@ -59,19 +84,12 @@ export class FlacParser extends AbstractID3Parser {
     /**
      * Parse STREAMINFO
      */
-    async readBlockStreamInfo(dataLen) {
-        if (dataLen !== Flac.BlockStreamInfo.len)
-            throw new FlacContentError('Unexpected block-stream-info length');
-        const streamInfo = await this.tokenizer.readToken(Flac.BlockStreamInfo);
+    async parseBlockStreamInfo(dataLen) {
+        if (dataLen !== Metadata.BlockStreamInfo.len)
+            throw new Error('Unexpected block-stream-info length');
+        const streamInfo = await this.tokenizer.readToken(Metadata.BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
-        this.processsStreamInfo(streamInfo);
-    }
-    /**
-     * Parse STREAMINFO
-     */
-    processsStreamInfo(streamInfo) {
         this.metadata.setFormat('codec', 'FLAC');
-        this.metadata.setFormat('hasAudio', true);
         this.metadata.setFormat('lossless', true);
         this.metadata.setFormat('numberOfChannels', streamInfo.channels);
         this.metadata.setFormat('bitsPerSample', streamInfo.bitsPerSample);
@@ -80,46 +98,78 @@ export class FlacParser extends AbstractID3Parser {
             this.metadata.setFormat('duration', streamInfo.totalSamples / streamInfo.sampleRate);
         }
     }
-    /**
-     * Read VORBIS_COMMENT from tokenizer
-     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
-     */
-    async readComment(dataLen) {
-        const data = await this.tokenizer.readToken(new Uint8ArrayType(dataLen));
-        return this.parseComment(data);
-    }
     /**
      * Parse VORBIS_COMMENT
      * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
      */
-    async parseComment(data) {
-        const decoder = new VorbisDecoder(data, 0);
-        const vendor = decoder.readStringUtf8();
-        if (vendor.length > 0) {
-            this.metadata.setFormat('tool', vendor);
-        }
+    async parseComment(dataLen) {
+        const data = await this.tokenizer.readToken(new token_types_1.Uint8ArrayType(dataLen));
+        const decoder = new VorbisDecoder_1.VorbisDecoder(data, 0);
+        decoder.readStringUtf8(); // vendor (skip)
         const commentListLength = decoder.readInt32();
-        const tags = new Array(commentListLength);
         for (let i = 0; i < commentListLength; i++) {
-            tags[i] = decoder.parseUserComment();
+            const tag = decoder.parseUserComment();
+            this.vorbisParser.addTag(tag.key, tag.value);
         }
-        await Promise.all(tags.map(tag => {
-            if (tag.key === 'ENCODER') {
-                this.metadata.setFormat('tool', tag.value);
-            }
-            return this.addTag(tag.key, tag.value);
-        }));
     }
     async parsePicture(dataLen) {
         if (this.options.skipCovers) {
             return this.tokenizer.ignore(dataLen);
         }
-        return this.addPictureTag(await this.tokenizer.readToken(new VorbisPictureToken(dataLen)));
+        else {
+            const picture = await this.tokenizer.readToken(new Vorbis_1.VorbisPictureToken(dataLen));
+            this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
+        }
     }
-    addPictureTag(picture) {
-        return this.addTag('METADATA_BLOCK_PICTURE', picture);
+}
+exports.FlacParser = FlacParser;
+class Metadata {
+}
+Metadata.BlockHeader = {
+    len: 4,
+    get: (buf, off) => {
+        return {
+            lastBlock: util.getBit(buf, off, 7),
+            type: util.getBitAllignedNumber(buf, off, 1, 7),
+            length: token_types_1.UINT24_BE.get(buf, off + 1)
+        };
     }
-    addTag(id, value) {
-        return this.vorbisParser.addTag(id, value);
+};
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+Metadata.BlockStreamInfo = {
+    len: 34,
+    get: (buf, off) => {
+        return {
+            // The minimum block size (in samples) used in the stream.
+            minimumBlockSize: token_types_1.UINT16_BE.get(buf, off),
+            // The maximum block size (in samples) used in the stream.
+            // (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
+            maximumBlockSize: token_types_1.UINT16_BE.get(buf, off + 2) / 1000,
+            // The minimum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            minimumFrameSize: token_types_1.UINT24_BE.get(buf, off + 4),
+            // The maximum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            maximumFrameSize: token_types_1.UINT24_BE.get(buf, off + 7),
+            // Sample rate in Hz. Though 20 bits are available,
+            // the maximum sample rate is limited by the structure of frame headers to 655350Hz.
+            // Also, a value of 0 is invalid.
+            sampleRate: token_types_1.UINT24_BE.get(buf, off + 10) >> 4,
+            // probably slower: sampleRate: common.getBitAllignedNumber(buf, off + 10, 0, 20),
+            // (number of channels)-1. FLAC supports from 1 to 8 channels
+            channels: util.getBitAllignedNumber(buf, off + 12, 4, 3) + 1,
+            // bits per sample)-1.
+            // FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
+            bitsPerSample: util.getBitAllignedNumber(buf, off + 12, 7, 5) + 1,
+            // Total samples in stream.
+            // 'Samples' means inter-channel sample, i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
+            // A value of zero here means the number of total samples is unknown.
+            totalSamples: util.getBitAllignedNumber(buf, off + 13, 4, 36),
+            // the MD5 hash of the file (see notes for usage... it's a littly tricky)
+            fileMD5: new token_types_1.Uint8ArrayType(16).get(buf, off + 18)
+        };
     }
-}
+};

package/node_modules/music-metadata/lib/id3v1/ID3v1Parser.d.ts

@@ -1,17 +1,13 @@
-import type { IRandomAccessTokenizer, ITokenizer } from 'strtok3';
-import { BasicParser } from '../common/BasicParser.js';
-import type { IPrivateOptions } from '../type.js';
-import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser';
+import { IRandomReader } from '../type';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres
  */
 export declare const Genres: string[];
 export declare class ID3v1Parser extends BasicParser {
-    private apeHeader;
-    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IPrivateOptions);
     private static getGenre;
     parse(): Promise<void>;
     private addTag;
 }
-export declare function hasID3v1Header(tokenizer: IRandomAccessTokenizer): Promise<boolean>;
+export declare function hasID3v1Header(reader: IRandomReader): Promise<boolean>;

package/node_modules/music-metadata/lib/id3v1/ID3v1Parser.js

@@ -1,15 +1,17 @@
-import initDebug from 'debug';
-import { StringType, UINT8 } from 'token-types';
-import * as util from '../common/Util.js';
-import { BasicParser } from '../common/BasicParser.js';
-import { APEv2Parser } from '../apev2/APEv2Parser.js';
-import { textDecode } from '@borewit/text-codec';
-const debug = initDebug('music-metadata:parser:ID3v1');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasID3v1Header = exports.ID3v1Parser = exports.Genres = void 0;
+const debug_1 = require("debug");
+const token_types_1 = require("token-types");
+const util = require("../common/Util");
+const BasicParser_1 = require("../common/BasicParser");
+const APEv2Parser_1 = require("../apev2/APEv2Parser");
+const debug = (0, debug_1.default)('music-metadata:parser:ID3v1');
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres
  */
-export const Genres = [
+exports.Genres = [
     'Blues', 'Classic Rock', 'Country', 'Dance', 'Disco', 'Funk', 'Grunge', 'Hip-Hop',
     'Jazz', 'Metal', 'New Age', 'Oldies', 'Other', 'Pop', 'R&B', 'Rap', 'Reggae', 'Rock',
     'Techno', 'Industrial', 'Alternative', 'Ska', 'Death Metal', 'Pranks', 'Soundtrack',
@@ -60,33 +62,28 @@ const Iid3v1Token = {
             year: new Id3v1StringType(4).get(buf, off + 93),
             comment: new Id3v1StringType(28).get(buf, off + 97),
             // ID3v1.1 separator for track
-            zeroByte: UINT8.get(buf, off + 127),
+            zeroByte: token_types_1.UINT8.get(buf, off + 127),
             // track: ID3v1.1 field added by Michael Mutschler
-            track: UINT8.get(buf, off + 126),
-            genre: UINT8.get(buf, off + 127)
+            track: token_types_1.UINT8.get(buf, off + 126),
+            genre: token_types_1.UINT8.get(buf, off + 127)
         } : null;
     }
 };
-class Id3v1StringType {
+class Id3v1StringType extends token_types_1.StringType {
     constructor(len) {
-        this.len = len;
-        this.stringType = new StringType(len, 'latin1');
+        super(len, 'binary');
     }
     get(buf, off) {
-        let value = this.stringType.get(buf, off);
+        let value = super.get(buf, off);
         value = util.trimRightNull(value);
         value = value.trim();
         return value.length > 0 ? value : undefined;
     }
 }
-export class ID3v1Parser extends BasicParser {
-    constructor(metadata, tokenizer, options) {
-        super(metadata, tokenizer, options);
-        this.apeHeader = options.apeHeader;
-    }
+class ID3v1Parser extends BasicParser_1.BasicParser {
     static getGenre(genreIndex) {
-        if (genreIndex < Genres.length) {
-            return Genres[genreIndex];
+        if (genreIndex < exports.Genres.length) {
+            return exports.Genres[genreIndex];
         }
         return undefined; // ToDO: generate warning
     }
@@ -95,10 +92,11 @@ export class ID3v1Parser extends BasicParser {
             debug('Skip checking for ID3v1 because the file-size is unknown');
             return;
         }
-        if (this.apeHeader) {
-            this.tokenizer.ignore(this.apeHeader.offset - this.tokenizer.position);
-            const apeParser = new APEv2Parser(this.metadata, this.tokenizer, this.options);
-            await apeParser.parseTags(this.apeHeader.footer);
+        if (this.options.apeHeader) {
+            this.tokenizer.ignore(this.options.apeHeader.offset - this.tokenizer.position);
+            const apeParser = new APEv2Parser_1.APEv2Parser();
+            apeParser.init(this.metadata, this.tokenizer, this.options);
+            await apeParser.parseTags(this.options.apeHeader.footer);
         }
         const offset = this.tokenizer.fileInfo.size - Iid3v1Token.len;
         if (this.tokenizer.position > offset) {
@@ -108,30 +106,29 @@ export class ID3v1Parser extends BasicParser {
         const header = await this.tokenizer.readToken(Iid3v1Token, offset);
         if (header) {
             debug('ID3v1 header found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
-            const props = ['title', 'artist', 'album', 'comment', 'track', 'year'];
-            for (const id of props) {
+            for (const id of ['title', 'artist', 'album', 'comment', 'track', 'year']) {
                 if (header[id] && header[id] !== '')
-                    await this.addTag(id, header[id]);
+                    this.addTag(id, header[id]);
             }
             const genre = ID3v1Parser.getGenre(header.genre);
             if (genre)
-                await this.addTag('genre', genre);
+                this.addTag('genre', genre);
         }
         else {
             debug('ID3v1 header not found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
         }
     }
-    async addTag(id, value) {
-        await this.metadata.addTag('ID3v1', id, value);
+    addTag(id, value) {
+        this.metadata.addTag('ID3v1', id, value);
     }
 }
-export async function hasID3v1Header(tokenizer) {
-    if (tokenizer.fileInfo.size >= 128) {
-        const tag = new Uint8Array(3);
-        const position = tokenizer.position;
-        await tokenizer.readBuffer(tag, { position: tokenizer.fileInfo.size - 128 });
-        tokenizer.setPosition(position); // Restore tokenizer position
-        return textDecode(tag, 'latin1') === 'TAG';
+exports.ID3v1Parser = ID3v1Parser;
+async function hasID3v1Header(reader) {
+    if (reader.fileSize >= 128) {
+        const tag = Buffer.alloc(3);
+        await reader.randomRead(tag, 0, tag.length, reader.fileSize - 128);
+        return tag.toString('binary') === 'TAG';
     }
     return false;
 }
+exports.hasID3v1Header = hasID3v1Header;

package/node_modules/music-metadata/lib/id3v1/ID3v1TagMap.d.ts

@@ -1,4 +1,4 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import { CommonTagMapper } from '../common/GenericTagMapper';
 export declare class ID3v1TagMapper extends CommonTagMapper {
     constructor();
 }

package/node_modules/music-metadata/lib/id3v1/ID3v1TagMap.js

@@ -1,4 +1,7 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ID3v1TagMapper = void 0;
+const GenericTagMapper_1 = require("../common/GenericTagMapper");
 /**
  * ID3v1 tag mappings
  */
@@ -11,8 +14,10 @@ const id3v1TagMap = {
     track: 'track',
     genre: 'genre'
 };
-export class ID3v1TagMapper extends CommonTagMapper {
+class ID3v1TagMapper extends GenericTagMapper_1.CommonTagMapper {
     constructor() {
         super(['ID3v1'], id3v1TagMap);
     }
 }
+exports.ID3v1TagMapper = ID3v1TagMapper;
+//# sourceMappingURL=ID3v1TagMap.js.map

package/node_modules/music-metadata/lib/id3v2/AbstractID3Parser.d.ts

@@ -1,5 +1,5 @@
-import { type ITokenizer } from 'strtok3';
-import { BasicParser } from '../common/BasicParser.js';
+import { ITokenizer } from 'strtok3/lib/core';
+import { BasicParser } from '../common/BasicParser';
 /**
  * Abstract parser which tries take ID3v2 and ID3v1 headers.
  */

package/node_modules/music-metadata/lib/id3v2/AbstractID3Parser.js

@@ -1,28 +1,31 @@
-import { EndOfStreamError } from 'strtok3';
-import initDebug from 'debug';
-import { ID3v2Header } from './ID3v2Token.js';
-import { ID3v2Parser } from './ID3v2Parser.js';
-import { ID3v1Parser } from '../id3v1/ID3v1Parser.js';
-import { BasicParser } from '../common/BasicParser.js';
-const debug = initDebug('music-metadata:parser:ID3');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractID3Parser = void 0;
+const core_1 = require("strtok3/lib/core");
+const debug_1 = require("debug");
+const ID3v2Token_1 = require("./ID3v2Token");
+const ID3v2Parser_1 = require("./ID3v2Parser");
+const ID3v1Parser_1 = require("../id3v1/ID3v1Parser");
+const BasicParser_1 = require("../common/BasicParser");
+const debug = (0, debug_1.default)('music-metadata:parser:ID3');
 /**
  * Abstract parser which tries take ID3v2 and ID3v1 headers.
  */
-export class AbstractID3Parser extends BasicParser {
+class AbstractID3Parser extends BasicParser_1.BasicParser {
     constructor() {
         super(...arguments);
-        this.id3parser = new ID3v2Parser();
+        this.id3parser = new ID3v2Parser_1.ID3v2Parser();
     }
     static async startsWithID3v2Header(tokenizer) {
-        return (await tokenizer.peekToken(ID3v2Header)).fileIdentifier === 'ID3';
+        return (await tokenizer.peekToken(ID3v2Token_1.ID3v2Header)).fileIdentifier === 'ID3';
     }
     async parse() {
         try {
             await this.parseID3v2();
         }
         catch (err) {
-            if (err instanceof EndOfStreamError) {
-                debug("End-of-stream");
+            if (err instanceof core_1.EndOfStreamError) {
+                debug(`End-of-stream`);
             }
             else {
                 throw err;
@@ -40,13 +43,13 @@ export class AbstractID3Parser extends BasicParser {
             this.finalize();
         }
         else {
-            const id3v1parser = new ID3v1Parser(this.metadata, this.tokenizer, this.options);
-            await id3v1parser.parse();
+            const id3v1parser = new ID3v1Parser_1.ID3v1Parser();
+            await id3v1parser.init(this.metadata, this.tokenizer, this.options).parse();
             this.finalize();
         }
     }
     async tryReadId3v2Headers() {
-        const id3Header = await this.tokenizer.peekToken(ID3v2Header);
+        const id3Header = await this.tokenizer.peekToken(ID3v2Token_1.ID3v2Header);
         if (id3Header.fileIdentifier === 'ID3') {
             debug('Found ID3v2 header, pos=%s', this.tokenizer.position);
             await this.id3parser.parse(this.metadata, this.tokenizer, this.options);
@@ -54,3 +57,4 @@ export class AbstractID3Parser extends BasicParser {
         }
     }
 }
+exports.AbstractID3Parser = AbstractID3Parser;