music-metadata 8.0.0 → 8.1.0

package/README.md

@@ -55,6 +55,7 @@ Following tag header formats are supported:
 *   [iTunes](https://github.com/sergiomb2/libmp4v2/wiki/iTunesMetadata)
 *   [RIFF](https://wikipedia.org/wiki/Resource_Interchange_File_Format)/INFO
 *   [Vorbis comment](https://wikipedia.org/wiki/Vorbis_comment)
+*   [AIFF](https://wikipedia.org/wiki/Audio_Interchange_File_Format)
 
 It allows many tags to be accessed in audio format, and tag format independent way.
 
@@ -79,7 +80,7 @@ Support for encoding / format details:
 
 Module: version 8 migrated from [CommonJS](https://en.wikipedia.org/wiki/CommonJS) to [pure ECMAScript Module (ESM)](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
 JavaScript is compliant with [ECMAScript 2019 (ES10)](https://en.wikipedia.org/wiki/ECMAScript#10th_Edition_%E2%80%93_ECMAScript_2019).
-Requires Node.js ≥ 12.20 engine.
+Requires Node.js ≥ 14.13.1 engine.
 
 ### Browser Support
 
@@ -91,8 +92,8 @@ import * as mm from 'music-metadata/lib/core';
 ```
 
 | function                                             | `music-metadata`           | `music-metadata/lib/core`  |
-| -----------------------------------------------------| ---------------------------|----------------------------|
-| [`parseBuffer`](#parsefile-function)                 | ✓                          | ✓                          |
+|------------------------------------------------------| ---------------------------|----------------------------|
+| [`parseBuffer`](#parsebuffer-function)               | ✓                          | ✓                          |
 | [`parseStream`](#parsestream-function) *             | ✓                          | ✓                          |
 | [`parseFromTokenizer`](#parsefromtokenizer-function) | ✓                          | ✓                          |
 | [`parseFile`](#parsefile-function)                   | ✓                          |                            |

package/lib/ParserFactory.d.ts

@@ -0,0 +1,48 @@
+import { INativeMetadataCollector } from './common/MetadataCollector.js';
+import { IOptions, IAudioMetadata, ParserType } from './type.js';
+import { ITokenizer } from 'strtok3/core';
+export interface ITokenParser {
+    /**
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param metadata - Output
+     * @param tokenizer - Input
+     * @param options - Parsing options
+     */
+    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    /**
+     * Parse audio track.
+     * Called after init(...).
+     * @returns Promise
+     */
+    parse(): Promise<void>;
+}
+export declare function parseHttpContentType(contentType: string): {
+    type: string;
+    subtype: string;
+    suffix?: string;
+    parameters: {
+        [id: string]: string;
+    };
+};
+export declare class ParserFactory {
+    /**
+     * Parse metadata from tokenizer
+     * @param tokenizer - Tokenizer
+     * @param opts - Options
+     * @returns Native metadata
+     */
+    static parseOnContentType(tokenizer: ITokenizer, opts: IOptions): Promise<IAudioMetadata>;
+    static parse(tokenizer: ITokenizer, parserId: ParserType, opts: IOptions): Promise<IAudioMetadata>;
+    /**
+     * @param filePath - Path, filename or extension to audio file
+     * @return Parser sub-module name
+     */
+    static getParserIdForExtension(filePath: string): ParserType;
+    static loadParser(moduleName: ParserType): Promise<ITokenParser>;
+    private static getExtension;
+    /**
+     * @param httpContentType - HTTP Content-Type, extension, path or filename
+     * @returns Parser sub-module name
+     */
+    private static getParserIdForMimeType;
+}

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

@@ -48,7 +48,6 @@ export class AIFFParser extends BasicParser {
             while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
                 debug('Reading AIFF chunk at offset=' + this.tokenizer.position);
                 const chunkHeader = await this.tokenizer.readToken(iff.Header);
-                debug(`Chunk id=${chunkHeader.chunkID}`);
                 const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
                 const bytesRead = await this.readData(chunkHeader);
                 await this.tokenizer.ignore(nextChunk - bytesRead);
@@ -85,8 +84,21 @@ export class AIFFParser extends BasicParser {
                     this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);
                 }
                 return 0;
+            case 'NAME': // Sample name chunk
+            case 'AUTH': // Author chunk
+            case '(c) ': // Copyright chunk
+            case 'ANNO': // Annotation chunk
+                return this.readTextChunk(header);
             default:
+                debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`);
                 return 0;
         }
     }
+    async readTextChunk(header) {
+        const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
+        value.split('\0').map(v => v.trim()).filter(v => v && v.length > 0).forEach(v => {
+            this.metadata.addTag('AIFF', header.chunkID, v.trim());
+        });
+        return header.chunkSize;
+    }
 }

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

@@ -0,0 +1,16 @@
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+/**
+ * ID3v1 tag mappings
+ */
+const tagMap = {
+    NAME: 'title',
+    AUTH: 'artist',
+    '(c) ': 'copyright',
+    ANNO: 'comment'
+};
+export class AiffTagMapper extends CommonTagMapper {
+    constructor() {
+        super(['AIFF'], tagMap);
+    }
+}
+//# sourceMappingURL=AiffTagMap.js.map

package/lib/aiff/AiffToken.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'node:buffer';
+import * as iff from '../iff/index.js';
+import { IGetToken } from 'strtok3';
+/**
+ * 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?: string;
+    compressionName?: string;
+}
+export declare class Common implements IGetToken<ICommon> {
+    private isAifc;
+    len: number;
+    constructor(header: iff.IChunkHeader, isAifc: boolean);
+    get(buf: Buffer, off: number): ICommon;
+}

package/lib/apev2/APEv2Parser.d.ts

@@ -0,0 +1,30 @@
+import * as strtok3 from 'strtok3/core';
+import { IOptions, IRandomReader, IApeHeader } from '../type.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { IFooter, IHeader } from './APEv2Token.js';
+export declare class APEv2Parser extends BasicParser {
+    static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
+    /**
+     * 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 reader
+     * @param offset
+     */
+    static findApeFooterOffset(reader: IRandomReader, offset: number): Promise<IApeHeader>;
+    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;
+}

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,100 @@
+import * as Token from 'token-types';
+import { IGetToken } from 'strtok3/core';
+/**
+ * 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 enum DataType {
+    text_utf8 = 0,
+    binary = 1,
+    external_info = 2,
+    reserved = 3
+}
+/**
+ * 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 declare const TagField: (footer: any) => Token.Uint8ArrayType;
+export interface ITagFlags {
+    containsHeader: boolean;
+    containsFooter: boolean;
+    isHeader: boolean;
+    readOnly: boolean;
+    dataType: DataType;
+}
+export declare function parseTagFlags(flags: any): 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: any, bit: any): boolean;

package/lib/asf/AsfObject.d.ts

@@ -0,0 +1,320 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IGetToken, ITokenizer } from 'strtok3/core';
+import { Buffer } from 'node:buffer';
+import { IPicture, ITag } from '../type.js';
+import GUID from './GUID.js';
+/**
+ * Data Type: Specifies the type of information being stored. The following values are recognized.
+ */
+export declare enum DataType {
+    /**
+     * Unicode string. The data consists of a sequence of Unicode characters.
+     */
+    UnicodeString = 0,
+    /**
+     * BYTE array. The type of data is implementation-specific.
+     */
+    ByteArray = 1,
+    /**
+     * BOOL. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer. Only 0x0000 or 0x0001 are permitted values.
+     */
+    Bool = 2,
+    /**
+     * DWORD. The data is 4 bytes long and should be interpreted as a 32-bit unsigned integer.
+     */
+    DWord = 3,
+    /**
+     * QWORD. The data is 8 bytes long and should be interpreted as a 64-bit unsigned integer.
+     */
+    QWord = 4,
+    /**
+     * WORD. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer.
+     */
+    Word = 5
+}
+/**
+ * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575
+ */
+export interface IAsfObjectHeader {
+    /**
+     * A GUID that identifies the object. 128 bits
+     */
+    objectId: GUID;
+    /**
+     * The size of the object (64-bits)
+     */
+    objectSize: number;
+}
+/**
+ * Interface for: 3. ASF top-level Header Object
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3
+ */
+export interface IAsfTopLevelObjectHeader extends IAsfObjectHeader {
+    numberOfHeaderObjects: number;
+}
+/**
+ * Token for: 3. ASF top-level Header Object
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3
+ */
+export declare const TopLevelHeaderObjectToken: IGetToken<IAsfTopLevelObjectHeader, Buffer>;
+/**
+ * Token for: 3.1 Header Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_1
+ */
+export declare const HeaderObjectToken: IGetToken<IAsfObjectHeader, Buffer>;
+export declare abstract class State<T> implements IGetToken<T> {
+    len: number;
+    constructor(header: IAsfObjectHeader);
+    abstract get(buf: Buffer, off: number): T;
+    protected postProcessTag(tags: ITag[], name: string, valueType: number, data: any): void;
+}
+export declare class IgnoreObjectState extends State<any> {
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): null;
+}
+/**
+ * Interface for: 3.2: File Properties Object (mandatory, one only)
+ *
+ * The File Properties Object defines the global characteristics of the combined digital media streams found within the Data Object.
+ */
+export interface IFilePropertiesObject {
+    /**
+     * Specifies the unique identifier for this file.
+     * The value of this field shall be regenerated every time the file is modified in any way.
+     * The value of this field shall be identical to the value of the File ID field of the Data Object.
+     */
+    fileId: GUID;
+    /**
+     * Specifies the size, in bytes, of the entire file.
+     * The value of this field is invalid if the Broadcast Flag bit in the Flags field is set to 1.
+     */
+    fileSize: bigint;
+    /**
+     * Specifies the date and time of the initial creation of the file. The value is given as the number of 100-nanosecond
+     * intervals since January 1, 1601, according to Coordinated Universal Time (Greenwich Mean Time). The value of this
+     * field may be invalid if the Broadcast Flag bit in the Flags field is set to 1.
+     */
+    creationDate: bigint;
+    /**
+     * Specifies the number of Data Packet entries that exist within the Data Object. The value of this field is invalid
+     * if the Broadcast Flag bit in the Flags field is set to 1.
+     */
+    dataPacketsCount: bigint;
+    /**
+     * Specifies the time needed to play the file in 100-nanosecond units.
+     * This value should include the duration (estimated, if an exact value is unavailable) of the the last media object
+     * in the presentation. The value of this field is invalid if the Broadcast Flag bit in the Flags field is set to 1.
+     */
+    playDuration: bigint;
+    /**
+     * Specifies the time needed to send the file in 100-nanosecond units.
+     * This value should include the duration of the last packet in the content.
+     * The value of this field is invalid if the Broadcast Flag bit in the Flags field is set to 1.
+     * Players can ignore this value.
+     */
+    sendDuration: bigint;
+    /**
+     * Specifies the amount of time to buffer data before starting to play the file, in millisecond units.
+     * If this value is nonzero, the Play Duration field and all of the payload Presentation Time fields have been offset
+     * by this amount. Therefore, player software must subtract the value in the preroll field from the play duration and
+     * presentation times to calculate their actual values. It follows that all payload Presentation Time fields need to
+     * be at least this value.
+     */
+    preroll: bigint;
+    /**
+     * The flags
+     */
+    flags: {
+        /**
+         * Specifies, if set, that a file is in the process of being created (for example, for recording applications),
+         * and thus that various values stored in the header objects are invalid. It is highly recommended that
+         * post-processing be performed to remove this condition at the earliest opportunity.
+         */
+        broadcast: boolean;
+        /**
+         * Specifies, if set, that a file is seekable.
+         * Note that for files containing a single audio stream and a Minimum Data Packet Size field equal to the Maximum
+         * Data Packet Size field, this flag shall always be set to 1.
+         * For files containing a single audio stream and a video stream or mutually exclusive video streams,
+         * this flag is only set to 1 if the file contains a matching Simple Index Object for each regular video stream
+         * (that is, video streams that are not hidden according to the method described in section 8.2.2).
+         */
+        seekable: boolean;
+    };
+    /**
+     * Specifies the minimum Data Packet size in bytes. In general, the value of this field is invalid if the Broadcast
+     * Flag bit in the Flags field is set to 1.
+     * However, for the purposes of this specification, the values for the Minimum Data Packet Size and Maximum Data
+     * Packet Size fields shall be set to the same value, and this value should be set to the packet size, even when the
+     * Broadcast Flag in the Flags field is set to 1.
+     */
+    minimumDataPacketSize: number;
+    /**
+     * Specifies the maximum Data Packet size in bytes.
+     * In general, the value of this field is invalid if the Broadcast Flag bit in the Flags field is set to 1.
+     * However, for the purposes of this specification, the values of the Minimum Data Packet Size and Maximum Data Packet
+     * Size fields shall be set to the same value,
+     * and this value should be set to the packet size, even when the Broadcast Flag field is set to 1.
+     */
+    maximumDataPacketSize: number;
+    /**
+     * Specifies the maximum instantaneous bit rate in bits per second for the entire file.
+     * This shall equal the sum of the bit rates of the individual digital media streams.
+     * It shall be noted that the digital media stream includes ASF data packetization overhead as well as digital media
+     * data in payloads.
+     * Only those streams that have a free-standing Stream Properties Object in the header shall have their bit rates
+     * included in the sum;
+     * streams whose Stream Properties Object exists as part of an Extended Stream Properties Object in the Header
+     * Extension Object shall not have their bit rates included in this sum, except when this value would otherwise be 0.
+     */
+    maximumBitrate: number;
+}
+/**
+ * Token for: 3.2: File Properties Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_2
+ */
+export declare class FilePropertiesObject extends State<IFilePropertiesObject> {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): IFilePropertiesObject;
+}
+/**
+ * Interface for: 3.3 Stream Properties Object (mandatory, one per stream)
+ */
+export interface IStreamPropertiesObject {
+    /**
+     * Stream Type
+     */
+    streamType: string;
+    /**
+     * Error Correction Type
+     */
+    errorCorrectionType: GUID;
+}
+/**
+ * Token for: 3.3 Stream Properties Object (mandatory, one per stream)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_3
+ */
+export declare class StreamPropertiesObject extends State<IStreamPropertiesObject> {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): IStreamPropertiesObject;
+}
+export interface IHeaderExtensionObject {
+    reserved1: GUID;
+    reserved2: number;
+    extensionDataSize: number;
+}
+/**
+ * 3.4: Header Extension Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_4
+ */
+export declare class HeaderExtensionObject implements IGetToken<IHeaderExtensionObject> {
+    static guid: GUID;
+    len: number;
+    constructor();
+    get(buf: Buffer, off: number): IHeaderExtensionObject;
+}
+export interface ICodecEntry {
+    type: {
+        videoCodec: boolean;
+        audioCodec: boolean;
+    };
+    codecName: string;
+    description: string;
+    information: Buffer;
+}
+/**
+ * 3.5: Read the Codec-List-Object, which provides user-friendly information about the codecs and formats used to encode the content found in the ASF file.
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_5
+ */
+export declare function readCodecEntries(tokenizer: ITokenizer): Promise<ICodecEntry[]>;
+/**
+ * 3.10 Content Description Object (optional, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_10
+ */
+export declare class ContentDescriptionObjectState extends State<ITag[]> {
+    static guid: GUID;
+    private static contentDescTags;
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): ITag[];
+}
+/**
+ * 3.11 Extended Content Description Object (optional, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_11
+ */
+export declare class ExtendedContentDescriptionObjectState extends State<ITag[]> {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): ITag[];
+}
+export interface IStreamName {
+    streamLanguageId: number;
+    streamName: string;
+}
+/**
+ * 4.1 Extended Stream Properties Object (optional, 1 per media stream)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_1
+ */
+export interface IExtendedStreamPropertiesObject {
+    startTime: bigint;
+    endTime: bigint;
+    dataBitrate: number;
+    bufferSize: number;
+    initialBufferFullness: number;
+    alternateDataBitrate: number;
+    alternateBufferSize: number;
+    alternateInitialBufferFullness: number;
+    maximumObjectSize: number;
+    flags: {
+        reliableFlag: boolean;
+        seekableFlag: boolean;
+        resendLiveCleanpointsFlag: boolean;
+    };
+    streamNumber: number;
+    streamLanguageId: number;
+    averageTimePerFrame: number;
+    streamNameCount: number;
+    payloadExtensionSystems: number;
+    streamNames: IStreamName[];
+    streamPropertiesObject: number;
+}
+/**
+ * 4.1 Extended Stream Properties Object (optional, 1 per media stream)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_1
+ */
+export declare class ExtendedStreamPropertiesObjectState extends State<IExtendedStreamPropertiesObject> {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+    get(buf: Buffer, off: number): IExtendedStreamPropertiesObject;
+}
+/**
+ * 4.7  Metadata Object (optional, 0 or 1)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_7
+ */
+export declare class MetadataObjectState extends State<ITag[]> {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+    get(uint8Array: Uint8Array, off: number): ITag[];
+}
+export declare class MetadataLibraryObjectState extends MetadataObjectState {
+    static guid: GUID;
+    constructor(header: IAsfObjectHeader);
+}
+export interface IWmPicture extends IPicture {
+    type: string;
+    format: string;
+    description: string;
+    size: number;
+    data: Buffer;
+}
+/**
+ * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd757977(v=vs.85).aspx
+ */
+export declare class WmPictureToken implements IGetToken<IWmPicture> {
+    len: any;
+    static fromBase64(base64str: string): IPicture;
+    static fromBuffer(buffer: Buffer): IWmPicture;
+    constructor(len: any);
+    get(buffer: Buffer, offset: number): IWmPicture;
+}

package/lib/asf/AsfParser.d.ts

@@ -0,0 +1,17 @@
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * Windows Media Metadata Usage Guidelines
+ * - Ref: https://msdn.microsoft.com/en-us/library/ms867702.aspx
+ *
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01
+ * - https://hwiegman.home.xs4all.nl/fileformats/asf/ASF_Specification.pdf
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ */
+export declare class AsfParser extends BasicParser {
+    parse(): Promise<void>;
+    private parseObjectHeader;
+    private addTags;
+    private parseExtensionObject;
+}

package/lib/asf/AsfTagMapper.d.ts

@@ -0,0 +1,7 @@
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import { IRating, ITag } from '../type.js';
+export declare class AsfTagMapper extends CommonTagMapper {
+    static toRating(rating: string): IRating;
+    constructor();
+    protected postMap(tag: ITag): void;
+}

package/lib/asf/AsfUtil.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'node:buffer';
+import { DataType } from './AsfObject.js';
+export declare type AttributeParser = (buf: Buffer) => boolean | string | number | bigint | Buffer;
+export declare class AsfUtil {
+    static getParserForAttr(i: DataType): AttributeParser;
+    static parseUnicodeAttr(uint8Array: Uint8Array): string;
+    private static attributeParsers;
+    private static parseByteArrayAttr;
+    private static parseBoolAttr;
+    private static parseDWordAttr;
+    private static parseQWordAttr;
+    private static parseWordAttr;
+}