@dragon708/docmind-markdown 1.2.5 → 1.2.7

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

@@ -1,46 +1,5 @@
-import { type ID3v2MajorVersion, type ITextEncoding } from './ID3v2Token.js';
-import type { IWarningCollector } from '../common/MetadataCollector.js';
-import { type IChapterInfo } from './ID3v2ChapterToken.js';
-interface ICustomTag {
-    owner_identifier: string;
-}
-export interface ICustomDataTag extends ICustomTag {
-    data: Uint8Array;
-}
-export interface IIdentifierTag extends ICustomTag {
-    identifier: Uint8Array;
-}
-export interface ITextTag {
-    description: string;
-    text: string[];
-}
-export interface IPopularimeter {
-    email: string;
-    rating: number;
-    counter: number;
-}
-export interface IGeneralEncapsulatedObject {
-    type: string;
-    filename: string;
-    description: string;
-    data: Uint8Array;
-}
-export type Chapter = {
-    label: string;
-    info: IChapterInfo;
-    frames: Map<string, unknown>;
-};
-export type TableOfContents = {
-    label: string;
-    flags: {
-        /** If set, this is the top-level table of contents */
-        topLevel: boolean;
-        /** If set, the child element IDs are in a defined order */
-        ordered: boolean;
-    };
-    childElementIds: string[];
-    frames: Map<string, unknown>;
-};
+import { ID3v2MajorVersion } from './ID3v2Token';
+import { IWarningCollector } from '../common/MetadataCollector';
 export declare function parseGenre(origVal: string): string[];
 export declare class FrameParser {
     private major;
@@ -51,11 +10,7 @@ export declare class FrameParser {
      * @param warningCollector - Used to collect decode issue
      */
     constructor(major: ID3v2MajorVersion, warningCollector: IWarningCollector);
-    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): unknown;
-    protected static readNullTerminatedString(uint8Array: Uint8Array, encoding: ITextEncoding): {
-        text: string;
-        len: number;
-    };
+    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): any;
     protected static fixPictureMimeType(pictureType: string): string;
     /**
      * Converts TMCL (Musician credits list) or TIPL (Involved people list)
@@ -71,22 +26,6 @@ export declare class FrameParser {
      */
     private splitValue;
     private static trimArray;
-    private static trimNullPadding;
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }
-declare const Id3v2ContentError_base: {
-    new (message: string): {
-        readonly fileType: string;
-        toString(): string;
-        name: "UnexpectedFileContentError";
-        message: string;
-        stack?: string;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
-};
-export declare class Id3v2ContentError extends Id3v2ContentError_base {
-}
-export {};

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

@@ -1,16 +1,14 @@
-import initDebug from 'debug';
-import * as Token from 'token-types';
-import * as util from '../common/Util.js';
-import { AttachedPictureType, SyncTextHeader, TextEncodingToken, TextHeader } from './ID3v2Token.js';
-import { Genres } from '../id3v1/ID3v1Parser.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-import { decodeUintBE } from '../common/Util.js';
-import { ChapterInfo } from './ID3v2ChapterToken.js';
-import { getFrameHeaderLength, readFrameHeader } from './FrameHeader.js';
-const debug = initDebug('music-metadata:id3v2:frame-parser');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameParser = exports.parseGenre = void 0;
+const debug_1 = require("debug");
+const Token = require("token-types");
+const util = require("../common/Util");
+const ID3v2Token_1 = require("./ID3v2Token");
+const ID3v1Parser_1 = require("../id3v1/ID3v1Parser");
+const debug = (0, debug_1.default)('music-metadata:id3v2:frame-parser');
 const defaultEnc = 'latin1'; // latin1 == iso-8859-1;
-const urlEnc = { encoding: defaultEnc, bom: false };
-export function parseGenre(origVal) {
+function parseGenre(origVal) {
     // match everything inside parentheses
     const genres = [];
     let code;
@@ -44,24 +42,23 @@ export function parseGenre(origVal) {
     }
     if (word) {
         if (genres.length === 0 && word.match(/^\d*$/)) {
-            word = parseGenreCode(word);
-        }
-        if (word) {
-            genres.push(word);
+            word = ID3v1Parser_1.Genres[word];
         }
+        genres.push(word);
     }
     return genres;
 }
+exports.parseGenre = parseGenre;
 function parseGenreCode(code) {
     if (code === 'RX')
         return 'Remix';
     if (code === 'CR')
         return 'Cover';
     if (code.match(/^\d*$/)) {
-        return Genres[Number.parseInt(code, 10)];
+        return ID3v1Parser_1.Genres[code];
     }
 }
-export class FrameParser {
+class FrameParser {
     /**
      * Create id3v2 frame parser
      * @param major - Major version, e.g. (4) for  id3v2.4
@@ -76,45 +73,38 @@ export class FrameParser {
             this.warningCollector.addWarning(`id3v2.${this.major} header has empty tag type=${type}`);
             return;
         }
-        const { encoding, bom } = TextEncodingToken.get(uint8Array, 0);
+        const { encoding, bom } = ID3v2Token_1.TextEncodingToken.get(uint8Array, 0);
         const length = uint8Array.length;
         let offset = 0;
         let output = []; // ToDo
         const nullTerminatorLength = FrameParser.getNullTerminatorLength(encoding);
         let fzero;
+        const out = {};
         debug(`Parsing tag type=${type}, encoding=${encoding}, bom=${bom}`);
         switch (type !== 'TXXX' && type[0] === 'T' ? 'T*' : type) {
             case 'T*': // 4.2.1. Text information frames - details
-            case 'GRP1': // iTunes-specific ID3v2 grouping field
-            case 'GP1': // iTunes-specific ID3v2.2 grouping field
             case 'IPLS': // v2.3: Involved people list
             case 'MVIN':
             case 'MVNM':
             case 'PCS':
-            case 'PCST': {
+            case 'PCST':
                 let text;
                 try {
-                    text = FrameParser.trimNullPadding(util.decodeString(uint8Array.subarray(1), encoding));
+                    text = util.decodeString(uint8Array.slice(1), encoding).replace(/\x00+$/, '');
                 }
                 catch (error) {
-                    if (error instanceof Error) {
-                        this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
-                        break;
-                    }
-                    throw error;
+                    this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
                 }
                 switch (type) {
                     case 'TMCL': // Musician credits list
                     case 'TIPL': // Involved people list
                     case 'IPLS': // Involved people list
-                        output = FrameParser.functionList(this.splitValue(type, text));
+                        output = this.splitValue(type, text);
+                        output = FrameParser.functionList(output);
                         break;
                     case 'TRK':
                     case 'TRCK':
                     case 'TPOS':
-                    case 'TIT1':
-                    case 'TIT2':
-                    case 'TIT3':
                         output = text;
                         break;
                     case 'TCOM':
@@ -140,144 +130,107 @@ export class FrameParser {
                         output = this.major >= 4 ? this.splitValue(type, text) : [text];
                 }
                 break;
-            }
-            case 'TXXX': {
-                const idAndData = FrameParser.readIdentifierAndData(uint8Array.subarray(1), encoding);
+            case 'TXXX':
+                output = FrameParser.readIdentifierAndData(uint8Array, offset + 1, length, encoding);
                 output = {
-                    description: idAndData.id,
-                    text: this.splitValue(type, util.decodeString(idAndData.data, encoding).replace(/\x00+$/, ''))
+                    description: output.id,
+                    text: this.splitValue(type, util.decodeString(output.data, encoding).replace(/\x00+$/, ''))
                 };
                 break;
-            }
             case 'PIC':
             case 'APIC':
                 if (includeCovers) {
                     const pic = {};
-                    uint8Array = uint8Array.subarray(1);
+                    offset += 1;
                     switch (this.major) {
                         case 2:
-                            pic.format = util.decodeString(uint8Array.subarray(0, 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
-                            uint8Array = uint8Array.subarray(3);
+                            pic.format = util.decodeString(uint8Array.slice(offset, offset + 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
+                            offset += 3;
                             break;
                         case 3:
                         case 4:
-                            fzero = util.findZero(uint8Array, defaultEnc);
-                            pic.format = util.decodeString(uint8Array.subarray(0, fzero), defaultEnc);
-                            uint8Array = uint8Array.subarray(fzero + 1);
+                            fzero = util.findZero(uint8Array, offset, length, defaultEnc);
+                            pic.format = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
+                            offset = fzero + 1;
                             break;
                         default:
-                            throw makeUnexpectedMajorVersionError(this.major);
+                            throw new Error('Warning: unexpected major versionIndex: ' + this.major);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
-                    pic.type = AttachedPictureType[uint8Array[0]];
-                    uint8Array = uint8Array.subarray(1);
-                    fzero = util.findZero(uint8Array, encoding);
-                    pic.description = util.decodeString(uint8Array.subarray(0, fzero), encoding);
-                    uint8Array = uint8Array.subarray(fzero + nullTerminatorLength);
-                    pic.data = uint8Array;
+                    pic.type = ID3v2Token_1.AttachedPictureType[uint8Array[offset]];
+                    offset += 1;
+                    fzero = util.findZero(uint8Array, offset, length, encoding);
+                    pic.description = util.decodeString(uint8Array.slice(offset, fzero), encoding);
+                    offset = fzero + nullTerminatorLength;
+                    pic.data = Buffer.from(uint8Array.slice(offset, length));
                     output = pic;
                 }
                 break;
             case 'CNT':
             case 'PCNT':
-                output = decodeUintBE(uint8Array);
+                output = Token.UINT32_BE.get(uint8Array, 0);
                 break;
-            case 'SYLT': {
-                const syltHeader = SyncTextHeader.get(uint8Array, 0);
-                uint8Array = uint8Array.subarray(SyncTextHeader.len);
-                const result = {
-                    descriptor: '',
-                    language: syltHeader.language,
-                    contentType: syltHeader.contentType,
-                    timeStampFormat: syltHeader.timeStampFormat,
-                    syncText: []
-                };
-                let readSyllables = false;
-                while (uint8Array.length > 0) {
-                    const nullStr = FrameParser.readNullTerminatedString(uint8Array, syltHeader.encoding);
-                    uint8Array = uint8Array.subarray(nullStr.len);
-                    if (readSyllables) {
-                        const timestamp = Token.UINT32_BE.get(uint8Array, 0);
-                        uint8Array = uint8Array.subarray(Token.UINT32_BE.len);
-                        result.syncText.push({
-                            text: nullStr.text,
-                            timestamp
-                        });
-                    }
-                    else {
-                        result.descriptor = nullStr.text;
-                        readSyllables = true;
-                    }
+            case 'SYLT':
+                // skip text encoding (1 byte),
+                //      language (3 bytes),
+                //      time stamp format (1 byte),
+                //      content tagTypes (1 byte),
+                //      content descriptor (1 byte)
+                offset += 7;
+                output = [];
+                while (offset < length) {
+                    const txt = uint8Array.slice(offset, offset = util.findZero(uint8Array, offset, length, encoding));
+                    offset += 5; // push offset forward one +  4 byte timestamp
+                    output.push(util.decodeString(txt, encoding));
                 }
-                output = result;
                 break;
-            }
             case 'ULT':
             case 'USLT':
             case 'COM':
-            case 'COMM': {
-                const textHeader = TextHeader.get(uint8Array, offset);
-                offset += TextHeader.len;
-                const descriptorStr = FrameParser.readNullTerminatedString(uint8Array.subarray(offset), textHeader.encoding);
-                offset += descriptorStr.len;
-                const textStr = FrameParser.readNullTerminatedString(uint8Array.subarray(offset), textHeader.encoding);
-                const comment = {
-                    language: textHeader.language,
-                    descriptor: descriptorStr.text,
-                    text: textStr.text
-                };
-                output = comment;
+            case 'COMM':
+                offset += 1;
+                out.language = util.decodeString(uint8Array.slice(offset, offset + 3), defaultEnc);
+                offset += 3;
+                fzero = util.findZero(uint8Array, offset, length, encoding);
+                out.description = util.decodeString(uint8Array.slice(offset, fzero), encoding);
+                offset = fzero + nullTerminatorLength;
+                out.text = util.decodeString(uint8Array.slice(offset, length), encoding).replace(/\x00+$/, '');
+                output = [out];
                 break;
-            }
-            case 'UFID': {
-                const ufid = FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
-                output = { owner_identifier: ufid.id, identifier: ufid.data };
+            case 'UFID':
+                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                output = { owner_identifier: output.id, identifier: output.data };
                 break;
-            }
-            case 'PRIV': { // private frame
-                const priv = FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
-                output = { owner_identifier: priv.id, data: priv.data };
+            case 'PRIV': // private frame
+                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                output = { owner_identifier: output.id, data: output.data };
                 break;
-            }
-            case 'POPM': { // Popularimeter
-                uint8Array = uint8Array.subarray(offset);
-                const emailStr = FrameParser.readNullTerminatedString(uint8Array, urlEnc);
-                const email = emailStr.text;
-                uint8Array = uint8Array.subarray(emailStr.len);
-                if (uint8Array.length === 0) {
-                    this.warningCollector.addWarning(`id3v2.${this.major} type=${type} POPM frame missing rating byte`);
-                    output = { email, rating: 0, counter: undefined };
-                    break;
-                }
-                const rating = Token.UINT8.get(uint8Array, 0);
-                const counterBytes = uint8Array.subarray(Token.UINT8.len);
+            case 'POPM': // Popularimeter
+                fzero = util.findZero(uint8Array, offset, length, defaultEnc);
+                const email = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
+                offset = fzero + 1;
+                const dataLen = length - offset;
                 output = {
                     email,
-                    rating,
-                    counter: counterBytes.length > 0 ? decodeUintBE(counterBytes) : undefined
+                    rating: Token.UINT8.get(uint8Array, offset),
+                    counter: dataLen >= 5 ? Token.UINT32_BE.get(uint8Array, offset + 1) : undefined
                 };
                 break;
-            }
             case 'GEOB': { // General encapsulated object
-                // [encoding] <MIME> 0x00 <filename> 0x00/0x00 0x00 <description> 0x00/0x00 0x00 <data>
-                const encoding = TextEncodingToken.get(uint8Array, 0);
-                uint8Array = uint8Array.subarray(1);
-                const mimeTypeStr = FrameParser.readNullTerminatedString(uint8Array, urlEnc);
-                const mimeType = mimeTypeStr.text;
-                uint8Array = uint8Array.subarray(mimeTypeStr.len);
-                const filenameStr = FrameParser.readNullTerminatedString(uint8Array, encoding);
-                const filename = filenameStr.text;
-                uint8Array = uint8Array.subarray(filenameStr.len);
-                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, encoding);
-                const description = descriptionStr.text;
-                uint8Array = uint8Array.subarray(descriptionStr.len);
-                const geob = {
+                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
+                const mimeType = util.decodeString(uint8Array.slice(offset + 1, fzero), defaultEnc);
+                offset = fzero + 1;
+                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                const filename = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
+                offset = fzero + 1;
+                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                const description = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
+                output = {
                     type: mimeType,
                     filename,
                     description,
-                    data: uint8Array
+                    data: uint8Array.slice(offset + 1, length)
                 };
-                output = geob;
                 break;
             }
             // W-Frames:
@@ -290,116 +243,31 @@ export class FrameParser {
             case 'WPAY':
             case 'WPUB':
                 // Decode URL
-                output = FrameParser.readNullTerminatedString(uint8Array, urlEnc).text;
+                output = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 break;
             case 'WXXX': {
-                // [encoding] <description> 0x00/0x00 0x00 <url>
-                const encoding = TextEncodingToken.get(uint8Array, 0);
-                uint8Array = uint8Array.subarray(1);
-                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, encoding);
-                const description = descriptionStr.text;
-                uint8Array = uint8Array.subarray(descriptionStr.len);
-                // URL is always ISO-8859-1
-                output = { description, url: FrameParser.trimNullPadding(util.decodeString(uint8Array, defaultEnc)) };
+                // Decode URL
+                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
+                const description = util.decodeString(uint8Array.slice(offset + 1, fzero), encoding);
+                offset = fzero + (encoding === 'utf16le' ? 2 : 1);
+                output = { description, url: util.decodeString(uint8Array.slice(offset, length), defaultEnc) };
                 break;
             }
             case 'WFD':
-            case 'WFED': {
-                const encoding = TextEncodingToken.get(uint8Array, 0);
-                uint8Array = uint8Array.subarray(1);
-                output = FrameParser.readNullTerminatedString(uint8Array, encoding).text;
+            case 'WFED':
+                output = util.decodeString(uint8Array.slice(offset + 1, util.findZero(uint8Array, offset + 1, length, encoding)), encoding);
                 break;
-            }
             case 'MCDI': {
                 // Music CD identifier
-                output = uint8Array.subarray(0, length);
-                break;
-            }
-            // ID3v2 Chapters 1.0
-            // https://mutagen-specs.readthedocs.io/en/latest/id3/id3v2-chapters-1.0.html#chapter-frame
-            case 'CHAP': { //  // Chapter frame
-                debug("Reading CHAP");
-                fzero = util.findZero(uint8Array, defaultEnc);
-                const chapter = {
-                    label: util.decodeString(uint8Array.subarray(0, fzero), defaultEnc),
-                    info: ChapterInfo.get(uint8Array, fzero + 1),
-                    frames: new Map()
-                };
-                offset += fzero + 1 + ChapterInfo.len;
-                while (offset < length) {
-                    const subFrame = readFrameHeader(uint8Array.subarray(offset), this.major, this.warningCollector);
-                    const headerSize = getFrameHeaderLength(this.major);
-                    offset += headerSize;
-                    const subOutput = this.readData(uint8Array.subarray(offset, offset + subFrame.length), subFrame.id, includeCovers);
-                    offset += subFrame.length;
-                    chapter.frames.set(subFrame.id, subOutput);
-                }
-                output = chapter;
-                break;
-            }
-            // ID3v2 Chapters 1.0
-            // https://mutagen-specs.readthedocs.io/en/latest/id3/id3v2-chapters-1.0.html#table-of-contents-frame
-            case 'CTOC': { // Table of contents frame
-                debug('Reading CTOC');
-                // Element ID (null-terminated latin1)
-                const idEnd = util.findZero(uint8Array, defaultEnc);
-                const label = util.decodeString(uint8Array.subarray(0, idEnd), defaultEnc);
-                offset = idEnd + 1;
-                // Flags
-                const flags = uint8Array[offset++];
-                const topLevel = (flags & 0x02) !== 0;
-                const ordered = (flags & 0x01) !== 0;
-                // Child element IDs
-                const entryCount = uint8Array[offset++];
-                const childElementIds = [];
-                for (let i = 0; i < entryCount && offset < length; i++) {
-                    const end = util.findZero(uint8Array.subarray(offset), defaultEnc);
-                    const childId = util.decodeString(uint8Array.subarray(offset, offset + end), defaultEnc);
-                    childElementIds.push(childId);
-                    offset += end + 1;
-                }
-                const toc = {
-                    label,
-                    flags: { topLevel, ordered },
-                    childElementIds,
-                    frames: new Map()
-                };
-                // Optional embedded sub-frames (e.g. TIT2) follow after the child list
-                while (offset < length) {
-                    const subFrame = readFrameHeader(uint8Array.subarray(offset), this.major, this.warningCollector);
-                    const headerSize = getFrameHeaderLength(this.major);
-                    offset += headerSize;
-                    const subOutput = this.readData(uint8Array.subarray(offset, offset + subFrame.length), subFrame.id, includeCovers);
-                    offset += subFrame.length;
-                    toc.frames.set(subFrame.id, subOutput);
-                }
-                output = toc;
+                output = uint8Array.slice(0, length);
                 break;
             }
             default:
-                debug(`Warning: unsupported id3v2-tag-type: ${type}`);
+                debug('Warning: unsupported id3v2-tag-type: ' + type);
                 break;
         }
         return output;
     }
-    static readNullTerminatedString(uint8Array, encoding) {
-        const bomSize = encoding.bom ? 2 : 0;
-        const originalLen = uint8Array.length;
-        const valueArray = uint8Array.subarray(bomSize);
-        const zeroIndex = util.findZero(valueArray, encoding.encoding);
-        if (zeroIndex >= valueArray.length) {
-            // No terminator found, decode full buffer remainder
-            return {
-                text: util.decodeString(valueArray, encoding.encoding),
-                len: originalLen
-            };
-        }
-        const txt = valueArray.subarray(0, zeroIndex);
-        return {
-            text: util.decodeString(txt, encoding.encoding),
-            len: bomSize + zeroIndex + FrameParser.getNullTerminatorLength(encoding.encoding)
-        };
-    }
     static fixPictureMimeType(pictureType) {
         pictureType = pictureType.toLocaleLowerCase();
         switch (pictureType) {
@@ -418,7 +286,7 @@ export class FrameParser {
         const res = {};
         for (let i = 0; i + 1 < entries.length; i += 2) {
             const names = entries[i + 1].split(',');
-            res[entries[i]] = res[entries[i]] ? res[entries[i]].concat(names) : names;
+            res[entries[i]] = res.hasOwnProperty(entries[i]) ? res[entries[i]].concat(names) : names;
         }
         return res;
     }
@@ -446,25 +314,16 @@ export class FrameParser {
         return FrameParser.trimArray(values);
     }
     static trimArray(values) {
-        return values.map(value => FrameParser.trimNullPadding(value).trim());
+        return values.map(value => value.replace(/\x00+$/, '').trim());
     }
-    static trimNullPadding(value) {
-        let end = value.length;
-        while (end > 0 && value.charCodeAt(end - 1) === 0) {
-            end--;
-        }
-        return end === value.length ? value : value.slice(0, end);
-    }
-    static readIdentifierAndData(uint8Array, encoding) {
-        const idStr = FrameParser.readNullTerminatedString(uint8Array, { encoding, bom: false });
-        return { id: idStr.text, data: uint8Array.subarray(idStr.len) };
+    static readIdentifierAndData(uint8Array, offset, length, encoding) {
+        const fzero = util.findZero(uint8Array, offset, length, encoding);
+        const id = util.decodeString(uint8Array.slice(offset, fzero), encoding);
+        offset = fzero + FrameParser.getNullTerminatorLength(encoding);
+        return { id, data: uint8Array.slice(offset, length) };
     }
     static getNullTerminatorLength(enc) {
-        return enc.startsWith('utf-16') ? 2 : 1;
+        return enc === 'utf16le' ? 2 : 1;
     }
 }
-export class Id3v2ContentError extends makeUnexpectedFileContentError('id3v2') {
-}
-function makeUnexpectedMajorVersionError(majorVer) {
-    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
-}
+exports.FrameParser = FrameParser;

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

@@ -1,5 +1,5 @@
-import type { INativeTagMap } from '../common/GenericTagTypes.js';
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+import { INativeTagMap } from '../common/GenericTagTypes';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap';
 /**
  * ID3v2.2 tag mappings
  */

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

@@ -1,8 +1,11 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ID3v22TagMapper = exports.id3v22TagMap = void 0;
+const CaseInsensitiveTagMap_1 = require("../common/CaseInsensitiveTagMap");
 /**
  * ID3v2.2 tag mappings
  */
-export const id3v22TagMap = {
+exports.id3v22TagMap = {
     TT2: 'title',
     TP1: 'artist',
     TP2: 'albumartist',
@@ -27,6 +30,12 @@ export const id3v22TagMap = {
     TEN: 'encodedby',
     TSS: 'encodersettings',
     WAR: 'website',
+    'COM:iTunPGAP': 'gapless'
+    /* ToDo: iTunes tags:
+    'COM:iTunNORM': ,
+    'COM:iTunSMPB': 'encoder delay',
+    'COM:iTunes_CDDB_IDs'
+    */ ,
     PCS: 'podcast',
     TCP: "compilation",
     TDR: 'date',
@@ -36,11 +45,12 @@ export const id3v22TagMap = {
     TSP: 'artistsort',
     TST: 'titlesort',
     WFD: 'podcasturl',
-    TBP: 'bpm',
-    GP1: 'grouping'
+    TBP: 'bpm'
 };
-export class ID3v22TagMapper extends CaseInsensitiveTagMap {
+class ID3v22TagMapper extends CaseInsensitiveTagMap_1.CaseInsensitiveTagMap {
     constructor() {
-        super(['ID3v2.2'], id3v22TagMap);
+        super(['ID3v2.2'], exports.id3v22TagMap);
     }
 }
+exports.ID3v22TagMapper = ID3v22TagMapper;
+//# sourceMappingURL=ID3v22TagMapper.js.map

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

@@ -1,14 +1,14 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
-import type { IRating, ITag } from '../type.js';
-import type { IPopularimeter } from './FrameParser.js';
+import { INativeMetadataCollector } from '../common/MetadataCollector';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap';
+import { IRating, ITag } from '../type';
 export declare class ID3v24TagMapper extends CaseInsensitiveTagMap {
-    static toRating(popm: IPopularimeter): IRating;
+    static toRating(popm: any): IRating;
     constructor();
     /**
      * Handle post mapping exceptions / correction
      * @param tag to post map
      * @param warnings Wil be used to register (collect) warnings
+     * @return Common value e.g. "Buena Vista Social Club"
      */
     protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
 }