music-metadata 8.3.0 → 9.0.0

package/README.md

@@ -1,4 +1,4 @@
-![Node.js CI](https://github.com/Borewit/music-metadata/workflows/Node.js%20CI/badge.svg)
+[![Node.js CI](https://github.com/Borewit/music-metadata/actions/workflows/nodejs-ci.yml/badge.svg?branch=master)](https://github.com/Borewit/music-metadata/actions?query=branch%3Amaster)
 [![Build status](https://ci.appveyor.com/api/projects/status/tgtqynlon8t99qq5/branch/master?svg=true)](https://ci.appveyor.com/project/Borewit/music-metadata/branch/master)
 [![NPM version](https://img.shields.io/npm/v/music-metadata.svg)](https://npmjs.org/package/music-metadata)
 [![npm downloads](http://img.shields.io/npm/dm/music-metadata.svg)](https://npmcharts.com/compare/music-metadata,jsmediatags,musicmetadata,node-id3,mp3-parser,id3-parser,wav-file-info?start=600)
@@ -11,9 +11,15 @@
 
 # music-metadata
 
-Stream and file based music metadata parser for [node.js](https://nodejs.org/).
+Stream and file based music metadata parser for [node.js](https://nodejs.org/) and browser projects.
 Supports any common audio and tagging format.
-[TypeScript](https://www.typescriptlang.org/) definitions are included.
+
+## Compatibility
+
+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 ≥ 16 engine.
+Primarily designed for [Node.js](https://nodejs.org/), but has also been designed for browser compatibility. 
 
 ## Features
 
@@ -25,12 +31,12 @@ Supports any common audio and tagging format.
 | AAC           | ADTS / Advanced Audio Coding    | [:link:](https://en.wikipedia.org/wiki/Advanced_Audio_Coding)      | <img src="https://svgshare.com/i/UT8.svg" width="40" alt="AAC logo">                                                                          |
 | APE           | Monkey's Audio                  | [:link:](https://wikipedia.org/wiki/Monkey's_Audio)                | <img src="https://foreverhits.files.wordpress.com/2015/05/ape_audio.jpg" width="40" alt="Monkey's Audio logo">                                |
 | ASF           | Advanced Systems Format         | [:link:](https://wikipedia.org/wiki/Advanced_Systems_Format)       |                                                                                                                                               |
-| BWF           | Broadcast Wave Format           | [:link:](https://en.wikipedia.org/wiki/Broadcast_Wave_Format)      |                                                                                                                                               |  
+| BWF           | Broadcast Wave Format           | [:link:](https://en.wikipedia.org/wiki/Broadcast_Wave_Format)      |                                                                                                                                               |
 | DSDIFF        | Philips DSDIFF                  | [:link:](https://wikipedia.org/wiki/Direct_Stream_Digital)         | <img src="https://upload.wikimedia.org/wikipedia/commons/b/bc/DSDlogo.svg" width="80" alt="DSD logo">                                         |
 | DSF           | Sony's DSD Stream File          | [:link:](https://wikipedia.org/wiki/Direct_Stream_Digital)         | <img src="https://upload.wikimedia.org/wikipedia/commons/b/bc/DSDlogo.svg" width="80" alt="DSD logo">                                         |
 | FLAC          | Free Lossless Audio Codec       | [:link:](https://wikipedia.org/wiki/FLAC)                          | <img src="https://upload.wikimedia.org/wikipedia/commons/a/a2/FLAC_logo_vector.svg" width="80" alt="FLAC logo">                               |
 | MP2           | MPEG-1 Audio Layer II           | [:link:](https://wikipedia.org/wiki/MPEG-1_Audio_Layer_II)         |                                                                                                                                               |
-| Matroska      | Matroska (EBML), mka, mkv       | [:link:](https://wikipedia.org/wiki/Matroska)                      | <img src="https://upload.wikimedia.org/wikipedia/commons/1/1a/Matroska_2010.svg" width="80" alt="Matroska logo">                              |                                                                                      
+| Matroska      | Matroska (EBML), mka, mkv       | [:link:](https://wikipedia.org/wiki/Matroska)                      | <img src="https://upload.wikimedia.org/wikipedia/commons/1/1a/Matroska_2010.svg" width="80" alt="Matroska logo">                              |
 | MP3           | MPEG-1 / MPEG-2 Audio Layer III | [:link:](https://wikipedia.org/wiki/MP3)                           | <img src="https://upload.wikimedia.org/wikipedia/commons/e/ea/Mp3.svg" width="80" alt="MP3 logo">                                             |
 | MPC           | Musepack SV7                    | [:link:](https://wikipedia.org/wiki/Musepack)                      | <img src="https://www.musepack.net/pictures/musepack_logo.png" width="80" alt="musepack logo">                                                |
 | MPEG 4        | mp4, m4a, m4v                   | [:link:](https://wikipedia.org/wiki/MPEG-4)                        | <img src="https://svgshare.com/i/UU3.svg" width="80" alt="mpeg 4 logo">                                                                       |
@@ -40,21 +46,21 @@ Supports any common audio and tagging format.
 | Theora        |                                 | [:link:](https://en.wikipedia.org/wiki/Theora)                     | <img src="https://upload.wikimedia.org/wikipedia/commons/5/57/Theora_logo_2007.svg" width="70" alt="Theora logo">                             |
 | Vorbis        | Vorbis audio compression        | [:link:](https://wikipedia.org/wiki/Ogg_Vorbis)                    | <img src="https://upload.wikimedia.org/wikipedia/commons/8/8d/Xiph.Org_logo_square.svg" width="70" alt="Vorbis logo">                         |
 | WAV           | RIFF WAVE                       | [:link:](https://wikipedia.org/wiki/WAV)                           |                                                                                                                                               |
-| WebM          | webm                            | [:link:](https://wikipedia.org/wiki/WebM)                          | <img src="https://upload.wikimedia.org/wikipedia/commons/3/34/WebM_logo.svg" width="80" alt="Matroska logo">                                  |                                                                                      
+| WebM          | webm                            | [:link:](https://wikipedia.org/wiki/WebM)                          | <img src="https://upload.wikimedia.org/wikipedia/commons/3/34/WebM_logo.svg" width="80" alt="Matroska logo">                                  |
 | WV            | WavPack                         | [:link:](https://wikipedia.org/wiki/WavPack)                       | <img src="http://www.wavpack.com/wavpacklogo.svg" width="60" alt="WavPack logo">                                                              |
 | WMA           | Windows Media Audio             | [:link:](https://wikipedia.org/wiki/Windows_Media_Audio)           | <img src="https://upload.wikimedia.org/wikipedia/commons/7/76/Windows_Media_Player_simplified_logo.svg" width="40" alt="Windows Media logo">  |
 
 ### Supported tag headers
 
 Following tag header formats are supported:
-*   [APE](https://wikipedia.org/wiki/APE_tag)
-*   [ASF](https://wikipedia.org/wiki/Advanced_Systems_Format)
-*   EXIF 2.3
-*   [ID3](https://wikipedia.org/wiki/ID3): ID3v1, ID3v1.1, ID3v2.2, [ID3v2.3](http://id3.org/id3v2.3.0) & [ID3v2.4](http://id3.org/id3v2.4.0-frames)
-*   [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)
+* [APE](https://wikipedia.org/wiki/APE_tag)
+* [ASF](https://wikipedia.org/wiki/Advanced_Systems_Format)
+* EXIF 2.3
+* [ID3](https://wikipedia.org/wiki/ID3): ID3v1, ID3v1.1, ID3v2.2, [ID3v2.3](http://id3.org/id3v2.3.0) & [ID3v2.4](http://id3.org/id3v2.4.0-frames)
+* [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.
 
@@ -64,38 +70,16 @@ Support for [MusicBrainz](https://musicbrainz.org/) tags as written by [Picard](
 ### Audio format & encoding details
 
 Support for encoding / format details:
-*   [Bit rate](https://wikipedia.org/wiki/Bit_rate)
-*   [Audio bit depth](https://wikipedia.org/wiki/Audio_bit_depth)
-*   Duration
-*   Encoding profile (e.g. [CBR](https://en.wikipedia.org/wiki/Constant_bitrate), V0, V2)
-  
-
-## Online demo's
-*   [<img src="https://raw.githubusercontent.com/Borewit/audio-tag-analyzer/master/src/assets/icon/audio-tag-analyzer.svg" width="40">Audio Tag Analyzer](https://audio-tag-analyzer.netlify.com/)
-*   [<img src="https://cdn.sanity.io/images/3do82whm/next/ba8c847f13a5fa39d88f8bc9b7846b7886531b18-2500x2500.svg" width="40"> Webamp](https://webamp.org/)
-
-
-## Compatibility
-
-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 ≥ 14.13.1 engine.
-
-### Browser Support
+* [Bit rate](https://wikipedia.org/wiki/Bit_rate)
+* [Audio bit depth](https://wikipedia.org/wiki/Audio_bit_depth)
+* Duration
+* Encoding profile (e.g. [CBR](https://en.wikipedia.org/wiki/Constant_bitrate), V0, V2)
 
-Although music-metadata is designed to run the node.js. [music-metadata-browser](https://github.com/Borewit/music-metadata-browser) can be used on the browser side. 
 
-To avoid Node `fs` dependency inclusion, you may use a sub-module inclusion:
-```js
-import * as mm from 'music-metadata/lib/core';
-```
+## Online demo's
+* [<img src="https://raw.githubusercontent.com/Borewit/audio-tag-analyzer/master/src/assets/icon/audio-tag-analyzer.svg" width="40">Audio Tag Analyzer](https://https://audio-tag-analyzer.netlify.app/)
+* [<img src="https://cdn.sanity.io/images/3do82whm/next/ba8c847f13a5fa39d88f8bc9b7846b7886531b18-2500x2500.svg" width="40"> Webamp](https://webamp.org/)
 
-| function                                             | `music-metadata`           | `music-metadata/lib/core`  |
-|------------------------------------------------------| ---------------------------|----------------------------|
-| [`parseBuffer`](#parsebuffer-function)               | ✓                          | ✓                          |
-| [`parseStream`](#parsestream-function) *             | ✓                          | ✓                          |
-| [`parseFromTokenizer`](#parsefromtokenizer-function) | ✓                          | ✓                          |
-| [`parseFile`](#parsefile-function)                   | ✓                          |                            |
 
 ### Sponsor
 [Become a sponsor to Borewit](https://github.com/sponsors/Borewit)
@@ -105,28 +89,26 @@ import * as mm from 'music-metadata/lib/core';
 Dependency diagram:
 ```mermaid
 graph TD;
-    MM(music-metadata)-->S(strtok3)
-    MM-->TY(token-types)
-    MM-->FT(file-type)
+    MMN("music-metadata (Node.js entry point)")-->MMP
+    MMN-->FTN
+    MMP("music-metadata (primary entry point)")-->S(strtok3)
+    MMP-->TY(token-types)
+    MMP-->FTP
+    MMP-->UAE
+    FTN("file-type (Node.js entry point)")-->FTP
+    FTP("file-type (primary entry point)")-->S
     S(strtok3)-->P(peek-readable)
-    S-->TO("@tokenizer/token")
-    TY-->TO
+    S(strtok3)-->TO("@tokenizer/token")
+    TY(token-types)-->TO
     TY-->IE("ieee754")
-    FT-->RWNS(readable-web-to-node-stream)
-    FT-->S
-    FT-->TY
-    TY-->NB(node:buffer)
-    RWNS-->RS(readable-stream)
-    RS-->SD(string_decoder)
-    SD-->SB(safe-buffer)
-    RS-->UD(util-deprecate)
-    RS-->I(inherits)
-    style NB fill:#F88,stroke:#A44
-    style SB fill:#F88,stroke:#A44
-    style SD fill:#CCC,stroke:#888
+    FTP-->TY
+    NS("node:stream")
+    FTN-->NS
+    FTP-->UAE(uint8array-extras)
+    style NS fill:#F88,stroke:#A44
     style IE fill:#CCC,stroke:#888
-    style UD fill:#CCC,stroke:#888
-    style I fill:#CCC,stroke:#888
+    style FTN fill:#FAA,stroke:#A44
+    style MMN fill:#FAA,stroke:#A44
 ```
 
 Dependency list:
@@ -192,8 +174,11 @@ import { inspect } from 'util';
 
 #### parseStream function
 
+_Only available for Node.js._
+
 Parses the provided audio stream for metadata.
-It is recommended to provide the corresponding [MIME-type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types). 
+The stream should be of type [Node.js Readable](https://nodejs.org/api/stream.html#class-streamreadable).
+It is recommended to provide the corresponding [MIME-type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types).
 An extension (e.g.: `.mp3`), filename or path will also work.
 If the MIME-type or filename (via `fileInfo.path`) is not provided, or not understood, music-metadata will try to derive the type from the content.
 
@@ -215,6 +200,41 @@ import { parseStream } from 'music-metadata';
 })();
 ```
 
+#### parseWebStream function
+
+Parses the provided audio web stream for metadata.
+The stream should be of type [ReadableStream<Uint8Array>](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream).
+It is recommended to provide the corresponding [MIME-type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types).
+An extension (e.g.: `.mp3`), filename or path will also work.
+If the MIME-type or filename (via `fileInfo.path`) is not provided, or not understood, music-metadata will try to derive the type from the content.
+
+```ts
+parseWebStream(stream: ReadableStream<Uint8Array>, fileInfo?: IFileInfo | string, opts?: IOptions = {}): Promise<IAudioMetadata>`
+```
+
+#### parseBlob function
+
+Parse an audio file from a [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [File](https://developer.mozilla.org/en-US/docs/Web/API/File).
+
+```js
+const musicMetadata = require('music-metadata');
+
+let blob;
+
+musicMetadata.parseBlob(blob).then(metadata => {
+    // metadata has all the metadata found in the blob or file
+  });
+```
+Or with async/await if you prefer:
+```js
+(async () => {
+  let blob; // File or Blob
+
+  const metadata = await musicMetadata.parseBlob(blob);
+  // metadata has all the metadata found in the blob or file
+});
+```
+
 #### parseBuffer function
 
 Parse metadata from an audio file, where the audio file is held in a [Buffer](https://nodejs.org/api/buffer.html).
@@ -242,7 +262,7 @@ This is a low level function, reading from a [strtok3](https://github.com/Borewi
 [music-metadata-browser](https://github.com/Borewit/music-metadata-browser) is depended on this function.
 
 This also enables special read modules like:
-*   [streaming-http-token-reader](https://github.com/Borewit/streaming-http-token-reader) for chunked HTTP(S) reading, using [HTTP range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests).
+* [streaming-http-token-reader](https://github.com/Borewit/streaming-http-token-reader) for chunked HTTP(S) reading, using [HTTP range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests).
 
 #### orderTags function
 
@@ -268,9 +288,9 @@ import { inspect } from 'util';
 ```
 
 #### ratingToStars function
-   
+
    Can be used to convert the normalized rating value to the 0..5 stars, where 0 an undefined rating, 1 the star the lowest rating and 5 the highest rating.
-   
+
    ```ts
    ratingToStars(rating: number): number
    ```
@@ -293,84 +313,84 @@ import { parseFile, selectCover } from 'music-metadata';
  ```
 
 ### Options
-*   `duration`: default: `false`, if set to `true`, it will parse the whole media file if required to determine the duration.
-*   `observer: (update: MetadataEvent) => void;`: Will be called after each change to `common` (generic) tag, or `format` properties.
-*   `skipCovers`: default: `false`, if set to `true`, it will not return embedded cover-art (images).
-*   `skipPostHeaders? boolean` default: `false`, if set to `true`, it will not search all the entire track for additional headers. Only recommenced to use in combination with streams.
-*   `includeChapters` default: `false`, if set to `true`, it will parse chapters (currently only MP4 files). _experimental functionality_
+- `duration`: default: `false`, if set to `true`, it will parse the whole media file if required to determine the duration.
+- `observer: (update: MetadataEvent) => void;`: Will be called after each change to `common` (generic) tag, or `format` properties.
+- `skipCovers`: default: `false`, if set to `true`, it will not return embedded cover-art (images).
+- `skipPostHeaders? boolean` default: `false`, if set to `true`, it will not search all the entire track for additional headers. Only recommenced to use in combination with streams.
+- `includeChapters` default: `false`, if set to `true`, it will parse chapters (currently only MP4 files). _experimental functionality_
 
 Although in most cases duration is included, in some cases it requires `music-metadata` parsing the entire file.
 To enforce parsing the entire file if needed you should set `duration` to `true`.
-    
+
 ### Metadata result
 
 If the returned promise resolves, the metadata (TypeScript `IAudioMetadata` interface) contains:
-*   [`metadata.format`](#metadataformat) Audio format information
-*   [`metadata.common`](#metadatacommon) Is a generic (abstract) way of reading metadata information. 
-*   [`metadata.trackInfo`](#metadatatrackInfo) Is a generic (abstract) way of reading metadata information. 
-*   `metadata.native` List of native (original) tags found in the parsed audio file.
-  
+- [`metadata.format`](#metadataformat) Audio format information
+- [`metadata.common`](#metadatacommon) Is a generic (abstract) way of reading metadata information.
+- [`metadata.trackInfo`](#metadatatrackInfo) Is a generic (abstract) way of reading metadata information.
+- `metadata.native` List of native (original) tags found in the parsed audio file.
+
 #### `metadata.format`
 
-The questionmark `?` indicates the property is optional. 
-  
+The questionmark `?` indicates the property is optional.
+
 Audio format information. Defined in the TypeScript `IFormat` interface:
-*   `format.container?: string` Audio encoding format. e.g.: 'flac'
-*   `format.codec?` Name of the codec (algorithm used for the audio compression)
-*   `format.codecProfile?: string` Codec profile / settings
-*   `format.tagTypes?: TagType[]`  List of tagging formats found in parsed audio file
-*   `format.duration?: number` Duration in seconds
-*   `format.bitrate?: number` Number bits per second of encoded audio file
-*   `format.sampleRate?: number` Sampling rate in Samples per second (S/s)
-*   `format.bitsPerSample?: number` Audio bit depth
-*   `format.lossless?: boolean` True if lossless,  false for lossy encoding
-*   `format.numberOfChannels?: number` Number of audio channels
-*   `format.creationTime?: Date` Track creation time
-*   `format.modificationTime?: Date` Track modification / tag update time
-*   `format.trackGain?: number` Track gain in dB
-*   `format.albumGain?: number` Album gain in dB
+- `format.container?: string` Audio encoding format. e.g.: 'flac'
+- `format.codec?` Name of the codec (algorithm used for the audio compression)
+- `format.codecProfile?: string` Codec profile / settings
+- `format.tagTypes?: TagType[]`  List of tagging formats found in parsed audio file
+- `format.duration?: number` Duration in seconds
+- `format.bitrate?: number` Number bits per second of encoded audio file
+- `format.sampleRate?: number` Sampling rate in Samples per second (S/s)
+- `format.bitsPerSample?: number` Audio bit depth
+- `format.lossless?: boolean` True if lossless,  false for lossy encoding
+- `format.numberOfChannels?: number` Number of audio channels
+- `format.creationTime?: Date` Track creation time
+- `format.modificationTime?: Date` Track modification / tag update time
+- `format.trackGain?: number` Track gain in dB
+- `format.albumGain?: number` Album gain in dB
 
 #### `metadata.trackInfo`
 
-To support advanced containers like [Matroska](https://wikipedia.org/wiki/Matroska) or [MPEG-4](https://en.wikipedia.org/wiki/MPEG-4), which may contain multiple audio and video tracks, the **experimental** `metadata.trackInfo` has been added,
-    
+To support advanced containers like [Matroska](https://wikipedia.org/wiki/Matroska) or [MPEG-4](https://en.wikipedia.org/wiki/MPEG-4), which may contain multiple audio and video tracks, the **experimental*- `metadata.trackInfo` has been added,
+
 `metadata.trackInfo` is either `undefined` or has an **array** of [trackInfo](#trackinfo)
-  
+
 ##### trackInfo
-  
+
 Audio format information. Defined in the TypeScript `IFormat` interface:
-*   `trackInfo.type?: TrackType` Track type
-*   `trackInfo.codecName?: string` Codec name
-*   `trackInfo.codecSettings?: string` Codec settings
-*   `trackInfo.flagEnabled?: boolean` Set if the track is usable, default: `true`
-*   `trackInfo.flagDefault?: boolean` Set if that track (audio, video or subs) SHOULD be active if no language found matches the user preference.
-*   `trackInfo.flagLacing?: boolean` Set if the track **may** contain blocks using lacing
-*   `trackInfo.name?: string` A human-readable track name.
-*   `trackInfo.language?: string` Specifies the language of the track
-*   `trackInfo.audio?: IAudioTrack`, see [`trackInfo.audioTrack`](#trackinfoaudiotrack)
-*   `trackInfo.video?: IVideoTrack`, see [`trackInfo.videoTrack`](#trackinfovideotrack)
+- `trackInfo.type?: TrackType` Track type
+- `trackInfo.codecName?: string` Codec name
+- `trackInfo.codecSettings?: string` Codec settings
+- `trackInfo.flagEnabled?: boolean` Set if the track is usable, default: `true`
+- `trackInfo.flagDefault?: boolean` Set if that track (audio, video or subs) SHOULD be active if no language found matches the user preference.
+- `trackInfo.flagLacing?: boolean` Set if the track **may** contain blocks using lacing
+- `trackInfo.name?: string` A human-readable track name.
+- `trackInfo.language?: string` Specifies the language of the track
+- `trackInfo.audio?: IAudioTrack`, see [`trackInfo.audioTrack`](#trackinfoaudiotrack)
+- `trackInfo.video?: IVideoTrack`, see [`trackInfo.videoTrack`](#trackinfovideotrack)
 
 ##### `trackInfo.audioTrack`
 
-*   `audioTrack.samplingFrequency?: number`
-*   `audioTrack.outputSamplingFrequency?: number`
-*   `audioTrack.channels?: number`
-*   `audioTrack.channelPositions?: Buffer`
-*   `audioTrack.bitDepth?: number`
+- `audioTrack.samplingFrequency?: number`
+- `audioTrack.outputSamplingFrequency?: number`
+- `audioTrack.channels?: number`
+- `audioTrack.channelPositions?: Buffer`
+- `audioTrack.bitDepth?: number`
 
 ##### `trackInfo.videoTrack`
 
-*   `videoTrack.flagInterlaced?: boolean`
-*   `videoTrack.stereoMode?: number`
-*   `videoTrack.pixelWidth?: number`
-*   `videoTrack.pixelHeight?: number`
-*   `videoTrack.displayWidth?: number`
-*   `videoTrack.displayHeight?: number`
-*   `videoTrack.displayUnit?: number`
-*   `videoTrack.aspectRatioType?: number`
-*   `videoTrack.colourSpace?: Buffer`
-*   `videoTrack.gammaValue?: number`
-  
+- `videoTrack.flagInterlaced?: boolean`
+- `videoTrack.stereoMode?: number`
+- `videoTrack.pixelWidth?: number`
+- `videoTrack.pixelHeight?: number`
+- `videoTrack.displayWidth?: number`
+- `videoTrack.displayHeight?: number`
+- `videoTrack.displayUnit?: number`
+- `videoTrack.aspectRatioType?: number`
+- `videoTrack.colourSpace?: Buffer`
+- `videoTrack.gammaValue?: number`
+
 #### `metadata.common`
 
 [Common tag documentation](doc/common_metadata.md) is automatically generated.
@@ -436,11 +456,11 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
 
         ```js
         import { parseFile } from 'music-metadata';
-        
+
         function parseFiles(audioFiles) {
-          
+
           const audioFile = audioFiles.shift();
-          
+
           if (audioFile) {
             return parseFile(audioFile).then(metadata => {
               // Do great things with the metadata
@@ -448,21 +468,21 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
             })
           }
         }
-        
+
         ```
 
     2.  Use async/await
-        
+
         Use [async/await](https://javascript.info/async-await)
-        
+
         ```js
         import { parseFile } from 'music-metadata';
-        
+
         // it is required to declare the function 'async' to allow the use of await
         async function parseFiles(audioFiles) {
-        
+
             for (const audioFile of audioFiles) {
-            
+
                 // await will ensure the metadata parsing is completed before we move on to the next file
                 const metadata = await parseFile(audioFile);
                 // Do great things with the metadata

package/lib/ParserFactory.d.ts

@@ -1,6 +1,6 @@
 import { INativeMetadataCollector } from './common/MetadataCollector.js';
 import { IOptions, IAudioMetadata, ParserType } from './type.js';
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 export interface ITokenParser {
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).

package/lib/ParserFactory.js

@@ -2,7 +2,6 @@ import { fileTypeFromBuffer } from 'file-type';
 import ContentType from 'content-type';
 import MimeType from 'media-typer';
 import initDebug from 'debug';
-import { Buffer } from 'node:buffer';
 import { MetadataCollector } from './common/MetadataCollector.js';
 import { AIFFParser } from './aiff/AiffParser.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
@@ -55,7 +54,7 @@ export class ParserFactory {
         if (!parserId) {
             // Parser could not be determined on MIME-type or extension
             debug('Guess parser on content...');
-            const buf = Buffer.alloc(4100);
+            const buf = new Uint8Array(4100);
             await tokenizer.peekBuffer(buf, { mayBeLess: true });
             if (tokenizer.fileInfo.path) {
                 parserId = this.getParserIdForExtension(tokenizer.fileInfo.path);

package/lib/aiff/AiffParser.js

@@ -1,6 +1,6 @@
 import * as Token from 'token-types';
 import initDebug from 'debug';
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
@@ -96,9 +96,8 @@ export class AIFFParser extends BasicParser {
     }
     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());
-        });
+        const values = value.split('\0').map(v => v.trim()).filter(v => v && v.length);
+        await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
         return header.chunkSize;
     }
 }

package/lib/aiff/AiffToken.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Buffer } from 'node:buffer';
 import * as iff from '../iff/index.js';
-import { IGetToken } from 'strtok3';
+import type { IGetToken } from 'strtok3';
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
@@ -19,5 +17,5 @@ export declare class Common implements IGetToken<ICommon> {
     private isAifc;
     len: number;
     constructor(header: iff.IChunkHeader, isAifc: boolean);
-    get(buf: Buffer, off: number): ICommon;
+    get(buf: Uint8Array, off: number): ICommon;
 }

package/lib/aiff/AiffToken.js

@@ -10,22 +10,22 @@ export class Common {
     }
     get(buf, off) {
         // see: https://cycling74.com/forums/aiffs-80-bit-sample-rate-value
-        const shift = buf.readUInt16BE(off + 8) - 16398;
-        const baseSampleRate = buf.readUInt16BE(off + 8 + 2);
+        const shift = Token.UINT16_BE.get(buf, off + 8) - 16398;
+        const baseSampleRate = Token.UINT16_BE.get(buf, off + 8 + 2);
         const res = {
-            numChannels: buf.readUInt16BE(off),
-            numSampleFrames: buf.readUInt32BE(off + 2),
-            sampleSize: buf.readUInt16BE(off + 6),
+            numChannels: Token.UINT16_BE.get(buf, off),
+            numSampleFrames: Token.UINT32_BE.get(buf, off + 2),
+            sampleSize: Token.UINT16_BE.get(buf, off + 6),
             sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
         };
         if (this.isAifc) {
             res.compressionType = FourCcToken.get(buf, off + 18);
             if (this.len > 22) {
-                const strLen = buf.readInt8(off + 22);
+                const strLen = Token.UINT8.get(buf, off + 22);
                 if (strLen > 0) {
                     const padding = (strLen + 1) % 2;
                     if (23 + strLen + padding === this.len) {
-                        res.compressionName = new Token.StringType(strLen, 'binary').get(buf, off + 23);
+                        res.compressionName = new Token.StringType(strLen, 'latin1').get(buf, off + 23);
                     }
                     else {
                         throw new Error('Illegal pstring length');

package/lib/apev2/APEv2Parser.d.ts

@@ -1,4 +1,4 @@
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { IOptions, IRandomReader, IApeHeader } from '../type.js';
 import { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';

package/lib/apev2/APEv2Parser.js

@@ -1,7 +1,7 @@
 import initDebug from 'debug';
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { StringType } from 'token-types';
-import { Buffer } from 'node:buffer';
+import { uint8ArrayToString } from 'uint8array-extras';
 import * as util from '../common/Util.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
@@ -35,7 +35,7 @@ export class APEv2Parser extends BasicParser {
      */
     static async findApeFooterOffset(reader, offset) {
         // Search for APE footer header at the end of the file
-        const apeBuf = Buffer.alloc(TagFooter.len);
+        const apeBuf = new Uint8Array(TagFooter.len);
         await reader.randomRead(apeBuf, 0, TagFooter.len, offset - TagFooter.len);
         const tagFooter = TagFooter.get(apeBuf, 0);
         if (tagFooter.ID === 'APETAGEX') {
@@ -70,7 +70,7 @@ export class APEv2Parser extends BasicParser {
             if (this.tokenizer.fileInfo.size) {
                 // Try to read the APEv2 header using just the footer-header
                 const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position; // ToDo: take ID3v1 into account
-                const buffer = Buffer.alloc(remaining);
+                const buffer = new Uint8Array(remaining);
                 await this.tokenizer.readBuffer(buffer);
                 return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
             }
@@ -87,7 +87,7 @@ export class APEv2Parser extends BasicParser {
         return this.tryParseApeHeader();
     }
     async parseTags(footer) {
-        const keyBuffer = Buffer.alloc(256); // maximum tag key length
+        const keyBuffer = new Uint8Array(256); // maximum tag key length
         let bytesRemaining = footer.size - TagFooter.len;
         debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
         for (let i = 0; i < footer.fields; i++) {
@@ -107,9 +107,7 @@ export class APEv2Parser extends BasicParser {
                 case DataType.text_utf8: { // utf-8 text-string
                     const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, 'utf8'));
                     const values = value.split(/\x00/g);
-                    for (const val of values) {
-                        this.metadata.addTag(tagFormat, key, val);
-                    }
+                    await Promise.all(values.map(val => this.metadata.addTag(tagFormat, key, val)));
                     break;
                 }
                 case DataType.binary: // binary (probably artwork)
@@ -117,12 +115,12 @@ export class APEv2Parser extends BasicParser {
                         await this.tokenizer.ignore(tagItemHeader.size);
                     }
                     else {
-                        const picData = Buffer.alloc(tagItemHeader.size);
+                        const picData = new Uint8Array(tagItemHeader.size);
                         await this.tokenizer.readBuffer(picData);
                         zero = util.findZero(picData, 0, picData.length);
-                        const description = picData.toString('utf8', 0, zero);
-                        const data = Buffer.from(picData.slice(zero + 1));
-                        this.metadata.addTag(tagFormat, key, {
+                        const description = uint8ArrayToString(picData.slice(0, zero));
+                        const data = picData.slice(zero + 1);
+                        await this.metadata.addTag(tagFormat, key, {
                             description,
                             data
                         });

package/lib/apev2/APEv2Token.d.ts

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * APETag versionIndex history / supported formats
  *