@dragon708/docmind-markdown 1.2.5 → 1.2.6

package/node_modules/music-metadata/lib/asf/AsfTagMapper.js

@@ -1,4 +1,7 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsfTagMapper = void 0;
+const GenericTagMapper_1 = require("../common/GenericTagMapper");
 /**
  * ASF Metadata tag mappings.
  * See http://msdn.microsoft.com/en-us/library/ms867702.aspx
@@ -8,7 +11,7 @@ const asfTagMap = {
     Author: 'artist',
     'WM/AlbumArtist': 'albumartist',
     'WM/AlbumTitle': 'album',
-    'WM/Year': 'date', // changed to 'year' to 'date' based on Picard mappings; ToDo: check me
+    'WM/Year': 'date',
     'WM/OriginalReleaseTime': 'originaldate',
     'WM/OriginalReleaseYear': 'originalyear',
     Description: 'comment',
@@ -70,10 +73,10 @@ const asfTagMap = {
     'WM/AuthorURL': 'website',
     'WM/Picture': 'picture'
 };
-export class AsfTagMapper extends CommonTagMapper {
+class AsfTagMapper extends GenericTagMapper_1.CommonTagMapper {
     static toRating(rating) {
         return {
-            rating: Number.parseFloat(rating + 1) / 5
+            rating: parseFloat(rating + 1) / 5
         };
     }
     constructor() {
@@ -81,12 +84,13 @@ export class AsfTagMapper extends CommonTagMapper {
     }
     postMap(tag) {
         switch (tag.id) {
-            case 'WM/SharedUserRating': {
+            case 'WM/SharedUserRating':
                 const keys = tag.id.split(':');
                 tag.value = AsfTagMapper.toRating(tag.value);
                 tag.id = keys[0];
                 break;
-            }
         }
     }
 }
+exports.AsfTagMapper = AsfTagMapper;
+//# sourceMappingURL=AsfTagMapper.js.map

package/node_modules/music-metadata/lib/asf/AsfUtil.d.ts

@@ -1,4 +1,13 @@
-import type { DataType } from './AsfObject.js';
-export type AttributeParser = (buf: Uint8Array) => boolean | string | number | bigint | Uint8Array;
-export declare function getParserForAttr(i: DataType): AttributeParser;
-export declare function parseUnicodeAttr(uint8Array: Uint8Array): string;
+/// <reference types="node" />
+import { DataType } from './AsfObject';
+export type AttributeParser = (buf: Buffer) => boolean | string | number | bigint | Buffer;
+export declare class AsfUtil {
+    static getParserForAttr(i: DataType): AttributeParser;
+    static parseUnicodeAttr(uint8Array: Uint8Array): string;
+    private static attributeParsers;
+    private static parseByteArrayAttr;
+    private static parseBoolAttr;
+    private static parseDWordAttr;
+    private static parseQWordAttr;
+    private static parseWordAttr;
+}

package/node_modules/music-metadata/lib/asf/AsfUtil.js

@@ -1,32 +1,38 @@
-import * as Token from 'token-types';
-import * as util from '../common/Util.js';
-export function getParserForAttr(i) {
-    return attributeParsers[i];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsfUtil = void 0;
+const Token = require("token-types");
+const util = require("../common/Util");
+class AsfUtil {
+    static getParserForAttr(i) {
+        return AsfUtil.attributeParsers[i];
+    }
+    static parseUnicodeAttr(uint8Array) {
+        return util.stripNulls(util.decodeString(uint8Array, 'utf16le'));
+    }
+    static parseByteArrayAttr(buf) {
+        return Buffer.from(buf);
+    }
+    static parseBoolAttr(buf, offset = 0) {
+        return AsfUtil.parseWordAttr(buf, offset) === 1;
+    }
+    static parseDWordAttr(buf, offset = 0) {
+        return buf.readUInt32LE(offset);
+    }
+    static parseQWordAttr(buf, offset = 0) {
+        return Token.UINT64_LE.get(buf, offset);
+    }
+    static parseWordAttr(buf, offset = 0) {
+        return buf.readUInt16LE(offset);
+    }
 }
-export function parseUnicodeAttr(uint8Array) {
-    return util.stripNulls(util.decodeString(uint8Array, 'utf-16le'));
-}
-const attributeParsers = [
-    parseUnicodeAttr,
-    parseByteArrayAttr,
-    parseBoolAttr,
-    parseDWordAttr,
-    parseQWordAttr,
-    parseWordAttr,
-    parseByteArrayAttr
+AsfUtil.attributeParsers = [
+    AsfUtil.parseUnicodeAttr,
+    AsfUtil.parseByteArrayAttr,
+    AsfUtil.parseBoolAttr,
+    AsfUtil.parseDWordAttr,
+    AsfUtil.parseQWordAttr,
+    AsfUtil.parseWordAttr,
+    AsfUtil.parseByteArrayAttr
 ];
-function parseByteArrayAttr(buf) {
-    return new Uint8Array(buf);
-}
-function parseBoolAttr(buf, offset = 0) {
-    return parseWordAttr(buf, offset) === 1;
-}
-function parseDWordAttr(buf, offset = 0) {
-    return Token.UINT32_LE.get(buf, offset);
-}
-function parseQWordAttr(buf, offset = 0) {
-    return Token.UINT64_LE.get(buf, offset);
-}
-function parseWordAttr(buf, offset = 0) {
-    return Token.UINT16_LE.get(buf, offset);
-}
+exports.AsfUtil = AsfUtil;

package/node_modules/music-metadata/lib/asf/GUID.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+/**
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ *
+ * ASF File Structure:
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ *
+ * ASF GUIDs:
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
+ */
+export default class GUID {
+    str: string;
+    static HeaderObject: GUID;
+    static DataObject: GUID;
+    static SimpleIndexObject: GUID;
+    static IndexObject: GUID;
+    static MediaObjectIndexObject: GUID;
+    static TimecodeIndexObject: GUID;
+    static FilePropertiesObject: GUID;
+    static StreamPropertiesObject: GUID;
+    static HeaderExtensionObject: GUID;
+    static CodecListObject: GUID;
+    static ScriptCommandObject: GUID;
+    static MarkerObject: GUID;
+    static BitrateMutualExclusionObject: GUID;
+    static ErrorCorrectionObject: GUID;
+    static ContentDescriptionObject: GUID;
+    static ExtendedContentDescriptionObject: GUID;
+    static ContentBrandingObject: GUID;
+    static StreamBitratePropertiesObject: GUID;
+    static ContentEncryptionObject: GUID;
+    static ExtendedContentEncryptionObject: GUID;
+    static DigitalSignatureObject: GUID;
+    static PaddingObject: GUID;
+    static ExtendedStreamPropertiesObject: GUID;
+    static AdvancedMutualExclusionObject: GUID;
+    static GroupMutualExclusionObject: GUID;
+    static StreamPrioritizationObject: GUID;
+    static BandwidthSharingObject: GUID;
+    static LanguageListObject: GUID;
+    static MetadataObject: GUID;
+    static MetadataLibraryObject: GUID;
+    static IndexParametersObject: GUID;
+    static MediaObjectIndexParametersObject: GUID;
+    static TimecodeIndexParametersObject: GUID;
+    static CompatibilityObject: GUID;
+    static AdvancedContentEncryptionObject: GUID;
+    static AudioMedia: GUID;
+    static VideoMedia: GUID;
+    static CommandMedia: GUID;
+    static JFIF_Media: GUID;
+    static Degradable_JPEG_Media: GUID;
+    static FileTransferMedia: GUID;
+    static BinaryMedia: GUID;
+    static ASF_Index_Placeholder_Object: GUID;
+    static fromBin(bin: Buffer, offset?: number): GUID;
+    /**
+     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @param objectId Binary GUID
+     * @param offset Read offset in bytes, default 0
+     * @returns GUID as dashed hexadecimal representation
+     */
+    static decode(objectId: Buffer, offset?: number): string;
+    /**
+     * Decode stream type
+     * @param mediaType Media type GUID
+     * @returns Media type
+     */
+    static decodeMediaType(mediaType: GUID): 'audio' | 'video' | 'command' | 'degradable-jpeg' | 'file-transfer' | 'binary' | undefined;
+    /**
+     * Encode GUID
+     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @returns Encoded Binary GUID
+     */
+    static encode(str: string): Buffer;
+    constructor(str: string);
+    equals(guid: GUID): boolean;
+    toBin(): Buffer;
+}

package/node_modules/music-metadata/lib/asf/GUID.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ *
+ * ASF File Structure:
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ *
+ * ASF GUIDs:
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
+ * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
+ */
+class GUID {
+    static fromBin(bin, offset = 0) {
+        return new GUID(this.decode(bin, offset));
+    }
+    /**
+     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @param objectId Binary GUID
+     * @param offset Read offset in bytes, default 0
+     * @returns GUID as dashed hexadecimal representation
+     */
+    static decode(objectId, offset = 0) {
+        const guid = objectId.readUInt32LE(offset).toString(16) + "-" +
+            objectId.readUInt16LE(offset + 4).toString(16) + "-" +
+            objectId.readUInt16LE(offset + 6).toString(16) + "-" +
+            objectId.readUInt16BE(offset + 8).toString(16) + "-" +
+            objectId.slice(offset + 10, offset + 16).toString('hex');
+        return guid.toUpperCase();
+    }
+    /**
+     * Decode stream type
+     * @param mediaType Media type GUID
+     * @returns Media type
+     */
+    static decodeMediaType(mediaType) {
+        switch (mediaType.str) {
+            case GUID.AudioMedia.str: return 'audio';
+            case GUID.VideoMedia.str: return 'video';
+            case GUID.CommandMedia.str: return 'command';
+            case GUID.Degradable_JPEG_Media.str: return 'degradable-jpeg';
+            case GUID.FileTransferMedia.str: return 'file-transfer';
+            case GUID.BinaryMedia.str: return 'binary';
+        }
+    }
+    /**
+     * Encode GUID
+     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+     * @returns Encoded Binary GUID
+     */
+    static encode(str) {
+        const bin = Buffer.alloc(16);
+        bin.writeUInt32LE(parseInt(str.slice(0, 8), 16), 0);
+        bin.writeUInt16LE(parseInt(str.slice(9, 13), 16), 4);
+        bin.writeUInt16LE(parseInt(str.slice(14, 18), 16), 6);
+        Buffer.from(str.slice(19, 23), "hex").copy(bin, 8);
+        Buffer.from(str.slice(24), "hex").copy(bin, 10);
+        return bin;
+    }
+    constructor(str) {
+        this.str = str;
+    }
+    equals(guid) {
+        return this.str === guid.str;
+    }
+    toBin() {
+        return GUID.encode(this.str);
+    }
+}
+// 10.1 Top-level ASF object GUIDs
+GUID.HeaderObject = new GUID("75B22630-668E-11CF-A6D9-00AA0062CE6C");
+GUID.DataObject = new GUID("75B22636-668E-11CF-A6D9-00AA0062CE6C");
+GUID.SimpleIndexObject = new GUID("33000890-E5B1-11CF-89F4-00A0C90349CB");
+GUID.IndexObject = new GUID("D6E229D3-35DA-11D1-9034-00A0C90349BE");
+GUID.MediaObjectIndexObject = new GUID("FEB103F8-12AD-4C64-840F-2A1D2F7AD48C");
+GUID.TimecodeIndexObject = new GUID("3CB73FD0-0C4A-4803-953D-EDF7B6228F0C");
+// 10.2 Header Object GUIDs
+GUID.FilePropertiesObject = new GUID("8CABDCA1-A947-11CF-8EE4-00C00C205365");
+GUID.StreamPropertiesObject = new GUID("B7DC0791-A9B7-11CF-8EE6-00C00C205365");
+GUID.HeaderExtensionObject = new GUID("5FBF03B5-A92E-11CF-8EE3-00C00C205365");
+GUID.CodecListObject = new GUID("86D15240-311D-11D0-A3A4-00A0C90348F6");
+GUID.ScriptCommandObject = new GUID("1EFB1A30-0B62-11D0-A39B-00A0C90348F6");
+GUID.MarkerObject = new GUID("F487CD01-A951-11CF-8EE6-00C00C205365");
+GUID.BitrateMutualExclusionObject = new GUID("D6E229DC-35DA-11D1-9034-00A0C90349BE");
+GUID.ErrorCorrectionObject = new GUID("75B22635-668E-11CF-A6D9-00AA0062CE6C");
+GUID.ContentDescriptionObject = new GUID("75B22633-668E-11CF-A6D9-00AA0062CE6C");
+GUID.ExtendedContentDescriptionObject = new GUID("D2D0A440-E307-11D2-97F0-00A0C95EA850");
+GUID.ContentBrandingObject = new GUID("2211B3FA-BD23-11D2-B4B7-00A0C955FC6E");
+GUID.StreamBitratePropertiesObject = new GUID("7BF875CE-468D-11D1-8D82-006097C9A2B2");
+GUID.ContentEncryptionObject = new GUID("2211B3FB-BD23-11D2-B4B7-00A0C955FC6E");
+GUID.ExtendedContentEncryptionObject = new GUID("298AE614-2622-4C17-B935-DAE07EE9289C");
+GUID.DigitalSignatureObject = new GUID("2211B3FC-BD23-11D2-B4B7-00A0C955FC6E");
+GUID.PaddingObject = new GUID("1806D474-CADF-4509-A4BA-9AABCB96AAE8");
+// 10.3 Header Extension Object GUIDs
+GUID.ExtendedStreamPropertiesObject = new GUID("14E6A5CB-C672-4332-8399-A96952065B5A");
+GUID.AdvancedMutualExclusionObject = new GUID("A08649CF-4775-4670-8A16-6E35357566CD");
+GUID.GroupMutualExclusionObject = new GUID("D1465A40-5A79-4338-B71B-E36B8FD6C249");
+GUID.StreamPrioritizationObject = new GUID("D4FED15B-88D3-454F-81F0-ED5C45999E24");
+GUID.BandwidthSharingObject = new GUID("A69609E6-517B-11D2-B6AF-00C04FD908E9");
+GUID.LanguageListObject = new GUID("7C4346A9-EFE0-4BFC-B229-393EDE415C85");
+GUID.MetadataObject = new GUID("C5F8CBEA-5BAF-4877-8467-AA8C44FA4CCA");
+GUID.MetadataLibraryObject = new GUID("44231C94-9498-49D1-A141-1D134E457054");
+GUID.IndexParametersObject = new GUID("D6E229DF-35DA-11D1-9034-00A0C90349BE");
+GUID.MediaObjectIndexParametersObject = new GUID("6B203BAD-3F11-48E4-ACA8-D7613DE2CFA7");
+GUID.TimecodeIndexParametersObject = new GUID("F55E496D-9797-4B5D-8C8B-604DFE9BFB24");
+GUID.CompatibilityObject = new GUID("26F18B5D-4584-47EC-9F5F-0E651F0452C9");
+GUID.AdvancedContentEncryptionObject = new GUID("43058533-6981-49E6-9B74-AD12CB86D58C");
+// 10.4 Stream Properties Object Stream Type GUIDs
+GUID.AudioMedia = new GUID("F8699E40-5B4D-11CF-A8FD-00805F5C442B");
+GUID.VideoMedia = new GUID("BC19EFC0-5B4D-11CF-A8FD-00805F5C442B");
+GUID.CommandMedia = new GUID("59DACFC0-59E6-11D0-A3AC-00A0C90348F6");
+GUID.JFIF_Media = new GUID("B61BE100-5B4E-11CF-A8FD-00805F5C442B");
+GUID.Degradable_JPEG_Media = new GUID("35907DE0-E415-11CF-A917-00805F5C442B");
+GUID.FileTransferMedia = new GUID("91BD222C-F21C-497A-8B6D-5AA86BFC0185");
+GUID.BinaryMedia = new GUID("3AFB65E2-47EF-40F2-AC2C-70A90D71D343");
+GUID.ASF_Index_Placeholder_Object = new GUID("D9AADE20-7C17-4F9C-BC28-8555DD98E2A2");
+exports.default = GUID;

package/node_modules/music-metadata/lib/common/BasicParser.d.ts

@@ -1,17 +1,17 @@
-import type { ITokenizer } from 'strtok3';
-import type { ITokenParser } from '../ParserFactory.js';
-import type { IOptions } from '../type.js';
-import type { INativeMetadataCollector } from './MetadataCollector.js';
+import { ITokenizer } from 'strtok3/lib/core';
+import { ITokenParser } from '../ParserFactory';
+import { IOptions, IPrivateOptions } from '../type';
+import { INativeMetadataCollector } from './MetadataCollector';
 export declare abstract class BasicParser implements ITokenParser {
-    protected readonly metadata: INativeMetadataCollector;
-    protected readonly tokenizer: ITokenizer;
-    protected readonly options: IOptions;
+    protected metadata: INativeMetadataCollector;
+    protected tokenizer: ITokenizer;
+    protected options: IPrivateOptions;
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
      * @param {INativeMetadataCollector} metadata Output
      * @param {ITokenizer} tokenizer Input
      * @param {IOptions} options Parsing options
      */
-    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions);
-    abstract parse(): Promise<void>;
+    init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;
+    abstract parse(): any;
 }

package/node_modules/music-metadata/lib/common/BasicParser.js

@@ -1,13 +1,18 @@
-export class BasicParser {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicParser = void 0;
+class BasicParser {
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
      * @param {INativeMetadataCollector} metadata Output
      * @param {ITokenizer} tokenizer Input
      * @param {IOptions} options Parsing options
      */
-    constructor(metadata, tokenizer, options) {
+    init(metadata, tokenizer, options) {
         this.metadata = metadata;
         this.tokenizer = tokenizer;
         this.options = options;
+        return this;
     }
 }
+exports.BasicParser = BasicParser;

package/node_modules/music-metadata/lib/common/CaseInsensitiveTagMap.d.ts

@@ -1,10 +1,10 @@
-import type { INativeTagMap, TagType } from './GenericTagTypes.js';
-import { CommonTagMapper } from './GenericTagMapper.js';
+import { INativeTagMap, TagType } from './GenericTagTypes';
+import { CommonTagMapper } from './GenericTagMapper';
 export declare class CaseInsensitiveTagMap extends CommonTagMapper {
     constructor(tagTypes: TagType[], tagMap: INativeTagMap);
     /**
      * @tag  Native header tag
      * @return common tag name (alias)
      */
-    protected getCommonName(tag: string): import("./GenericTagTypes.js").GenericTagId;
+    protected getCommonName(tag: string): import("./GenericTagTypes").GenericTagId;
 }

package/node_modules/music-metadata/lib/common/CaseInsensitiveTagMap.js

@@ -1,5 +1,8 @@
-import { CommonTagMapper } from './GenericTagMapper.js';
-export class CaseInsensitiveTagMap extends CommonTagMapper {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseInsensitiveTagMap = void 0;
+const GenericTagMapper_1 = require("./GenericTagMapper");
+class CaseInsensitiveTagMap extends GenericTagMapper_1.CommonTagMapper {
     constructor(tagTypes, tagMap) {
         const upperCaseMap = {};
         for (const tag of Object.keys(tagMap)) {
@@ -15,3 +18,5 @@ export class CaseInsensitiveTagMap extends CommonTagMapper {
         return this.tagMap[tag.toUpperCase()];
     }
 }
+exports.CaseInsensitiveTagMap = CaseInsensitiveTagMap;
+//# sourceMappingURL=CaseInsensitiveTagMap.js.map

package/node_modules/music-metadata/lib/common/CombinedTagMapper.d.ts

@@ -1,7 +1,7 @@
-import type { IGenericTag, TagType } from './GenericTagTypes.js';
-import type { IGenericTagMapper } from './GenericTagMapper.js';
-import type { ITag } from '../type.js';
-import type { INativeMetadataCollector } from './MetadataCollector.js';
+import { IGenericTag, TagType } from './GenericTagTypes';
+import { IGenericTagMapper } from './GenericTagMapper';
+import { ITag } from '../type';
+import { INativeMetadataCollector } from './MetadataCollector';
 export declare class CombinedTagMapper {
     tagMappers: {
         [index: string]: IGenericTagMapper;
@@ -14,6 +14,6 @@ export declare class CombinedTagMapper {
      * @param warnings
      * @return Generic tag result (output of this function)
      */
-    mapTag(tagType: TagType, tag: ITag, warnings: INativeMetadataCollector): IGenericTag | null;
+    mapTag(tagType: TagType, tag: ITag, warnings: INativeMetadataCollector): IGenericTag;
     private registerTagMapper;
 }

package/node_modules/music-metadata/lib/common/CombinedTagMapper.js

@@ -1,29 +1,31 @@
-import { ID3v1TagMapper } from '../id3v1/ID3v1TagMap.js';
-import { ID3v24TagMapper } from '../id3v2/ID3v24TagMapper.js';
-import { AsfTagMapper } from '../asf/AsfTagMapper.js';
-import { ID3v22TagMapper } from '../id3v2/ID3v22TagMapper.js';
-import { APEv2TagMapper } from '../apev2/APEv2TagMapper.js';
-import { MP4TagMapper } from '../mp4/MP4TagMapper.js';
-import { VorbisTagMapper } from '../ogg/vorbis/VorbisTagMapper.js';
-import { RiffInfoTagMapper } from '../riff/RiffInfoTagMap.js';
-import { MatroskaTagMapper } from '../matroska/MatroskaTagMapper.js';
-import { AiffTagMapper } from '../aiff/AiffTagMap.js';
-import { InternalParserError } from '../ParseError.js';
-export class CombinedTagMapper {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CombinedTagMapper = void 0;
+const ID3v1TagMap_1 = require("../id3v1/ID3v1TagMap");
+const ID3v24TagMapper_1 = require("../id3v2/ID3v24TagMapper");
+const AsfTagMapper_1 = require("../asf/AsfTagMapper");
+const ID3v22TagMapper_1 = require("../id3v2/ID3v22TagMapper");
+const APEv2TagMapper_1 = require("../apev2/APEv2TagMapper");
+const MP4TagMapper_1 = require("../mp4/MP4TagMapper");
+const VorbisTagMapper_1 = require("../ogg/vorbis/VorbisTagMapper");
+const RiffInfoTagMap_1 = require("../riff/RiffInfoTagMap");
+const MatroskaTagMapper_1 = require("../matroska/MatroskaTagMapper");
+const AiffTagMap_1 = require("../aiff/AiffTagMap");
+class CombinedTagMapper {
     constructor() {
         this.tagMappers = {};
         [
-            new ID3v1TagMapper(),
-            new ID3v22TagMapper(),
-            new ID3v24TagMapper(),
-            new MP4TagMapper(),
-            new MP4TagMapper(),
-            new VorbisTagMapper(),
-            new APEv2TagMapper(),
-            new AsfTagMapper(),
-            new RiffInfoTagMapper(),
-            new MatroskaTagMapper(),
-            new AiffTagMapper()
+            new ID3v1TagMap_1.ID3v1TagMapper(),
+            new ID3v22TagMapper_1.ID3v22TagMapper(),
+            new ID3v24TagMapper_1.ID3v24TagMapper(),
+            new MP4TagMapper_1.MP4TagMapper(),
+            new MP4TagMapper_1.MP4TagMapper(),
+            new VorbisTagMapper_1.VorbisTagMapper(),
+            new APEv2TagMapper_1.APEv2TagMapper(),
+            new AsfTagMapper_1.AsfTagMapper(),
+            new RiffInfoTagMap_1.RiffInfoTagMapper(),
+            new MatroskaTagMapper_1.MatroskaTagMapper(),
+            new AiffTagMap_1.AiffTagMapper()
         ].forEach(mapper => {
             this.registerTagMapper(mapper);
         });
@@ -40,7 +42,7 @@ export class CombinedTagMapper {
         if (tagMapper) {
             return this.tagMappers[tagType].mapGenericTag(tag, warnings);
         }
-        throw new InternalParserError(`No generic tag mapper defined for tag-format: ${tagType}`);
+        throw new Error('No generic tag mapper defined for tag-format: ' + tagType);
     }
     registerTagMapper(genericTagMapper) {
         for (const tagType of genericTagMapper.tagTypes) {
@@ -48,3 +50,5 @@ export class CombinedTagMapper {
         }
     }
 }
+exports.CombinedTagMapper = CombinedTagMapper;
+//# sourceMappingURL=CombinedTagMapper.js.map

package/node_modules/music-metadata/lib/common/FourCC.d.ts

@@ -1,4 +1,4 @@
-import type { IToken } from 'strtok3';
+import { IToken } from 'strtok3/lib/core';
 /**
  * Token for read FourCC
  * Ref: https://en.wikipedia.org/wiki/FourCC

package/node_modules/music-metadata/lib/common/FourCC.js

@@ -1,25 +1,26 @@
-import { textDecode, textEncode } from '@borewit/text-codec';
-import * as util from './Util.js';
-import { InternalParserError, FieldDecodingError } from '../ParseError.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FourCcToken = void 0;
+const util = require("./Util");
 const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
 /**
  * Token for read FourCC
  * Ref: https://en.wikipedia.org/wiki/FourCC
  */
-export const FourCcToken = {
+exports.FourCcToken = {
     len: 4,
     get: (buf, off) => {
-        const id = textDecode(buf.subarray(off, off + FourCcToken.len), 'latin1');
+        const id = buf.toString('binary', off, off + exports.FourCcToken.len);
         if (!id.match(validFourCC)) {
-            throw new FieldDecodingError(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
+            throw new Error(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
         }
         return id;
     },
     put: (buffer, offset, id) => {
-        const str = textEncode(id, 'latin1');
+        const str = Buffer.from(id, 'binary');
         if (str.length !== 4)
-            throw new InternalParserError('Invalid length');
-        buffer.set(str, offset);
-        return offset + 4;
+            throw new Error('Invalid length');
+        return str.copy(buffer, offset);
     }
 };
+//# sourceMappingURL=FourCC.js.map

package/node_modules/music-metadata/lib/common/GenericTagMapper.d.ts

@@ -1,9 +1,9 @@
-import type * as generic from './GenericTagTypes.js';
-import type { ITag } from '../type.js';
-import type { INativeMetadataCollector, IWarningCollector } from './MetadataCollector.js';
+import * as generic from './GenericTagTypes';
+import { ITag } from '../type';
+import { INativeMetadataCollector, IWarningCollector } from './MetadataCollector';
 export interface IGenericTagMapper {
     /**
-     * Which tagType is able to map to the generic mapping format
+     * Which tagType it able to map to the generic mapping format
      */
     tagTypes: generic.TagType[];
     /**
@@ -16,17 +16,17 @@ export interface IGenericTagMapper {
      * @param warnings  Register warnings
      * @return Generic tag, if native tag could be mapped
      */
-    mapGenericTag(tag: ITag, warnings: INativeMetadataCollector): generic.IGenericTag | null;
+    mapGenericTag(tag: ITag, warnings: INativeMetadataCollector): generic.IGenericTag;
 }
 export declare class CommonTagMapper implements IGenericTagMapper {
+    tagTypes: generic.TagType[];
+    tagMap: generic.INativeTagMap;
     static maxRatingScore: number;
-    static toIntOrNull(str: string): number | null;
+    static toIntOrNull(str: string): number;
     static normalizeTrack(origVal: number | string): {
-        no: number | null;
-        of: number | null;
+        no: number;
+        of: number;
     };
-    tagTypes: generic.TagType[];
-    tagMap: generic.INativeTagMap;
     constructor(tagTypes: generic.TagType[], tagMap: generic.INativeTagMap);
     /**
      * Process and set common tags
@@ -35,10 +35,10 @@ export declare class CommonTagMapper implements IGenericTagMapper {
      * @param warnings Register warnings
      * @return common name
      */
-    mapGenericTag(tag: ITag, warnings: IWarningCollector): generic.IGenericTag | null;
+    mapGenericTag(tag: ITag, warnings: IWarningCollector): generic.IGenericTag;
     /**
      * Convert native tag key to common tag key
-     * @param tag Native header tag
+     * @tag  Native header tag
      * @return common tag name (alias)
      */
     protected getCommonName(tag: string): generic.GenericTagId;
@@ -47,5 +47,5 @@ export declare class CommonTagMapper implements IGenericTagMapper {
      * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
      * @param warnings Used to register warnings
      */
-    protected postMap(_tag: ITag, _warnings: IWarningCollector): void;
+    protected postMap(tag: ITag, warnings: IWarningCollector): void;
 }