@agentdocumentformat/cli 0.7.2

package/dist/chunks/AsfParser-VVRSLFOM.mjs

@@ -0,0 +1,538 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import "./chunk-2DIECGFL.mjs";
+import {
+  TrackType
+} from "./chunk-EWL5FG4I.mjs";
+import {
+  AttachedPictureType
+} from "./chunk-DXWDD5XJ.mjs";
+import {
+  decodeString,
+  getBit,
+  stripNulls
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  BasicParser,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  UINT64_LE,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/asf/AsfParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/win-guid/lib/guid.js
+function parseWindowsGuid(guid) {
+  let s = guid.trim();
+  if (s.length !== 36 || s[8] !== "-" || s[13] !== "-" || s[18] !== "-" || s[23] !== "-")
+    throw new Error(`Invalid GUID format: ${guid}`);
+  let v, out = new Uint8Array(16);
+  v = parseInt(s.slice(0, 8), 16), out[0] = v & 255, out[1] = v >>> 8 & 255, out[2] = v >>> 16 & 255, out[3] = v >>> 24 & 255, v = parseInt(s.slice(9, 13), 16), out[4] = v & 255, out[5] = v >>> 8 & 255, v = parseInt(s.slice(14, 18), 16), out[6] = v & 255, out[7] = v >>> 8 & 255, v = parseInt(s.slice(19, 23), 16), out[8] = v >>> 8 & 255, out[9] = v & 255, v = parseInt(s.slice(24, 32), 16), out[10] = v >>> 24 & 255, out[11] = v >>> 16 & 255, out[12] = v >>> 8 & 255, out[13] = v & 255, v = parseInt(s.slice(32, 36), 16), out[14] = v >>> 8 & 255, out[15] = v & 255;
+  for (let i = 0; i < 16; i++)
+    if (!Number.isFinite(out[i]))
+      throw new Error(`Invalid GUID format: ${guid}`);
+  if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s))
+    throw new Error(`Invalid GUID format: ${guid}`);
+  return out;
+}
+var Guid = class _Guid {
+  constructor(bytes) {
+    if (bytes.length !== 16)
+      throw new Error("GUID must be exactly 16 bytes");
+    this.bytes = bytes;
+  }
+  static fromString(guid) {
+    return new _Guid(parseWindowsGuid(guid));
+  }
+  /**
+   * Convert Windows / CFBF byte order into canonical GUID string:
+   * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+   */
+  toString() {
+    let b = this.bytes, hx = (n) => n.toString(16).padStart(2, "0"), g1 = hx(b[3]) + hx(b[2]) + hx(b[1]) + hx(b[0]), g2 = hx(b[5]) + hx(b[4]), g3 = hx(b[7]) + hx(b[6]), g4 = hx(b[8]) + hx(b[9]), g5 = hx(b[10]) + hx(b[11]) + hx(b[12]) + hx(b[13]) + hx(b[14]) + hx(b[15]);
+    return `${g1}-${g2}-${g3}-${g4}-${g5}`.toUpperCase();
+  }
+  /**
+   * Compare against a Uint8Array containing GUID bytes
+   * in Windows / CFBF layout.
+   */
+  equals(buf, offset = 0) {
+    if (offset < 0 || buf.length - offset < 16)
+      return !1;
+    let a = this.bytes;
+    for (let i = 0; i < 16; i++)
+      if (buf[offset + i] !== a[i])
+        return !1;
+    return !0;
+  }
+};
+
+// node_modules/music-metadata/lib/asf/AsfGuid.js
+var AsfGuid = class _AsfGuid {
+  static fromBin(bin, offset = 0) {
+    return new _AsfGuid(_AsfGuid.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) {
+    return new Guid(objectId.subarray(offset, offset + 16)).toString();
+  }
+  /**
+   * Decode stream type
+   * @param mediaType Media type GUID
+   * @returns Media type
+   */
+  static decodeMediaType(mediaType) {
+    switch (mediaType.str) {
+      case _AsfGuid.AudioMedia.str:
+        return "audio";
+      case _AsfGuid.VideoMedia.str:
+        return "video";
+      case _AsfGuid.CommandMedia.str:
+        return "command";
+      case _AsfGuid.Degradable_JPEG_Media.str:
+        return "degradable-jpeg";
+      case _AsfGuid.FileTransferMedia.str:
+        return "file-transfer";
+      case _AsfGuid.BinaryMedia.str:
+        return "binary";
+    }
+  }
+  /**
+   * Encode GUID
+   * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
+   * @returns Encoded Binary GUID
+   */
+  static encode(guid) {
+    return parseWindowsGuid(guid);
+  }
+  constructor(str) {
+    this.str = str;
+  }
+  equals(guid) {
+    return this.str === guid.str;
+  }
+  toBin() {
+    return _AsfGuid.encode(this.str);
+  }
+};
+AsfGuid.HeaderObject = new AsfGuid("75B22630-668E-11CF-A6D9-00AA0062CE6C");
+AsfGuid.DataObject = new AsfGuid("75B22636-668E-11CF-A6D9-00AA0062CE6C");
+AsfGuid.SimpleIndexObject = new AsfGuid("33000890-E5B1-11CF-89F4-00A0C90349CB");
+AsfGuid.IndexObject = new AsfGuid("D6E229D3-35DA-11D1-9034-00A0C90349BE");
+AsfGuid.MediaObjectIndexObject = new AsfGuid("FEB103F8-12AD-4C64-840F-2A1D2F7AD48C");
+AsfGuid.TimecodeIndexObject = new AsfGuid("3CB73FD0-0C4A-4803-953D-EDF7B6228F0C");
+AsfGuid.FilePropertiesObject = new AsfGuid("8CABDCA1-A947-11CF-8EE4-00C00C205365");
+AsfGuid.StreamPropertiesObject = new AsfGuid("B7DC0791-A9B7-11CF-8EE6-00C00C205365");
+AsfGuid.HeaderExtensionObject = new AsfGuid("5FBF03B5-A92E-11CF-8EE3-00C00C205365");
+AsfGuid.CodecListObject = new AsfGuid("86D15240-311D-11D0-A3A4-00A0C90348F6");
+AsfGuid.ScriptCommandObject = new AsfGuid("1EFB1A30-0B62-11D0-A39B-00A0C90348F6");
+AsfGuid.MarkerObject = new AsfGuid("F487CD01-A951-11CF-8EE6-00C00C205365");
+AsfGuid.BitrateMutualExclusionObject = new AsfGuid("D6E229DC-35DA-11D1-9034-00A0C90349BE");
+AsfGuid.ErrorCorrectionObject = new AsfGuid("75B22635-668E-11CF-A6D9-00AA0062CE6C");
+AsfGuid.ContentDescriptionObject = new AsfGuid("75B22633-668E-11CF-A6D9-00AA0062CE6C");
+AsfGuid.ExtendedContentDescriptionObject = new AsfGuid("D2D0A440-E307-11D2-97F0-00A0C95EA850");
+AsfGuid.ContentBrandingObject = new AsfGuid("2211B3FA-BD23-11D2-B4B7-00A0C955FC6E");
+AsfGuid.StreamBitratePropertiesObject = new AsfGuid("7BF875CE-468D-11D1-8D82-006097C9A2B2");
+AsfGuid.ContentEncryptionObject = new AsfGuid("2211B3FB-BD23-11D2-B4B7-00A0C955FC6E");
+AsfGuid.ExtendedContentEncryptionObject = new AsfGuid("298AE614-2622-4C17-B935-DAE07EE9289C");
+AsfGuid.DigitalSignatureObject = new AsfGuid("2211B3FC-BD23-11D2-B4B7-00A0C955FC6E");
+AsfGuid.PaddingObject = new AsfGuid("1806D474-CADF-4509-A4BA-9AABCB96AAE8");
+AsfGuid.ExtendedStreamPropertiesObject = new AsfGuid("14E6A5CB-C672-4332-8399-A96952065B5A");
+AsfGuid.AdvancedMutualExclusionObject = new AsfGuid("A08649CF-4775-4670-8A16-6E35357566CD");
+AsfGuid.GroupMutualExclusionObject = new AsfGuid("D1465A40-5A79-4338-B71B-E36B8FD6C249");
+AsfGuid.StreamPrioritizationObject = new AsfGuid("D4FED15B-88D3-454F-81F0-ED5C45999E24");
+AsfGuid.BandwidthSharingObject = new AsfGuid("A69609E6-517B-11D2-B6AF-00C04FD908E9");
+AsfGuid.LanguageListObject = new AsfGuid("7C4346A9-EFE0-4BFC-B229-393EDE415C85");
+AsfGuid.MetadataObject = new AsfGuid("C5F8CBEA-5BAF-4877-8467-AA8C44FA4CCA");
+AsfGuid.MetadataLibraryObject = new AsfGuid("44231C94-9498-49D1-A141-1D134E457054");
+AsfGuid.IndexParametersObject = new AsfGuid("D6E229DF-35DA-11D1-9034-00A0C90349BE");
+AsfGuid.MediaObjectIndexParametersObject = new AsfGuid("6B203BAD-3F11-48E4-ACA8-D7613DE2CFA7");
+AsfGuid.TimecodeIndexParametersObject = new AsfGuid("F55E496D-9797-4B5D-8C8B-604DFE9BFB24");
+AsfGuid.CompatibilityObject = new AsfGuid("26F18B5D-4584-47EC-9F5F-0E651F0452C9");
+AsfGuid.AdvancedContentEncryptionObject = new AsfGuid("43058533-6981-49E6-9B74-AD12CB86D58C");
+AsfGuid.AudioMedia = new AsfGuid("F8699E40-5B4D-11CF-A8FD-00805F5C442B");
+AsfGuid.VideoMedia = new AsfGuid("BC19EFC0-5B4D-11CF-A8FD-00805F5C442B");
+AsfGuid.CommandMedia = new AsfGuid("59DACFC0-59E6-11D0-A3AC-00A0C90348F6");
+AsfGuid.JFIF_Media = new AsfGuid("B61BE100-5B4E-11CF-A8FD-00805F5C442B");
+AsfGuid.Degradable_JPEG_Media = new AsfGuid("35907DE0-E415-11CF-A917-00805F5C442B");
+AsfGuid.FileTransferMedia = new AsfGuid("91BD222C-F21C-497A-8B6D-5AA86BFC0185");
+AsfGuid.BinaryMedia = new AsfGuid("3AFB65E2-47EF-40F2-AC2C-70A90D71D343");
+AsfGuid.ASF_Index_Placeholder_Object = new AsfGuid("D9AADE20-7C17-4F9C-BC28-8555DD98E2A2");
+var AsfGuid_default = AsfGuid;
+
+// node_modules/music-metadata/lib/asf/AsfUtil.js
+function getParserForAttr(i) {
+  return attributeParsers[i];
+}
+function parseUnicodeAttr(uint8Array) {
+  return stripNulls(decodeString(uint8Array, "utf-16le"));
+}
+var attributeParsers = [
+  parseUnicodeAttr,
+  parseByteArrayAttr,
+  parseBoolAttr,
+  parseDWordAttr,
+  parseQWordAttr,
+  parseWordAttr,
+  parseByteArrayAttr
+];
+function parseByteArrayAttr(buf) {
+  return new Uint8Array(buf);
+}
+function parseBoolAttr(buf, offset = 0) {
+  return parseWordAttr(buf, offset) === 1;
+}
+function parseDWordAttr(buf, offset = 0) {
+  return UINT32_LE.get(buf, offset);
+}
+function parseQWordAttr(buf, offset = 0) {
+  return UINT64_LE.get(buf, offset);
+}
+function parseWordAttr(buf, offset = 0) {
+  return UINT16_LE.get(buf, offset);
+}
+
+// node_modules/music-metadata/lib/asf/AsfObject.js
+var AsfContentParseError = class extends makeUnexpectedFileContentError("ASF") {
+};
+var TopLevelHeaderObjectToken = {
+  len: 30,
+  get: (buf, off) => ({
+    objectId: AsfGuid_default.fromBin(buf, off),
+    objectSize: Number(UINT64_LE.get(buf, off + 16)),
+    numberOfHeaderObjects: UINT32_LE.get(buf, off + 24)
+    // Reserved: 2 bytes
+  })
+}, HeaderObjectToken = {
+  len: 24,
+  get: (buf, off) => ({
+    objectId: AsfGuid_default.fromBin(buf, off),
+    objectSize: Number(UINT64_LE.get(buf, off + 16))
+  })
+}, State = class {
+  constructor(header) {
+    this.len = Number(header.objectSize) - HeaderObjectToken.len;
+  }
+  postProcessTag(tags, name, valueType, data) {
+    if (name === "WM/Picture")
+      tags.push({ id: name, value: WmPictureToken.fromBuffer(data) });
+    else {
+      let parseAttr = getParserForAttr(valueType);
+      if (!parseAttr)
+        throw new AsfContentParseError(`unexpected value headerType: ${valueType}`);
+      tags.push({ id: name, value: parseAttr(data) });
+    }
+  }
+}, IgnoreObjectState = class extends State {
+  get(_buf, _off) {
+    return null;
+  }
+}, FilePropertiesObject = class extends State {
+  get(buf, off) {
+    return {
+      fileId: AsfGuid_default.fromBin(buf, off),
+      fileSize: UINT64_LE.get(buf, off + 16),
+      creationDate: UINT64_LE.get(buf, off + 24),
+      dataPacketsCount: UINT64_LE.get(buf, off + 32),
+      playDuration: UINT64_LE.get(buf, off + 40),
+      sendDuration: UINT64_LE.get(buf, off + 48),
+      preroll: UINT64_LE.get(buf, off + 56),
+      flags: {
+        broadcast: getBit(buf, off + 64, 24),
+        seekable: getBit(buf, off + 64, 25)
+      },
+      // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
+      minimumDataPacketSize: UINT32_LE.get(buf, off + 68),
+      maximumDataPacketSize: UINT32_LE.get(buf, off + 72),
+      maximumBitrate: UINT32_LE.get(buf, off + 76)
+    };
+  }
+};
+FilePropertiesObject.guid = AsfGuid_default.FilePropertiesObject;
+var StreamPropertiesObject = class extends State {
+  get(buf, off) {
+    return {
+      streamType: AsfGuid_default.decodeMediaType(AsfGuid_default.fromBin(buf, off)),
+      errorCorrectionType: AsfGuid_default.fromBin(buf, off + 8)
+      // ToDo
+    };
+  }
+};
+StreamPropertiesObject.guid = AsfGuid_default.StreamPropertiesObject;
+var HeaderExtensionObject = class {
+  constructor() {
+    this.len = 22;
+  }
+  get(buf, off) {
+    let view = new DataView(buf.buffer, off);
+    return {
+      reserved1: AsfGuid_default.fromBin(buf, off),
+      reserved2: view.getUint16(16, !0),
+      extensionDataSize: view.getUint16(18, !0)
+    };
+  }
+};
+HeaderExtensionObject.guid = AsfGuid_default.HeaderExtensionObject;
+var CodecListObjectHeader = {
+  len: 20,
+  get: (buf, off) => ({
+    entryCount: new DataView(buf.buffer, off).getUint16(16, !0)
+  })
+};
+async function readString(tokenizer) {
+  let length = await tokenizer.readNumber(UINT16_LE);
+  return (await tokenizer.readToken(new StringType(length * 2, "utf-16le"))).replace("\0", "");
+}
+async function readCodecEntries(tokenizer) {
+  let codecHeader = await tokenizer.readToken(CodecListObjectHeader), entries = [];
+  for (let i = 0; i < codecHeader.entryCount; ++i)
+    entries.push(await readCodecEntry(tokenizer));
+  return entries;
+}
+async function readInformation(tokenizer) {
+  let length = await tokenizer.readNumber(UINT16_LE), buf = new Uint8Array(length);
+  return await tokenizer.readBuffer(buf), buf;
+}
+async function readCodecEntry(tokenizer) {
+  let type = await tokenizer.readNumber(UINT16_LE);
+  return {
+    type: {
+      videoCodec: (type & 1) === 1,
+      audioCodec: (type & 2) === 2
+    },
+    codecName: await readString(tokenizer),
+    description: await readString(tokenizer),
+    information: await readInformation(tokenizer)
+  };
+}
+var ContentDescriptionObjectState = class _ContentDescriptionObjectState extends State {
+  get(buf, off) {
+    let tags = [], view = new DataView(buf.buffer, off), pos = 10;
+    for (let i = 0; i < _ContentDescriptionObjectState.contentDescTags.length; ++i) {
+      let length = view.getUint16(i * 2, !0);
+      if (length > 0) {
+        let tagName = _ContentDescriptionObjectState.contentDescTags[i], end = pos + length;
+        tags.push({ id: tagName, value: parseUnicodeAttr(buf.subarray(off + pos, off + end)) }), pos = end;
+      }
+    }
+    return tags;
+  }
+};
+ContentDescriptionObjectState.guid = AsfGuid_default.ContentDescriptionObject;
+ContentDescriptionObjectState.contentDescTags = ["Title", "Author", "Copyright", "Description", "Rating"];
+var ExtendedContentDescriptionObjectState = class extends State {
+  get(buf, off) {
+    let tags = [], view = new DataView(buf.buffer, off), attrCount = view.getUint16(0, !0), pos = 2;
+    for (let i = 0; i < attrCount; i += 1) {
+      let nameLen = view.getUint16(pos, !0);
+      pos += 2;
+      let name = parseUnicodeAttr(buf.subarray(off + pos, off + pos + nameLen));
+      pos += nameLen;
+      let valueType = view.getUint16(pos, !0);
+      pos += 2;
+      let valueLen = view.getUint16(pos, !0);
+      pos += 2;
+      let value = buf.subarray(off + pos, off + pos + valueLen);
+      pos += valueLen, this.postProcessTag(tags, name, valueType, value);
+    }
+    return tags;
+  }
+};
+ExtendedContentDescriptionObjectState.guid = AsfGuid_default.ExtendedContentDescriptionObject;
+var ExtendedStreamPropertiesObjectState = class extends State {
+  get(buf, off) {
+    let view = new DataView(buf.buffer, off);
+    return {
+      startTime: UINT64_LE.get(buf, off),
+      endTime: UINT64_LE.get(buf, off + 8),
+      dataBitrate: view.getInt32(12, !0),
+      bufferSize: view.getInt32(16, !0),
+      initialBufferFullness: view.getInt32(20, !0),
+      alternateDataBitrate: view.getInt32(24, !0),
+      alternateBufferSize: view.getInt32(28, !0),
+      alternateInitialBufferFullness: view.getInt32(32, !0),
+      maximumObjectSize: view.getInt32(36, !0),
+      flags: {
+        reliableFlag: getBit(buf, off + 40, 0),
+        seekableFlag: getBit(buf, off + 40, 1),
+        resendLiveCleanpointsFlag: getBit(buf, off + 40, 2)
+      },
+      // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
+      streamNumber: view.getInt16(42, !0),
+      streamLanguageId: view.getInt16(44, !0),
+      averageTimePerFrame: view.getInt32(52, !0),
+      streamNameCount: view.getInt32(54, !0),
+      payloadExtensionSystems: view.getInt32(56, !0),
+      streamNames: [],
+      // ToDo
+      streamPropertiesObject: null
+    };
+  }
+};
+ExtendedStreamPropertiesObjectState.guid = AsfGuid_default.ExtendedStreamPropertiesObject;
+var MetadataObjectState = class extends State {
+  get(uint8Array, off) {
+    let tags = [], view = new DataView(uint8Array.buffer, off), descriptionRecordsCount = view.getUint16(0, !0), pos = 2;
+    for (let i = 0; i < descriptionRecordsCount; i += 1) {
+      pos += 4;
+      let nameLen = view.getUint16(pos, !0);
+      pos += 2;
+      let dataType = view.getUint16(pos, !0);
+      pos += 2;
+      let dataLen = view.getUint32(pos, !0);
+      pos += 4;
+      let name = parseUnicodeAttr(uint8Array.subarray(off + pos, off + pos + nameLen));
+      pos += nameLen;
+      let data = uint8Array.subarray(off + pos, off + pos + dataLen);
+      pos += dataLen, this.postProcessTag(tags, name, dataType, data);
+    }
+    return tags;
+  }
+};
+MetadataObjectState.guid = AsfGuid_default.MetadataObject;
+var MetadataLibraryObjectState = class extends MetadataObjectState {
+};
+MetadataLibraryObjectState.guid = AsfGuid_default.MetadataLibraryObject;
+var WmPictureToken = class _WmPictureToken {
+  static fromBuffer(buffer) {
+    return new _WmPictureToken(buffer.length).get(buffer, 0);
+  }
+  constructor(len) {
+    this.len = len;
+  }
+  get(buffer, offset) {
+    let view = new DataView(buffer.buffer, offset), typeId = view.getUint8(0), size = view.getInt32(1, !0), index = 5;
+    for (; view.getUint16(index) !== 0; )
+      index += 2;
+    let format = new StringType(index - 5, "utf-16le").get(buffer, 5);
+    for (; view.getUint16(index) !== 0; )
+      index += 2;
+    let description = new StringType(index - 5, "utf-16le").get(buffer, 5);
+    return {
+      type: AttachedPictureType[typeId],
+      format,
+      description,
+      size,
+      data: buffer.slice(index + 4)
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/asf/AsfParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:ASF"), headerType = "asf", AsfParser = class extends BasicParser {
+  async parse() {
+    let header = await this.tokenizer.readToken(TopLevelHeaderObjectToken);
+    if (!header.objectId.equals(AsfGuid_default.HeaderObject))
+      throw new AsfContentParseError(`expected asf header; but was not found; got: ${header.objectId.str}`);
+    await this.parseObjectHeader(header.numberOfHeaderObjects);
+  }
+  async parseObjectHeader(numberOfObjectHeaders) {
+    let tags;
+    do {
+      let header = await this.tokenizer.readToken(HeaderObjectToken);
+      switch (debug("header GUID=%s", header.objectId.str), header.objectId.str) {
+        case FilePropertiesObject.guid.str: {
+          let fpo = await this.tokenizer.readToken(new FilePropertiesObject(header));
+          this.metadata.setFormat("duration", Number(fpo.playDuration / BigInt(1e3)) / 1e4 - Number(fpo.preroll) / 1e3), this.metadata.setFormat("bitrate", fpo.maximumBitrate);
+          break;
+        }
+        case StreamPropertiesObject.guid.str: {
+          let spo = await this.tokenizer.readToken(new StreamPropertiesObject(header));
+          this.metadata.setFormat("container", `ASF/${spo.streamType}`);
+          break;
+        }
+        case HeaderExtensionObject.guid.str: {
+          let extHeader = await this.tokenizer.readToken(new HeaderExtensionObject());
+          await this.parseExtensionObject(extHeader.extensionDataSize);
+          break;
+        }
+        case ContentDescriptionObjectState.guid.str:
+          tags = await this.tokenizer.readToken(new ContentDescriptionObjectState(header)), await this.addTags(tags);
+          break;
+        case ExtendedContentDescriptionObjectState.guid.str:
+          tags = await this.tokenizer.readToken(new ExtendedContentDescriptionObjectState(header)), await this.addTags(tags);
+          break;
+        case AsfGuid_default.CodecListObject.str: {
+          let codecs = await readCodecEntries(this.tokenizer);
+          codecs.forEach((codec) => {
+            this.metadata.addStreamInfo({
+              type: codec.type.videoCodec ? TrackType.video : TrackType.audio,
+              codecName: codec.codecName
+            });
+          });
+          let audioCodecs = codecs.filter((codec) => codec.type.audioCodec).map((codec) => codec.codecName).join("/");
+          this.metadata.setFormat("codec", audioCodecs);
+          break;
+        }
+        case AsfGuid_default.StreamBitratePropertiesObject.str:
+          await this.tokenizer.ignore(header.objectSize - HeaderObjectToken.len);
+          break;
+        case AsfGuid_default.PaddingObject.str:
+          debug("Padding: %s bytes", header.objectSize - HeaderObjectToken.len), await this.tokenizer.ignore(header.objectSize - HeaderObjectToken.len);
+          break;
+        default:
+          this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`), debug("Ignore ASF-Object-GUID: %s", header.objectId.str), await this.tokenizer.readToken(new IgnoreObjectState(header));
+      }
+    } while (--numberOfObjectHeaders);
+  }
+  async addTags(tags) {
+    await Promise.all(tags.map(({ id, value }) => this.metadata.addTag(headerType, id, value)));
+  }
+  async parseExtensionObject(extensionSize) {
+    do {
+      let header = await this.tokenizer.readToken(HeaderObjectToken), remaining = header.objectSize - HeaderObjectToken.len;
+      if (remaining < 0)
+        throw new AsfContentParseError(`Invalid ASF header object size: ${header.objectSize}`);
+      switch (header.objectId.str) {
+        case ExtendedStreamPropertiesObjectState.guid.str:
+          await this.tokenizer.readToken(new ExtendedStreamPropertiesObjectState(header));
+          break;
+        case MetadataObjectState.guid.str: {
+          let moTags = await this.tokenizer.readToken(new MetadataObjectState(header));
+          await this.addTags(moTags);
+          break;
+        }
+        case MetadataLibraryObjectState.guid.str: {
+          let mlTags = await this.tokenizer.readToken(new MetadataLibraryObjectState(header));
+          await this.addTags(mlTags);
+          break;
+        }
+        case AsfGuid_default.PaddingObject.str:
+          await this.tokenizer.ignore(remaining);
+          break;
+        case AsfGuid_default.CompatibilityObject.str:
+          await this.tokenizer.ignore(remaining);
+          break;
+        case AsfGuid_default.ASF_Index_Placeholder_Object.str:
+          await this.tokenizer.ignore(remaining);
+          break;
+        default:
+          this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`), await this.tokenizer.readToken(new IgnoreObjectState(header));
+          break;
+      }
+      extensionSize -= header.objectSize;
+    } while (extensionSize > 0);
+  }
+};
+export {
+  AsfParser
+};

package/dist/chunks/DsdiffParser-CMD4AX7A.mjs

@@ -0,0 +1,156 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  ID3v2Parser
+} from "./chunk-XYTWGHFS.mjs";
+import "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import "./chunk-XX7OSWTO.mjs";
+import {
+  fromBuffer
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  INT64_BE,
+  StringType,
+  UINT16_BE,
+  UINT32_BE,
+  UINT32_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/dsdiff/DsdiffParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/dsdiff/DsdiffToken.js
+var ChunkHeader64 = {
+  len: 12,
+  get: (buf, off) => ({
+    // Group-ID
+    chunkID: FourCcToken.get(buf, off),
+    // Size
+    chunkSize: INT64_BE.get(buf, off + 4)
+  })
+};
+
+// node_modules/music-metadata/lib/dsdiff/DsdiffParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:aiff"), DsdiffContentParseError = class extends makeUnexpectedFileContentError("DSDIFF") {
+}, DsdiffParser = class extends BasicParser {
+  async parse() {
+    let header = await this.tokenizer.readToken(ChunkHeader64);
+    if (header.chunkID !== "FRM8")
+      throw new DsdiffContentParseError("Unexpected chunk-ID");
+    this.metadata.setAudioOnly();
+    let type = (await this.tokenizer.readToken(FourCcToken)).trim();
+    if (type === "DSD")
+      return this.metadata.setFormat("container", `DSDIFF/${type}`), this.metadata.setFormat("lossless", !0), this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
+    throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
+  }
+  async readFmt8Chunks(remainingSize) {
+    for (; remainingSize >= ChunkHeader64.len; ) {
+      let chunkHeader = await this.tokenizer.readToken(ChunkHeader64);
+      debug(`Chunk id=${chunkHeader.chunkID}`), await this.readData(chunkHeader), remainingSize -= BigInt(ChunkHeader64.len) + chunkHeader.chunkSize;
+    }
+  }
+  async readData(header) {
+    debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+    let p0 = this.tokenizer.position;
+    switch (header.chunkID.trim()) {
+      case "FVER": {
+        let version = await this.tokenizer.readToken(UINT32_LE);
+        debug(`DSDIFF version=${version}`);
+        break;
+      }
+      case "PROP": {
+        if (await this.tokenizer.readToken(FourCcToken) !== "SND ")
+          throw new DsdiffContentParseError("Unexpected PROP-chunk ID");
+        await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
+        break;
+      }
+      case "ID3": {
+        let id3_data = await this.tokenizer.readToken(new Uint8ArrayType(Number(header.chunkSize))), rst = fromBuffer(id3_data);
+        await new ID3v2Parser().parse(this.metadata, rst, this.options);
+        break;
+      }
+      case "DSD":
+        this.metadata.format.numberOfChannels && this.metadata.setFormat("numberOfSamples", Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels))), this.metadata.format.numberOfSamples && this.metadata.format.sampleRate && this.metadata.setFormat("duration", this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+        break;
+      default:
+        debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+        break;
+    }
+    let remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
+    remaining > 0 && (debug(`After Parsing chunk, remaining ${remaining} bytes`), await this.tokenizer.ignore(Number(remaining)));
+  }
+  async handleSoundPropertyChunks(remainingSize) {
+    for (debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`); remainingSize > 0; ) {
+      let sndPropHeader = await this.tokenizer.readToken(ChunkHeader64);
+      debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+      let p0 = this.tokenizer.position;
+      switch (sndPropHeader.chunkID.trim()) {
+        case "FS": {
+          let sampleRate = await this.tokenizer.readToken(UINT32_BE);
+          this.metadata.setFormat("sampleRate", sampleRate);
+          break;
+        }
+        case "CHNL": {
+          let numChannels = await this.tokenizer.readToken(UINT16_BE);
+          this.metadata.setFormat("numberOfChannels", numChannels), await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(UINT16_BE.len));
+          break;
+        }
+        case "CMPR": {
+          let compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim(), count = await this.tokenizer.readToken(UINT8), compressionName = await this.tokenizer.readToken(new StringType(count, "ascii"));
+          compressionIdCode === "DSD" && (this.metadata.setFormat("lossless", !0), this.metadata.setFormat("bitsPerSample", 1)), this.metadata.setFormat("codec", `${compressionIdCode} (${compressionName})`);
+          break;
+        }
+        case "ABSS": {
+          let hours = await this.tokenizer.readToken(UINT16_BE), minutes = await this.tokenizer.readToken(UINT8), seconds = await this.tokenizer.readToken(UINT8), samples = await this.tokenizer.readToken(UINT32_BE);
+          debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
+          break;
+        }
+        case "LSCO": {
+          let lsConfig = await this.tokenizer.readToken(UINT16_BE);
+          debug(`LSCO lsConfig=${lsConfig}`);
+          break;
+        }
+        default:
+          debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`), await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
+      }
+      let remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);
+      remaining > 0 && (debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`), await this.tokenizer.ignore(Number(remaining))), remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize, debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+    }
+    if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+      let bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
+      this.metadata.setFormat("bitrate", bitrate);
+    }
+  }
+  async handleChannelChunks(remainingSize) {
+    debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
+    let channels = [];
+    for (; remainingSize >= FourCcToken.len; ) {
+      let channelId = await this.tokenizer.readToken(FourCcToken);
+      debug(`Channel[ID=${channelId}]`), channels.push(channelId), remainingSize -= BigInt(FourCcToken.len);
+    }
+    return debug(`Channels: ${channels.join(", ")}`), channels;
+  }
+};
+export {
+  DsdiffContentParseError,
+  DsdiffParser
+};