@dragon708/docmind-markdown 1.2.5 → 1.2.7

package/node_modules/music-metadata/lib/ParserFactory.d.ts

@@ -1,20 +1,14 @@
-import { type MediaType } from 'media-typer';
-import { type INativeMetadataCollector } from './common/MetadataCollector.js';
-import { type IAudioMetadata, type IOptions, type ParserType } from './type.js';
-import type { ITokenizer } from 'strtok3';
-export interface IParserLoader {
-    /**
-     * Returns a list of supported file extensions
-     */
-    extensions: string[];
-    mimeTypes: string[];
-    parserType: ParserType;
+import { IOptions, IAudioMetadata, ParserType } from './type';
+import { ITokenizer } from 'strtok3/lib/core';
+import { INativeMetadataCollector } from './common/MetadataCollector';
+export interface ITokenParser {
     /**
-     * Lazy load the parser implementation class.
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param metadata - Output
+     * @param tokenizer - Input
+     * @param options - Parsing options
      */
-    load(): Promise<new (metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions) => ITokenParser>;
-}
-export interface ITokenParser {
+    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
     /**
      * Parse audio track.
      * Called after init(...).
@@ -22,23 +16,33 @@ export interface ITokenParser {
      */
     parse(): Promise<void>;
 }
-interface IContentType extends MediaType {
+export declare function parseHttpContentType(contentType: string): {
+    type: string;
+    subtype: string;
+    suffix?: string;
     parameters: {
         [id: string]: string;
     };
-}
-export declare function parseHttpContentType(contentType: string): IContentType;
+};
 export declare class ParserFactory {
-    parsers: IParserLoader[];
-    constructor();
-    registerParser(parser: IParserLoader): void;
-    parse(tokenizer: ITokenizer, parserLoader: IParserLoader | undefined, opts?: IOptions): Promise<IAudioMetadata>;
+    /**
+     * Parse metadata from tokenizer
+     * @param tokenizer - Tokenizer
+     * @param opts - Options
+     * @returns Native metadata
+     */
+    static parseOnContentType(tokenizer: ITokenizer, opts: IOptions): Promise<IAudioMetadata>;
+    static parse(tokenizer: ITokenizer, parserId: ParserType, opts: IOptions): Promise<IAudioMetadata>;
     /**
      * @param filePath - Path, filename or extension to audio file
-     * @return Parser submodule name
+     * @return Parser sub-module name
+     */
+    static getParserIdForExtension(filePath: string): ParserType;
+    static loadParser(moduleName: ParserType): Promise<ITokenParser>;
+    private static getExtension;
+    /**
+     * @param httpContentType - HTTP Content-Type, extension, path or filename
+     * @returns Parser sub-module name
      */
-    findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined;
-    findLoaderForContentType(httpContentType: string): IParserLoader | undefined;
-    getSupportedMimeTypes(): string[];
+    private static getParserIdForMimeType;
 }
-export {};

package/node_modules/music-metadata/lib/ParserFactory.js

@@ -1,28 +1,28 @@
-import { fileTypeFromBuffer } from 'file-type';
-import ContentType from 'content-type';
-import { parse as mimeTypeParse } from 'media-typer';
-import initDebug from 'debug';
-import { MetadataCollector } from './common/MetadataCollector.js';
-import { TrackType } from './type.js';
-import { mpegParserLoader } from './mpeg/MpegLoader.js';
-import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
-import { apeParserLoader } from './apev2/Apev2Loader.js';
-import { asfParserLoader } from './asf/AsfLoader.js';
-import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
-import { aiffParserLoader } from './aiff/AiffLoader.js';
-import { dsfParserLoader } from './dsf/DsfLoader.js';
-import { flacParserLoader } from './flac/FlacLoader.js';
-import { matroskaParserLoader } from './matroska/MatroskaLoader.js';
-import { mp4ParserLoader } from './mp4/Mp4Loader.js';
-import { musepackParserLoader } from './musepack/MusepackLoader.js';
-import { oggParserLoader } from './ogg/OggLoader.js';
-import { wavpackParserLoader } from './wavpack/WavPackLoader.js';
-import { riffParserLoader } from './wav/WaveLoader.js';
-import { scanAppendingHeaders } from './core.js';
-const debug = initDebug('music-metadata:parser:factory');
-export function parseHttpContentType(contentType) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserFactory = exports.parseHttpContentType = void 0;
+const FileType = require("file-type/core");
+const ContentType = require("content-type");
+const MimeType = require("media-typer");
+const debug_1 = require("debug");
+const MetadataCollector_1 = require("./common/MetadataCollector");
+const AiffParser_1 = require("./aiff/AiffParser");
+const APEv2Parser_1 = require("./apev2/APEv2Parser");
+const AsfParser_1 = require("./asf/AsfParser");
+const FlacParser_1 = require("./flac/FlacParser");
+const MP4Parser_1 = require("./mp4/MP4Parser");
+const MpegParser_1 = require("./mpeg/MpegParser");
+const musepack_1 = require("./musepack");
+const OggParser_1 = require("./ogg/OggParser");
+const WaveParser_1 = require("./wav/WaveParser");
+const WavPackParser_1 = require("./wavpack/WavPackParser");
+const DsfParser_1 = require("./dsf/DsfParser");
+const DsdiffParser_1 = require("./dsdiff/DsdiffParser");
+const MatroskaParser_1 = require("./matroska/MatroskaParser");
+const debug = (0, debug_1.default)('music-metadata:parser:factory');
+function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
-    const mime = mimeTypeParse(type.type);
+    const mime = MimeType.parse(type.type);
     return {
         type: mime.type,
         subtype: mime.subtype,
@@ -30,112 +30,223 @@ export function parseHttpContentType(contentType) {
         parameters: type.parameters
     };
 }
-export class ParserFactory {
-    constructor() {
-        this.parsers = [];
-        [
-            flacParserLoader,
-            mpegParserLoader,
-            apeParserLoader,
-            mp4ParserLoader,
-            matroskaParserLoader,
-            riffParserLoader,
-            oggParserLoader,
-            asfParserLoader,
-            aiffParserLoader,
-            wavpackParserLoader,
-            musepackParserLoader,
-            dsfParserLoader,
-            dsdiffParserLoader
-        ].forEach(parser => { this.registerParser(parser); });
-    }
-    registerParser(parser) {
-        this.parsers.push(parser);
-    }
-    async parse(tokenizer, parserLoader, opts) {
-        if (tokenizer.supportsRandomAccess()) {
-            debug('tokenizer supports random-access, scanning for appending headers');
-            await scanAppendingHeaders(tokenizer, opts);
-        }
-        else {
-            debug('tokenizer does not support random-access, cannot scan for appending headers');
+exports.parseHttpContentType = parseHttpContentType;
+async function parse(tokenizer, parserId, opts = {}) {
+    // Parser found, execute parser
+    const parser = await ParserFactory.loadParser(parserId);
+    const metadata = new MetadataCollector_1.MetadataCollector(opts);
+    await parser.init(metadata, tokenizer, opts).parse();
+    return metadata.toCommonMetadata();
+}
+class ParserFactory {
+    /**
+     * Parse metadata from tokenizer
+     * @param tokenizer - Tokenizer
+     * @param opts - Options
+     * @returns Native metadata
+     */
+    static async parseOnContentType(tokenizer, opts) {
+        const { mimeType, path, url } = await tokenizer.fileInfo;
+        // Resolve parser based on MIME-type or file extension
+        const parserId = ParserFactory.getParserIdForMimeType(mimeType) || ParserFactory.getParserIdForExtension(path) || ParserFactory.getParserIdForExtension(url);
+        if (!parserId) {
+            debug('No parser found for MIME-type / extension: ' + mimeType);
         }
-        if (!parserLoader) {
-            const buf = new Uint8Array(4100);
-            if (tokenizer.fileInfo.mimeType) {
-                parserLoader = this.findLoaderForContentType(tokenizer.fileInfo.mimeType);
-            }
-            if (!parserLoader && tokenizer.fileInfo.path) {
-                parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);
+        return this.parse(tokenizer, parserId, opts);
+    }
+    static async parse(tokenizer, parserId, opts) {
+        if (!parserId) {
+            // Parser could not be determined on MIME-type or extension
+            debug('Guess parser on content...');
+            const buf = Buffer.alloc(4100);
+            await tokenizer.peekBuffer(buf, { mayBeLess: true });
+            if (tokenizer.fileInfo.path) {
+                parserId = this.getParserIdForExtension(tokenizer.fileInfo.path);
             }
-            if (!parserLoader) {
-                // Parser could not be determined on MIME-type or extension
-                debug('Guess parser on content...');
-                await tokenizer.peekBuffer(buf, { mayBeLess: true });
-                const guessedType = await fileTypeFromBuffer(buf, { mpegOffsetTolerance: 10 });
-                if (!guessedType || !guessedType.mime) {
-                    throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
+            if (!parserId) {
+                const guessedType = await FileType.fromBuffer(buf);
+                if (!guessedType) {
+                    throw new Error('Failed to determine audio format');
                 }
                 debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
-                parserLoader = this.findLoaderForContentType(guessedType.mime);
-                if (!parserLoader) {
-                    throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
+                parserId = ParserFactory.getParserIdForMimeType(guessedType.mime);
+                if (!parserId) {
+                    throw new Error('Guessed MIME-type not supported: ' + guessedType.mime);
                 }
             }
         }
         // Parser found, execute parser
-        debug(`Loading ${parserLoader.parserType} parser...`);
-        const metadata = new MetadataCollector(opts);
-        const ParserImpl = await parserLoader.load();
-        const parser = new ParserImpl(metadata, tokenizer, opts ?? {});
-        debug(`Parser ${parserLoader.parserType} loaded`);
-        await parser.parse();
-        if (metadata.format.trackInfo) {
-            if (metadata.format.hasAudio === undefined) {
-                metadata.setFormat('hasAudio', !!metadata.format.trackInfo.find(track => track.type === TrackType.audio));
-            }
-            if (metadata.format.hasVideo === undefined) {
-                metadata.setFormat('hasVideo', !!metadata.format.trackInfo.find(track => track.type === TrackType.video));
-            }
-        }
-        return metadata.toCommonMetadata();
+        return parse(tokenizer, parserId, opts);
     }
     /**
      * @param filePath - Path, filename or extension to audio file
-     * @return Parser submodule name
+     * @return Parser sub-module name
      */
-    findLoaderForExtension(filePath) {
+    static getParserIdForExtension(filePath) {
         if (!filePath)
             return;
-        const extension = getExtension(filePath).toLocaleLowerCase() || filePath;
-        return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);
+        const extension = this.getExtension(filePath).toLocaleLowerCase() || filePath;
+        switch (extension) {
+            case '.mp2':
+            case '.mp3':
+            case '.m2a':
+            case '.aac': // Assume it is ADTS-container
+                return 'mpeg';
+            case '.ape':
+                return 'apev2';
+            case '.mp4':
+            case '.m4a':
+            case '.m4b':
+            case '.m4pa':
+            case '.m4v':
+            case '.m4r':
+            case '.3gp':
+                return 'mp4';
+            case '.wma':
+            case '.wmv':
+            case '.asf':
+                return 'asf';
+            case '.flac':
+                return 'flac';
+            case '.ogg':
+            case '.ogv':
+            case '.oga':
+            case '.ogm':
+            case '.ogx':
+            case '.opus': // recommended filename extension for Ogg Opus
+            case '.spx': // recommended filename extension for Ogg Speex
+                return 'ogg';
+            case '.aif':
+            case '.aiff':
+            case '.aifc':
+                return 'aiff';
+            case '.wav':
+            case '.bwf': // Broadcast Wave Format
+                return 'riff';
+            case '.wv':
+            case '.wvp':
+                return 'wavpack';
+            case '.mpc':
+                return 'musepack';
+            case '.dsf':
+                return 'dsf';
+            case '.dff':
+                return 'dsdiff';
+            case '.mka':
+            case '.mkv':
+            case '.mk3d':
+            case '.mks':
+            case '.webm':
+                return 'matroska';
+        }
     }
-    findLoaderForContentType(httpContentType) {
+    static async loadParser(moduleName) {
+        switch (moduleName) {
+            case 'aiff': return new AiffParser_1.AIFFParser();
+            case 'adts':
+            case 'mpeg':
+                return new MpegParser_1.MpegParser();
+            case 'apev2': return new APEv2Parser_1.APEv2Parser();
+            case 'asf': return new AsfParser_1.AsfParser();
+            case 'dsf': return new DsfParser_1.DsfParser();
+            case 'dsdiff': return new DsdiffParser_1.DsdiffParser();
+            case 'flac': return new FlacParser_1.FlacParser();
+            case 'mp4': return new MP4Parser_1.MP4Parser();
+            case 'musepack': return new musepack_1.default();
+            case 'ogg': return new OggParser_1.OggParser();
+            case 'riff': return new WaveParser_1.WaveParser();
+            case 'wavpack': return new WavPackParser_1.WavPackParser();
+            case 'matroska': return new MatroskaParser_1.MatroskaParser();
+            default:
+                throw new Error(`Unknown parser type: ${moduleName}`);
+        }
+    }
+    static getExtension(fname) {
+        const i = fname.lastIndexOf('.');
+        return i === -1 ? '' : fname.slice(i);
+    }
+    /**
+     * @param httpContentType - HTTP Content-Type, extension, path or filename
+     * @returns Parser sub-module name
+     */
+    static getParserIdForMimeType(httpContentType) {
         let mime;
-        if (!httpContentType)
-            return;
         try {
             mime = parseHttpContentType(httpContentType);
         }
-        catch (_err) {
+        catch (err) {
             debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
             return;
         }
         const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;
-        return this.parsers.find(parser => parser.mimeTypes.find(loader => loader.indexOf(`${mime.type}/${subType}`) !== -1));
-    }
-    getSupportedMimeTypes() {
-        const mimeTypeSet = new Set();
-        this.parsers.forEach(loader => {
-            loader.mimeTypes.forEach(mimeType => {
-                mimeTypeSet.add(mimeType);
-                mimeTypeSet.add(mimeType.replace('/', '/x-'));
-            });
-        });
-        return Array.from(mimeTypeSet);
+        switch (mime.type) {
+            case 'audio':
+                switch (subType) {
+                    case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object
+                    case 'mpeg':
+                        return 'mpeg';
+                    case 'aac':
+                    case 'aacp':
+                        return 'adts';
+                    case 'flac':
+                        return 'flac';
+                    case 'ape':
+                    case 'monkeys-audio':
+                        return 'apev2';
+                    case 'mp4':
+                    case 'm4a':
+                        return 'mp4';
+                    case 'ogg': // RFC 7845
+                    case 'opus': // RFC 6716
+                    case 'speex': // RFC 5574
+                        return 'ogg';
+                    case 'ms-wma':
+                    case 'ms-wmv':
+                    case 'ms-asf':
+                        return 'asf';
+                    case 'aiff':
+                    case 'aif':
+                    case 'aifc':
+                        return 'aiff';
+                    case 'vnd.wave':
+                    case 'wav':
+                    case 'wave':
+                        return 'riff';
+                    case 'wavpack':
+                        return 'wavpack';
+                    case 'musepack':
+                        return 'musepack';
+                    case 'matroska':
+                    case 'webm':
+                        return 'matroska';
+                    case 'dsf':
+                        return 'dsf';
+                }
+                break;
+            case 'video':
+                switch (subType) {
+                    case 'ms-asf':
+                    case 'ms-wmv':
+                        return 'asf';
+                    case 'm4v':
+                    case 'mp4':
+                        return 'mp4';
+                    case 'ogg':
+                        return 'ogg';
+                    case 'matroska':
+                    case 'webm':
+                        return 'matroska';
+                }
+                break;
+            case 'application':
+                switch (subType) {
+                    case 'vnd.ms-asf':
+                        return 'asf';
+                    case 'ogg':
+                        return 'ogg';
+                }
+                break;
+        }
     }
 }
-function getExtension(fname) {
-    const i = fname.lastIndexOf('.');
-    return i === -1 ? '' : fname.substring(i);
-}
+exports.ParserFactory = ParserFactory;

package/node_modules/music-metadata/lib/aiff/AiffParser.d.ts

@@ -1,5 +1,5 @@
-import { BasicParser } from '../common/BasicParser.js';
-import * as iff from '../iff/index.js';
+import { BasicParser } from '../common/BasicParser';
+import * as iff from '../iff';
 /**
  * AIFF - Audio Interchange File Format
  *

package/node_modules/music-metadata/lib/aiff/AiffParser.js

@@ -1,13 +1,26 @@
-import * as Token from 'token-types';
-import initDebug from 'debug';
-import * as strtok3 from 'strtok3';
-import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { FourCcToken } from '../common/FourCC.js';
-import { BasicParser } from '../common/BasicParser.js';
-import * as AiffToken from './AiffToken.js';
-import { AiffContentError, compressionTypes } from './AiffToken.js';
-import * as iff from '../iff/index.js';
-const debug = initDebug('music-metadata:parser:aiff');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIFFParser = void 0;
+const Token = require("token-types");
+const debug_1 = require("debug");
+const strtok3 = require("strtok3/lib/core");
+const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
+const FourCC_1 = require("../common/FourCC");
+const BasicParser_1 = require("../common/BasicParser");
+const AiffToken = require("./AiffToken");
+const iff = require("../iff");
+const debug = (0, debug_1.default)('music-metadata:parser:aiff');
+const compressionTypes = {
+    NONE: 'not compressed	PCM	Apple Computer',
+    sowt: 'PCM (byte swapped)',
+    fl32: '32-bit floating point IEEE 32-bit float',
+    fl64: '64-bit floating point IEEE 64-bit float	Apple Computer',
+    alaw: 'ALaw 2:1	8-bit ITU-T G.711 A-law',
+    ulaw: 'µLaw 2:1	8-bit ITU-T G.711 µ-law	Apple Computer',
+    ULAW: 'CCITT G.711 u-law 8-bit ITU-T G.711 µ-law',
+    ALAW: 'CCITT G.711 A-law 8-bit ITU-T G.711 A-law',
+    FL32: 'Float 32	IEEE 32-bit float '
+};
 /**
  * AIFF - Audio Interchange File Format
  *
@@ -15,16 +28,12 @@ const debug = initDebug('music-metadata:parser:aiff');
  * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
  * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
  */
-export class AIFFParser extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.isCompressed = null;
-    }
+class AIFFParser extends BasicParser_1.BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(iff.Header);
         if (header.chunkID !== 'FORM')
-            throw new AiffContentError('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
-        const type = await this.tokenizer.readToken(FourCcToken);
+            throw new Error('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
+        const type = await this.tokenizer.readToken(FourCC_1.FourCcToken);
         switch (type) {
             case 'AIFF':
                 this.metadata.setFormat('container', type);
@@ -35,13 +44,12 @@ export class AIFFParser extends BasicParser {
                 this.isCompressed = true;
                 break;
             default:
-                throw new AiffContentError(`Unsupported AIFF type: ${type}`);
+                throw Error('Unsupported AIFF type: ' + type);
         }
         this.metadata.setFormat('lossless', !this.isCompressed);
-        this.metadata.setAudioOnly();
         try {
             while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
-                debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
+                debug('Reading AIFF chunk at offset=' + this.tokenizer.position);
                 const chunkHeader = await this.tokenizer.readToken(iff.Header);
                 const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
                 const bytesRead = await this.readData(chunkHeader);
@@ -50,7 +58,7 @@ export class AIFFParser extends BasicParser {
         }
         catch (err) {
             if (err instanceof strtok3.EndOfStreamError) {
-                debug("End-of-stream");
+                debug(`End-of-stream`);
             }
             else {
                 throw err;
@@ -58,28 +66,22 @@ export class AIFFParser extends BasicParser {
         }
     }
     async readData(header) {
+        var _a;
         switch (header.chunkID) {
-            case 'COMM': { // The Common Chunk
-                if (this.isCompressed === null) {
-                    throw new AiffContentError('Failed to parse AIFF.COMM chunk when compression type is unknown');
-                }
+            case 'COMM': // The Common Chunk
                 const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
                 this.metadata.setFormat('bitsPerSample', common.sampleSize);
                 this.metadata.setFormat('sampleRate', common.sampleRate);
                 this.metadata.setFormat('numberOfChannels', common.numChannels);
                 this.metadata.setFormat('numberOfSamples', common.numSampleFrames);
                 this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);
-                if (common.compressionName || common.compressionType) {
-                    this.metadata.setFormat('codec', common.compressionName ?? compressionTypes[common.compressionType]);
-                }
+                this.metadata.setFormat('codec', (_a = common.compressionName) !== null && _a !== void 0 ? _a : compressionTypes[common.compressionType]);
                 return header.chunkSize;
-            }
-            case 'ID3 ': { // ID3-meta-data
+            case 'ID3 ': // ID3-meta-data
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(header.chunkSize));
                 const rst = strtok3.fromBuffer(id3_data);
-                await new ID3v2Parser().parse(this.metadata, rst, this.options);
+                await new ID3v2Parser_1.ID3v2Parser().parse(this.metadata, rst, this.options);
                 return header.chunkSize;
-            }
             case 'SSND': // Sound Data Chunk
                 if (this.metadata.format.duration) {
                     this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);
@@ -97,8 +99,10 @@ export class AIFFParser extends BasicParser {
     }
     async readTextChunk(header) {
         const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
-        const values = value.split('\0').map(v => v.trim()).filter(v => v?.length);
-        await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
+        value.split('\0').map(v => v.trim()).filter(v => v && v.length > 0).forEach(v => {
+            this.metadata.addTag('AIFF', header.chunkID, v.trim());
+        });
         return header.chunkSize;
     }
 }
+exports.AIFFParser = AIFFParser;

package/node_modules/music-metadata/lib/aiff/AiffTagMap.d.ts

@@ -1,4 +1,4 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+import { CommonTagMapper } from '../common/GenericTagMapper';
 export declare class AiffTagMapper extends CommonTagMapper {
     constructor();
 }

package/node_modules/music-metadata/lib/aiff/AiffTagMap.js

@@ -1,4 +1,7 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiffTagMapper = void 0;
+const GenericTagMapper_1 = require("../common/GenericTagMapper");
 /**
  * ID3v1 tag mappings
  */
@@ -8,8 +11,10 @@ const tagMap = {
     '(c) ': 'copyright',
     ANNO: 'comment'
 };
-export class AiffTagMapper extends CommonTagMapper {
+class AiffTagMapper extends GenericTagMapper_1.CommonTagMapper {
     constructor() {
         super(['AIFF'], tagMap);
     }
 }
+exports.AiffTagMapper = AiffTagMapper;
+//# sourceMappingURL=AiffTagMap.js.map