@probityrules/jsmediatags 4.0.0

package/build/ID3v2FrameReader.js

@@ -0,0 +1,582 @@
+'use strict';
+const MediaFileReader = require('./MediaFileReader');
+const StringUtils = require('./StringUtils');
+const ArrayFileReader = require('./ArrayFileReader');
+const FRAME_DESCRIPTIONS = {
+    // v2.2
+    "BUF": "Recommended buffer size",
+    "CNT": "Play counter",
+    "COM": "Comments",
+    "CRA": "Audio encryption",
+    "CRM": "Encrypted meta frame",
+    "ETC": "Event timing codes",
+    "EQU": "Equalization",
+    "GEO": "General encapsulated object",
+    "IPL": "Involved people list",
+    "LNK": "Linked information",
+    "MCI": "Music CD Identifier",
+    "MLL": "MPEG location lookup table",
+    "PIC": "Attached picture",
+    "POP": "Popularimeter",
+    "REV": "Reverb",
+    "RVA": "Relative volume adjustment",
+    "SLT": "Synchronized lyric/text",
+    "STC": "Synced tempo codes",
+    "TAL": "Album/Movie/Show title",
+    "TBP": "BPM (Beats Per Minute)",
+    "TCM": "Composer",
+    "TCO": "Content type",
+    "TCR": "Copyright message",
+    "TDA": "Date",
+    "TDY": "Playlist delay",
+    "TEN": "Encoded by",
+    "TFT": "File type",
+    "TIM": "Time",
+    "TKE": "Initial key",
+    "TLA": "Language(s)",
+    "TLE": "Length",
+    "TMT": "Media type",
+    "TOA": "Original artist(s)/performer(s)",
+    "TOF": "Original filename",
+    "TOL": "Original Lyricist(s)/text writer(s)",
+    "TOR": "Original release year",
+    "TOT": "Original album/Movie/Show title",
+    "TP1": "Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group",
+    "TP2": "Band/Orchestra/Accompaniment",
+    "TP3": "Conductor/Performer refinement",
+    "TP4": "Interpreted, remixed, or otherwise modified by",
+    "TPA": "Part of a set",
+    "TPB": "Publisher",
+    "TRC": "ISRC (International Standard Recording Code)",
+    "TRD": "Recording dates",
+    "TRK": "Track number/Position in set",
+    "TSI": "Size",
+    "TSS": "Software/hardware and settings used for encoding",
+    "TT1": "Content group description",
+    "TT2": "Title/Songname/Content description",
+    "TT3": "Subtitle/Description refinement",
+    "TXT": "Lyricist/text writer",
+    "TXX": "User defined text information frame",
+    "TYE": "Year",
+    "UFI": "Unique file identifier",
+    "ULT": "Unsychronized lyric/text transcription",
+    "WAF": "Official audio file webpage",
+    "WAR": "Official artist/performer webpage",
+    "WAS": "Official audio source webpage",
+    "WCM": "Commercial information",
+    "WCP": "Copyright/Legal information",
+    "WPB": "Publishers official webpage",
+    "WXX": "User defined URL link frame",
+    // v2.3
+    "AENC": "Audio encryption",
+    "APIC": "Attached picture",
+    "ASPI": "Audio seek point index",
+    "CHAP": "Chapter",
+    "CTOC": "Table of contents",
+    "COMM": "Comments",
+    "COMR": "Commercial frame",
+    "ENCR": "Encryption method registration",
+    "EQU2": "Equalisation (2)",
+    "EQUA": "Equalization",
+    "ETCO": "Event timing codes",
+    "GEOB": "General encapsulated object",
+    "GRID": "Group identification registration",
+    "IPLS": "Involved people list",
+    "LINK": "Linked information",
+    "MCDI": "Music CD identifier",
+    "MLLT": "MPEG location lookup table",
+    "OWNE": "Ownership frame",
+    "PRIV": "Private frame",
+    "PCNT": "Play counter",
+    "POPM": "Popularimeter",
+    "POSS": "Position synchronisation frame",
+    "RBUF": "Recommended buffer size",
+    "RVA2": "Relative volume adjustment (2)",
+    "RVAD": "Relative volume adjustment",
+    "RVRB": "Reverb",
+    "SEEK": "Seek frame",
+    "SYLT": "Synchronized lyric/text",
+    "SYTC": "Synchronized tempo codes",
+    "TALB": "Album/Movie/Show title",
+    "TBPM": "BPM (beats per minute)",
+    "TCOM": "Composer",
+    "TCON": "Content type",
+    "TCOP": "Copyright message",
+    "TDAT": "Date",
+    "TDLY": "Playlist delay",
+    "TDRC": "Recording time",
+    "TDRL": "Release time",
+    "TDTG": "Tagging time",
+    "TENC": "Encoded by",
+    "TEXT": "Lyricist/Text writer",
+    "TFLT": "File type",
+    "TIME": "Time",
+    "TIPL": "Involved people list",
+    "TIT1": "Content group description",
+    "TIT2": "Title/songname/content description",
+    "TIT3": "Subtitle/Description refinement",
+    "TKEY": "Initial key",
+    "TLAN": "Language(s)",
+    "TLEN": "Length",
+    "TMCL": "Musician credits list",
+    "TMED": "Media type",
+    "TMOO": "Mood",
+    "TOAL": "Original album/movie/show title",
+    "TOFN": "Original filename",
+    "TOLY": "Original lyricist(s)/text writer(s)",
+    "TOPE": "Original artist(s)/performer(s)",
+    "TORY": "Original release year",
+    "TOWN": "File owner/licensee",
+    "TPE1": "Lead performer(s)/Soloist(s)",
+    "TPE2": "Band/orchestra/accompaniment",
+    "TPE3": "Conductor/performer refinement",
+    "TPE4": "Interpreted, remixed, or otherwise modified by",
+    "TPOS": "Part of a set",
+    "TPRO": "Produced notice",
+    "TPUB": "Publisher",
+    "TRCK": "Track number/Position in set",
+    "TRDA": "Recording dates",
+    "TRSN": "Internet radio station name",
+    "TRSO": "Internet radio station owner",
+    "TSOA": "Album sort order",
+    "TSOP": "Performer sort order",
+    "TSOT": "Title sort order",
+    "TSIZ": "Size",
+    "TSRC": "ISRC (international standard recording code)",
+    "TSSE": "Software/Hardware and settings used for encoding",
+    "TSST": "Set subtitle",
+    "TYER": "Year",
+    "TXXX": "User defined text information frame",
+    "UFID": "Unique file identifier",
+    "USER": "Terms of use",
+    "USLT": "Unsychronized lyric/text transcription",
+    "WCOM": "Commercial information",
+    "WCOP": "Copyright/Legal information",
+    "WOAF": "Official audio file webpage",
+    "WOAR": "Official artist/performer webpage",
+    "WOAS": "Official audio source webpage",
+    "WORS": "Official internet radio station homepage",
+    "WPAY": "Payment",
+    "WPUB": "Publishers official webpage",
+    "WXXX": "User defined URL link frame"
+};
+class ID3v2FrameReader {
+    static getFrameReaderFunction(frameId) {
+        var _a, _b, _c;
+        if (frameId in frameReaderFunctions) {
+            return (_a = frameReaderFunctions[frameId]) !== null && _a !== void 0 ? _a : null;
+        }
+        else if (frameId[0] === "T") {
+            return (_b = frameReaderFunctions["T*"]) !== null && _b !== void 0 ? _b : null;
+        }
+        else if (frameId[0] === "W") {
+            return (_c = frameReaderFunctions["W*"]) !== null && _c !== void 0 ? _c : null;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * All the frames consists of a frame header followed by one or more fields
+     * containing the actual information.
+     * The frame ID made out of the characters capital A-Z and 0-9. Identifiers
+     * beginning with "X", "Y" and "Z" are for experimental use and free for
+     * everyone to use, without the need to set the experimental bit in the tag
+     * header. Have in mind that someone else might have used the same identifier
+     * as you. All other identifiers are either used or reserved for future use.
+     * The frame ID is followed by a size descriptor, making a total header size
+     * of ten bytes in every frame. The size is calculated as frame size excluding
+     * frame header (frame size - 10).
+     */
+    static readFrames(offset, end, data, id3header, tags) {
+        var _a;
+        const frames = {};
+        var frameHeaderSize = this._getFrameHeaderSize(id3header);
+        // console.log('header', id3header);
+        while (
+        // we should be able to read at least the frame header
+        offset < (end - frameHeaderSize)) {
+            var header = this._readFrameHeader(data, offset, id3header);
+            var frameId = header.id;
+            // No frame ID sometimes means it's the last frame (GTFO).
+            if (!frameId) {
+                break;
+            }
+            var flags = header.flags;
+            var frameSize = header.size;
+            var frameDataOffset = offset + header.headerSize;
+            var frameData = data;
+            // console.log(offset, frameId, header.size + header.headerSize, flags && flags.format.unsynchronisation);
+            // advance data offset to the next frame data
+            offset += header.headerSize + header.size;
+            // skip unwanted tags
+            if (tags && tags.indexOf(frameId) === -1) {
+                continue;
+            }
+            // Workaround: MP3ext V3.3.17 places a non-compliant padding string at
+            // the end of the ID3v2 header. A string like "MP3ext V3.3.19(ansi)"
+            // is added multiple times at the end of the ID3 tag. More information
+            // about this issue can be found at
+            // https://github.com/aadsm/jsmediatags/issues/58#issuecomment-313865336
+            if (frameId === 'MP3e' || frameId === '\x00MP3' ||
+                frameId === '\x00\x00MP' || frameId === ' MP3') {
+                break;
+            }
+            if (flags && flags.format.unsynchronisation && !id3header.flags.unsynchronisation) {
+                frameData = this.getUnsyncFileReader(frameData, frameDataOffset, frameSize);
+                frameDataOffset = 0;
+                frameSize = frameData.getSize();
+            }
+            // the first 4 bytes are the real data size
+            // (after unsynchronisation && encryption)
+            if (flags && flags.format.data_length_indicator) {
+                // var frameDataSize = frameData.getSynchsafeInteger32At(frameDataOffset);
+                frameDataOffset += 4;
+                frameSize -= 4;
+            }
+            var readFrameFunc = ID3v2FrameReader.getFrameReaderFunction(frameId);
+            var parsedData = readFrameFunc
+                ? readFrameFunc.apply(this, [
+                    frameDataOffset,
+                    frameSize,
+                    frameData,
+                    (_a = flags) !== null && _a !== void 0 ? _a : null,
+                    id3header,
+                ])
+                : null;
+            var desc = this._getFrameDescription(frameId);
+            var frame = {
+                id: frameId,
+                size: frameSize,
+                description: desc,
+                data: parsedData
+            };
+            if (frameId in frames) {
+                const existing = frames[frameId];
+                if (existing && !Array.isArray(existing) && existing.id) {
+                    frames[frameId] = [existing];
+                }
+                frames[frameId].push(frame);
+            }
+            else {
+                frames[frameId] = frame;
+            }
+        }
+        return frames;
+    }
+    static _getFrameHeaderSize(id3header) {
+        var major = id3header.major;
+        if (major == 2) {
+            return 6;
+        }
+        else if (major == 3 || major == 4) {
+            return 10;
+        }
+        else {
+            return 0;
+        }
+    }
+    static _readFrameHeader(data, offset, id3header) {
+        var major = id3header.major;
+        var flags = null;
+        var frameHeaderSize = this._getFrameHeaderSize(id3header);
+        let frameId = "";
+        let frameSize = 0;
+        switch (major) {
+            case 2:
+                frameId = data.getStringAt(offset, 3);
+                frameSize = data.getInteger24At(offset + 3, true);
+                break;
+            case 3:
+                frameId = data.getStringAt(offset, 4);
+                frameSize = data.getLongAt(offset + 4, true);
+                break;
+            case 4:
+                frameId = data.getStringAt(offset, 4);
+                frameSize = data.getSynchsafeInteger32At(offset + 4);
+                break;
+        }
+        if (frameId == String.fromCharCode(0, 0, 0) ||
+            frameId == String.fromCharCode(0, 0, 0, 0)) {
+            frameId = "";
+        }
+        // if frameId is empty then it's the last frame
+        if (frameId) {
+            // read frame message and format flags
+            if (major > 2) {
+                flags = this._readFrameFlags(data, offset + 8);
+            }
+        }
+        return {
+            "id": frameId || "",
+            "size": frameSize || 0,
+            "headerSize": frameHeaderSize || 0,
+            "flags": flags
+        };
+    }
+    static _readFrameFlags(data, offset) {
+        return {
+            message: {
+                tag_alter_preservation: data.isBitSetAt(offset, 6),
+                file_alter_preservation: data.isBitSetAt(offset, 5),
+                read_only: data.isBitSetAt(offset, 4)
+            },
+            format: {
+                grouping_identity: data.isBitSetAt(offset + 1, 7),
+                compression: data.isBitSetAt(offset + 1, 3),
+                encryption: data.isBitSetAt(offset + 1, 2),
+                unsynchronisation: data.isBitSetAt(offset + 1, 1),
+                data_length_indicator: data.isBitSetAt(offset + 1, 0)
+            }
+        };
+    }
+    static _getFrameDescription(frameId) {
+        if (frameId in FRAME_DESCRIPTIONS) {
+            return FRAME_DESCRIPTIONS[frameId];
+        }
+        else {
+            return 'Unknown';
+        }
+    }
+    static getUnsyncFileReader(data, offset, size) {
+        var frameData = data.getBytesAt(offset, size);
+        for (var i = 0; i < frameData.length - 1; i++) {
+            if (frameData[i] === 0xff && frameData[i + 1] === 0x00) {
+                frameData.splice(i + 1, 1);
+            }
+        }
+        return new ArrayFileReader(frameData);
+    }
+}
+const frameReaderFunctions = {};
+frameReaderFunctions['APIC'] = function readPictureFrame(offset, length, data, flags, id3header) {
+    var start = offset;
+    var charset = getTextEncoding(data.getByteAt(offset));
+    let format;
+    switch (id3header && id3header.major) {
+        case 2:
+            format = data.getStringAt(offset + 1, 3);
+            offset += 4;
+            break;
+        case 3:
+        case 4: {
+            const fmt = data.getStringWithCharsetAt(offset + 1, length - 1);
+            format = fmt.toString();
+            offset += 1 + fmt.bytesReadCount;
+            break;
+        }
+        default:
+            throw new Error("Couldn't read ID3v2 major version.");
+    }
+    var bite = data.getByteAt(offset);
+    var type = PICTURE_TYPE[bite];
+    var desc = data.getStringWithCharsetAt(offset + 1, length - (offset - start) - 1, charset);
+    offset += 1 + desc.bytesReadCount;
+    return {
+        "format": format,
+        "type": type,
+        "description": desc.toString(),
+        "data": data.getBytesAt(offset, (start + length) - offset)
+    };
+};
+// ID3v2 chapters according to http://id3.org/id3v2-chapters-1.0
+frameReaderFunctions['CHAP'] = function readChapterFrame(offset, length, data, flags, id3header) {
+    var originalOffset = offset;
+    var result = {};
+    var id = StringUtils.readNullTerminatedString(data.getBytesAt(offset, length));
+    result.id = id.toString();
+    offset += id.bytesReadCount;
+    result.startTime = data.getLongAt(offset, true);
+    offset += 4;
+    result.endTime = data.getLongAt(offset, true);
+    offset += 4;
+    result.startOffset = data.getLongAt(offset, true);
+    offset += 4;
+    result.endOffset = data.getLongAt(offset, true);
+    offset += 4;
+    var remainingLength = length - (offset - originalOffset);
+    result.subFrames = ID3v2FrameReader.readFrames(offset, offset + remainingLength, data, id3header, undefined);
+    return result;
+};
+// ID3v2 table of contents according to http://id3.org/id3v2-chapters-1.0
+frameReaderFunctions['CTOC'] = function readTableOfContentsFrame(offset, length, data, flags, id3header) {
+    var originalOffset = offset;
+    var result = {
+        childElementIds: [],
+    };
+    var id = StringUtils.readNullTerminatedString(data.getBytesAt(offset, length));
+    result.id = id.toString();
+    offset += id.bytesReadCount;
+    result.topLevel = data.isBitSetAt(offset, 1);
+    result.ordered = data.isBitSetAt(offset, 0);
+    offset++;
+    result.entryCount = data.getByteAt(offset);
+    offset++;
+    const entryCount = result.entryCount;
+    for (var i = 0; i < entryCount; i++) {
+        var childId = StringUtils.readNullTerminatedString(data.getBytesAt(offset, length - (offset - originalOffset)));
+        result.childElementIds.push(childId.toString());
+        offset += childId.bytesReadCount;
+    }
+    var remainingLength = length - (offset - originalOffset);
+    result.subFrames = ID3v2FrameReader.readFrames(offset, offset + remainingLength, data, id3header, undefined);
+    return result;
+};
+frameReaderFunctions['COMM'] = function readCommentsFrame(offset, length, data, flags, id3header) {
+    var start = offset;
+    var charset = getTextEncoding(data.getByteAt(offset));
+    var language = data.getStringAt(offset + 1, 3);
+    var shortdesc = data.getStringWithCharsetAt(offset + 4, length - 4, charset);
+    offset += 4 + shortdesc.bytesReadCount;
+    var text = data.getStringWithCharsetAt(offset, (start + length) - offset, charset);
+    return {
+        language: language,
+        short_description: shortdesc.toString(),
+        text: text.toString()
+    };
+};
+frameReaderFunctions['COM'] = frameReaderFunctions['COMM'];
+frameReaderFunctions['PIC'] = function (offset, length, data, flags, id3header) {
+    return frameReaderFunctions['APIC'](offset, length, data, flags, id3header);
+};
+frameReaderFunctions['PCNT'] = function readCounterFrame(offset, length, data, flags, id3header) {
+    // FIXME: implement the rest of the spec
+    return data.getLongAt(offset, false);
+};
+frameReaderFunctions['CNT'] = frameReaderFunctions['PCNT'];
+frameReaderFunctions['SYLT'] = function readSynchronizedLyricsFrame(offset, length, data, flags, id3header) {
+    var start = offset;
+    var contentTypes = ['other', 'lyrics', 'transcription', 'movement', 'events', 'chord', 'trivia'];
+    var timeStampFormats = ['unset', 'frames', 'milliseconds'];
+    var charset = getTextEncoding(data.getByteAt(offset));
+    offset += 1;
+    var language = data.getStringAt(offset, 3);
+    offset += 3;
+    var timeStampFormat = timeStampFormats[data.getByteAt(offset)];
+    offset += 1;
+    var contentType = contentTypes[data.getByteAt(offset)];
+    offset += 1;
+    var descriptor = data.getStringWithCharsetAt(offset, length + start - offset, charset);
+    offset += descriptor.bytesReadCount;
+    var synchronisedText = [];
+    while (offset < length + start) {
+        const line = data.getStringWithCharsetAt(offset, length + start - offset, charset);
+        offset += line.bytesReadCount;
+        synchronisedText.push({
+            text: line.toString(),
+            timeStamp: data.getLongAt(offset, true)
+        });
+        offset += 4;
+    }
+    return {
+        language: language,
+        timeStampFormat: timeStampFormat,
+        contentType: contentType,
+        descriptor: descriptor.toString(),
+        synchronisedText: synchronisedText
+    };
+};
+frameReaderFunctions['T*'] = function readTextFrame(offset, length, data, flags, id3header) {
+    var charset = getTextEncoding(data.getByteAt(offset));
+    return data.getStringWithCharsetAt(offset + 1, length - 1, charset).toString();
+};
+frameReaderFunctions['TXXX'] = function readTextFrame(offset, length, data, flags, id3header) {
+    var charset = getTextEncoding(data.getByteAt(offset));
+    return getUserDefinedFields(offset, length, data, charset);
+};
+frameReaderFunctions['WXXX'] = function readUrlFrame(offset, length, data, flags, id3header) {
+    if (length === 0) {
+        return null;
+    }
+    var charset = getTextEncoding(data.getByteAt(offset));
+    return getUserDefinedFields(offset, length, data, charset);
+};
+frameReaderFunctions['W*'] = function readUrlFrame(offset, length, data, flags, id3header) {
+    if (length === 0) {
+        return null;
+    }
+    return data.getStringWithCharsetAt(offset, length, 'iso-8859-1').toString();
+};
+frameReaderFunctions['TCON'] = function readGenreFrame(offset, length, data, flags) {
+    const fn = frameReaderFunctions["T*"];
+    var text = fn.apply(this, arguments);
+    return text.replace(/^\(\d+\)/, '');
+};
+frameReaderFunctions['TCO'] = frameReaderFunctions['TCON'];
+frameReaderFunctions['USLT'] = function readLyricsFrame(offset, length, data, flags, id3header) {
+    var start = offset;
+    var charset = getTextEncoding(data.getByteAt(offset));
+    var language = data.getStringAt(offset + 1, 3);
+    var descriptor = data.getStringWithCharsetAt(offset + 4, length - 4, charset);
+    offset += 4 + descriptor.bytesReadCount;
+    var lyrics = data.getStringWithCharsetAt(offset, (start + length) - offset, charset);
+    return {
+        language: language,
+        descriptor: descriptor.toString(),
+        lyrics: lyrics.toString()
+    };
+};
+frameReaderFunctions['ULT'] = frameReaderFunctions['USLT'];
+frameReaderFunctions['UFID'] = function readLyricsFrame(offset, length, data, flags, id3header) {
+    var ownerIdentifier = StringUtils.readNullTerminatedString(data.getBytesAt(offset, length));
+    offset += ownerIdentifier.bytesReadCount;
+    var identifier = data.getBytesAt(offset, length - ownerIdentifier.bytesReadCount);
+    return {
+        ownerIdentifier: ownerIdentifier.toString(),
+        identifier: identifier
+    };
+};
+function getTextEncoding(bite) {
+    var charset;
+    switch (bite) {
+        case 0x00:
+            charset = 'iso-8859-1';
+            break;
+        case 0x01:
+            charset = 'utf-16';
+            break;
+        case 0x02:
+            charset = 'utf-16be';
+            break;
+        case 0x03:
+            charset = 'utf-8';
+            break;
+        default:
+            charset = 'iso-8859-1';
+    }
+    return charset;
+}
+// Handles reading description/data from either http://id3.org/id3v2.3.0#User_defined_text_information_frame
+// and http://id3.org/id3v2.3.0#User_defined_URL_link_frame
+function getUserDefinedFields(offset, length, data, charset) {
+    var userDesc = data.getStringWithCharsetAt(offset + 1, length - 1, charset);
+    var userDefinedData = data.getStringWithCharsetAt(offset + 1 + userDesc.bytesReadCount, length - 1 - userDesc.bytesReadCount, charset);
+    return {
+        user_description: userDesc.toString(),
+        data: userDefinedData.toString()
+    };
+}
+const PICTURE_TYPE = [
+    "Other",
+    "32x32 pixels 'file icon' (PNG only)",
+    "Other file icon",
+    "Cover (front)",
+    "Cover (back)",
+    "Leaflet page",
+    "Media (e.g. label side of CD)",
+    "Lead artist/lead performer/soloist",
+    "Artist/performer",
+    "Conductor",
+    "Band/Orchestra",
+    "Composer",
+    "Lyricist/text writer",
+    "Recording Location",
+    "During recording",
+    "During performance",
+    "Movie/video screen capture",
+    "A bright coloured fish",
+    "Illustration",
+    "Band/artist logotype",
+    "Publisher/Studio logotype"
+];
+module.exports = ID3v2FrameReader;

package/build/ID3v2TagContents.d.ts

@@ -0,0 +1,82 @@
+import type { ByteArray, TagHeaderFlags, TagFrameFlags } from './types';
+declare class ID3v2TagContents {
+    _size: number;
+    _major: number;
+    _revision: number;
+    _contents: ByteArray;
+    _frames: {
+        [key: string]: Array<ByteArray>;
+    };
+    _extendedHeader: Record<string, number>;
+    _hasExtendedHeader: boolean;
+    _nextFrameOffset: number;
+    constructor(major: number, revision: number);
+    toArray(): ByteArray;
+    setFlags(flags: TagHeaderFlags): ID3v2TagContents;
+    _updateFlags(flags: Partial<TagHeaderFlags>, binaryFlags?: number): ID3v2TagContents;
+    setCrc(crc: ByteArray): ID3v2TagContents;
+    setTagIsUpdate(): ID3v2TagContents;
+    /**
+     * For some applications it might be desired to restrict a tag in more
+     * ways than imposed by the ID3v2 specification. Note that the
+     * presence of these restrictions does not affect how the tag is
+     * decoded, merely how it was restricted before encoding. If this flag
+     * is set the tag is restricted as follows:
+     *
+     *    Flag data length       $01
+     *    Restrictions           %ppqrrstt
+     *
+     * p - Tag size restrictions
+  
+     *   00   No more than 128 frames and 1 MB total tag size.
+     *   01   No more than 64 frames and 128 KB total tag size.
+     *   10   No more than 32 frames and 40 KB total tag size.
+     *   11   No more than 32 frames and 4 KB total tag size.
+     *
+     * q - Text encoding restrictions
+     *
+     *   0    No restrictions
+     *   1    Strings are only encoded with ISO-8859-1 [ISO-8859-1] or
+     *        UTF-8 [UTF-8].
+     *
+     * r - Text fields size restrictions
+     *
+     *   00   No restrictions
+     *   01   No string is longer than 1024 characters.
+     *   10   No string is longer than 128 characters.
+     *   11   No string is longer than 30 characters.
+     *
+     *   Note that nothing is said about how many bytes is used to
+     *   represent those characters, since it is encoding dependent. If a
+     *   text frame consists of more than one string, the sum of the
+     *   strungs is restricted as stated.
+     *
+     * s - Image encoding restrictions
+     *
+     *   0   No restrictions
+     *   1   Images are encoded only with PNG [PNG] or JPEG [JFIF].
+     *
+     * t - Image size restrictions
+     *
+     *   00  No restrictions
+     *   01  All images are 256x256 pixels or smaller.
+     *   10  All images are 64x64 pixels or smaller.
+     *   11  All images are exactly 64x64 pixels, unless required
+     *       otherwise.
+     */
+    setTagRestrictions(size: number, textEncoding: number, textSize: number, imageEncoding: number, imageSize: number): ID3v2TagContents;
+    /**
+     * noFlagsDataLength - The data length if all flags were set to 0,
+     *   for instance, the length before compression and unsynchronisation.
+     *   This field is only needed when data_length_indicator flag is set.
+     */
+    addFrame(id: string, data: ByteArray, flags?: TagFrameFlags, noFlagsDataLength?: number): ID3v2TagContents;
+    _addExtendedHeaderData(tagKey: string, tagData: ByteArray): void;
+    _initExtendedHeader(): void;
+    _updateSize(): void;
+    _setBitAtOffset(offset: number, bit: number): void;
+    _getData(offset: number, length: number): ByteArray;
+    _setData(offset: number, data: ByteArray): void;
+    _addData(offset: number, data: ByteArray): void;
+}
+export = ID3v2TagContents;