music-metadata 8.0.0 → 8.1.0

package/lib/asf/GUID.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ *
+ * ASF File Structure:
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ *
+ * ASF GUIDs:
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
+ */
+export default class GUID {
+    str: string;
+    static HeaderObject: GUID;
+    static DataObject: GUID;
+    static SimpleIndexObject: GUID;
+    static IndexObject: GUID;
+    static MediaObjectIndexObject: GUID;
+    static TimecodeIndexObject: GUID;
+    static FilePropertiesObject: GUID;
+    static StreamPropertiesObject: GUID;
+    static HeaderExtensionObject: GUID;
+    static CodecListObject: GUID;
+    static ScriptCommandObject: GUID;
+    static MarkerObject: GUID;
+    static BitrateMutualExclusionObject: GUID;
+    static ErrorCorrectionObject: GUID;
+    static ContentDescriptionObject: GUID;
+    static ExtendedContentDescriptionObject: GUID;
+    static ContentBrandingObject: GUID;
+    static StreamBitratePropertiesObject: GUID;
+    static ContentEncryptionObject: GUID;
+    static ExtendedContentEncryptionObject: GUID;
+    static DigitalSignatureObject: GUID;
+    static PaddingObject: GUID;
+    static ExtendedStreamPropertiesObject: GUID;
+    static AdvancedMutualExclusionObject: GUID;
+    static GroupMutualExclusionObject: GUID;
+    static StreamPrioritizationObject: GUID;
+    static BandwidthSharingObject: GUID;
+    static LanguageListObject: GUID;
+    static MetadataObject: GUID;
+    static MetadataLibraryObject: GUID;
+    static IndexParametersObject: GUID;
+    static MediaObjectIndexParametersObject: GUID;
+    static TimecodeIndexParametersObject: GUID;
+    static CompatibilityObject: GUID;
+    static AdvancedContentEncryptionObject: GUID;
+    static AudioMedia: GUID;
+    static VideoMedia: GUID;
+    static CommandMedia: GUID;
+    static JFIF_Media: GUID;
+    static Degradable_JPEG_Media: GUID;
+    static FileTransferMedia: GUID;
+    static BinaryMedia: GUID;
+    static ASF_Index_Placeholder_Object: GUID;
+    static fromBin(bin: Buffer, offset?: number): GUID;
+    /**
+     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @param objectId Binary GUID
+     * @param offset Read offset in bytes, default 0
+     * @returns GUID as dashed hexadecimal representation
+     */
+    static decode(objectId: Buffer, offset?: number): string;
+    /**
+     * Decode stream type
+     * @param mediaType Media type GUID
+     * @returns Media type
+     */
+    static decodeMediaType(mediaType: GUID): 'audio' | 'video' | 'command' | 'degradable-jpeg' | 'file-transfer' | 'binary' | undefined;
+    /**
+     * Encode GUID
+     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @returns Encoded Binary GUID
+     */
+    static encode(str: string): Buffer;
+    constructor(str: string);
+    equals(guid: GUID): boolean;
+    toBin(): Buffer;
+}

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/CombinedTagMapper.js

@@ -7,6 +7,7 @@ import { MP4TagMapper } from '../mp4/MP4TagMapper.js';
 import { VorbisTagMapper } from '../ogg/vorbis/VorbisTagMapper.js';
 import { RiffInfoTagMapper } from '../riff/RiffInfoTagMap.js';
 import { MatroskaTagMapper } from '../matroska/MatroskaTagMapper.js';
+import { AiffTagMapper } from '../aiff/AiffTagMap.js';
 export class CombinedTagMapper {
     constructor() {
         this.tagMappers = {};
@@ -20,7 +21,8 @@ export class CombinedTagMapper {
             new APEv2TagMapper(),
             new AsfTagMapper(),
             new RiffInfoTagMapper(),
-            new MatroskaTagMapper()
+            new MatroskaTagMapper(),
+            new AiffTagMapper()
         ].forEach(mapper => {
             this.registerTagMapper(mapper);
         });

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/FourCC.js

@@ -8,11 +8,8 @@ export const FourCcToken = {
     len: 4,
     get: (buf, off) => {
         const id = buf.toString('binary', off, off + FourCcToken.len);
-        switch (id) {
-            default:
-                if (!id.match(validFourCC)) {
-                    throw new Error(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
-                }
+        if (!id.match(validFourCC)) {
+            throw new Error(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
         }
         return id;
     },

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' | 'AIFF';
+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/MetadataCollector.js

@@ -6,7 +6,7 @@ import { CommonTagMapper } from './GenericTagMapper.js';
 import { toRatio } from './Util.js';
 import { fileTypeFromBuffer } from 'file-type';
 const debug = initDebug('music-metadata:collector');
-const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'ID3v1'];
+const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'AIFF', 'ID3v1'];
 /**
  * Provided to the parser to uodate the metadata result.
  * Responsible for triggering async updates
@@ -41,7 +41,7 @@ export class MetadataCollector {
             this.originPriority[tagType] = priority++;
         }
         this.originPriority.artificial = 500; // Filled using alternative tags
-        this.originPriority.id3v1 = 600; // Consider worst due to field length limit
+        this.originPriority.id3v1 = 600; // Consider as the worst because of the field length limit
     }
     /**
      * @returns {boolean} true if one or more tags have been found

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;
+}