music-metadata 7.11.1 → 7.11.5

package/lib/ogg/vorbis/VorbisParser.js

@@ -1,128 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VorbisParser = void 0;
-const Token = require("token-types");
-const _debug = require("debug");
-const VorbisDecoder_1 = require("./VorbisDecoder");
-const Vorbis_1 = require("./Vorbis");
-const debug = _debug('music-metadata:parser:ogg:vorbis1');
-/**
- * Vorbis 1 Parser.
- * Used by OggParser
- */
-class VorbisParser {
-    constructor(metadata, options) {
-        this.metadata = metadata;
-        this.options = options;
-        this.pageSegments = [];
-    }
-    /**
-     * Vorbis 1 parser
-     * @param header Ogg Page Header
-     * @param pageData Page data
-     */
-    parsePage(header, pageData) {
-        if (header.headerType.firstPage) {
-            this.parseFirstPage(header, pageData);
-        }
-        else {
-            if (header.headerType.continued) {
-                if (this.pageSegments.length === 0) {
-                    throw new Error("Cannot continue on previous page");
-                }
-                this.pageSegments.push(pageData);
-            }
-            if (header.headerType.lastPage || !header.headerType.continued) {
-                // Flush page segments
-                if (this.pageSegments.length > 0) {
-                    const fullPage = Buffer.concat(this.pageSegments);
-                    this.parseFullPage(fullPage);
-                }
-                // Reset page segments
-                this.pageSegments = header.headerType.lastPage ? [] : [pageData];
-            }
-        }
-        if (header.headerType.lastPage) {
-            this.calculateDuration(header);
-        }
-    }
-    flush() {
-        this.parseFullPage(Buffer.concat(this.pageSegments));
-    }
-    parseUserComment(pageData, offset) {
-        const decoder = new VorbisDecoder_1.VorbisDecoder(pageData, offset);
-        const tag = decoder.parseUserComment();
-        this.addTag(tag.key, tag.value);
-        return tag.len;
-    }
-    addTag(id, value) {
-        if (id === 'METADATA_BLOCK_PICTURE' && (typeof value === 'string')) {
-            if (this.options.skipCovers) {
-                debug(`Ignore picture`);
-                return;
-            }
-            value = Vorbis_1.VorbisPictureToken.fromBase64(value);
-            debug(`Push picture: id=${id}, format=${value.format}`);
-        }
-        else {
-            debug(`Push tag: id=${id}, value=${value}`);
-        }
-        this.metadata.addTag('vorbis', id, value);
-    }
-    calculateDuration(header) {
-        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
-            // Calculate duration
-            this.metadata.setFormat('numberOfSamples', header.absoluteGranulePosition);
-            this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
-        }
-    }
-    /**
-     * Parse first Ogg/Vorbis page
-     * @param {IPageHeader} header
-     * @param {Buffer} pageData
-     */
-    parseFirstPage(header, pageData) {
-        this.metadata.setFormat('codec', 'Vorbis I');
-        debug("Parse first page");
-        // Parse  Vorbis common header
-        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
-        if (commonHeader.vorbis !== 'vorbis')
-            throw new Error('Metadata does not look like Vorbis');
-        if (commonHeader.packetType === 1) {
-            const idHeader = Vorbis_1.IdentificationHeader.get(pageData, Vorbis_1.CommonHeader.len);
-            this.metadata.setFormat('sampleRate', idHeader.sampleRate);
-            this.metadata.setFormat('bitrate', idHeader.bitrateNominal);
-            this.metadata.setFormat('numberOfChannels', idHeader.channelMode);
-            debug("sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s", idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
-        }
-        else
-            throw new Error('First Ogg page should be type 1: the identification header');
-    }
-    parseFullPage(pageData) {
-        // New page
-        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
-        debug("Parse full page: type=%s, byteLength=%s", commonHeader.packetType, pageData.byteLength);
-        switch (commonHeader.packetType) {
-            case 3: //  type 3: comment header
-                return this.parseUserCommentList(pageData, Vorbis_1.CommonHeader.len);
-            case 1: // type 1: the identification header
-            case 5: // type 5: setup header type
-                break; // ignore
-        }
-    }
-    /**
-     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
-     */
-    parseUserCommentList(pageData, offset) {
-        const strLen = Token.UINT32_LE.get(pageData, offset);
-        offset += 4;
-        // const vendorString = new Token.StringType(strLen, 'utf-8').get(pageData, offset);
-        offset += strLen;
-        let userCommentListLength = Token.UINT32_LE.get(pageData, offset);
-        offset += 4;
-        while (userCommentListLength-- > 0) {
-            offset += this.parseUserComment(pageData, offset);
-        }
-    }
-}
-exports.VorbisParser = VorbisParser;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VorbisParser = void 0;
+const Token = require("token-types");
+const _debug = require("debug");
+const VorbisDecoder_1 = require("./VorbisDecoder");
+const Vorbis_1 = require("./Vorbis");
+const debug = _debug('music-metadata:parser:ogg:vorbis1');
+/**
+ * Vorbis 1 Parser.
+ * Used by OggParser
+ */
+class VorbisParser {
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.options = options;
+        this.pageSegments = [];
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            this.parseFirstPage(header, pageData);
+        }
+        else {
+            if (header.headerType.continued) {
+                if (this.pageSegments.length === 0) {
+                    throw new Error("Cannot continue on previous page");
+                }
+                this.pageSegments.push(pageData);
+            }
+            if (header.headerType.lastPage || !header.headerType.continued) {
+                // Flush page segments
+                if (this.pageSegments.length > 0) {
+                    const fullPage = Buffer.concat(this.pageSegments);
+                    this.parseFullPage(fullPage);
+                }
+                // Reset page segments
+                this.pageSegments = header.headerType.lastPage ? [] : [pageData];
+            }
+        }
+        if (header.headerType.lastPage) {
+            this.calculateDuration(header);
+        }
+    }
+    flush() {
+        this.parseFullPage(Buffer.concat(this.pageSegments));
+    }
+    parseUserComment(pageData, offset) {
+        const decoder = new VorbisDecoder_1.VorbisDecoder(pageData, offset);
+        const tag = decoder.parseUserComment();
+        this.addTag(tag.key, tag.value);
+        return tag.len;
+    }
+    addTag(id, value) {
+        if (id === 'METADATA_BLOCK_PICTURE' && (typeof value === 'string')) {
+            if (this.options.skipCovers) {
+                debug(`Ignore picture`);
+                return;
+            }
+            value = Vorbis_1.VorbisPictureToken.fromBase64(value);
+            debug(`Push picture: id=${id}, format=${value.format}`);
+        }
+        else {
+            debug(`Push tag: id=${id}, value=${value}`);
+        }
+        this.metadata.addTag('vorbis', id, value);
+    }
+    calculateDuration(header) {
+        if (this.metadata.format.sampleRate && header.absoluteGranulePosition >= 0) {
+            // Calculate duration
+            this.metadata.setFormat('numberOfSamples', header.absoluteGranulePosition);
+            this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+        }
+    }
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param {IPageHeader} header
+     * @param {Buffer} pageData
+     */
+    parseFirstPage(header, pageData) {
+        this.metadata.setFormat('codec', 'Vorbis I');
+        debug("Parse first page");
+        // Parse  Vorbis common header
+        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
+        if (commonHeader.vorbis !== 'vorbis')
+            throw new Error('Metadata does not look like Vorbis');
+        if (commonHeader.packetType === 1) {
+            const idHeader = Vorbis_1.IdentificationHeader.get(pageData, Vorbis_1.CommonHeader.len);
+            this.metadata.setFormat('sampleRate', idHeader.sampleRate);
+            this.metadata.setFormat('bitrate', idHeader.bitrateNominal);
+            this.metadata.setFormat('numberOfChannels', idHeader.channelMode);
+            debug("sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s", idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
+        }
+        else
+            throw new Error('First Ogg page should be type 1: the identification header');
+    }
+    parseFullPage(pageData) {
+        // New page
+        const commonHeader = Vorbis_1.CommonHeader.get(pageData, 0);
+        debug("Parse full page: type=%s, byteLength=%s", commonHeader.packetType, pageData.byteLength);
+        switch (commonHeader.packetType) {
+            case 3: //  type 3: comment header
+                return this.parseUserCommentList(pageData, Vorbis_1.CommonHeader.len);
+            case 1: // type 1: the identification header
+            case 5: // type 5: setup header type
+                break; // ignore
+        }
+    }
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    parseUserCommentList(pageData, offset) {
+        const strLen = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        // const vendorString = new Token.StringType(strLen, 'utf-8').get(pageData, offset);
+        offset += strLen;
+        let userCommentListLength = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        while (userCommentListLength-- > 0) {
+            offset += this.parseUserComment(pageData, offset);
+        }
+    }
+}
+exports.VorbisParser = VorbisParser;

package/lib/ogg/vorbis/VorbisTagMapper.d.ts

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

package/lib/ogg/vorbis/VorbisTagMapper.js

@@ -1,132 +1,133 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VorbisTagMapper = void 0;
-const GenericTagMapper_1 = require("../../common/GenericTagMapper");
-/**
- * Vorbis tag mappings
- *
- * Mapping from native header format to one or possibly more 'common' entries
- * The common entries aim to read the same information from different media files
- * independent of the underlying format
- */
-const vorbisTagMap = {
-    TITLE: 'title',
-    ARTIST: 'artist',
-    ARTISTS: 'artists',
-    ALBUMARTIST: 'albumartist',
-    'ALBUM ARTIST': 'albumartist',
-    ALBUM: 'album',
-    DATE: 'date',
-    ORIGINALDATE: 'originaldate',
-    ORIGINALYEAR: 'originalyear',
-    COMMENT: 'comment',
-    TRACKNUMBER: 'track',
-    DISCNUMBER: 'disk',
-    GENRE: 'genre',
-    METADATA_BLOCK_PICTURE: 'picture',
-    COMPOSER: 'composer',
-    LYRICS: 'lyrics',
-    ALBUMSORT: 'albumsort',
-    TITLESORT: 'titlesort',
-    WORK: 'work',
-    ARTISTSORT: 'artistsort',
-    ALBUMARTISTSORT: 'albumartistsort',
-    COMPOSERSORT: 'composersort',
-    LYRICIST: 'lyricist',
-    WRITER: 'writer',
-    CONDUCTOR: 'conductor',
-    // 'PERFORMER=artist (instrument)': 'performer:instrument', // ToDo
-    REMIXER: 'remixer',
-    ARRANGER: 'arranger',
-    ENGINEER: 'engineer',
-    PRODUCER: 'producer',
-    DJMIXER: 'djmixer',
-    MIXER: 'mixer',
-    LABEL: 'label',
-    GROUPING: 'grouping',
-    SUBTITLE: 'subtitle',
-    DISCSUBTITLE: 'discsubtitle',
-    TRACKTOTAL: 'totaltracks',
-    DISCTOTAL: 'totaldiscs',
-    COMPILATION: 'compilation',
-    RATING: 'rating',
-    BPM: 'bpm',
-    KEY: 'key',
-    MOOD: 'mood',
-    MEDIA: 'media',
-    CATALOGNUMBER: 'catalognumber',
-    RELEASESTATUS: 'releasestatus',
-    RELEASETYPE: 'releasetype',
-    RELEASECOUNTRY: 'releasecountry',
-    SCRIPT: 'script',
-    LANGUAGE: 'language',
-    COPYRIGHT: 'copyright',
-    LICENSE: 'license',
-    ENCODEDBY: 'encodedby',
-    ENCODERSETTINGS: 'encodersettings',
-    BARCODE: 'barcode',
-    ISRC: 'isrc',
-    ASIN: 'asin',
-    MUSICBRAINZ_TRACKID: 'musicbrainz_recordingid',
-    MUSICBRAINZ_RELEASETRACKID: 'musicbrainz_trackid',
-    MUSICBRAINZ_ALBUMID: 'musicbrainz_albumid',
-    MUSICBRAINZ_ARTISTID: 'musicbrainz_artistid',
-    MUSICBRAINZ_ALBUMARTISTID: 'musicbrainz_albumartistid',
-    MUSICBRAINZ_RELEASEGROUPID: 'musicbrainz_releasegroupid',
-    MUSICBRAINZ_WORKID: 'musicbrainz_workid',
-    MUSICBRAINZ_TRMID: 'musicbrainz_trmid',
-    MUSICBRAINZ_DISCID: 'musicbrainz_discid',
-    ACOUSTID_ID: 'acoustid_id',
-    ACOUSTID_ID_FINGERPRINT: 'acoustid_fingerprint',
-    MUSICIP_PUID: 'musicip_puid',
-    // 'FINGERPRINT=MusicMagic Fingerprint {fingerprint}': 'musicip_fingerprint', // ToDo
-    WEBSITE: 'website',
-    NOTES: 'notes',
-    TOTALTRACKS: 'totaltracks',
-    TOTALDISCS: 'totaldiscs',
-    // Discogs
-    DISCOGS_ARTIST_ID: 'discogs_artist_id',
-    DISCOGS_ARTISTS: 'artists',
-    DISCOGS_ARTIST_NAME: 'artists',
-    DISCOGS_ALBUM_ARTISTS: 'albumartist',
-    DISCOGS_CATALOG: 'catalognumber',
-    DISCOGS_COUNTRY: 'releasecountry',
-    DISCOGS_DATE: 'originaldate',
-    DISCOGS_LABEL: 'label',
-    DISCOGS_LABEL_ID: 'discogs_label_id',
-    DISCOGS_MASTER_RELEASE_ID: 'discogs_master_release_id',
-    DISCOGS_RATING: 'discogs_rating',
-    DISCOGS_RELEASED: 'date',
-    DISCOGS_RELEASE_ID: 'discogs_release_id',
-    DISCOGS_VOTES: 'discogs_votes',
-    CATALOGID: 'catalognumber',
-    STYLE: 'genre',
-    //
-    REPLAYGAIN_TRACK_GAIN: 'replaygain_track_gain',
-    REPLAYGAIN_TRACK_PEAK: 'replaygain_track_peak',
-    REPLAYGAIN_ALBUM_GAIN: 'replaygain_album_gain',
-    REPLAYGAIN_ALBUM_PEAK: 'replaygain_album_peak',
-    // To Sure if these (REPLAYGAIN_MINMAX, REPLAYGAIN_ALBUM_MINMAX & REPLAYGAIN_UNDO) are used for Vorbis:
-    REPLAYGAIN_MINMAX: 'replaygain_track_minmax',
-    REPLAYGAIN_ALBUM_MINMAX: 'replaygain_album_minmax',
-    REPLAYGAIN_UNDO: 'replaygain_undo'
-};
-class VorbisTagMapper extends GenericTagMapper_1.CommonTagMapper {
-    static toRating(email, rating) {
-        return {
-            source: email ? email.toLowerCase() : email,
-            rating: parseFloat(rating) * GenericTagMapper_1.CommonTagMapper.maxRatingScore
-        };
-    }
-    constructor() {
-        super(['vorbis'], vorbisTagMap);
-    }
-    postMap(tag) {
-        if (tag.id.indexOf('RATING:') === 0) {
-            const keys = tag.id.split(':');
-            tag.value = VorbisTagMapper.toRating(keys[1], tag.value);
-            tag.id = keys[0];
-        }
-    }
-}
-exports.VorbisTagMapper = VorbisTagMapper;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VorbisTagMapper = void 0;
+const GenericTagMapper_1 = require("../../common/GenericTagMapper");
+/**
+ * Vorbis tag mappings
+ *
+ * Mapping from native header format to one or possibly more 'common' entries
+ * The common entries aim to read the same information from different media files
+ * independent of the underlying format
+ */
+const vorbisTagMap = {
+    TITLE: 'title',
+    ARTIST: 'artist',
+    ARTISTS: 'artists',
+    ALBUMARTIST: 'albumartist',
+    'ALBUM ARTIST': 'albumartist',
+    ALBUM: 'album',
+    DATE: 'date',
+    ORIGINALDATE: 'originaldate',
+    ORIGINALYEAR: 'originalyear',
+    COMMENT: 'comment',
+    TRACKNUMBER: 'track',
+    DISCNUMBER: 'disk',
+    GENRE: 'genre',
+    METADATA_BLOCK_PICTURE: 'picture',
+    COMPOSER: 'composer',
+    LYRICS: 'lyrics',
+    ALBUMSORT: 'albumsort',
+    TITLESORT: 'titlesort',
+    WORK: 'work',
+    ARTISTSORT: 'artistsort',
+    ALBUMARTISTSORT: 'albumartistsort',
+    COMPOSERSORT: 'composersort',
+    LYRICIST: 'lyricist',
+    WRITER: 'writer',
+    CONDUCTOR: 'conductor',
+    // 'PERFORMER=artist (instrument)': 'performer:instrument', // ToDo
+    REMIXER: 'remixer',
+    ARRANGER: 'arranger',
+    ENGINEER: 'engineer',
+    PRODUCER: 'producer',
+    DJMIXER: 'djmixer',
+    MIXER: 'mixer',
+    LABEL: 'label',
+    GROUPING: 'grouping',
+    SUBTITLE: 'subtitle',
+    DISCSUBTITLE: 'discsubtitle',
+    TRACKTOTAL: 'totaltracks',
+    DISCTOTAL: 'totaldiscs',
+    COMPILATION: 'compilation',
+    RATING: 'rating',
+    BPM: 'bpm',
+    KEY: 'key',
+    MOOD: 'mood',
+    MEDIA: 'media',
+    CATALOGNUMBER: 'catalognumber',
+    RELEASESTATUS: 'releasestatus',
+    RELEASETYPE: 'releasetype',
+    RELEASECOUNTRY: 'releasecountry',
+    SCRIPT: 'script',
+    LANGUAGE: 'language',
+    COPYRIGHT: 'copyright',
+    LICENSE: 'license',
+    ENCODEDBY: 'encodedby',
+    ENCODERSETTINGS: 'encodersettings',
+    BARCODE: 'barcode',
+    ISRC: 'isrc',
+    ASIN: 'asin',
+    MUSICBRAINZ_TRACKID: 'musicbrainz_recordingid',
+    MUSICBRAINZ_RELEASETRACKID: 'musicbrainz_trackid',
+    MUSICBRAINZ_ALBUMID: 'musicbrainz_albumid',
+    MUSICBRAINZ_ARTISTID: 'musicbrainz_artistid',
+    MUSICBRAINZ_ALBUMARTISTID: 'musicbrainz_albumartistid',
+    MUSICBRAINZ_RELEASEGROUPID: 'musicbrainz_releasegroupid',
+    MUSICBRAINZ_WORKID: 'musicbrainz_workid',
+    MUSICBRAINZ_TRMID: 'musicbrainz_trmid',
+    MUSICBRAINZ_DISCID: 'musicbrainz_discid',
+    ACOUSTID_ID: 'acoustid_id',
+    ACOUSTID_ID_FINGERPRINT: 'acoustid_fingerprint',
+    MUSICIP_PUID: 'musicip_puid',
+    // 'FINGERPRINT=MusicMagic Fingerprint {fingerprint}': 'musicip_fingerprint', // ToDo
+    WEBSITE: 'website',
+    NOTES: 'notes',
+    TOTALTRACKS: 'totaltracks',
+    TOTALDISCS: 'totaldiscs',
+    // Discogs
+    DISCOGS_ARTIST_ID: 'discogs_artist_id',
+    DISCOGS_ARTISTS: 'artists',
+    DISCOGS_ARTIST_NAME: 'artists',
+    DISCOGS_ALBUM_ARTISTS: 'albumartist',
+    DISCOGS_CATALOG: 'catalognumber',
+    DISCOGS_COUNTRY: 'releasecountry',
+    DISCOGS_DATE: 'originaldate',
+    DISCOGS_LABEL: 'label',
+    DISCOGS_LABEL_ID: 'discogs_label_id',
+    DISCOGS_MASTER_RELEASE_ID: 'discogs_master_release_id',
+    DISCOGS_RATING: 'discogs_rating',
+    DISCOGS_RELEASED: 'date',
+    DISCOGS_RELEASE_ID: 'discogs_release_id',
+    DISCOGS_VOTES: 'discogs_votes',
+    CATALOGID: 'catalognumber',
+    STYLE: 'genre',
+    //
+    REPLAYGAIN_TRACK_GAIN: 'replaygain_track_gain',
+    REPLAYGAIN_TRACK_PEAK: 'replaygain_track_peak',
+    REPLAYGAIN_ALBUM_GAIN: 'replaygain_album_gain',
+    REPLAYGAIN_ALBUM_PEAK: 'replaygain_album_peak',
+    // To Sure if these (REPLAYGAIN_MINMAX, REPLAYGAIN_ALBUM_MINMAX & REPLAYGAIN_UNDO) are used for Vorbis:
+    REPLAYGAIN_MINMAX: 'replaygain_track_minmax',
+    REPLAYGAIN_ALBUM_MINMAX: 'replaygain_album_minmax',
+    REPLAYGAIN_UNDO: 'replaygain_undo'
+};
+class VorbisTagMapper extends GenericTagMapper_1.CommonTagMapper {
+    static toRating(email, rating) {
+        return {
+            source: email ? email.toLowerCase() : email,
+            rating: parseFloat(rating) * GenericTagMapper_1.CommonTagMapper.maxRatingScore
+        };
+    }
+    constructor() {
+        super(['vorbis'], vorbisTagMap);
+    }
+    postMap(tag) {
+        if (tag.id.indexOf('RATING:') === 0) {
+            const keys = tag.id.split(':');
+            tag.value = VorbisTagMapper.toRating(keys[1], tag.value);
+            tag.id = keys[0];
+        }
+    }
+}
+exports.VorbisTagMapper = VorbisTagMapper;
+//# sourceMappingURL=VorbisTagMapper.js.map

package/lib/riff/RiffChunk.d.ts

@@ -1,16 +1,16 @@
-import { IChunkHeader } from '../iff';
-import { IGetToken } from 'strtok3/lib/core';
-export { IChunkHeader } from '../iff';
-/**
- * Common RIFF chunk header
- */
-export declare const Header: IGetToken<IChunkHeader>;
-/**
- * Token to parse RIFF-INFO tag value
- */
-export declare class ListInfoTagValue implements IGetToken<string> {
-    private tagHeader;
-    len: number;
-    constructor(tagHeader: IChunkHeader);
-    get(buf: any, off: any): string;
-}
+import { IGetToken } from 'strtok3/lib/core';
+import { IChunkHeader } from '../iff';
+export { IChunkHeader } from '../iff';
+/**
+ * Common RIFF chunk header
+ */
+export declare const Header: IGetToken<IChunkHeader>;
+/**
+ * Token to parse RIFF-INFO tag value
+ */
+export declare class ListInfoTagValue implements IGetToken<string> {
+    private tagHeader;
+    len: number;
+    constructor(tagHeader: IChunkHeader);
+    get(buf: any, off: any): string;
+}

package/lib/riff/RiffChunk.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListInfoTagValue = exports.Header = void 0;
-const Token = require("token-types");
-/**
- * Common RIFF chunk header
- */
-exports.Header = {
-    len: 8,
-    get: (buf, off) => {
-        return {
-            // Group-ID
-            chunkID: buf.toString('binary', off, off + 4),
-            // Size
-            chunkSize: Token.UINT32_LE.get(buf, 4)
-        };
-    }
-};
-/**
- * Token to parse RIFF-INFO tag value
- */
-class ListInfoTagValue {
-    constructor(tagHeader) {
-        this.tagHeader = tagHeader;
-        this.len = tagHeader.chunkSize;
-        this.len += this.len & 1; // if it is an odd length, round up to even
-    }
-    get(buf, off) {
-        return new Token.StringType(this.tagHeader.chunkSize, 'ascii').get(buf, off);
-    }
-}
-exports.ListInfoTagValue = ListInfoTagValue;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListInfoTagValue = exports.Header = void 0;
+const Token = require("token-types");
+/**
+ * Common RIFF chunk header
+ */
+exports.Header = {
+    len: 8,
+    get: (buf, off) => {
+        return {
+            // Group-ID
+            chunkID: buf.toString('binary', off, off + 4),
+            // Size
+            chunkSize: Token.UINT32_LE.get(buf, 4)
+        };
+    }
+};
+/**
+ * Token to parse RIFF-INFO tag value
+ */
+class ListInfoTagValue {
+    constructor(tagHeader) {
+        this.tagHeader = tagHeader;
+        this.len = tagHeader.chunkSize;
+        this.len += this.len & 1; // if it is an odd length, round up to even
+    }
+    get(buf, off) {
+        return new Token.StringType(this.tagHeader.chunkSize, 'ascii').get(buf, off);
+    }
+}
+exports.ListInfoTagValue = ListInfoTagValue;

package/lib/riff/RiffInfoTagMap.d.ts

@@ -1,10 +1,10 @@
-import { INativeTagMap } from '../common/GenericTagTypes';
-import { CommonTagMapper } from '../common/GenericTagMapper';
-/**
- * RIFF Info Tags; part of the EXIF 2.3
- * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
- */
-export declare const riffInfoTagMap: INativeTagMap;
-export declare class RiffInfoTagMapper extends CommonTagMapper {
-    constructor();
-}
+import { INativeTagMap } from '../common/GenericTagTypes';
+import { CommonTagMapper } from '../common/GenericTagMapper';
+/**
+ * RIFF Info Tags; part of the EXIF 2.3
+ * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
+ */
+export declare const riffInfoTagMap: INativeTagMap;
+export declare class RiffInfoTagMapper extends CommonTagMapper {
+    constructor();
+}