music-metadata 11.12.2 → 11.12.3

package/lib/ParseError.d.ts

@@ -0,0 +1,87 @@
+export type UnionOfParseErrors = CouldNotDetermineFileTypeError | UnsupportedFileTypeError | UnexpectedFileContentError | FieldDecodingError | InternalParserError;
+export declare const makeParseError: <Name extends string>(name: Name) => {
+    new (message: string): {
+        name: Name;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare const CouldNotDetermineFileTypeError_base: {
+    new (message: string): {
+        name: "CouldNotDetermineFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class CouldNotDetermineFileTypeError extends CouldNotDetermineFileTypeError_base {
+}
+declare const UnsupportedFileTypeError_base: {
+    new (message: string): {
+        name: "UnsupportedFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class UnsupportedFileTypeError extends UnsupportedFileTypeError_base {
+}
+declare const UnexpectedFileContentError_base: {
+    new (message: string): {
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+declare class UnexpectedFileContentError extends UnexpectedFileContentError_base {
+    readonly fileType: string;
+    constructor(fileType: string, message: string);
+    toString(): string;
+}
+declare const FieldDecodingError_base: {
+    new (message: string): {
+        name: "FieldDecodingError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class FieldDecodingError extends FieldDecodingError_base {
+}
+declare const InternalParserError_base: {
+    new (message: string): {
+        name: "InternalParserError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class InternalParserError extends InternalParserError_base {
+}
+export declare const makeUnexpectedFileContentError: <FileType extends string>(fileType: FileType) => {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export {};

package/lib/ParserFactory.d.ts

@@ -0,0 +1,44 @@
+import { type MediaType } from 'media-typer';
+import { type INativeMetadataCollector } from './common/MetadataCollector.js';
+import { type IAudioMetadata, type IOptions, type ParserType } from './type.js';
+import type { ITokenizer } from 'strtok3';
+export interface IParserLoader {
+    /**
+     * Returns a list of supported file extensions
+     */
+    extensions: string[];
+    mimeTypes: string[];
+    parserType: ParserType;
+    /**
+     * Lazy load the parser implementation class.
+     */
+    load(): Promise<new (metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions) => ITokenParser>;
+}
+export interface ITokenParser {
+    /**
+     * Parse audio track.
+     * Called after init(...).
+     * @returns Promise
+     */
+    parse(): Promise<void>;
+}
+interface IContentType extends MediaType {
+    parameters: {
+        [id: string]: string;
+    };
+}
+export declare function parseHttpContentType(contentType: string): IContentType;
+export declare class ParserFactory {
+    parsers: IParserLoader[];
+    constructor();
+    registerParser(parser: IParserLoader): void;
+    parse(tokenizer: ITokenizer, parserLoader: IParserLoader | undefined, opts?: IOptions): Promise<IAudioMetadata>;
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser submodule name
+     */
+    findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined;
+    findLoaderForContentType(httpContentType: string): IParserLoader | undefined;
+    getSupportedMimeTypes(): string[];
+}
+export {};

package/lib/aiff/AiffLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const aiffParserLoader: IParserLoader;

package/lib/aiff/AiffParser.d.ts

@@ -0,0 +1,15 @@
+import { BasicParser } from '../common/BasicParser.js';
+import * as iff from '../iff/index.js';
+/**
+ * AIFF - Audio Interchange File Format
+ *
+ * Ref:
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
+ * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
+ */
+export declare class AIFFParser extends BasicParser {
+    private isCompressed;
+    parse(): Promise<void>;
+    readData(header: iff.IChunkHeader): Promise<number>;
+    readTextChunk(header: iff.IChunkHeader): Promise<number>;
+}

package/lib/aiff/AiffTagMap.d.ts

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

package/lib/aiff/AiffToken.d.ts

@@ -0,0 +1,48 @@
+import type * as iff from '../iff/index.js';
+import type { IGetToken } from 'strtok3';
+export declare const compressionTypes: {
+    NONE: string;
+    sowt: string;
+    fl32: string;
+    fl64: string;
+    alaw: string;
+    ulaw: string;
+    ULAW: string;
+    ALAW: string;
+    FL32: string;
+};
+export type CompressionTypeCode = keyof typeof compressionTypes;
+declare const AiffContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class AiffContentError extends AiffContentError_base {
+}
+/**
+ * The Common Chunk.
+ * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
+ * digital audio are stored in the FORM AIFF.
+ */
+export interface ICommon {
+    numChannels: number;
+    numSampleFrames: number;
+    sampleSize: number;
+    sampleRate: number;
+    compressionType?: CompressionTypeCode;
+    compressionName?: string;
+}
+export declare class Common implements IGetToken<ICommon> {
+    len: number;
+    private isAifc;
+    constructor(header: iff.IChunkHeader, isAifc: boolean);
+    get(buf: Uint8Array, off: number): ICommon;
+}
+export {};

package/lib/apev2/APEv2Parser.d.ts

@@ -0,0 +1,46 @@
+import * as strtok3 from 'strtok3';
+import type { IOptions, IApeHeader } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { type IFooter, type IHeader } from './APEv2Token.js';
+import type { IRandomAccessTokenizer } from 'strtok3';
+declare const ApeContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class ApeContentError extends ApeContentError_base {
+}
+export declare function tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
+export declare class APEv2Parser extends BasicParser {
+    /**
+     * Calculate the media file duration
+     * @param ah ApeHeader
+     * @return {number} duration in seconds
+     */
+    static calculateDuration(ah: IHeader): number;
+    /**
+     * Calculates the APEv1 / APEv2 first field offset
+     * @param tokenizer
+     * @param offset
+     */
+    static findApeFooterOffset(tokenizer: IRandomAccessTokenizer, offset: number): Promise<IApeHeader | undefined>;
+    private static parseTagFooter;
+    private ape;
+    /**
+     * Parse APEv1 / APEv2 header if header signature found
+     */
+    tryParseApeHeader(): Promise<void>;
+    parse(): Promise<void>;
+    parseTags(footer: IFooter): Promise<void>;
+    private parseDescriptorExpansion;
+    private parseHeader;
+}
+export {};

package/lib/apev2/APEv2TagMapper.d.ts

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

package/lib/apev2/APEv2Token.d.ts

@@ -0,0 +1,99 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * APETag versionIndex history / supported formats
+ *
+ * 1.0 (1000) - Original APE tag spec.  Fully supported by this code.
+ * 2.0 (2000) - Refined APE tag spec (better streaming support, UTF StringEncoding). Fully supported by this code.
+ *
+ * Notes:
+ * - also supports reading of ID3v1.1 tags
+ * - all saving done in the APE Tag format using CURRENT_APE_TAG_VERSION
+ *
+ * APE File Format Overview: (pieces in order -- only valid for the latest versionIndex APE files)
+ *
+ * JUNK - any amount of "junk" before the APE_DESCRIPTOR (so people that put ID3v2 tags on the files aren't hosed)
+ * APE_DESCRIPTOR - defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+ * APE_HEADER - describes all of the necessary information about the APE file
+ * SEEK TABLE - the table that represents seek offsets [optional]
+ * HEADER DATA - the pre-audio data from the original file [optional]
+ * APE FRAMES - the actual compressed audio (broken into frames for seekability)
+ * TERMINATING DATA - the post-audio data from the original file [optional]
+ * TAG - describes all the properties of the file [optional]
+ */
+export interface IDescriptor {
+    ID: string;
+    version: number;
+    descriptorBytes: number;
+    headerBytes: number;
+    seekTableBytes: number;
+    headerDataBytes: number;
+    apeFrameDataBytes: number;
+    apeFrameDataBytesHigh: number;
+    terminatingDataBytes: number;
+    fileMD5: Uint8Array;
+}
+/**
+ * APE_HEADER: describes all of the necessary information about the APE file
+ */
+export interface IHeader {
+    compressionLevel: number;
+    formatFlags: number;
+    blocksPerFrame: number;
+    finalFrameBlocks: number;
+    totalFrames: number;
+    bitsPerSample: number;
+    channel: number;
+    sampleRate: number;
+}
+export interface IFooter {
+    ID: string;
+    version: number;
+    size: number;
+    fields: number;
+    flags: ITagFlags;
+}
+export declare const DataType: {
+    text_utf8: number;
+    binary: number;
+    external_info: number;
+    reserved: number;
+};
+export type DataType = typeof DataType[keyof typeof DataType];
+/**
+ * APE_DESCRIPTOR: defines the sizes (and offsets) of all the pieces, as well as the MD5 checksum
+ */
+export declare const DescriptorParser: IGetToken<IDescriptor>;
+/**
+ * APE_HEADER: describes all of the necessary information about the APE file
+ */
+export declare const Header: IGetToken<IHeader>;
+/**
+ * APE Tag Header/Footer Version 2.0
+ * TAG: describes all the properties of the file [optional]
+ */
+export declare const TagFooter: IGetToken<IFooter>;
+/**
+ * APE Tag v2.0 Item Header
+ */
+export interface ITagItemHeader {
+    size: number;
+    flags: ITagFlags;
+}
+/**
+ * APE Tag v2.0 Item Header
+ */
+export declare const TagItemHeader: IGetToken<ITagItemHeader>;
+export interface ITagFlags {
+    containsHeader: boolean;
+    containsFooter: boolean;
+    isHeader: boolean;
+    readOnly: boolean;
+    dataType: DataType;
+}
+export declare function parseTagFlags(flags: number): ITagFlags;
+/**
+ * @param num {number}
+ * @param bit 0 is least significant bit (LSB)
+ * @return {boolean} true if bit is 1; otherwise false
+ */
+export declare function isBitSet(num: number, bit: number): boolean;

package/lib/apev2/Apev2Loader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const apeParserLoader: IParserLoader;

package/lib/asf/AsfGuid.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 AsfGuid {
+    static HeaderObject: AsfGuid;
+    static DataObject: AsfGuid;
+    static SimpleIndexObject: AsfGuid;
+    static IndexObject: AsfGuid;
+    static MediaObjectIndexObject: AsfGuid;
+    static TimecodeIndexObject: AsfGuid;
+    static FilePropertiesObject: AsfGuid;
+    static StreamPropertiesObject: AsfGuid;
+    static HeaderExtensionObject: AsfGuid;
+    static CodecListObject: AsfGuid;
+    static ScriptCommandObject: AsfGuid;
+    static MarkerObject: AsfGuid;
+    static BitrateMutualExclusionObject: AsfGuid;
+    static ErrorCorrectionObject: AsfGuid;
+    static ContentDescriptionObject: AsfGuid;
+    static ExtendedContentDescriptionObject: AsfGuid;
+    static ContentBrandingObject: AsfGuid;
+    static StreamBitratePropertiesObject: AsfGuid;
+    static ContentEncryptionObject: AsfGuid;
+    static ExtendedContentEncryptionObject: AsfGuid;
+    static DigitalSignatureObject: AsfGuid;
+    static PaddingObject: AsfGuid;
+    static ExtendedStreamPropertiesObject: AsfGuid;
+    static AdvancedMutualExclusionObject: AsfGuid;
+    static GroupMutualExclusionObject: AsfGuid;
+    static StreamPrioritizationObject: AsfGuid;
+    static BandwidthSharingObject: AsfGuid;
+    static LanguageListObject: AsfGuid;
+    static MetadataObject: AsfGuid;
+    static MetadataLibraryObject: AsfGuid;
+    static IndexParametersObject: AsfGuid;
+    static MediaObjectIndexParametersObject: AsfGuid;
+    static TimecodeIndexParametersObject: AsfGuid;
+    static CompatibilityObject: AsfGuid;
+    static AdvancedContentEncryptionObject: AsfGuid;
+    static AudioMedia: AsfGuid;
+    static VideoMedia: AsfGuid;
+    static CommandMedia: AsfGuid;
+    static JFIF_Media: AsfGuid;
+    static Degradable_JPEG_Media: AsfGuid;
+    static FileTransferMedia: AsfGuid;
+    static BinaryMedia: AsfGuid;
+    static ASF_Index_Placeholder_Object: AsfGuid;
+    static fromBin(bin: Uint8Array, offset?: number): AsfGuid;
+    /**
+     * 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: Uint8Array, offset?: number): string;
+    /**
+     * Decode stream type
+     * @param mediaType Media type GUID
+     * @returns Media type
+     */
+    static decodeMediaType(mediaType: AsfGuid): '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(guid: string): Uint8Array;
+    str: string;
+    constructor(str: string);
+    equals(guid: AsfGuid): boolean;
+    toBin(): Uint8Array;
+}

package/lib/asf/AsfLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const asfParserLoader: IParserLoader;