music-metadata 8.0.0 → 8.0.1

package/lib/id3v2/FrameParser.d.ts

@@ -0,0 +1,31 @@
+import { ID3v2MajorVersion } from './ID3v2Token.js';
+import { IWarningCollector } from '../common/MetadataCollector.js';
+export declare function parseGenre(origVal: string): string[];
+export declare class FrameParser {
+    private major;
+    private warningCollector;
+    /**
+     * Create id3v2 frame parser
+     * @param major - Major version, e.g. (4) for  id3v2.4
+     * @param warningCollector - Used to collect decode issue
+     */
+    constructor(major: ID3v2MajorVersion, warningCollector: IWarningCollector);
+    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): any;
+    protected static fixPictureMimeType(pictureType: string): string;
+    /**
+     * Converts TMCL (Musician credits list) or TIPL (Involved people list)
+     * @param entries
+     */
+    private static functionList;
+    /**
+     * id3v2.4 defines that multiple T* values are separated by 0x00
+     * id3v2.3 defines that TCOM, TEXT, TOLY, TOPE & TPE1 values are separated by /
+     * @param tag - Tag name
+     * @param text - Concatenated tag value
+     * @returns Split tag value
+     */
+    private splitValue;
+    private static trimArray;
+    private static readIdentifierAndData;
+    private static getNullTerminatorLength;
+}

package/lib/id3v2/ID3v22TagMapper.d.ts

@@ -0,0 +1,9 @@
+import { INativeTagMap } from '../common/GenericTagTypes.js';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+/**
+ * ID3v2.2 tag mappings
+ */
+export declare const id3v22TagMap: INativeTagMap;
+export declare class ID3v22TagMapper extends CaseInsensitiveTagMap {
+    constructor();
+}

package/lib/id3v2/ID3v24TagMapper.d.ts

@@ -0,0 +1,14 @@
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { IRating, ITag } from '../type.js';
+export declare class ID3v24TagMapper extends CaseInsensitiveTagMap {
+    static toRating(popm: any): IRating;
+    constructor();
+    /**
+     * Handle post mapping exceptions / correction
+     * @param tag to post map
+     * @param warnings Wil be used to register (collect) warnings
+     * @return Common value e.g. "Buena Vista Social Club"
+     */
+    protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
+}

package/lib/id3v2/ID3v2Parser.d.ts

@@ -0,0 +1,28 @@
+import { ITokenizer } from 'strtok3/core';
+import { IOptions } from '../type.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+export declare class ID3v2Parser {
+    static removeUnsyncBytes(buffer: Uint8Array): Uint8Array;
+    private static getFrameHeaderLength;
+    private static readFrameFlags;
+    private static readFrameData;
+    /**
+     * Create a combined tag key, of tag & description
+     * @param tag e.g.: COM
+     * @param description e.g. iTunPGAP
+     * @returns string e.g. COM:iTunPGAP
+     */
+    private static makeDescriptionTagName;
+    private tokenizer;
+    private id3Header;
+    private metadata;
+    private headerType;
+    private options;
+    parse(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): Promise<void>;
+    parseExtendedHeader(): Promise<void>;
+    parseExtendedHeaderData(dataRemaining: number, extendedHeaderSize: number): Promise<void>;
+    parseId3Data(dataLen: number): Promise<void>;
+    private addTag;
+    private parseMetadata;
+    private readFrameHeader;
+}

package/lib/id3v2/ID3v2Token.d.ts

@@ -0,0 +1,73 @@
+import { IGetToken } from 'strtok3/core';
+import * as util from '../common/Util.js';
+/**
+ * The picture type according to the ID3v2 APIC frame
+ * Ref: http://id3.org/id3v2.3.0#Attached_picture
+ */
+export declare enum AttachedPictureType {
+    'Other' = 0,
+    "32x32 pixels 'file icon' (PNG only)" = 1,
+    'Other file icon' = 2,
+    'Cover (front)' = 3,
+    'Cover (back)' = 4,
+    'Leaflet page' = 5,
+    'Media (e.g. label side of CD)' = 6,
+    'Lead artist/lead performer/soloist' = 7,
+    'Artist/performer' = 8,
+    'Conductor' = 9,
+    'Band/Orchestra' = 10,
+    'Composer' = 11,
+    'Lyricist/text writer' = 12,
+    'Recording Location' = 13,
+    'During recording' = 14,
+    'During performance' = 15,
+    'Movie/video screen capture' = 16,
+    'A bright coloured fish' = 17,
+    'Illustration' = 18,
+    'Band/artist logotype' = 19,
+    'Publisher/Studio logotype' = 20
+}
+export declare type ID3v2MajorVersion = 2 | 3 | 4;
+export interface IExtendedHeader {
+    size: number;
+    extendedFlags: number;
+    sizeOfPadding: number;
+    crcDataPresent: boolean;
+}
+/**
+ * 28 bits (representing up to 256MB) integer, the msb is 0 to avoid 'false syncsignals'.
+ * 4 * %0xxxxxxx
+ */
+export declare const UINT32SYNCSAFE: {
+    get: (buf: Uint8Array, off: number) => number;
+    len: number;
+};
+/**
+ * ID3v2 tag header
+ */
+export interface IID3v2header {
+    fileIdentifier: string;
+    version: {
+        major: ID3v2MajorVersion;
+        revision: number;
+    };
+    flags: {
+        unsynchronisation: boolean;
+        isExtendedHeader: boolean;
+        expIndicator: boolean;
+        footer: boolean;
+    };
+    size: number;
+}
+/**
+ * ID3v2 header
+ * Ref: http://id3.org/id3v2.3.0#ID3v2_header
+ * ToDo
+ */
+export declare const ID3v2Header: IGetToken<IID3v2header>;
+export declare const ExtendedHeader: IGetToken<IExtendedHeader>;
+export interface ITextEncoding {
+    encoding: util.StringEncoding;
+    bom?: boolean;
+}
+export declare const TextEncodingToken: IGetToken<ITextEncoding>;

package/lib/iff/index.d.ts

@@ -0,0 +1,33 @@
+import { IGetToken } from 'strtok3/core';
+/**
+ * "EA IFF 85" Standard for Interchange Format Files
+ * Ref: http://www.martinreddy.net/gfx/2d/IFF.txt
+ */
+export interface IChunkHeader {
+    /**
+     * A chunk ID (ie, 4 ASCII bytes)
+     */
+    chunkID: string;
+    /**
+     * Number of data bytes following this data header
+     */
+    chunkSize: number;
+}
+/**
+ * "EA IFF 85" Standard for Interchange Format Files
+ * Ref: http://www.martinreddy.net/gfx/2d/IFF.txt
+ */
+export interface IChunkHeader64 {
+    /**
+     * A chunk ID (ie, 4 ASCII bytes)
+     */
+    chunkID: string;
+    /**
+     * Number of data bytes following this data header
+     */
+    chunkSize: bigint;
+}
+/**
+ * Common AIFF chunk header
+ */
+export declare const Header: IGetToken<IChunkHeader>;

package/lib/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as Stream from 'stream';
+import * as strtok3 from 'strtok3';
+import { IAudioMetadata, IOptions } from './type.js';
+export { IAudioMetadata, IOptions, ITag, INativeTagDict, ICommonTagsResult, IFormat, IPicture, IRatio, IChapter } from './type.js';
+export { parseFromTokenizer, parseBuffer, selectCover, orderTags, ratingToStars, IFileInfo } from './core.js';
+/**
+ * Parse audio from Node Stream.Readable
+ * @param stream - Stream to read the audio track from
+ * @param fileInfo - File information object or MIME-type, e.g.: 'audio/mpeg'
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseStream(stream: Stream.Readable, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from Node file
+ * @param filePath - Media file to read meta-data from
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseFile(filePath: string, options?: IOptions): Promise<IAudioMetadata>;

package/lib/lyrics3/Lyrics3.d.ts

@@ -0,0 +1,3 @@
+import { IRandomReader } from '../type.js';
+export declare const endTag2 = "LYRICS200";
+export declare function getLyricsHeaderLength(reader: IRandomReader): Promise<number>;

package/lib/matroska/MatroskaDtd.d.ts

@@ -0,0 +1,8 @@
+import { IContainerType } from './types.js';
+/**
+ * Elements of document type description
+ * Derived from https://github.com/tungol/EBML/blob/master/doctypes/matroska.dtd
+ * Extended with:
+ * - https://www.matroska.org/technical/specs/index.html
+ */
+export declare const elements: IContainerType;

package/lib/matroska/MatroskaParser.d.ts

@@ -0,0 +1,37 @@
+import { ITokenizer } from 'strtok3/core';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { IOptions } from '../type.js';
+import { ITokenParser } from '../ParserFactory.js';
+/**
+ * Extensible Binary Meta Language (EBML) parser
+ * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
+ * http://matroska.sourceforge.net/technical/specs/rfc/index.html
+ *
+ * WEBM VP8 AUDIO FILE
+ */
+export declare class MatroskaParser extends BasicParser {
+    private padding;
+    private parserMap;
+    private ebmlMaxIDLength;
+    private ebmlMaxSizeLength;
+    constructor();
+    /**
+     * 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;
+    parse(): Promise<void>;
+    private parseContainer;
+    private readVintData;
+    private readElement;
+    private isMaxValue;
+    private readFloat;
+    private readFlag;
+    private readUint;
+    private readString;
+    private readBuffer;
+    private addTag;
+}

package/lib/matroska/MatroskaTagMapper.d.ts

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

package/lib/matroska/types.d.ts

@@ -0,0 +1,175 @@
+/// <reference types="node" resolution-mode="require"/>
+export interface IHeader {
+    id: number;
+    len: number;
+}
+export declare enum DataType {
+    'string' = 0,
+    uint = 1,
+    uid = 2,
+    bool = 3,
+    binary = 4,
+    float = 5
+}
+export interface IElementType<T> {
+    readonly name: string;
+    readonly value?: DataType;
+    readonly container?: IContainerType;
+    readonly multiple?: boolean;
+}
+export interface IContainerType {
+    [id: number]: IElementType<string | number | boolean | Buffer>;
+}
+export interface ITree {
+    [name: string]: string | number | boolean | Buffer | ITree | ITree[];
+}
+export interface ISeekHead {
+    id?: Buffer;
+    position?: number;
+}
+export interface IMetaSeekInformation {
+    seekHeads: ISeekHead[];
+}
+export interface ISegmentInformation {
+    uid?: Buffer;
+    timecodeScale?: number;
+    duration?: number;
+    dateUTC?: number;
+    title?: string;
+    muxingApp?: string;
+    writingApp?: string;
+}
+export interface ITrackEntry {
+    uid?: Buffer;
+    trackNumber?: number;
+    trackType?: TrackType;
+    audio?: ITrackAudio;
+    video?: ITrackVideo;
+    flagEnabled?: boolean;
+    flagDefault?: boolean;
+    flagLacing?: boolean;
+    defaultDuration?: number;
+    trackTimecodeScale?: number;
+    name?: string;
+    language?: string;
+    codecID?: string;
+    codecPrivate?: Buffer;
+    codecName?: string;
+    codecSettings?: string;
+    codecInfoUrl?: string;
+    codecDownloadUrl?: string;
+    codecDecodeAll?: string;
+    trackOverlay?: string;
+}
+export interface ITrackVideo {
+    flagInterlaced?: boolean;
+    stereoMode?: number;
+    pixelWidth?: number;
+    pixelHeight?: number;
+    displayWidth?: number;
+    displayHeight?: number;
+    displayUnit?: number;
+    aspectRatioType?: number;
+    colourSpace?: Buffer;
+    gammaValue?: number;
+}
+export interface ITrackAudio {
+    samplingFrequency?: number;
+    outputSamplingFrequency?: number;
+    channels?: number;
+    channelPositions?: Buffer;
+    bitDepth?: number;
+}
+export interface ICuePoint {
+    cueTime?: number;
+    cueTrackPositions: ICueTrackPosition[];
+}
+export interface ICueTrackPosition {
+    cueTrack?: number;
+    cueClusterPosition?: number;
+    cueBlockNumber?: number;
+    cueCodecState?: number;
+    cueReference?: ICueReference;
+}
+export interface ICueReference {
+    cueRefTime?: number;
+    cueRefCluster?: number;
+    cueRefNumber?: number;
+    cueRefCodecState?: number;
+}
+export interface ISimpleTag {
+    name?: string;
+    'string'?: string;
+    binary?: Buffer;
+    language?: string;
+    default?: boolean;
+}
+export declare enum TargetType {
+    shot = 10,
+    scene = 20,
+    track = 30,
+    part = 40,
+    album = 50,
+    edition = 60,
+    collection = 70
+}
+export declare enum TrackType {
+    video = 1,
+    audio = 2,
+    complex = 3,
+    logo = 4,
+    subtitle = 17,
+    button = 18,
+    control = 32
+}
+export interface ITarget {
+    trackUID?: Buffer;
+    chapterUID?: Buffer;
+    attachmentUID?: Buffer;
+    targetTypeValue?: TargetType;
+    targetType?: string;
+}
+export interface ITag {
+    target: ITarget;
+    simpleTags: ISimpleTag[];
+}
+export interface ITags {
+    tag: ITag[];
+}
+export interface ITrackElement {
+    entries?: ITrackEntry[];
+}
+export interface IAttachmedFile {
+    description?: string;
+    name: string;
+    mimeType: string;
+    data: Buffer;
+    uid: string;
+}
+export interface IAttachments {
+    attachedFiles?: IAttachmedFile[];
+}
+export interface IMatroskaSegment {
+    metaSeekInfo?: IMetaSeekInformation;
+    seekHeads?: ISeekHead[];
+    info?: ISegmentInformation;
+    tracks?: ITrackElement;
+    tags?: ITags;
+    cues?: ICuePoint[];
+    attachments?: IAttachments;
+}
+export interface IEbmlElements {
+    version?: number;
+    readVersion?: number;
+    maxIDWidth?: number;
+    maxSizeWidth?: number;
+    docType?: string;
+    docTypeVersion?: number;
+    docTypeReadVersion?: number;
+}
+export interface IEbmlDoc {
+    ebml: IEbmlElements;
+}
+export interface IMatroskaDoc extends IEbmlDoc {
+    segment: IMatroskaSegment;
+}

package/lib/mp4/Atom.d.ts

@@ -0,0 +1,16 @@
+import * as AtomToken from './AtomToken.js';
+import { ITokenizer } from 'strtok3/core';
+export declare type AtomDataHandler = (atom: Atom, remaining: number) => Promise<void>;
+export declare class Atom {
+    readonly header: AtomToken.IAtomHeader;
+    extended: boolean;
+    readonly parent: Atom;
+    static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom, remaining: number): Promise<Atom>;
+    readonly children: Atom[];
+    readonly atomPath: string;
+    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom);
+    getHeaderLength(): number;
+    getPayloadLength(remaining: number): number;
+    readAtoms(tokenizer: ITokenizer, dataHandler: AtomDataHandler, size: number): Promise<void>;
+    private readData;
+}