valley-baileys 1.0.0

package/node_modules/music-metadata/lib/id3v2/ID3v24TagMapper.js

@@ -0,0 +1,195 @@
+import { UINT32_LE } from 'token-types';
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+import { decodeString } from '../common/Util.js';
+/**
+ * ID3v2.3/ID3v2.4 tag mappings
+ */
+const id3v24TagMap = {
+    // id3v2.3
+    TIT2: 'title',
+    TPE1: 'artist',
+    'TXXX:Artists': 'artists',
+    TPE2: 'albumartist',
+    TALB: 'album',
+    TDRV: 'date', // [ 'date', 'year' ] ToDo: improve 'year' mapping
+    /**
+     * Original release year
+     */
+    TORY: 'originalyear',
+    TPOS: 'disk',
+    TCON: 'genre',
+    APIC: 'picture',
+    TCOM: 'composer',
+    USLT: 'lyrics',
+    TSOA: 'albumsort',
+    TSOT: 'titlesort',
+    TOAL: 'originalalbum',
+    TSOP: 'artistsort',
+    TSO2: 'albumartistsort',
+    TSOC: 'composersort',
+    TEXT: 'lyricist',
+    'TXXX:Writer': 'writer',
+    TPE3: 'conductor',
+    // 'IPLS:instrument': 'performer:instrument', // ToDo
+    TPE4: 'remixer',
+    'IPLS:arranger': 'arranger',
+    'IPLS:engineer': 'engineer',
+    'IPLS:producer': 'producer',
+    'IPLS:DJ-mix': 'djmixer',
+    'IPLS:mix': 'mixer',
+    TPUB: 'label',
+    TIT1: 'grouping',
+    TIT3: 'subtitle',
+    TRCK: 'track',
+    TCMP: 'compilation',
+    POPM: 'rating',
+    TBPM: 'bpm',
+    TMED: 'media',
+    'TXXX:CATALOGNUMBER': 'catalognumber',
+    'TXXX:MusicBrainz Album Status': 'releasestatus',
+    'TXXX:MusicBrainz Album Type': 'releasetype',
+    /**
+     * Release country as documented: https://picard.musicbrainz.org/docs/mappings/#cite_note-0
+     */
+    'TXXX:MusicBrainz Album Release Country': 'releasecountry',
+    /**
+     * Release country as implemented // ToDo: report
+     */
+    'TXXX:RELEASECOUNTRY': 'releasecountry',
+    'TXXX:SCRIPT': 'script',
+    TLAN: 'language',
+    TCOP: 'copyright',
+    WCOP: 'license',
+    TENC: 'encodedby',
+    TSSE: 'encodersettings',
+    'TXXX:BARCODE': 'barcode',
+    'TXXX:ISRC': 'isrc',
+    TSRC: 'isrc',
+    'TXXX:ASIN': 'asin',
+    'TXXX:originalyear': 'originalyear',
+    'UFID:http://musicbrainz.org': 'musicbrainz_recordingid',
+    'TXXX:MusicBrainz Release Track Id': 'musicbrainz_trackid',
+    'TXXX:MusicBrainz Album Id': 'musicbrainz_albumid',
+    'TXXX:MusicBrainz Artist Id': 'musicbrainz_artistid',
+    'TXXX:MusicBrainz Album Artist Id': 'musicbrainz_albumartistid',
+    'TXXX:MusicBrainz Release Group Id': 'musicbrainz_releasegroupid',
+    'TXXX:MusicBrainz Work Id': 'musicbrainz_workid',
+    'TXXX:MusicBrainz TRM Id': 'musicbrainz_trmid',
+    'TXXX:MusicBrainz Disc Id': 'musicbrainz_discid',
+    'TXXX:ACOUSTID_ID': 'acoustid_id',
+    'TXXX:Acoustid Id': 'acoustid_id',
+    'TXXX:Acoustid Fingerprint': 'acoustid_fingerprint',
+    'TXXX:MusicIP PUID': 'musicip_puid',
+    'TXXX:MusicMagic Fingerprint': 'musicip_fingerprint',
+    WOAR: 'website',
+    // id3v2.4
+    // ToDo: In same sequence as defined at http://id3.org/id3v2.4.0-frames
+    TDRC: 'date', // date YYYY-MM-DD
+    TYER: 'year',
+    TDOR: 'originaldate',
+    // 'TMCL:instrument': 'performer:instrument',
+    'TIPL:arranger': 'arranger',
+    'TIPL:engineer': 'engineer',
+    'TIPL:producer': 'producer',
+    'TIPL:DJ-mix': 'djmixer',
+    'TIPL:mix': 'mixer',
+    TMOO: 'mood',
+    // additional mappings:
+    SYLT: 'lyrics',
+    TSST: 'discsubtitle',
+    TKEY: 'key',
+    COMM: 'comment',
+    TOPE: 'originalartist',
+    // Windows Media Player
+    'PRIV:AverageLevel': 'averageLevel',
+    'PRIV:PeakLevel': 'peakLevel',
+    // Discogs
+    'TXXX:DISCOGS_ARTIST_ID': 'discogs_artist_id',
+    'TXXX:DISCOGS_ARTISTS': 'artists',
+    'TXXX:DISCOGS_ARTIST_NAME': 'artists',
+    'TXXX:DISCOGS_ALBUM_ARTISTS': 'albumartist',
+    'TXXX:DISCOGS_CATALOG': 'catalognumber',
+    'TXXX:DISCOGS_COUNTRY': 'releasecountry',
+    'TXXX:DISCOGS_DATE': 'originaldate',
+    'TXXX:DISCOGS_LABEL': 'label',
+    'TXXX:DISCOGS_LABEL_ID': 'discogs_label_id',
+    'TXXX:DISCOGS_MASTER_RELEASE_ID': 'discogs_master_release_id',
+    'TXXX:DISCOGS_RATING': 'discogs_rating',
+    'TXXX:DISCOGS_RELEASED': 'date',
+    'TXXX:DISCOGS_RELEASE_ID': 'discogs_release_id',
+    'TXXX:DISCOGS_VOTES': 'discogs_votes',
+    'TXXX:CATALOGID': 'catalognumber',
+    'TXXX:STYLE': 'genre',
+    'TXXX:REPLAYGAIN_TRACK_PEAK': 'replaygain_track_peak',
+    'TXXX:REPLAYGAIN_TRACK_GAIN': 'replaygain_track_gain',
+    'TXXX:REPLAYGAIN_ALBUM_PEAK': 'replaygain_album_peak',
+    'TXXX:REPLAYGAIN_ALBUM_GAIN': 'replaygain_album_gain',
+    'TXXX:MP3GAIN_MINMAX': 'replaygain_track_minmax',
+    'TXXX:MP3GAIN_ALBUM_MINMAX': 'replaygain_album_minmax',
+    'TXXX:MP3GAIN_UNDO': 'replaygain_undo',
+    MVNM: 'movement',
+    MVIN: 'movementIndex',
+    PCST: 'podcast',
+    TCAT: 'category',
+    TDES: 'description',
+    TDRL: 'releasedate',
+    TGID: 'podcastId',
+    TKWD: 'keywords',
+    WFED: 'podcasturl',
+    GRP1: 'grouping',
+    PCNT: 'playCounter',
+};
+export class ID3v24TagMapper extends CaseInsensitiveTagMap {
+    static toRating(popm) {
+        return {
+            source: popm.email,
+            rating: popm.rating > 0 ? (popm.rating - 1) / 254 * CommonTagMapper.maxRatingScore : undefined
+        };
+    }
+    constructor() {
+        super(['ID3v2.3', 'ID3v2.4'], id3v24TagMap);
+    }
+    /**
+     * Handle post mapping exceptions / correction
+     * @param tag to post map
+     * @param warnings Wil be used to register (collect) warnings
+     */
+    postMap(tag, warnings) {
+        switch (tag.id) {
+            case 'UFID':
+                {
+                    // decode MusicBrainz Recording Id
+                    const idTag = tag.value;
+                    if (idTag.owner_identifier === 'http://musicbrainz.org') {
+                        tag.id += `:${idTag.owner_identifier}`;
+                        tag.value = decodeString(idTag.identifier, 'latin1'); // latin1 == iso-8859-1
+                    }
+                }
+                break;
+            case 'PRIV':
+                {
+                    const customTag = tag.value;
+                    switch (customTag.owner_identifier) {
+                        // decode Windows Media Player
+                        case 'AverageLevel':
+                        case 'PeakValue':
+                            tag.id += `:${customTag.owner_identifier}`;
+                            tag.value = customTag.data.length === 4 ? UINT32_LE.get(customTag.data, 0) : null;
+                            if (tag.value === null) {
+                                warnings.addWarning('Failed to parse PRIV:PeakValue');
+                            }
+                            break;
+                        default:
+                            warnings.addWarning(`Unknown PRIV owner-identifier: ${customTag.data}`);
+                    }
+                }
+                break;
+            case 'POPM':
+                tag.value = ID3v24TagMapper.toRating(tag.value);
+                break;
+            default:
+                break;
+        }
+    }
+}

package/node_modules/music-metadata/lib/id3v2/ID3v2ChapterToken.d.ts

@@ -0,0 +1,11 @@
+import type { IGetToken } from 'strtok3';
+export interface IChapterInfo {
+    startTime: number;
+    endTime: number;
+    startOffset?: number;
+    endOffset?: number;
+}
+/**
+ * Data portion of `CHAP` sub frame
+ */
+export declare const ChapterInfo: IGetToken<IChapterInfo>;

package/node_modules/music-metadata/lib/id3v2/ID3v2ChapterToken.js

@@ -0,0 +1,17 @@
+import * as Token from 'token-types';
+/**
+ * Data portion of `CHAP` sub frame
+ */
+export const ChapterInfo = {
+    len: 16,
+    get: (buf, off) => {
+        const startOffset = Token.UINT32_BE.get(buf, off + 8);
+        const endOffset = Token.UINT32_BE.get(buf, off + 12);
+        return {
+            startTime: Token.UINT32_BE.get(buf, off),
+            endTime: Token.UINT32_BE.get(buf, off + 4),
+            startOffset: startOffset === 0xFFFFFFFF ? undefined : startOffset,
+            endOffset: endOffset === 0xFFFFFFFF ? undefined : endOffset,
+        };
+    }
+};

package/node_modules/music-metadata/lib/id3v2/ID3v2Parser.d.ts

@@ -0,0 +1,33 @@
+import type { ITokenizer } from 'strtok3';
+import type { IOptions } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+export declare class ID3v2Parser {
+    static removeUnsyncBytes(buffer: Uint8Array): Uint8Array;
+    private static readFrameData;
+    /**
+     * Create a combined tag key, of tag & description
+     * @param tag e.g.: COM
+     * @param description e.g. iTunPGAP
+     * @returns string e.g. COM:iTunPGAP
+     */
+    private static makeDescriptionTagName;
+    private tokenizer;
+    private id3Header;
+    private metadata;
+    private headerType;
+    private options;
+    parse(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): Promise<void>;
+    parseExtendedHeader(): Promise<void>;
+    parseExtendedHeaderData(dataRemaining: number, extendedHeaderSize: number): Promise<void>;
+    parseId3Data(dataLen: number): Promise<void>;
+    private handleTag;
+    private addTag;
+    private parseMetadata;
+    /**
+     * Convert parsed ID3v2 chapter frames (CHAP / CTOC) to generic `format.chapters`.
+     *
+     * This function expects the `native` tags already to contain parsed `CHAP` and `CTOC` frame values,
+     * as produced by `FrameParser.readData`.
+     */
+    private static mapId3v2Chapters;
+}

package/node_modules/music-metadata/lib/id3v2/ID3v2Parser.js

@@ -0,0 +1,169 @@
+import * as Token from 'token-types';
+import { FrameParser, Id3v2ContentError } from './FrameParser.js';
+import { ExtendedHeader, ID3v2Header } from './ID3v2Token.js';
+import { getFrameHeaderLength, readFrameHeader } from './FrameHeader.js';
+export class ID3v2Parser {
+    constructor() {
+        this.tokenizer = undefined;
+        this.id3Header = undefined;
+        this.metadata = undefined;
+        this.headerType = undefined;
+        this.options = undefined;
+    }
+    static removeUnsyncBytes(buffer) {
+        let readI = 0;
+        let writeI = 0;
+        while (readI < buffer.length - 1) {
+            if (readI !== writeI) {
+                buffer[writeI] = buffer[readI];
+            }
+            readI += (buffer[readI] === 0xFF && buffer[readI + 1] === 0) ? 2 : 1;
+            writeI++;
+        }
+        if (readI < buffer.length) {
+            buffer[writeI++] = buffer[readI];
+        }
+        return buffer.subarray(0, writeI);
+    }
+    static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
+        const frameParser = new FrameParser(majorVer, warningCollector);
+        switch (majorVer) {
+            case 2:
+                return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
+            case 3:
+            case 4:
+                if (frameHeader.flags?.format.unsynchronisation) {
+                    uint8Array = ID3v2Parser.removeUnsyncBytes(uint8Array);
+                }
+                if (frameHeader.flags?.format.data_length_indicator) {
+                    uint8Array = uint8Array.subarray(4, uint8Array.length);
+                }
+                return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
+            default:
+                throw makeUnexpectedMajorVersionError(majorVer);
+        }
+    }
+    /**
+     * Create a combined tag key, of tag & description
+     * @param tag e.g.: COM
+     * @param description e.g. iTunPGAP
+     * @returns string e.g. COM:iTunPGAP
+     */
+    static makeDescriptionTagName(tag, description) {
+        return tag + (description ? `:${description}` : '');
+    }
+    async parse(metadata, tokenizer, options) {
+        this.tokenizer = tokenizer;
+        this.metadata = metadata;
+        this.options = options;
+        const id3Header = await this.tokenizer.readToken(ID3v2Header);
+        if (id3Header.fileIdentifier !== 'ID3') {
+            throw new Id3v2ContentError('expected ID3-header file-identifier \'ID3\' was not found');
+        }
+        this.id3Header = id3Header;
+        this.headerType = (`ID3v2.${id3Header.version.major}`);
+        await (id3Header.flags.isExtendedHeader ? this.parseExtendedHeader() : this.parseId3Data(id3Header.size));
+        // Post process
+        const chapters = ID3v2Parser.mapId3v2Chapters(this.metadata.native[this.headerType]);
+        this.metadata.setFormat('chapters', chapters);
+    }
+    async parseExtendedHeader() {
+        const extendedHeader = await this.tokenizer.readToken(ExtendedHeader);
+        const dataRemaining = extendedHeader.size - ExtendedHeader.len;
+        return dataRemaining > 0 ? this.parseExtendedHeaderData(dataRemaining, extendedHeader.size) : this.parseId3Data(this.id3Header.size - extendedHeader.size);
+    }
+    async parseExtendedHeaderData(dataRemaining, extendedHeaderSize) {
+        await this.tokenizer.ignore(dataRemaining);
+        return this.parseId3Data(this.id3Header.size - extendedHeaderSize);
+    }
+    async parseId3Data(dataLen) {
+        const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(dataLen));
+        for (const tag of this.parseMetadata(uint8Array)) {
+            switch (tag.id) {
+                case 'TXXX':
+                    if (tag.value) {
+                        await this.handleTag(tag, tag.value.text, () => tag.value.description);
+                    }
+                    break;
+                default:
+                    await (Array.isArray(tag.value) ? Promise.all(tag.value.map(value => this.addTag(tag.id, value))) : this.addTag(tag.id, tag.value));
+            }
+        }
+    }
+    async handleTag(tag, values, descriptor, resolveValue = value => value) {
+        await Promise.all(values.map(value => this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, descriptor(value)), resolveValue(value))));
+    }
+    async addTag(id, value) {
+        await this.metadata.addTag(this.headerType, id, value);
+    }
+    parseMetadata(data) {
+        let offset = 0;
+        const tags = [];
+        while (true) {
+            if (offset === data.length)
+                break;
+            const frameHeaderLength = getFrameHeaderLength(this.id3Header.version.major);
+            if (offset + frameHeaderLength > data.length) {
+                this.metadata.addWarning('Illegal ID3v2 tag length');
+                break;
+            }
+            const frameHeaderBytes = data.subarray(offset, offset + frameHeaderLength);
+            offset += frameHeaderLength;
+            const frameHeader = readFrameHeader(frameHeaderBytes, this.id3Header.version.major, this.metadata);
+            const frameDataBytes = data.subarray(offset, offset + frameHeader.length);
+            offset += frameHeader.length;
+            const values = ID3v2Parser.readFrameData(frameDataBytes, frameHeader, this.id3Header.version.major, !this.options.skipCovers, this.metadata);
+            if (values) {
+                tags.push({ id: frameHeader.id, value: values });
+            }
+        }
+        return tags;
+    }
+    /**
+     * Convert parsed ID3v2 chapter frames (CHAP / CTOC) to generic `format.chapters`.
+     *
+     * This function expects the `native` tags already to contain parsed `CHAP` and `CTOC` frame values,
+     * as produced by `FrameParser.readData`.
+     */
+    static mapId3v2Chapters(id3Tags) {
+        if (!id3Tags)
+            return;
+        const chapFrames = id3Tags.filter(t => t.id === 'CHAP');
+        if (!chapFrames?.length)
+            return;
+        const tocFrames = id3Tags.filter(t => t.id === 'CTOC');
+        const topLevelToc = tocFrames?.find(t => t.value.flags?.topLevel);
+        const chapterById = new Map();
+        for (const chap of chapFrames) {
+            chapterById.set(chap.value.label, chap.value);
+        }
+        const orderedIds = topLevelToc?.value.childElementIds;
+        const chapters = [];
+        const source = orderedIds ?? [...chapterById.keys()];
+        for (const id of source) {
+            const chap = chapterById.get(id);
+            if (!chap)
+                continue;
+            const frames = chap.frames;
+            const title = frames.get('TIT2');
+            if (!title)
+                continue; // title is required
+            chapters.push({
+                id,
+                title,
+                url: frames.get('WXXX'),
+                start: chap.info.startTime / 1000,
+                end: chap.info.endTime / 1000,
+                image: frames.get('APIC')
+            });
+        }
+        // If no ordered CTOC, sort by time
+        if (!orderedIds) {
+            chapters.sort((a, b) => a.start - b.start);
+        }
+        return chapters.length ? chapters : undefined;
+    }
+}
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}

package/node_modules/music-metadata/lib/id3v2/ID3v2Token.d.ts

@@ -0,0 +1,111 @@
+import type { IGetToken } from 'strtok3';
+import * as util from '../common/Util.js';
+/**
+ * The picture type according to the ID3v2 APIC frame
+ * Ref: http://id3.org/id3v2.3.0#Attached_picture
+ */
+export declare const AttachedPictureType: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+};
+export type ID3v2MajorVersion = 2 | 3 | 4;
+export interface IExtendedHeader {
+    size: number;
+    extendedFlags: number;
+    sizeOfPadding: number;
+    crcDataPresent: boolean;
+}
+/**
+ * https://id3.org/id3v2.3.0#Synchronised_lyrics.2Ftext
+ */
+export declare const LyricsContentType: {
+    other: number;
+    lyrics: number;
+    text: number;
+    movement_part: number;
+    events: number;
+    chord: number;
+    trivia_pop: number;
+};
+export type LyricsContentType = typeof LyricsContentType[keyof typeof LyricsContentType];
+export declare const TimestampFormat: {
+    notSynchronized: number;
+    mpegFrameNumber: number;
+    milliseconds: number;
+};
+export type TimestampFormat = typeof TimestampFormat[keyof typeof TimestampFormat];
+/**
+ * 28 bits (representing up to 256MB) integer, the msb is 0 to avoid 'false syncsignals'.
+ * 4 * %0xxxxxxx
+ */
+export declare const UINT32SYNCSAFE: IGetToken<number>;
+/**
+ * ID3v2 tag header
+ */
+export interface IID3v2header {
+    fileIdentifier: string;
+    version: {
+        major: ID3v2MajorVersion;
+        revision: number;
+    };
+    flags: {
+        unsynchronisation: boolean;
+        isExtendedHeader: boolean;
+        expIndicator: boolean;
+        footer: boolean;
+    };
+    size: number;
+}
+/**
+ * ID3v2 header
+ * Ref: http://id3.org/id3v2.3.0#ID3v2_header
+ * ToDo
+ */
+export declare const ID3v2Header: IGetToken<IID3v2header>;
+export declare const ExtendedHeader: IGetToken<IExtendedHeader>;
+export interface ITextEncoding {
+    encoding: util.StringEncoding;
+    bom?: boolean;
+}
+export declare const TextEncodingToken: IGetToken<ITextEncoding>;
+/**
+ * `USLT` frame fields
+ */
+export interface ITextHeader {
+    encoding: ITextEncoding;
+    language: string;
+}
+/**
+ * Used to read first portion of `SYLT` frame
+ */
+export declare const TextHeader: IGetToken<ITextHeader>;
+/**
+ * SYLT` frame fields
+ */
+export interface ISyncTextHeader extends ITextHeader {
+    contentType: LyricsContentType;
+    timeStampFormat: TimestampFormat;
+}
+/**
+ * Used to read first portion of `SYLT` frame
+ */
+export declare const SyncTextHeader: IGetToken<ISyncTextHeader>;

package/node_modules/music-metadata/lib/id3v2/ID3v2Token.js

@@ -0,0 +1,146 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+/**
+ * The picture type according to the ID3v2 APIC frame
+ * Ref: http://id3.org/id3v2.3.0#Attached_picture
+ */
+export const AttachedPictureType = {
+    0: 'Other',
+    1: "32x32 pixels 'file icon' (PNG only)",
+    2: 'Other file icon',
+    3: 'Cover (front)',
+    4: 'Cover (back)',
+    5: 'Leaflet page',
+    6: 'Media (e.g. label side of CD)',
+    7: 'Lead artist/lead performer/soloist',
+    8: 'Artist/performer',
+    9: 'Conductor',
+    10: 'Band/Orchestra',
+    11: 'Composer',
+    12: 'Lyricist/text writer',
+    13: 'Recording Location',
+    14: 'During recording',
+    15: 'During performance',
+    16: 'Movie/video screen capture',
+    17: 'A bright coloured fish',
+    18: 'Illustration',
+    19: 'Band/artist logotype',
+    20: 'Publisher/Studio logotype'
+};
+/**
+ * https://id3.org/id3v2.3.0#Synchronised_lyrics.2Ftext
+ */
+export const LyricsContentType = {
+    other: 0,
+    lyrics: 1,
+    text: 2,
+    movement_part: 3,
+    events: 4,
+    chord: 5,
+    trivia_pop: 6,
+};
+export const TimestampFormat = {
+    notSynchronized: 0,
+    mpegFrameNumber: 1,
+    milliseconds: 2
+};
+/**
+ * 28 bits (representing up to 256MB) integer, the msb is 0 to avoid 'false syncsignals'.
+ * 4 * %0xxxxxxx
+ */
+export const UINT32SYNCSAFE = {
+    get: (buf, off) => {
+        return buf[off + 3] & 0x7f | ((buf[off + 2]) << 7) |
+            ((buf[off + 1]) << 14) | ((buf[off]) << 21);
+    },
+    len: 4
+};
+/**
+ * ID3v2 header
+ * Ref: http://id3.org/id3v2.3.0#ID3v2_header
+ * ToDo
+ */
+export const ID3v2Header = {
+    len: 10,
+    get: (buf, off) => {
+        return {
+            // ID3v2/file identifier   "ID3"
+            fileIdentifier: new Token.StringType(3, 'ascii').get(buf, off),
+            // ID3v2 versionIndex
+            version: {
+                major: Token.INT8.get(buf, off + 3),
+                revision: Token.INT8.get(buf, off + 4)
+            },
+            // ID3v2 flags
+            flags: {
+                // Unsynchronisation
+                unsynchronisation: util.getBit(buf, off + 5, 7),
+                // Extended header
+                isExtendedHeader: util.getBit(buf, off + 5, 6),
+                // Experimental indicator
+                expIndicator: util.getBit(buf, off + 5, 5),
+                footer: util.getBit(buf, off + 5, 4)
+            },
+            size: UINT32SYNCSAFE.get(buf, off + 6)
+        };
+    }
+};
+export const ExtendedHeader = {
+    len: 10,
+    get: (buf, off) => {
+        return {
+            // Extended header size
+            size: Token.UINT32_BE.get(buf, off),
+            // Extended Flags
+            extendedFlags: Token.UINT16_BE.get(buf, off + 4),
+            // Size of padding
+            sizeOfPadding: Token.UINT32_BE.get(buf, off + 6),
+            // CRC data present
+            crcDataPresent: util.getBit(buf, off + 4, 31)
+        };
+    }
+};
+export const TextEncodingToken = {
+    len: 1,
+    get: (uint8Array, off) => {
+        switch (uint8Array[off]) {
+            case 0x00:
+                return { encoding: 'latin1' }; // binary
+            case 0x01:
+                return { encoding: 'utf-16le', bom: true };
+            case 0x02:
+                return { encoding: 'utf-16le', bom: false };
+            case 0x03:
+                return { encoding: 'utf8', bom: false };
+            default:
+                return { encoding: 'utf8', bom: false };
+        }
+    }
+};
+/**
+ * Used to read first portion of `SYLT` frame
+ */
+export const TextHeader = {
+    len: 4,
+    get: (uint8Array, off) => {
+        return {
+            encoding: TextEncodingToken.get(uint8Array, off),
+            language: new Token.StringType(3, 'latin1').get(uint8Array, off + 1)
+        };
+    }
+};
+/**
+ * Used to read first portion of `SYLT` frame
+ */
+export const SyncTextHeader = {
+    len: 6,
+    get: (uint8Array, off) => {
+        const text = TextHeader.get(uint8Array, off);
+        return {
+            encoding: text.encoding,
+            language: text.language,
+            timeStampFormat: Token.UINT8.get(uint8Array, off + 4),
+            contentType: Token.UINT8.get(uint8Array, off + 5)
+        };
+    }
+};