music-metadata 8.0.0 → 8.0.1

package/lib/browser.js

@@ -0,0 +1,99 @@
+import initDebug from 'debug';
+import { ReadableWebToNodeStream } from 'readable-web-to-node-stream';
+import * as mm from './core.js';
+export { parseBuffer, parseFromTokenizer, orderTags, ratingToStars, selectCover } from './core.js';
+const debug = initDebug('music-metadata-browser:main');
+/**
+ * Parse audio Stream
+ * @param stream - ReadableStream
+ * @param contentType - MIME-Type
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export const parseNodeStream = mm.parseStream;
+/**
+ * Parse Web API ReadableStream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+ * @param stream - ReadableStream (web stream according WTWG Streams Standard)
+ * @param fileInfo FileInfo object or MIME-Type
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export async function parseReadableStream(stream, fileInfo, options) {
+    const ns = new ReadableWebToNodeStream(stream);
+    const res = await parseNodeStream(ns, typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo, options);
+    await ns.close();
+    return res;
+}
+/**
+ * Parse Web API File
+ * @param blob - Blob to parse
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export async function parseBlob(blob, options) {
+    const fileInfo = { mimeType: blob.type, size: blob.size };
+    if (blob instanceof File) {
+        fileInfo.path = blob.name;
+    }
+    const stream = blob.stream ? blob.stream() : convertBlobToReadableStream(blob);
+    return parseReadableStream(stream, { mimeType: blob.type, size: blob.size }, options);
+}
+/**
+ * Convert Blob to ReadableStream
+ * Fallback for Safari versions < 14.1
+ * @param blob
+ */
+function convertBlobToReadableStream(blob) {
+    const fileReader = new FileReader();
+    return new ReadableStream({
+        start(controller) {
+            // The following function handles each data chunk
+            fileReader.onloadend = event => {
+                let data = event.target.result;
+                if (data instanceof ArrayBuffer) {
+                    data = new Uint8Array(data);
+                }
+                controller.enqueue(data);
+                controller.close();
+            };
+            fileReader.onerror = error => {
+                controller.close();
+            };
+            fileReader.onabort = error => {
+                controller.close();
+            };
+            fileReader.readAsArrayBuffer(blob);
+        }
+    });
+}
+/**
+ * Parse fetched file, using the Web Fetch API
+ * @param audioTrackUrl - URL to download the audio track from
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export async function fetchFromUrl(audioTrackUrl, options) {
+    const response = await fetch(audioTrackUrl);
+    const fileInfo = {
+        size: parseInt(response.headers.get('Content-Length'), 10),
+        mimeType: response.headers.get('Content-Type')
+    };
+    if (response.ok) {
+        if (response.body) {
+            const res = await parseReadableStream(response.body, fileInfo, options);
+            debug('Closing HTTP-readable-stream...');
+            if (!response.body.locked) { // Prevent error in Firefox
+                await response.body.cancel();
+            }
+            debug('HTTP-readable-stream closed.');
+            return res;
+        }
+        else {
+            // Fall back on Blob
+            return parseBlob(await response.blob(), options);
+        }
+    }
+    else {
+        throw new Error(`HTTP error status=${response.status}: ${response.statusText}`);
+    }
+}

package/lib/common/BasicParser.d.ts

@@ -0,0 +1,17 @@
+import { ITokenizer } from 'strtok3/core';
+import { ITokenParser } from '../ParserFactory.js';
+import { IOptions, IPrivateOptions } from '../type.js';
+import { INativeMetadataCollector } from './MetadataCollector.js';
+export declare abstract class BasicParser implements ITokenParser {
+    protected metadata: INativeMetadataCollector;
+    protected tokenizer: ITokenizer;
+    protected options: IPrivateOptions;
+    /**
+     * 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: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    abstract parse(): any;
+}

package/lib/common/CaseInsensitiveTagMap.d.ts

@@ -0,0 +1,10 @@
+import { INativeTagMap, TagType } from './GenericTagTypes.js';
+import { CommonTagMapper } from './GenericTagMapper.js';
+export declare class CaseInsensitiveTagMap extends CommonTagMapper {
+    constructor(tagTypes: TagType[], tagMap: INativeTagMap);
+    /**
+     * @tag  Native header tag
+     * @return common tag name (alias)
+     */
+    protected getCommonName(tag: string): import("./GenericTagTypes.js").GenericTagId;
+}

package/lib/common/CombinedTagMapper.d.ts

@@ -0,0 +1,19 @@
+import { IGenericTag, TagType } from './GenericTagTypes.js';
+import { IGenericTagMapper } from './GenericTagMapper.js';
+import { ITag } from '../type.js';
+import { INativeMetadataCollector } from './MetadataCollector.js';
+export declare class CombinedTagMapper {
+    tagMappers: {
+        [index: string]: IGenericTagMapper;
+    };
+    constructor();
+    /**
+     * Convert native to generic (common) tags
+     * @param tagType Originating tag format
+     * @param tag     Native tag to map to a generic tag id
+     * @param warnings
+     * @return Generic tag result (output of this function)
+     */
+    mapTag(tagType: TagType, tag: ITag, warnings: INativeMetadataCollector): IGenericTag;
+    private registerTagMapper;
+}

package/lib/common/FourCC.d.ts

@@ -0,0 +1,6 @@
+import { IToken } from 'strtok3/core';
+/**
+ * Token for read FourCC
+ * Ref: https://en.wikipedia.org/wiki/FourCC
+ */
+export declare const FourCcToken: IToken<string>;

package/lib/common/GenericTagMapper.d.ts

@@ -0,0 +1,51 @@
+import * as generic from './GenericTagTypes.js';
+import { ITag } from '../type.js';
+import { INativeMetadataCollector, IWarningCollector } from './MetadataCollector.js';
+export interface IGenericTagMapper {
+    /**
+     * Which tagType it able to map to the generic mapping format
+     */
+    tagTypes: generic.TagType[];
+    /**
+     * Basic tag map
+     */
+    tagMap: generic.INativeTagMap;
+    /**
+     * Map native tag to generic tag
+     * @param tag       Native tag
+     * @param warnings  Register warnings
+     * @return Generic tag, if native tag could be mapped
+     */
+    mapGenericTag(tag: ITag, warnings: INativeMetadataCollector): generic.IGenericTag;
+}
+export declare class CommonTagMapper implements IGenericTagMapper {
+    tagTypes: generic.TagType[];
+    tagMap: generic.INativeTagMap;
+    static maxRatingScore: number;
+    static toIntOrNull(str: string): number;
+    static normalizeTrack(origVal: number | string): {
+        no: number;
+        of: number;
+    };
+    constructor(tagTypes: generic.TagType[], tagMap: generic.INativeTagMap);
+    /**
+     * Process and set common tags
+     * write common tags to
+     * @param tag Native tag
+     * @param warnings Register warnings
+     * @return common name
+     */
+    mapGenericTag(tag: ITag, warnings: IWarningCollector): generic.IGenericTag;
+    /**
+     * Convert native tag key to common tag key
+     * @param tag Native header tag
+     * @return common tag name (alias)
+     */
+    protected getCommonName(tag: string): generic.GenericTagId;
+    /**
+     * Handle post mapping exceptions / correction
+     * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
+     * @param warnings Used to register warnings
+     */
+    protected postMap(tag: ITag, warnings: IWarningCollector): void;
+}

package/lib/common/GenericTagTypes.d.ts

@@ -0,0 +1,33 @@
+export declare type TagType = 'vorbis' | 'ID3v1' | 'ID3v2.2' | 'ID3v2.3' | 'ID3v2.4' | 'APEv2' | 'asf' | 'iTunes' | 'exif' | 'matroska';
+export interface IGenericTag {
+    id: GenericTagId;
+    value: any;
+}
+export declare type GenericTagId = 'track' | 'disk' | 'year' | 'title' | 'artist' | 'artists' | 'albumartist' | 'album' | 'date' | 'originaldate' | 'originalyear' | 'comment' | 'genre' | 'picture' | 'composer' | 'lyrics' | 'albumsort' | 'titlesort' | 'work' | 'artistsort' | 'albumartistsort' | 'composersort' | 'lyricist' | 'writer' | 'conductor' | 'remixer' | 'arranger' | 'engineer' | 'technician' | 'producer' | 'djmixer' | 'mixer' | 'publisher' | 'label' | 'grouping' | 'subtitle' | 'discsubtitle' | 'totaltracks' | 'totaldiscs' | 'compilation' | 'rating' | 'bpm' | 'mood' | 'media' | 'catalognumber' | 'tvShow' | 'tvShowSort' | 'tvEpisode' | 'tvEpisodeId' | 'tvNetwork' | 'tvSeason' | 'podcast' | 'podcasturl' | 'releasestatus' | 'releasetype' | 'releasecountry' | 'script' | 'language' | 'copyright' | 'license' | 'encodedby' | 'encodersettings' | 'gapless' | 'barcode' | 'isrc' | 'asin' | 'musicbrainz_recordingid' | 'musicbrainz_trackid' | 'musicbrainz_albumid' | 'musicbrainz_artistid' | 'musicbrainz_albumartistid' | 'musicbrainz_releasegroupid' | 'musicbrainz_workid' | 'musicbrainz_trmid' | 'musicbrainz_discid' | 'acoustid_id' | 'acoustid_fingerprint' | 'musicip_puid' | 'musicip_fingerprint' | 'website' | 'performer:instrument' | 'peakLevel' | 'averageLevel' | 'notes' | 'key' | 'originalalbum' | 'originalartist' | 'discogs_artist_id' | 'discogs_label_id' | 'discogs_master_release_id' | 'discogs_rating' | 'discogs_release_id' | 'discogs_votes' | 'replaygain_track_gain' | 'replaygain_track_peak' | 'replaygain_album_gain' | 'replaygain_album_peak' | 'replaygain_track_minmax' | 'replaygain_album_minmax' | 'replaygain_undo' | 'description' | 'longDescription' | 'category' | 'hdVideo' | 'keywords' | 'movement' | 'movementIndex' | 'movementTotal' | 'podcastId' | 'showMovement' | 'stik';
+export interface INativeTagMap {
+    [index: string]: GenericTagId;
+}
+export interface ITagInfo {
+    /**
+     * True if result is an array
+     */
+    multiple: boolean;
+    /**
+     * True if the result is an array and each value in the array should be unique
+     */
+    unique?: boolean;
+}
+export interface ITagInfoMap {
+    [index: string]: ITagInfo;
+}
+export declare const commonTags: ITagInfoMap;
+/**
+ * @param alias Name of common tag
+ * @returns {boolean|*} true if given alias is mapped as a singleton', otherwise false
+ */
+export declare function isSingleton(alias: GenericTagId): boolean;
+/**
+ * @param alias Common (generic) tag
+ * @returns {boolean|*} true if given alias is a singleton or explicitly marked as unique
+ */
+export declare function isUnique(alias: GenericTagId): boolean;

package/lib/common/MetadataCollector.d.ts

@@ -0,0 +1,76 @@
+import { FormatId, IAudioMetadata, ICommonTagsResult, IFormat, INativeTags, IOptions, IQualityInformation, ITrackInfo } from '../type.js';
+import { IGenericTag, TagType } from './GenericTagTypes.js';
+/**
+ * Combines all generic-tag-mappers for each tag type
+ */
+export interface IWarningCollector {
+    /**
+     * Register parser warning
+     * @param warning
+     */
+    addWarning(warning: string): any;
+}
+export interface INativeMetadataCollector extends IWarningCollector {
+    /**
+     * Only use this for reading
+     */
+    readonly format: IFormat;
+    readonly native: INativeTags;
+    readonly quality: IQualityInformation;
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny(): boolean;
+    setFormat(key: FormatId, value: any): void;
+    addTag(tagType: TagType, tagId: string, value: any): void;
+    addStreamInfo(streamInfo: ITrackInfo): void;
+}
+/**
+ * Provided to the parser to uodate the metadata result.
+ * Responsible for triggering async updates
+ */
+export declare class MetadataCollector implements INativeMetadataCollector {
+    private opts;
+    readonly format: IFormat;
+    readonly native: INativeTags;
+    readonly common: ICommonTagsResult;
+    readonly quality: IQualityInformation;
+    /**
+     * Keeps track of origin priority for each mapped id
+     */
+    private readonly commonOrigin;
+    /**
+     * Maps a tag type to a priority
+     */
+    private readonly originPriority;
+    private tagMapper;
+    constructor(opts: IOptions);
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny(): boolean;
+    addStreamInfo(streamInfo: ITrackInfo): void;
+    setFormat(key: FormatId, value: any): void;
+    addTag(tagType: TagType, tagId: string, value: any): void;
+    addWarning(warning: string): void;
+    postMap(tagType: TagType | 'artificial', tag: IGenericTag): any;
+    /**
+     * Convert native tags to common tags
+     * @returns {IAudioMetadata} Native + common tags
+     */
+    toCommonMetadata(): IAudioMetadata;
+    /**
+     * Fix some common issues with picture object
+     * @param picture Picture
+     */
+    private postFixPicture;
+    /**
+     * Convert native tag to common tags
+     */
+    private toCommon;
+    /**
+     * Set generic tag
+     */
+    private setGenericTag;
+}
+export declare function joinArtists(artists: string[]): string;

package/lib/common/RandomFileReader.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IRandomReader } from '../type.js';
+/**
+ * Provides abstract file access via the IRandomRead interface
+ */
+export declare class RandomFileReader implements IRandomReader {
+    private readonly fileHandle;
+    filePath: string;
+    fileSize: number;
+    private constructor();
+    /**
+     * Read from a given position of an abstracted file or buffer.
+     * @param buffer {Buffer} is the buffer that the data will be written to.
+     * @param offset {number} is the offset in the buffer to start writing at.
+     * @param length {number}is an integer specifying the number of bytes to read.
+     * @param position {number} is an argument specifying where to begin reading from in the file.
+     * @return {Promise<number>} bytes read
+     */
+    randomRead(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
+    close(): Promise<void>;
+    static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
+}

package/lib/common/RandomUint8ArrayReader.d.ts

@@ -0,0 +1,18 @@
+import { IRandomReader } from '../type.js';
+/**
+ * Provides abstract Uint8Array access via the IRandomRead interface
+ */
+export declare class RandomUint8ArrayReader implements IRandomReader {
+    private readonly uint8Array;
+    readonly fileSize: number;
+    constructor(uint8Array: Uint8Array);
+    /**
+     * Read from a given position of an abstracted file or buffer.
+     * @param uint8Array - Uint8Array that the data will be written to.
+     * @param offset - Offset in the buffer to start writing at.
+     * @param length - Integer specifying the number of bytes to read.
+     * @param position - Specifies where to begin reading from in the file.
+     * @return Promise providing bytes read
+     */
+    randomRead(uint8Array: Uint8Array, offset: number, length: number, position: number): Promise<number>;
+}

package/lib/common/Util.d.ts

@@ -0,0 +1,57 @@
+import { IRatio } from '../type.js';
+export declare type StringEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
+export interface ITextEncoding {
+    encoding: StringEncoding;
+    bom?: boolean;
+}
+export declare function getBit(buf: Uint8Array, off: number, bit: number): boolean;
+/**
+ * Found delimiting zero in uint8Array
+ * @param uint8Array Uint8Array to find the zero delimiter in
+ * @param start Offset in uint8Array
+ * @param end Last position to parse in uint8Array
+ * @param encoding The string encoding used
+ * @return Absolute position on uint8Array where zero found
+ */
+export declare function findZero(uint8Array: Uint8Array, start: number, end: number, encoding?: StringEncoding): number;
+export declare function trimRightNull(x: string): string;
+/**
+ * Decode string
+ */
+export declare function decodeString(uint8Array: Uint8Array, encoding: StringEncoding): string;
+export declare function stripNulls(str: string): string;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte buffer
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = lsb
+ * @param len Length of number in bits
+ * @return Decoded bit aligned number
+ */
+export declare function getBitAllignedNumber(source: Uint8Array, byteOffset: number, bitOffset: number, len: number): number;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte Uint8Array
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
+ * @return True if bit is set
+ */
+export declare function isBitSet(source: Uint8Array, byteOffset: number, bitOffset: number): boolean;
+export declare function a2hex(str: string): string;
+/**
+ * Convert power ratio to DB
+ * ratio: [0..1]
+ */
+export declare function ratioToDb(ratio: number): number;
+/**
+ * Convert dB to ratio
+ * db Decibels
+ */
+export declare function dbToRatio(dB: number): number;
+/**
+ * Convert replay gain to ratio and Decibel
+ * @param value string holding a ratio like '0.034' or '-7.54 dB'
+ */
+export declare function toRatio(value: string): IRatio;

package/lib/core.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable } from 'stream';
+import * as strtok3 from 'strtok3/core';
+import { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type.js';
+export { IFileInfo } from 'strtok3/core';
+/**
+ * Parse audio from Node Stream.Readable
+ * @param stream - Stream to read the audio track from
+ * @param options - Parsing options
+ * @param fileInfo - File information object or MIME-type string
+ * @returns Metadata
+ */
+export declare function parseStream(stream: Readable, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from Node Buffer
+ * @param uint8Array - Uint8Array holding audio data
+ * @param fileInfo - File information object or MIME-type string
+ * @param options - Parsing options
+ * @returns Metadata
+ * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
+ */
+export declare function parseBuffer(uint8Array: Uint8Array, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from ITokenizer source
+ * @param tokenizer - Audio source implementing the tokenizer interface
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseFromTokenizer(tokenizer: strtok3.ITokenizer, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Create a dictionary ordered by their tag id (key)
+ * @param nativeTags list of tags
+ * @returns tags indexed by id
+ */
+export declare function orderTags(nativeTags: ITag[]): INativeTagDict;
+/**
+ * Convert rating to 1-5 star rating
+ * @param rating: Normalized rating [0..1] (common.rating[n].rating)
+ * @returns Number of stars: 1, 2, 3, 4 or 5 stars
+ */
+export declare function ratingToStars(rating: number): number;
+/**
+ * Select most likely cover image.
+ * @param pictures Usually metadata.common.picture
+ * @return Cover image, if any, otherwise null
+ */
+export declare function selectCover(pictures?: IPicture[]): IPicture | null;
+export declare function scanAppendingHeaders(randomReader: IRandomReader, options?: IPrivateOptions): Promise<void>;

package/lib/dsdiff/DsdiffParser.d.ts

@@ -0,0 +1,14 @@
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
+ *
+ * Ref:
+ * - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export declare class DsdiffParser extends BasicParser {
+    parse(): Promise<void>;
+    private readFmt8Chunks;
+    private readData;
+    private handleSoundPropertyChunks;
+    private handleChannelChunks;
+}

package/lib/dsdiff/DsdiffToken.d.ts

@@ -0,0 +1,9 @@
+import { IGetToken } from 'strtok3/core';
+import { IChunkHeader64 } from '../iff/index.js';
+export { IChunkHeader64 } from '../iff/index.js';
+/**
+ * DSDIFF chunk header
+ * The data-size encoding is deviating from EA-IFF 85
+ * Ref: http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
+ */
+export declare const ChunkHeader64: IGetToken<IChunkHeader64>;

package/lib/dsf/DsfChunk.d.ts

@@ -0,0 +1,86 @@
+import { IGetToken } from 'strtok3/core';
+/**
+ * Common interface for the common chunk DSD header
+ */
+export interface IChunkHeader {
+    /**
+     * Chunk ID
+     */
+    id: string;
+    /**
+     * Chunk size
+     */
+    size: bigint;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const ChunkHeader: IGetToken<IChunkHeader>;
+/**
+ * Interface to DSD payload chunk
+ */
+export interface IDsdChunk {
+    /**
+     * Total file size
+     */
+    fileSize: bigint;
+    /**
+     * If Metadata doesn’t exist, set 0. If the file has ID3v2 tag, then set the pointer to it.
+     * ID3v2 tag should be located in the end of the file.
+     */
+    metadataPointer: bigint;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const DsdChunk: IGetToken<IDsdChunk>;
+export declare enum ChannelType {
+    mono = 1,
+    stereo = 2,
+    channels = 3,
+    quad = 4,
+    '4 channels' = 5,
+    '5 channels' = 6,
+    '5.1 channels' = 7
+}
+/**
+ * Interface to format chunk payload chunk
+ */
+export interface IFormatChunk {
+    /**
+     * Version of this file format
+     */
+    formatVersion: number;
+    /**
+     * Format ID
+     */
+    formatID: number;
+    /**
+     * Channel Type
+     */
+    channelType: ChannelType;
+    /**
+     * Channel num
+     */
+    channelNum: number;
+    /**
+     * Sampling frequency
+     */
+    samplingFrequency: number;
+    /**
+     * Bits per sample
+     */
+    bitsPerSample: number;
+    /**
+     * Sample count
+     */
+    sampleCount: bigint;
+    /**
+     * Block size per channel
+     */
+    blockSizePerChannel: number;
+}
+/**
+ * Common chunk DSD header: the 'chunk name (Four-CC)' & chunk size
+ */
+export declare const FormatChunk: IGetToken<IFormatChunk>;

package/lib/dsf/DsfParser.d.ts

@@ -0,0 +1,9 @@
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+/**
+ * DSF (dsd stream file) File Parser
+ * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
+ */
+export declare class DsfParser extends AbstractID3Parser {
+    postId3v2Parse(): Promise<void>;
+    private parseChunks;
+}

package/lib/flac/FlacParser.d.ts

@@ -0,0 +1,28 @@
+import { ITokenizer } from 'strtok3/core';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { IOptions } from '../type.js';
+import { ITokenParser } from '../ParserFactory.js';
+export declare class FlacParser extends AbstractID3Parser {
+    private vorbisParser;
+    private padding;
+    /**
+     * 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: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    postId3v2Parse(): Promise<void>;
+    private parseDataBlock;
+    /**
+     * Parse STREAMINFO
+     */
+    private parseBlockStreamInfo;
+    /**
+     * Parse VORBIS_COMMENT
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    private parseComment;
+    private parsePicture;
+}

package/lib/id3v1/ID3v1Parser.d.ts

@@ -0,0 +1,13 @@
+import { BasicParser } from '../common/BasicParser.js';
+import { IRandomReader } from '../type.js';
+/**
+ * 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 static getGenre;
+    parse(): Promise<void>;
+    private addTag;
+}
+export declare function hasID3v1Header(reader: IRandomReader): Promise<boolean>;

package/lib/id3v1/ID3v1TagMap.d.ts

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

package/lib/id3v2/AbstractID3Parser.d.ts

@@ -0,0 +1,17 @@
+import { ITokenizer } from 'strtok3/core';
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * Abstract parser which tries take ID3v2 and ID3v1 headers.
+ */
+export declare abstract class AbstractID3Parser extends BasicParser {
+    static startsWithID3v2Header(tokenizer: ITokenizer): Promise<boolean>;
+    private id3parser;
+    parse(): Promise<void>;
+    /**
+     * Called after ID3v2 headers are parsed
+     */
+    abstract postId3v2Parse(): Promise<void>;
+    protected finalize(): void;
+    private parseID3v2;
+    private tryReadId3v2Headers;
+}