@dragon708/docmind-markdown 1.2.5 → 1.2.7

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

@@ -1,50 +1,51 @@
+"use strict";
 // ASF Objects
-import * as Token from 'token-types';
-import * as util from '../common/Util.js';
-import AsfGuid from './AsfGuid.js';
-import { getParserForAttr, parseUnicodeAttr } from './AsfUtil.js';
-import { AttachedPictureType } from '../id3v2/ID3v2Token.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
-export class AsfContentParseError extends makeUnexpectedFileContentError('ASF') {
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WmPictureToken = exports.MetadataLibraryObjectState = exports.MetadataObjectState = exports.ExtendedStreamPropertiesObjectState = exports.ExtendedContentDescriptionObjectState = exports.ContentDescriptionObjectState = exports.readCodecEntries = exports.HeaderExtensionObject = exports.StreamPropertiesObject = exports.FilePropertiesObject = exports.IgnoreObjectState = exports.State = exports.HeaderObjectToken = exports.TopLevelHeaderObjectToken = exports.DataType = void 0;
+const util = require("../common/Util");
+const Token = require("token-types");
+const GUID_1 = require("./GUID");
+const AsfUtil_1 = require("./AsfUtil");
+const ID3v2Token_1 = require("../id3v2/ID3v2Token");
 /**
  * Data Type: Specifies the type of information being stored. The following values are recognized.
  */
-export const DataType = {
+var DataType;
+(function (DataType) {
     /**
      * Unicode string. The data consists of a sequence of Unicode characters.
      */
-    UnicodeString: 0,
+    DataType[DataType["UnicodeString"] = 0] = "UnicodeString";
     /**
      * BYTE array. The type of data is implementation-specific.
      */
-    ByteArray: 1,
+    DataType[DataType["ByteArray"] = 1] = "ByteArray";
     /**
      * BOOL. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer. Only 0x0000 or 0x0001 are permitted values.
      */
-    Bool: 2,
+    DataType[DataType["Bool"] = 2] = "Bool";
     /**
      * DWORD. The data is 4 bytes long and should be interpreted as a 32-bit unsigned integer.
      */
-    DWord: 3,
+    DataType[DataType["DWord"] = 3] = "DWord";
     /**
      * QWORD. The data is 8 bytes long and should be interpreted as a 64-bit unsigned integer.
      */
-    QWord: 4,
+    DataType[DataType["QWord"] = 4] = "QWord";
     /**
      * WORD. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer.
      */
-    Word: 5
-};
+    DataType[DataType["Word"] = 5] = "Word";
+})(DataType = exports.DataType || (exports.DataType = {}));
 /**
  * Token for: 3. ASF top-level Header Object
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3
  */
-export const TopLevelHeaderObjectToken = {
+exports.TopLevelHeaderObjectToken = {
     len: 30,
     get: (buf, off) => {
         return {
-            objectId: AsfGuid.fromBin(buf, off),
+            objectId: GUID_1.default.fromBin(new Token.BufferType(16).get(buf, off)),
             objectSize: Number(Token.UINT64_LE.get(buf, off + 16)),
             numberOfHeaderObjects: Token.UINT32_LE.get(buf, off + 24)
             // Reserved: 2 bytes
@@ -55,46 +56,54 @@ export const TopLevelHeaderObjectToken = {
  * Token for: 3.1 Header Object (mandatory, one only)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_1
  */
-export const HeaderObjectToken = {
+exports.HeaderObjectToken = {
     len: 24,
     get: (buf, off) => {
         return {
-            objectId: AsfGuid.fromBin(buf, off),
+            objectId: GUID_1.default.fromBin(new Token.BufferType(16).get(buf, off)),
             objectSize: Number(Token.UINT64_LE.get(buf, off + 16))
         };
     }
 };
-export class State {
+class State {
     constructor(header) {
-        this.len = Number(header.objectSize) - HeaderObjectToken.len;
+        this.len = Number(header.objectSize) - exports.HeaderObjectToken.len;
     }
     postProcessTag(tags, name, valueType, data) {
         if (name === 'WM/Picture') {
             tags.push({ id: name, value: WmPictureToken.fromBuffer(data) });
         }
         else {
-            const parseAttr = getParserForAttr(valueType);
+            const parseAttr = AsfUtil_1.AsfUtil.getParserForAttr(valueType);
             if (!parseAttr) {
-                throw new AsfContentParseError(`unexpected value headerType: ${valueType}`);
+                throw new Error('unexpected value headerType: ' + valueType);
             }
             tags.push({ id: name, value: parseAttr(data) });
         }
     }
 }
+exports.State = State;
 // ToDo: use ignore type
-export class IgnoreObjectState extends State {
-    get(_buf, _off) {
+class IgnoreObjectState extends State {
+    constructor(header) {
+        super(header);
+    }
+    get(buf, off) {
         return null;
     }
 }
+exports.IgnoreObjectState = IgnoreObjectState;
 /**
  * Token for: 3.2: File Properties Object (mandatory, one only)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_2
  */
-export class FilePropertiesObject extends State {
+class FilePropertiesObject extends State {
+    constructor(header) {
+        super(header);
+    }
     get(buf, off) {
         return {
-            fileId: AsfGuid.fromBin(buf, off),
+            fileId: GUID_1.default.fromBin(buf, off),
             fileSize: Token.UINT64_LE.get(buf, off + 16),
             creationDate: Token.UINT64_LE.get(buf, off + 24),
             dataPacketsCount: Token.UINT64_LE.get(buf, off + 32),
@@ -112,39 +121,44 @@ export class FilePropertiesObject extends State {
         };
     }
 }
-FilePropertiesObject.guid = AsfGuid.FilePropertiesObject;
+FilePropertiesObject.guid = GUID_1.default.FilePropertiesObject;
+exports.FilePropertiesObject = FilePropertiesObject;
 /**
  * Token for: 3.3 Stream Properties Object (mandatory, one per stream)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_3
  */
-export class StreamPropertiesObject extends State {
+class StreamPropertiesObject extends State {
+    constructor(header) {
+        super(header);
+    }
     get(buf, off) {
         return {
-            streamType: AsfGuid.decodeMediaType(AsfGuid.fromBin(buf, off)),
-            errorCorrectionType: AsfGuid.fromBin(buf, off + 8)
+            streamType: GUID_1.default.decodeMediaType(GUID_1.default.fromBin(buf, off)),
+            errorCorrectionType: GUID_1.default.fromBin(buf, off + 8)
             // ToDo
         };
     }
 }
-StreamPropertiesObject.guid = AsfGuid.StreamPropertiesObject;
+StreamPropertiesObject.guid = GUID_1.default.StreamPropertiesObject;
+exports.StreamPropertiesObject = StreamPropertiesObject;
 /**
  * 3.4: Header Extension Object (mandatory, one only)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_4
  */
-export class HeaderExtensionObject {
+class HeaderExtensionObject {
     constructor() {
         this.len = 22;
     }
     get(buf, off) {
-        const view = new DataView(buf.buffer, off);
         return {
-            reserved1: AsfGuid.fromBin(buf, off),
-            reserved2: view.getUint16(16, true),
-            extensionDataSize: view.getUint16(18, true)
+            reserved1: GUID_1.default.fromBin(buf, off),
+            reserved2: buf.readUInt16LE(off + 16),
+            extensionDataSize: buf.readUInt32LE(off + 18)
         };
     }
 }
-HeaderExtensionObject.guid = AsfGuid.HeaderExtensionObject;
+HeaderExtensionObject.guid = GUID_1.default.HeaderExtensionObject;
+exports.HeaderExtensionObject = HeaderExtensionObject;
 /**
  * 3.5: The Codec List Object provides user-friendly information about the codecs and formats used to encode the content found in the ASF file.
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_5
@@ -152,21 +166,20 @@ HeaderExtensionObject.guid = AsfGuid.HeaderExtensionObject;
 const CodecListObjectHeader = {
     len: 20,
     get: (buf, off) => {
-        const view = new DataView(buf.buffer, off);
         return {
-            entryCount: view.getUint16(16, true)
+            entryCount: buf.readUInt16LE(off + 16)
         };
     }
 };
 async function readString(tokenizer) {
     const length = await tokenizer.readNumber(Token.UINT16_LE);
-    return (await tokenizer.readToken(new Token.StringType(length * 2, 'utf-16le'))).replace('\0', '');
+    return (await tokenizer.readToken(new Token.StringType(length * 2, 'utf16le'))).replace('\0', '');
 }
 /**
  * 3.5: Read the Codec-List-Object, which provides user-friendly information about the codecs and formats used to encode the content found in the ASF file.
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_5
  */
-export async function readCodecEntries(tokenizer) {
+async function readCodecEntries(tokenizer) {
     const codecHeader = await tokenizer.readToken(CodecListObjectHeader);
     const entries = [];
     for (let i = 0; i < codecHeader.entryCount; ++i) {
@@ -174,9 +187,10 @@ export async function readCodecEntries(tokenizer) {
     }
     return entries;
 }
+exports.readCodecEntries = readCodecEntries;
 async function readInformation(tokenizer) {
     const length = await tokenizer.readNumber(Token.UINT16_LE);
-    const buf = new Uint8Array(length);
+    const buf = Buffer.alloc(length);
     await tokenizer.readBuffer(buf);
     return buf;
 }
@@ -200,122 +214,142 @@ async function readCodecEntry(tokenizer) {
  * 3.10 Content Description Object (optional, one only)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_10
  */
-export class ContentDescriptionObjectState extends State {
+class ContentDescriptionObjectState extends State {
+    constructor(header) {
+        super(header);
+    }
     get(buf, off) {
         const tags = [];
-        const view = new DataView(buf.buffer, off);
-        let pos = 10;
+        let pos = off + 10;
         for (let i = 0; i < ContentDescriptionObjectState.contentDescTags.length; ++i) {
-            const length = view.getUint16(i * 2, true);
+            const length = buf.readUInt16LE(off + i * 2);
             if (length > 0) {
                 const tagName = ContentDescriptionObjectState.contentDescTags[i];
                 const end = pos + length;
-                tags.push({ id: tagName, value: parseUnicodeAttr(buf.subarray(off + pos, off + end)) });
+                tags.push({ id: tagName, value: AsfUtil_1.AsfUtil.parseUnicodeAttr(buf.slice(pos, end)) });
                 pos = end;
             }
         }
         return tags;
     }
 }
-ContentDescriptionObjectState.guid = AsfGuid.ContentDescriptionObject;
+ContentDescriptionObjectState.guid = GUID_1.default.ContentDescriptionObject;
 ContentDescriptionObjectState.contentDescTags = ['Title', 'Author', 'Copyright', 'Description', 'Rating'];
+exports.ContentDescriptionObjectState = ContentDescriptionObjectState;
 /**
  * 3.11 Extended Content Description Object (optional, one only)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_11
  */
-export class ExtendedContentDescriptionObjectState extends State {
+class ExtendedContentDescriptionObjectState extends State {
+    constructor(header) {
+        super(header);
+    }
     get(buf, off) {
         const tags = [];
-        const view = new DataView(buf.buffer, off);
-        const attrCount = view.getUint16(0, true);
-        let pos = 2;
+        const attrCount = buf.readUInt16LE(off);
+        let pos = off + 2;
         for (let i = 0; i < attrCount; i += 1) {
-            const nameLen = view.getUint16(pos, true);
+            const nameLen = buf.readUInt16LE(pos);
             pos += 2;
-            const name = parseUnicodeAttr(buf.subarray(off + pos, off + pos + nameLen));
+            const name = AsfUtil_1.AsfUtil.parseUnicodeAttr(buf.slice(pos, pos + nameLen));
             pos += nameLen;
-            const valueType = view.getUint16(pos, true);
+            const valueType = buf.readUInt16LE(pos);
             pos += 2;
-            const valueLen = view.getUint16(pos, true);
+            const valueLen = buf.readUInt16LE(pos);
             pos += 2;
-            const value = buf.subarray(off + pos, off + pos + valueLen);
+            const value = buf.slice(pos, pos + valueLen);
             pos += valueLen;
             this.postProcessTag(tags, name, valueType, value);
         }
         return tags;
     }
 }
-ExtendedContentDescriptionObjectState.guid = AsfGuid.ExtendedContentDescriptionObject;
+ExtendedContentDescriptionObjectState.guid = GUID_1.default.ExtendedContentDescriptionObject;
+exports.ExtendedContentDescriptionObjectState = ExtendedContentDescriptionObjectState;
 /**
  * 4.1 Extended Stream Properties Object (optional, 1 per media stream)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_1
  */
-export class ExtendedStreamPropertiesObjectState extends State {
+class ExtendedStreamPropertiesObjectState extends State {
+    constructor(header) {
+        super(header);
+    }
     get(buf, off) {
-        const view = new DataView(buf.buffer, off);
         return {
             startTime: Token.UINT64_LE.get(buf, off),
             endTime: Token.UINT64_LE.get(buf, off + 8),
-            dataBitrate: view.getInt32(12, true),
-            bufferSize: view.getInt32(16, true),
-            initialBufferFullness: view.getInt32(20, true),
-            alternateDataBitrate: view.getInt32(24, true),
-            alternateBufferSize: view.getInt32(28, true),
-            alternateInitialBufferFullness: view.getInt32(32, true),
-            maximumObjectSize: view.getInt32(36, true),
+            dataBitrate: buf.readInt32LE(off + 12),
+            bufferSize: buf.readInt32LE(off + 16),
+            initialBufferFullness: buf.readInt32LE(off + 20),
+            alternateDataBitrate: buf.readInt32LE(off + 24),
+            alternateBufferSize: buf.readInt32LE(off + 28),
+            alternateInitialBufferFullness: buf.readInt32LE(off + 32),
+            maximumObjectSize: buf.readInt32LE(off + 36),
             flags: {
                 reliableFlag: util.getBit(buf, off + 40, 0),
                 seekableFlag: util.getBit(buf, off + 40, 1),
                 resendLiveCleanpointsFlag: util.getBit(buf, off + 40, 2)
             },
             // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
-            streamNumber: view.getInt16(42, true),
-            streamLanguageId: view.getInt16(44, true),
-            averageTimePerFrame: view.getInt32(52, true),
-            streamNameCount: view.getInt32(54, true),
-            payloadExtensionSystems: view.getInt32(56, true),
-            streamNames: [], // ToDo
+            streamNumber: buf.readInt16LE(off + 42),
+            streamLanguageId: buf.readInt16LE(off + 44),
+            averageTimePerFrame: buf.readInt32LE(off + 52),
+            streamNameCount: buf.readInt32LE(off + 54),
+            payloadExtensionSystems: buf.readInt32LE(off + 56),
+            streamNames: [],
             streamPropertiesObject: null
         };
     }
 }
-ExtendedStreamPropertiesObjectState.guid = AsfGuid.ExtendedStreamPropertiesObject;
+ExtendedStreamPropertiesObjectState.guid = GUID_1.default.ExtendedStreamPropertiesObject;
+exports.ExtendedStreamPropertiesObjectState = ExtendedStreamPropertiesObjectState;
 /**
  * 4.7  Metadata Object (optional, 0 or 1)
  * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_7
  */
-export class MetadataObjectState extends State {
+class MetadataObjectState extends State {
+    constructor(header) {
+        super(header);
+    }
     get(uint8Array, off) {
         const tags = [];
-        const view = new DataView(uint8Array.buffer, off);
-        const descriptionRecordsCount = view.getUint16(0, true);
-        let pos = 2;
+        const buf = Buffer.from(uint8Array);
+        const descriptionRecordsCount = buf.readUInt16LE(off);
+        let pos = off + 2;
         for (let i = 0; i < descriptionRecordsCount; i += 1) {
             pos += 4;
-            const nameLen = view.getUint16(pos, true);
+            const nameLen = buf.readUInt16LE(pos);
             pos += 2;
-            const dataType = view.getUint16(pos, true);
+            const dataType = buf.readUInt16LE(pos);
             pos += 2;
-            const dataLen = view.getUint32(pos, true);
+            const dataLen = buf.readUInt32LE(pos);
             pos += 4;
-            const name = parseUnicodeAttr(uint8Array.subarray(off + pos, off + pos + nameLen));
+            const name = AsfUtil_1.AsfUtil.parseUnicodeAttr(buf.slice(pos, pos + nameLen));
             pos += nameLen;
-            const data = uint8Array.subarray(off + pos, off + pos + dataLen);
+            const data = buf.slice(pos, pos + dataLen);
             pos += dataLen;
             this.postProcessTag(tags, name, dataType, data);
         }
         return tags;
     }
 }
-MetadataObjectState.guid = AsfGuid.MetadataObject;
+MetadataObjectState.guid = GUID_1.default.MetadataObject;
+exports.MetadataObjectState = MetadataObjectState;
 // 4.8	Metadata Library Object (optional, 0 or 1)
-export class MetadataLibraryObjectState extends MetadataObjectState {
+class MetadataLibraryObjectState extends MetadataObjectState {
+    constructor(header) {
+        super(header);
+    }
 }
-MetadataLibraryObjectState.guid = AsfGuid.MetadataLibraryObject;
+MetadataLibraryObjectState.guid = GUID_1.default.MetadataLibraryObject;
+exports.MetadataLibraryObjectState = MetadataLibraryObjectState;
 /**
  * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd757977(v=vs.85).aspx
  */
-export class WmPictureToken {
+class WmPictureToken {
+    static fromBase64(base64str) {
+        return this.fromBuffer(Buffer.from(base64str, 'base64'));
+    }
     static fromBuffer(buffer) {
         const pic = new WmPictureToken(buffer.length);
         return pic.get(buffer, 0);
@@ -324,20 +358,19 @@ export class WmPictureToken {
         this.len = len;
     }
     get(buffer, offset) {
-        const view = new DataView(buffer.buffer, offset);
-        const typeId = view.getUint8(0);
-        const size = view.getInt32(1, true);
+        const typeId = buffer.readUInt8(offset++);
+        const size = buffer.readInt32LE(offset);
         let index = 5;
-        while (view.getUint16(index) !== 0) {
+        while (buffer.readUInt16BE(index) !== 0) {
             index += 2;
         }
-        const format = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
-        while (view.getUint16(index) !== 0) {
+        const format = buffer.slice(5, index).toString('utf16le');
+        while (buffer.readUInt16BE(index) !== 0) {
             index += 2;
         }
-        const description = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
+        const description = buffer.slice(5, index).toString('utf16le');
         return {
-            type: AttachedPictureType[typeId],
+            type: ID3v2Token_1.AttachedPictureType[typeId],
             format,
             description,
             size,
@@ -345,3 +378,4 @@ export class WmPictureToken {
         };
     }
 }
+exports.WmPictureToken = WmPictureToken;

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

@@ -1,4 +1,4 @@
-import { BasicParser } from '../common/BasicParser.js';
+import { BasicParser } from '../common/BasicParser';
 /**
  * Windows Media Metadata Usage Guidelines
  * - Ref: https://msdn.microsoft.com/en-us/library/ms867702.aspx

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

@@ -1,10 +1,12 @@
-import initDebug from 'debug';
-import { TrackType } from '../type.js';
-import AsfGuid from './AsfGuid.js';
-import * as AsfObject from './AsfObject.js';
-import { BasicParser } from '../common/BasicParser.js';
-import { AsfContentParseError } from './AsfObject.js';
-const debug = initDebug('music-metadata:parser:ASF');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsfParser = void 0;
+const debug_1 = require("debug");
+const type_1 = require("../type");
+const GUID_1 = require("./GUID");
+const AsfObject = require("./AsfObject");
+const BasicParser_1 = require("../common/BasicParser");
+const debug = (0, debug_1.default)('music-metadata:parser:ASF');
 const headerType = 'asf';
 /**
  * Windows Media Metadata Usage Guidelines
@@ -16,13 +18,18 @@ const headerType = 'asf';
  * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
  * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
  */
-export class AsfParser extends BasicParser {
+class AsfParser extends BasicParser_1.BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(AsfObject.TopLevelHeaderObjectToken);
-        if (!header.objectId.equals(AsfGuid.HeaderObject)) {
-            throw new AsfContentParseError(`expected asf header; but was not found; got: ${header.objectId.str}`);
+        if (!header.objectId.equals(GUID_1.default.HeaderObject)) {
+            throw new Error('expected asf header; but was not found; got: ' + header.objectId.str);
+        }
+        try {
+            await this.parseObjectHeader(header.numberOfHeaderObjects);
+        }
+        catch (err) {
+            debug('Error while parsing ASF: %s', err);
         }
-        await this.parseObjectHeader(header.numberOfHeaderObjects);
     }
     async parseObjectHeader(numberOfObjectHeaders) {
         let tags;
@@ -32,98 +39,91 @@ export class AsfParser extends BasicParser {
             // Parse data part of the ASF Object
             debug('header GUID=%s', header.objectId.str);
             switch (header.objectId.str) {
-                case AsfObject.FilePropertiesObject.guid.str: { // 3.2
+                case AsfObject.FilePropertiesObject.guid.str: // 3.2
                     const fpo = await this.tokenizer.readToken(new AsfObject.FilePropertiesObject(header));
                     this.metadata.setFormat('duration', Number(fpo.playDuration / BigInt(1000)) / 10000 - Number(fpo.preroll) / 1000);
                     this.metadata.setFormat('bitrate', fpo.maximumBitrate);
                     break;
-                }
-                case AsfObject.StreamPropertiesObject.guid.str: { // 3.3
+                case AsfObject.StreamPropertiesObject.guid.str: // 3.3
                     const spo = await this.tokenizer.readToken(new AsfObject.StreamPropertiesObject(header));
-                    this.metadata.setFormat('container', `ASF/${spo.streamType}`);
+                    this.metadata.setFormat('container', 'ASF/' + spo.streamType);
                     break;
-                }
-                case AsfObject.HeaderExtensionObject.guid.str: { // 3.4
+                case AsfObject.HeaderExtensionObject.guid.str: // 3.4
                     const extHeader = await this.tokenizer.readToken(new AsfObject.HeaderExtensionObject());
                     await this.parseExtensionObject(extHeader.extensionDataSize);
                     break;
-                }
                 case AsfObject.ContentDescriptionObjectState.guid.str: // 3.10
                     tags = await this.tokenizer.readToken(new AsfObject.ContentDescriptionObjectState(header));
-                    await this.addTags(tags);
+                    this.addTags(tags);
                     break;
                 case AsfObject.ExtendedContentDescriptionObjectState.guid.str: // 3.11
                     tags = await this.tokenizer.readToken(new AsfObject.ExtendedContentDescriptionObjectState(header));
-                    await this.addTags(tags);
+                    this.addTags(tags);
                     break;
-                case AsfGuid.CodecListObject.str: {
+                case GUID_1.default.CodecListObject.str:
                     const codecs = await AsfObject.readCodecEntries(this.tokenizer);
                     codecs.forEach(codec => {
                         this.metadata.addStreamInfo({
-                            type: codec.type.videoCodec ? TrackType.video : TrackType.audio,
+                            type: codec.type.videoCodec ? type_1.TrackType.video : type_1.TrackType.audio,
                             codecName: codec.codecName
                         });
                     });
                     const audioCodecs = codecs.filter(codec => codec.type.audioCodec).map(codec => codec.codecName).join('/');
                     this.metadata.setFormat('codec', audioCodecs);
                     break;
-                }
-                case AsfGuid.StreamBitratePropertiesObject.str:
+                case GUID_1.default.StreamBitratePropertiesObject.str:
                     // ToDo?
                     await this.tokenizer.ignore(header.objectSize - AsfObject.HeaderObjectToken.len);
                     break;
-                case AsfGuid.PaddingObject.str:
+                case GUID_1.default.PaddingObject.str:
                     // ToDo: register bytes pad
                     debug('Padding: %s bytes', header.objectSize - AsfObject.HeaderObjectToken.len);
                     await this.tokenizer.ignore(header.objectSize - AsfObject.HeaderObjectToken.len);
                     break;
                 default:
-                    this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`);
+                    this.metadata.addWarning('Ignore ASF-Object-GUID: ' + header.objectId.str);
                     debug('Ignore ASF-Object-GUID: %s', header.objectId.str);
                     await this.tokenizer.readToken(new AsfObject.IgnoreObjectState(header));
             }
         } while (--numberOfObjectHeaders);
         // done
     }
-    async addTags(tags) {
-        await Promise.all(tags.map(({ id, value }) => this.metadata.addTag(headerType, id, value)));
+    addTags(tags) {
+        tags.forEach(tag => {
+            this.metadata.addTag(headerType, tag.id, tag.value);
+        });
     }
     async parseExtensionObject(extensionSize) {
         do {
             // Parse common header of the ASF Object (3.1)
             const header = await this.tokenizer.readToken(AsfObject.HeaderObjectToken);
             const remaining = header.objectSize - AsfObject.HeaderObjectToken.len;
-            if (remaining < 0) {
-                throw new AsfContentParseError(`Invalid ASF header object size: ${header.objectSize}`);
-            }
             // Parse data part of the ASF Object
             switch (header.objectId.str) {
                 case AsfObject.ExtendedStreamPropertiesObjectState.guid.str: // 4.1
                     // ToDo: extended stream header properties are ignored
                     await this.tokenizer.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
                     break;
-                case AsfObject.MetadataObjectState.guid.str: { // 4.7
+                case AsfObject.MetadataObjectState.guid.str: // 4.7
                     const moTags = await this.tokenizer.readToken(new AsfObject.MetadataObjectState(header));
-                    await this.addTags(moTags);
+                    this.addTags(moTags);
                     break;
-                }
-                case AsfObject.MetadataLibraryObjectState.guid.str: { // 4.8
+                case AsfObject.MetadataLibraryObjectState.guid.str: // 4.8
                     const mlTags = await this.tokenizer.readToken(new AsfObject.MetadataLibraryObjectState(header));
-                    await this.addTags(mlTags);
+                    this.addTags(mlTags);
                     break;
-                }
-                case AsfGuid.PaddingObject.str:
+                case GUID_1.default.PaddingObject.str:
                     // ToDo: register bytes pad
                     await this.tokenizer.ignore(remaining);
                     break;
-                case AsfGuid.CompatibilityObject.str:
-                    await this.tokenizer.ignore(remaining);
+                case GUID_1.default.CompatibilityObject.str:
+                    this.tokenizer.ignore(remaining);
                     break;
-                case AsfGuid.ASF_Index_Placeholder_Object.str:
+                case GUID_1.default.ASF_Index_Placeholder_Object.str:
                     await this.tokenizer.ignore(remaining);
                     break;
                 default:
-                    this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`);
+                    this.metadata.addWarning('Ignore ASF-Object-GUID: ' + header.objectId.str);
                     // console.log("Ignore ASF-Object-GUID: %s", header.objectId.str);
                     await this.tokenizer.readToken(new AsfObject.IgnoreObjectState(header));
                     break;
@@ -132,3 +132,4 @@ export class AsfParser extends BasicParser {
         } while (extensionSize > 0);
     }
 }
+exports.AsfParser = AsfParser;

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

@@ -1,5 +1,5 @@
-import { CommonTagMapper } from '../common/GenericTagMapper.js';
-import type { IRating, ITag } from '../type.js';
+import { CommonTagMapper } from '../common/GenericTagMapper';
+import { IRating, ITag } from '../type';
 export declare class AsfTagMapper extends CommonTagMapper {
     static toRating(rating: string): IRating;
     constructor();