create jsmediatags 3.9 (#37180)

* jsmediatags initial

* linting updates

* tag and type updates

* remove currently unused

* unused files error

* consolidate to single index file

* Revert "consolidate to single index file"

This reverts commit fe0b24b49eaa1c8a6ff7ce581980dcc3c5e583a2.

* further restructuring

* Further fixes

* update paths

* Revert "update paths"

This reverts commit 4711549a8e930f548546bbb1d405b015cadcd8c7.

* more attempts at path updates

* simplify jsmediatags namespace

* strip useless comments

types/jsmediatags/build2/ArrayFileReader.d.ts

@@ -0,0 +1,21 @@
+import {
+    Byte,
+    ByteArray,
+    LoadCallbackType
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+
+export default class ArrayFileReader extends MediaFileReader {
+    _array: ByteArray;
+    _size: number;
+
+    constructor(array: ByteArray);
+
+    static canReadFile(file: any): boolean;
+
+    init(callbacks: LoadCallbackType): void;
+
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+
+    getByteAt(offset: number): Byte;
+}

types/jsmediatags/build2/BlobFileReader.d.ts

@@ -0,0 +1,20 @@
+import {
+    LoadCallbackType
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+import ChunkedFileData from './ChunkedFileData';
+
+export default class BlobFileReader extends MediaFileReader {
+    _blob: Blob;
+    _fileData: ChunkedFileData;
+
+    constructor(blob: Blob);
+
+    static canReadFile(file: any): boolean;
+
+    _init(callbacks: LoadCallbackType): void;
+
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+
+    getByteAt(offset: number): number;
+}

types/jsmediatags/build2/ByteArrayUtils.d.ts

@@ -0,0 +1,13 @@
+import {
+    ByteArray
+} from '../types';
+
+export function bin(string: string): ByteArray;
+
+export function pad(array: any[], size: number): any[];
+
+export function getSynchsafeInteger32(number: number): ByteArray;
+
+export function getInteger32(number: number): ByteArray;
+
+export function getInteger24(number: number): ByteArray;

types/jsmediatags/build2/ChunkedFileData.d.ts

@@ -0,0 +1,23 @@
+import {
+    ChunkType,
+    DataType
+} from '../types';
+
+export default class ChunkedFileData {
+    static NOT_FOUND: number;
+
+    addData(offset: number, data: DataType): void;
+
+    _concatData(dataA: DataType, dataB: DataType): DataType;
+
+    _sliceData(data: DataType, begin: number, end: number): DataType;
+
+    _getChunkRange(
+        offsetStart: number,
+        offsetEnd: number
+      ): {startIx: number, endIx: number, insertIx?: number};
+
+    hasDataRange(offsetStart: number, offsetEnd: number): boolean;
+
+    getByteAt(offset: number): any;
+}

types/jsmediatags/build2/FLACTagContents.d.ts

@@ -0,0 +1,31 @@
+import {
+    ByteArray
+} from '../types';
+
+export default class FLACTagContents {
+    blocks: MetadataBlock[];
+
+    constructor(blocks?: MetadataBlock[]);
+
+    toArray(): ByteArray;
+
+    static createBlock(type: number, data: ByteArray): MetadataBlock;
+
+    static createStreamBlock(): MetadataBlock;
+
+    static createCommentBlock(...data: string[][]): MetadataBlock;
+
+    static createPictureBlock(): void;
+}
+
+export class MetadataBlock {
+    _data: number[];
+    _final: boolean;
+    _type: number;
+
+    constructor(type: number, data: ByteArray);
+
+    setFinal(): void;
+
+    toArray(): void;
+}

types/jsmediatags/build2/FLACTagReader.d.ts

@@ -0,0 +1,34 @@
+import {
+    LoadCallbackType,
+    ByteRange,
+    TagType
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+import MediaTagReader from './MediaTagReader';
+
+export default class FLACTagReader extends MediaTagReader {
+    _commentOffset: number;
+    _pictureOffset: number;
+
+    static getTagIdentifierByteRange(): ByteRange;
+
+    static canReadTagFormat(tagIdentifier: number[]): boolean;
+
+    _loadData(mediaFileReader: MediaFileReader, callbacks: LoadCallbackType): void;
+
+    _loadBlock(
+        mediaFileReader: MediaFileReader,
+        offset: number,
+        callbacks: LoadCallbackType
+    ): void;
+
+    _nextBlock(
+        mediaFileReader: MediaFileReader,
+        offset: number,
+        blockHeader: number,
+        blockSize: number,
+        callbacks: LoadCallbackType
+    ): void;
+
+    _parseData(data: MediaFileReader, tags?: string[]): TagType;
+}

types/jsmediatags/build2/ID3v1TagReader.d.ts

@@ -0,0 +1,17 @@
+import {
+    LoadCallbackType,
+    ByteRange,
+    TagType
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+import MediaTagReader from './MediaTagReader';
+
+export default class ID3v1TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange(): ByteRange;
+
+    static canReadTagFormat(tagIdentifier: number[]): boolean;
+
+    _loadData(mediaFileReader: MediaFileReader, callbacks: LoadCallbackType): void;
+
+    _parseData(data: MediaFileReader, tags?: string[]): TagType;
+}

types/jsmediatags/build2/ID3v2FrameReader.d.ts

@@ -0,0 +1,43 @@
+import {
+    CharsetType,
+    FrameReaderSignature,
+    TagHeader,
+    TagFrames,
+    TagFrameHeader,
+    TagFrameFlags
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+
+// tslint:disable-next-line:interface-name
+interface ID3v2FrameReader {
+    getFrameReaderFunction(frameId: string): FrameReaderSignature | null;
+
+    readFrames(
+        offset: number,
+        end: number,
+        data: MediaFileReader,
+        id3header: TagHeader,
+        tags?: string[]
+      ): TagFrames;
+
+    _getFrameHeaderSize(id3header: TagHeader): number;
+
+    _readFrameHeader(
+        data: MediaFileReader,
+        offset: number,
+        id3header: TagHeader
+      ): TagFrameHeader;
+
+    _readFrameFlags(data: MediaFileReader, offset: number): TagFrameFlags;
+
+    _getFrameDescription(frameId: string): string;
+
+    getUnsyncFileReader(
+        data: MediaFileReader,
+        offset: number,
+        size: number
+      ): MediaFileReader;
+}
+
+declare const ID3v2FrameReader: ID3v2FrameReader;
+export default ID3v2FrameReader;

types/jsmediatags/build2/ID3v2TagContents.d.ts

@@ -0,0 +1,61 @@
+import {
+    ByteArray,
+    TagHeaderFlags,
+    TagFrameFlags
+} from '../types';
+
+export default class ID3v2TagContents {
+    _size: number;
+    _major: number;
+    _revision: number;
+    _contents: ByteArray;
+    _frames: { [key: string]: ByteArray[] };
+    _extendedHeader: {
+        UPDATE: number,
+        CRC: number,
+        RESTRICTIONS: number
+    };
+    _hasExtendedHeader: boolean;
+    _nextFrameOffset: number;
+
+    constructor(major: number, revision: number);
+
+    toArray(): ByteArray;
+
+    setFlags(flags: TagHeaderFlags): ID3v2TagContents;
+
+    _updateFlags(flags: TagHeaderFlags, binaryFlags?: number): ID3v2TagContents;
+
+    setCrc(crc: ByteArray): ID3v2TagContents;
+
+    setTagIsUpdate(): ID3v2TagContents;
+
+    setTagRestrictions(
+        size: number,
+        textEncoding: number,
+        textSize: number,
+        imageEncoding: number,
+        imageSize: number
+    ): ID3v2TagContents;
+
+    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;
+}

types/jsmediatags/build2/ID3v2TagReader.d.ts

@@ -0,0 +1,27 @@
+import {
+    CallbackType,
+    LoadCallbackType,
+    TagFrames,
+    TagHeader,
+    TagFrameHeader,
+    TagFrameFlags,
+    CharsetType,
+    ByteRange,
+    TagType,
+} from '../types';
+import MediaTagReader from './MediaTagReader';
+import MediaFileReader from './MediaFileReader';
+
+export default class ID3v2TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange(): ByteRange;
+
+    static canReadTagFormat(tagIdentifier: number[]): boolean;
+
+    _loadData(mediaFileReader: MediaFileReader, callbacks: LoadCallbackType): void;
+
+    _parseData(data: MediaFileReader, tags?: string[]): TagType;
+
+    _getFrameData(frames: TagFrames, ids: string[]): any;
+
+    getShortcuts(): {[key: string]: string|string[]};
+}

types/jsmediatags/build2/MP4TagContents.d.ts

@@ -0,0 +1,27 @@
+import {
+    ByteArray
+} from '../types';
+
+export class Atom {
+    _name: string;
+    _data: number[];
+    _atoms: Atom[];
+
+    constructor(name: string, data?: ByteArray, atoms?: Atom[]);
+
+    toArray(): ByteArray;
+}
+
+export default class MP4TagContents {
+    _atoms: Atom[];
+
+    constructor(ftyp: string, atoms?: Atom[]);
+
+    toArray(): ByteArray;
+
+    static createAtom(atomName: string): Atom;
+
+    static createContainerAtom(atomName: string, atoms: Atom[], data?: ByteArray): Atom;
+
+    static createMetadataAtom(atomName: string, type: string, data: ByteArray): Atom;
+}

types/jsmediatags/build2/MP4TagReader.d.ts

@@ -0,0 +1,45 @@
+import {
+    CallbackType,
+    LoadCallbackType,
+    CharsetType,
+    ByteRange,
+    TagType,
+    TagFrame
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+import MediaTagReader from './MediaTagReader';
+
+export default class MP4TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange(): ByteRange;
+
+    static canReadTagFormat(tagIdentifier: number[]): boolean;
+
+    _loadData(mediaFileReader: MediaFileReader, callbacks: LoadCallbackType): void;
+
+    _loadAtom(
+        mediaFileReader: MediaFileReader,
+        offset: number,
+        parentAtomFullName: string,
+        callbacks: LoadCallbackType
+      ): void;
+
+    _isContainerAtom(atomName: string): boolean;
+
+    _canReadAtom(atomName: string): boolean;
+
+    _parseData(data: MediaFileReader, tagsToRead?: string[]): TagType;
+
+    _readAtom(
+        tags: any,
+        data: MediaFileReader,
+        offset: number,
+        length: number,
+        tagsToRead?: string[],
+        parentAtomFullName?: string,
+        indent?: string
+      ): void;
+
+    _readMetadataAtom(data: MediaFileReader, offset: number): TagFrame;
+
+    getShortcuts(): {[key: string]: string|string[]};
+}

types/jsmediatags/build2/MediaFileReader.d.ts

@@ -0,0 +1,33 @@
+import { CallbackType, CharsetType, LoadCallbackType } from '../types';
+import { DecodedString } from './StringUtils';
+
+export default class MediaFileReader {
+    _isInitialized: boolean;
+    _size: number;
+
+    constructor(path?: any);
+
+    static canReadFile(file: any): boolean;
+
+    init(callbacks: LoadCallbackType): void;
+    _init(callbacks: LoadCallbackType): void;
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+    getSize(): number;
+    getByteAt(offset: number): number;
+    getBytesAt(offset: number, length: number): number[];
+    isBitSetAt(offset: number, bit: number): boolean;
+    getSByteAt(offset: number): number;
+    getShortAt(offset: number, isBigEndian: boolean): number;
+    getSShortAt(offset: number, isBigEndian: boolean): number;
+    getLongAt(offset: number, isBigEndian: boolean): number;
+    getSLongAt(offset: number, isBigEndian: boolean): number;
+    getInteger24At(offset: number, isBigEndian: boolean): number;
+    getStringAt(offset: number, length: number): string;
+    getStringWithCharsetAt(
+        offset: number,
+        length: number,
+        charset?: CharsetType,
+      ): DecodedString;
+    getCharAt(offset: number): string;
+    getSynchsafeInteger32At(offset: number): number;
+}

types/jsmediatags/build2/MediaTagReader.d.ts

@@ -0,0 +1,33 @@
+import {
+    CallbackType,
+    LoadCallbackType,
+    ByteRange,
+    TagType
+} from '../types';
+import MediaFileReader from './MediaFileReader';
+
+export default class MediaTagReader {
+    _mediaFileReader: MediaFileReader;
+    _tags?: string[];
+
+    constructor(mediaFileReader: MediaFileReader);
+
+    static getTagIdentifierByteRange(): ByteRange;
+
+    static canReadTagFormat(tagIdentifier: number[]): boolean;
+
+    setTagsToRead(tags: string[]): MediaTagReader;
+
+    read(callbacks: CallbackType): void;
+
+    getShortcuts(): {[key: string]: (string|string[])};
+
+    _loadData(
+        mediaFileReader: MediaFileReader,
+        callbacks: LoadCallbackType
+      ): void;
+
+    _parseData(mediaFileReader: MediaFileReader, tags?: string[]): TagType;
+
+    _expandShortcutTags(tagsWithShortcuts?: string[]): string[] | null;
+}

types/jsmediatags/build2/NodeFileReader.d.ts

@@ -0,0 +1,18 @@
+import { LoadCallbackType } from '../types';
+import MediaFileReader from './MediaFileReader';
+import ChunkedFileData from './ChunkedFileData';
+
+export default class NodeFileReader extends MediaFileReader {
+    _path: string;
+    _fileData: ChunkedFileData;
+
+    constructor(path: string);
+
+    static canReadFile(file: any): boolean;
+
+    getByteAt(offset: number): number;
+
+    _init(callbacks: LoadCallbackType): void;
+
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+}

types/jsmediatags/build2/StringUtils.d.ts

@@ -0,0 +1,11 @@
+export type DecodedString = InternalDecodedString;
+
+export default class InternalDecodedString {
+  _value: string;
+  bytesReadCount: number;
+  length: number;
+
+  constructor(value: string, bytesReadCount: number);
+
+  toString(): string;
+}

types/jsmediatags/build2/XhrFileReader.d.ts

@@ -0,0 +1,61 @@
+import { CallbackType, LoadCallbackType } from '../types';
+import MediaFileReader from './MediaFileReader';
+import ChunkedFileData from './ChunkedFileData';
+
+export interface ContentRangeType {
+    firstBytePosition?: number;
+    lastBytePosition?: number;
+    instanceLength?: number;
+}
+
+export default class XhrFileReader extends MediaFileReader {
+    static _config: {
+      avoidHeadRequests: boolean,
+      disallowedXhrHeaders: string[],
+      timeoutInSec: number
+    };
+    _url: string;
+    _fileData: ChunkedFileData;
+
+    constructor(url: string);
+
+    static canReadFile(file: any): boolean;
+
+    static setConfig(config: any): void;
+
+    _init(callbacks: LoadCallbackType): void;
+
+    _fetchSizeWithHeadRequest(callbacks: LoadCallbackType): void;
+
+    _fetchSizeWithGetRequest(callbacks: LoadCallbackType): void;
+
+    _fetchEntireFile(callbacks: LoadCallbackType): void;
+
+    _getXhrResponseContent(xhr: XMLHttpRequest): string;
+
+    _parseContentLength(xhr: XMLHttpRequest): number|null;
+
+    _parseContentRange(xhr: XMLHttpRequest): ContentRangeType|null;
+
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+
+    _roundRangeToChunkMultiple(range: [number, number]): [number, number];
+
+    _makeXHRRequest(
+        method: string,
+        range: [number, number] | null,
+        callbacks: CallbackType
+      ): void;
+
+    _setRequestHeader(xhr: XMLHttpRequest, headerName: string, headerValue: string): void;
+
+    _hasResponseHeader(xhr: XMLHttpRequest, headerName: string): boolean;
+
+    _getResponseHeader(xhr: XMLHttpRequest, headerName: string): string|null;
+
+    getByteAt(offset: number): number;
+
+    _isWebWorker(): boolean;
+
+    _createXHRObject(): XMLHttpRequest;
+}

types/jsmediatags/index.d.ts

@@ -0,0 +1,46 @@
+// Type definitions for jsmediatags 3.9
+// Project: https://github.com/aadsm/jsmediatags#readme
+// Definitions by: Gunnar Már Óttarsson <https://github.com/gunnim>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { CallbackType, LoadCallbackType } from './types';
+import MediaFileReader from './build2/MediaFileReader';
+import MediaTagReader from './build2/MediaTagReader';
+
+export as namespace jsmediatags;
+export function read(location: any, callbacks: CallbackType): void;
+
+export class Reader {
+  _file: any;
+  _tagsToRead: string[];
+  _fileReader: typeof MediaFileReader;
+  _tagReader: typeof MediaTagReader;
+
+  constructor(file: any);
+
+  setFileReader(fileReader: typeof MediaFileReader): Reader;
+
+  setTagsToRead(tagsToRead: string[]): Reader;
+  setTagReader(tagReader: typeof MediaTagReader): Reader;
+
+  read(callbacks: CallbackType): void;
+  _getFileReader(): typeof MediaFileReader;
+  _findFileReader(): typeof MediaFileReader;
+  _getTagReader(fileReader: MediaFileReader, callbacks: CallbackType): void;
+  _findTagReader(fileReader: MediaFileReader, callbacks: CallbackType): void;
+  _loadTagIdentifierRanges(
+    fileReader: MediaFileReader,
+    tagReaders: Array<typeof MediaTagReader>,
+    callbacks: LoadCallbackType
+  ): void;
+}
+export const Config: Config;
+
+export interface Config {
+  addFileReader(fileReader: typeof MediaFileReader): Config;
+  addTagReader(tagReader: typeof MediaTagReader): Config;
+  removeTagReader(tagReader: typeof MediaTagReader): Config;
+  EXPERIMENTAL_avoidHeadRequests(): void;
+  setDisallowedXhrHeaders(disallowedXhrHeaders: string[]): void;
+  setXhrTimeoutInSec(timeoutInSec: number): void;
+}

types/jsmediatags/jsmediatags-tests.ts

@@ -0,0 +1,30 @@
+import * as jsmediatags from 'jsmediatags';
+import MediaFileReader from 'jsmediatags/build2/MediaFileReader';
+import MediaTagReader from 'jsmediatags/build2/MediaTagReader';
+
+const url = '';
+
+// $ExpectType void
+jsmediatags.read(url, {
+  onSuccess(tag: any) {
+  },
+  onError(error: any) {
+  },
+});
+
+class TestFileReader extends MediaFileReader {
+    static canReadFile = (_file: any) => false;
+}
+class TestTagReader extends MediaTagReader {
+}
+
+// $ExpectType Config
+jsmediatags.Config.addFileReader(TestFileReader)
+    .addTagReader(TestTagReader)
+    .removeTagReader(TestTagReader);
+// $ExpectType void
+jsmediatags.Config.setDisallowedXhrHeaders(['']);
+// $ExpectType void
+jsmediatags.Config.setXhrTimeoutInSec(0);
+// $ExpectType void
+jsmediatags.Config.EXPERIMENTAL_avoidHeadRequests();

types/jsmediatags/tsconfig.json

@@ -0,0 +1,41 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "jsmediatags-tests.ts",
+        "build2/ArrayFileReader.d.ts",
+        "build2/BlobFileReader.d.ts",
+        "build2/ByteArrayUtils.d.ts",
+        "build2/ChunkedFileData.d.ts",
+        "build2/FLACTagContents.d.ts",
+        "build2/FLACTagReader.d.ts",
+        "build2/ID3v1TagReader.d.ts",
+        "build2/ID3v2FrameReader.d.ts",
+        "build2/ID3v2TagContents.d.ts",
+        "build2/ID3v2TagReader.d.ts",
+        "build2/MediaFileReader.d.ts",
+        "build2/MediaTagReader.d.ts",
+        "build2/MP4TagContents.d.ts",
+        "build2/MP4TagReader.d.ts",
+        "build2/NodeFileReader.d.ts",
+        "build2/StringUtils.d.ts",
+        "build2/XhrFileReader.d.ts"
+    ]
+}

types/jsmediatags/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }

types/jsmediatags/types/index.d.ts

@@ -0,0 +1,131 @@
+import MediaFileReader from '../build2/MediaFileReader';
+
+export interface jsmediatagsError {
+    type: string;
+    info: string;
+    xhr?: XMLHttpRequest;
+}
+export interface CallbackType {
+    onSuccess: (data: TagType) => void;
+    onError?: (error: jsmediatagsError) => void;
+}
+
+export interface LoadCallbackType {
+    onSuccess: () => void;
+    onError?: (error: jsmediatagsError) => void;
+}
+
+export type CharsetType =
+    "utf-16" |
+    "utf-16le" |
+    "utf-16be" |
+    "utf-8" |
+    "iso-8859-1";
+
+export interface ByteRange {
+    offset: number; // negative offset is relative to the end of the file.
+    length: number;
+}
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+
+export type DataType = number[] | TypedArray | string;
+
+export interface ChunkType {
+    offset: number;
+    data: DataType;
+}
+
+export type Byte = number;
+
+export type ByteArray = Byte[];
+
+export type FrameReaderSignature = (
+    offset: number,
+    length: number,
+    data: MediaFileReader,
+    flags?: any,
+    id3header?: TagHeader
+) => any;
+
+export interface TagFrames {
+    [key: string]: TagFrame;
+}
+
+export interface TagFrame {
+    id: string;
+    size: number;
+    description: string;
+    data: any;
+}
+
+export interface TagFrameHeader {
+    id: string;
+    size: number;
+    headerSize: number;
+    flags?: TagFrameFlags;
+}
+
+export interface TagFrameFlags {
+    message: {
+        tag_alter_preservation: boolean;
+        file_alter_preservation: boolean;
+        read_only: boolean;
+    };
+    format: {
+        grouping_identity: boolean;
+        compression: boolean;
+        encryption: boolean;
+        unsynchronisation: boolean;
+        data_length_indicator: boolean;
+    };
+}
+
+export interface TagHeader {
+    version: string;
+    major: number;
+    revision: number;
+    flags: TagHeaderFlags;
+    size: number;
+}
+
+export interface TagHeaderFlags {
+    unsynchronisation: boolean;
+    extended_header: boolean;
+    experimental_indicator: boolean;
+    footer_present: boolean;
+}
+
+export interface TagType {
+    type: string;
+    tags: Tags;
+}
+
+export interface ShortcutTags {
+    title?: string;
+    artist?: string;
+    album?: string;
+    year?: string;
+    comment?: string;
+    track?: string;
+    genre?: string;
+    picture?: string;
+    lyrics?: string;
+}
+export type Tags = ShortcutTags & TagFrames;
+
+export interface FrameType {
+    id: string;
+    description: string;
+    data: any;
+}
+
+export type ShortcutNameType =
+    "title" |
+    "artist" |
+    "album" |
+    "year" |
+    "comment" |
+    "track" |
+    "genre" |
+    "picture" |
+    "lyrics";