@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-XYTWGHFS.mjs

@@ -0,0 +1,600 @@
+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 {
+  Genres
+} from "./chunk-VAUOM3IN.mjs";
+import {
+  AttachedPictureType,
+  ExtendedHeader,
+  ID3v2Header,
+  SyncTextHeader,
+  TextEncodingToken,
+  TextHeader,
+  UINT32SYNCSAFE
+} from "./chunk-DXWDD5XJ.mjs";
+import {
+  decodeString,
+  decodeUintBE,
+  findZero,
+  getBit
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  UINT24_BE,
+  UINT32_BE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  textDecode
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/id3v2/FrameParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/id3v2/ID3v2ChapterToken.js
+var ChapterInfo = {
+  len: 16,
+  get: (buf, off) => {
+    let startOffset = UINT32_BE.get(buf, off + 8), endOffset = UINT32_BE.get(buf, off + 12);
+    return {
+      startTime: UINT32_BE.get(buf, off),
+      endTime: UINT32_BE.get(buf, off + 4),
+      startOffset: startOffset === 4294967295 ? void 0 : startOffset,
+      endOffset: endOffset === 4294967295 ? void 0 : endOffset
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/id3v2/FrameHeader.js
+function getFrameHeaderLength(majorVer) {
+  switch (majorVer) {
+    case 2:
+      return 6;
+    case 3:
+    case 4:
+      return 10;
+    default:
+      throw makeUnexpectedMajorVersionError(majorVer);
+  }
+}
+function readFrameFlags(b, majorVer) {
+  return majorVer === 3 ? {
+    status: {
+      tag_alter_preservation: getBit(b, 0, 7),
+      file_alter_preservation: getBit(b, 0, 6),
+      read_only: getBit(b, 0, 5)
+    },
+    format: {
+      compression: getBit(b, 1, 7),
+      encryption: getBit(b, 1, 6),
+      grouping_identity: getBit(b, 1, 5),
+      // Unsynchronisation and data-length-indicator do not exist as per-frame flags in ID3v2.3.
+      unsynchronisation: !1,
+      data_length_indicator: !1
+    }
+  } : {
+    status: {
+      tag_alter_preservation: getBit(b, 0, 6),
+      file_alter_preservation: getBit(b, 0, 5),
+      read_only: getBit(b, 0, 4)
+    },
+    format: {
+      grouping_identity: getBit(b, 1, 6),
+      compression: getBit(b, 1, 3),
+      encryption: getBit(b, 1, 2),
+      unsynchronisation: getBit(b, 1, 1),
+      data_length_indicator: getBit(b, 1, 0)
+    }
+  };
+}
+function readFrameHeader(uint8Array, majorVer, warningCollector) {
+  switch (majorVer) {
+    case 2:
+      return parseFrameHeaderV22(uint8Array, majorVer, warningCollector);
+    case 3:
+    case 4:
+      return parseFrameHeaderV23V24(uint8Array, majorVer, warningCollector);
+    default:
+      throw makeUnexpectedMajorVersionError(majorVer);
+  }
+}
+function parseFrameHeaderV22(uint8Array, majorVer, warningCollector) {
+  let header = {
+    id: textDecode(uint8Array.subarray(0, 3), "ascii"),
+    length: UINT24_BE.get(uint8Array, 3)
+  };
+  return header.id.match(/^[A-Z0-9]{3}$/) || warningCollector.addWarning(`Invalid ID3v2.${majorVer} frame-header-ID: ${header.id}`), header;
+}
+function parseFrameHeaderV23V24(uint8Array, majorVer, warningCollector) {
+  let header = {
+    id: textDecode(uint8Array.subarray(0, 4), "ascii"),
+    length: (majorVer === 4 ? UINT32SYNCSAFE : UINT32_BE).get(uint8Array, 4),
+    flags: readFrameFlags(uint8Array.subarray(8, 10), majorVer)
+  };
+  return header.id.match(/^[A-Z0-9]{4}$/) || warningCollector.addWarning(`Invalid ID3v2.${majorVer} frame-header-ID: ${header.id}`), header;
+}
+function makeUnexpectedMajorVersionError(majorVer) {
+  throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
+
+// node_modules/music-metadata/lib/id3v2/FrameParser.js
+var debug = (0, import_debug.default)("music-metadata:id3v2:frame-parser"), defaultEnc = "latin1", urlEnc = { encoding: defaultEnc, bom: !1 };
+function parseGenre(origVal) {
+  let genres = [], code, word = "";
+  for (let c of origVal)
+    if (typeof code == "string")
+      if (c === "(" && code === "")
+        word += "(", code = void 0;
+      else if (c === ")") {
+        word !== "" && (genres.push(word), word = "");
+        let genre = parseGenreCode(code);
+        genre && genres.push(genre), code = void 0;
+      } else
+        code += c;
+    else c === "(" ? code = "" : word += c;
+  return word && (genres.length === 0 && word.match(/^\d*$/) && (word = parseGenreCode(word)), word && genres.push(word)), genres;
+}
+function parseGenreCode(code) {
+  if (code === "RX")
+    return "Remix";
+  if (code === "CR")
+    return "Cover";
+  if (code.match(/^\d*$/))
+    return Genres[Number.parseInt(code, 10)];
+}
+var FrameParser = class _FrameParser {
+  /**
+   * Create id3v2 frame parser
+   * @param major - Major version, e.g. (4) for  id3v2.4
+   * @param warningCollector - Used to collect decode issue
+   */
+  constructor(major, warningCollector) {
+    this.major = major, this.warningCollector = warningCollector;
+  }
+  readData(uint8Array, type, includeCovers) {
+    if (uint8Array.length === 0) {
+      this.warningCollector.addWarning(`id3v2.${this.major} header has empty tag type=${type}`);
+      return;
+    }
+    let { encoding, bom } = TextEncodingToken.get(uint8Array, 0), length = uint8Array.length, offset = 0, output = [], nullTerminatorLength = _FrameParser.getNullTerminatorLength(encoding), fzero;
+    switch (debug(`Parsing tag type=${type}, encoding=${encoding}, bom=${bom}`), type !== "TXXX" && type[0] === "T" ? "T*" : type) {
+      case "T*":
+      // 4.2.1. Text information frames - details
+      case "GRP1":
+      // iTunes-specific ID3v2 grouping field
+      case "GP1":
+      // iTunes-specific ID3v2.2 grouping field
+      case "IPLS":
+      // v2.3: Involved people list
+      case "MVIN":
+      case "MVNM":
+      case "PCS":
+      case "PCST": {
+        let text;
+        try {
+          text = _FrameParser.trimNullPadding(decodeString(uint8Array.subarray(1), encoding));
+        } catch (error) {
+          if (error instanceof Error) {
+            this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
+            break;
+          }
+          throw error;
+        }
+        switch (type) {
+          case "TMCL":
+          // Musician credits list
+          case "TIPL":
+          // Involved people list
+          case "IPLS":
+            output = _FrameParser.functionList(this.splitValue(type, text));
+            break;
+          case "TRK":
+          case "TRCK":
+          case "TPOS":
+          case "TIT1":
+          case "TIT2":
+          case "TIT3":
+            output = text;
+            break;
+          case "TCOM":
+          case "TEXT":
+          case "TOLY":
+          case "TOPE":
+          case "TPE1":
+          case "TSRC":
+            output = this.splitValue(type, text);
+            break;
+          case "TCO":
+          case "TCON":
+            output = this.splitValue(type, text).map((v) => parseGenre(v)).reduce((acc, val) => acc.concat(val), []);
+            break;
+          case "PCS":
+          case "PCST":
+            output = this.major >= 4 ? this.splitValue(type, text) : [text], output = Array.isArray(output) && output[0] === "" ? 1 : 0;
+            break;
+          default:
+            output = this.major >= 4 ? this.splitValue(type, text) : [text];
+        }
+        break;
+      }
+      case "TXXX": {
+        let idAndData = _FrameParser.readIdentifierAndData(uint8Array.subarray(1), encoding);
+        output = {
+          description: idAndData.id,
+          text: this.splitValue(type, decodeString(idAndData.data, encoding).replace(/\x00+$/, ""))
+        };
+        break;
+      }
+      case "PIC":
+      case "APIC":
+        if (includeCovers) {
+          let pic = {};
+          switch (uint8Array = uint8Array.subarray(1), this.major) {
+            case 2:
+              pic.format = decodeString(uint8Array.subarray(0, 3), "latin1"), uint8Array = uint8Array.subarray(3);
+              break;
+            case 3:
+            case 4:
+              fzero = findZero(uint8Array, defaultEnc), pic.format = decodeString(uint8Array.subarray(0, fzero), defaultEnc), uint8Array = uint8Array.subarray(fzero + 1);
+              break;
+            default:
+              throw makeUnexpectedMajorVersionError2(this.major);
+          }
+          pic.format = _FrameParser.fixPictureMimeType(pic.format), pic.type = AttachedPictureType[uint8Array[0]], uint8Array = uint8Array.subarray(1), fzero = findZero(uint8Array, encoding), pic.description = decodeString(uint8Array.subarray(0, fzero), encoding), uint8Array = uint8Array.subarray(fzero + nullTerminatorLength), pic.data = uint8Array, output = pic;
+        }
+        break;
+      case "CNT":
+      case "PCNT":
+        output = decodeUintBE(uint8Array);
+        break;
+      case "SYLT": {
+        let syltHeader = SyncTextHeader.get(uint8Array, 0);
+        uint8Array = uint8Array.subarray(SyncTextHeader.len);
+        let result = {
+          descriptor: "",
+          language: syltHeader.language,
+          contentType: syltHeader.contentType,
+          timeStampFormat: syltHeader.timeStampFormat,
+          syncText: []
+        }, readSyllables = !1;
+        for (; uint8Array.length > 0; ) {
+          let nullStr = _FrameParser.readNullTerminatedString(uint8Array, syltHeader.encoding);
+          if (uint8Array = uint8Array.subarray(nullStr.len), readSyllables) {
+            let timestamp = UINT32_BE.get(uint8Array, 0);
+            uint8Array = uint8Array.subarray(UINT32_BE.len), result.syncText.push({
+              text: nullStr.text,
+              timestamp
+            });
+          } else
+            result.descriptor = nullStr.text, readSyllables = !0;
+        }
+        output = result;
+        break;
+      }
+      case "ULT":
+      case "USLT":
+      case "COM":
+      case "COMM": {
+        let textHeader = TextHeader.get(uint8Array, offset);
+        offset += TextHeader.len;
+        let descriptorStr = _FrameParser.readNullTerminatedString(uint8Array.subarray(offset), textHeader.encoding);
+        offset += descriptorStr.len;
+        let textStr = _FrameParser.readNullTerminatedString(uint8Array.subarray(offset), textHeader.encoding);
+        output = {
+          language: textHeader.language,
+          descriptor: descriptorStr.text,
+          text: textStr.text
+        };
+        break;
+      }
+      case "UFID": {
+        let ufid = _FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
+        output = { owner_identifier: ufid.id, identifier: ufid.data };
+        break;
+      }
+      case "PRIV": {
+        let priv = _FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
+        output = { owner_identifier: priv.id, data: priv.data };
+        break;
+      }
+      case "POPM": {
+        uint8Array = uint8Array.subarray(offset);
+        let emailStr = _FrameParser.readNullTerminatedString(uint8Array, urlEnc), email = emailStr.text;
+        if (uint8Array = uint8Array.subarray(emailStr.len), uint8Array.length === 0) {
+          this.warningCollector.addWarning(`id3v2.${this.major} type=${type} POPM frame missing rating byte`), output = { email, rating: 0, counter: void 0 };
+          break;
+        }
+        let rating = UINT8.get(uint8Array, 0), counterBytes = uint8Array.subarray(UINT8.len);
+        output = {
+          email,
+          rating,
+          counter: counterBytes.length > 0 ? decodeUintBE(counterBytes) : void 0
+        };
+        break;
+      }
+      case "GEOB": {
+        let encoding2 = TextEncodingToken.get(uint8Array, 0);
+        uint8Array = uint8Array.subarray(1);
+        let mimeTypeStr = _FrameParser.readNullTerminatedString(uint8Array, urlEnc), mimeType = mimeTypeStr.text;
+        uint8Array = uint8Array.subarray(mimeTypeStr.len);
+        let filenameStr = _FrameParser.readNullTerminatedString(uint8Array, encoding2), filename = filenameStr.text;
+        uint8Array = uint8Array.subarray(filenameStr.len);
+        let descriptionStr = _FrameParser.readNullTerminatedString(uint8Array, encoding2), description = descriptionStr.text;
+        uint8Array = uint8Array.subarray(descriptionStr.len), output = {
+          type: mimeType,
+          filename,
+          description,
+          data: uint8Array
+        };
+        break;
+      }
+      // W-Frames:
+      case "WCOM":
+      case "WCOP":
+      case "WOAF":
+      case "WOAR":
+      case "WOAS":
+      case "WORS":
+      case "WPAY":
+      case "WPUB":
+        output = _FrameParser.readNullTerminatedString(uint8Array, urlEnc).text;
+        break;
+      case "WXXX": {
+        let encoding2 = TextEncodingToken.get(uint8Array, 0);
+        uint8Array = uint8Array.subarray(1);
+        let descriptionStr = _FrameParser.readNullTerminatedString(uint8Array, encoding2), description = descriptionStr.text;
+        uint8Array = uint8Array.subarray(descriptionStr.len), output = { description, url: _FrameParser.trimNullPadding(decodeString(uint8Array, defaultEnc)) };
+        break;
+      }
+      case "WFD":
+      case "WFED": {
+        let encoding2 = TextEncodingToken.get(uint8Array, 0);
+        uint8Array = uint8Array.subarray(1), output = _FrameParser.readNullTerminatedString(uint8Array, encoding2).text;
+        break;
+      }
+      case "MCDI": {
+        output = uint8Array.subarray(0, length);
+        break;
+      }
+      // ID3v2 Chapters 1.0
+      // https://mutagen-specs.readthedocs.io/en/latest/id3/id3v2-chapters-1.0.html#chapter-frame
+      case "CHAP": {
+        debug("Reading CHAP"), fzero = findZero(uint8Array, defaultEnc);
+        let chapter = {
+          label: decodeString(uint8Array.subarray(0, fzero), defaultEnc),
+          info: ChapterInfo.get(uint8Array, fzero + 1),
+          frames: /* @__PURE__ */ new Map()
+        };
+        for (offset += fzero + 1 + ChapterInfo.len; offset < length; ) {
+          let subFrame = readFrameHeader(uint8Array.subarray(offset), this.major, this.warningCollector), headerSize = getFrameHeaderLength(this.major);
+          offset += headerSize;
+          let subOutput = this.readData(uint8Array.subarray(offset, offset + subFrame.length), subFrame.id, includeCovers);
+          offset += subFrame.length, chapter.frames.set(subFrame.id, subOutput);
+        }
+        output = chapter;
+        break;
+      }
+      // ID3v2 Chapters 1.0
+      // https://mutagen-specs.readthedocs.io/en/latest/id3/id3v2-chapters-1.0.html#table-of-contents-frame
+      case "CTOC": {
+        debug("Reading CTOC");
+        let idEnd = findZero(uint8Array, defaultEnc), label = decodeString(uint8Array.subarray(0, idEnd), defaultEnc);
+        offset = idEnd + 1;
+        let flags = uint8Array[offset++], topLevel = (flags & 2) !== 0, ordered = (flags & 1) !== 0, entryCount = uint8Array[offset++], childElementIds = [];
+        for (let i = 0; i < entryCount && offset < length; i++) {
+          let end = findZero(uint8Array.subarray(offset), defaultEnc), childId = decodeString(uint8Array.subarray(offset, offset + end), defaultEnc);
+          childElementIds.push(childId), offset += end + 1;
+        }
+        let toc = {
+          label,
+          flags: { topLevel, ordered },
+          childElementIds,
+          frames: /* @__PURE__ */ new Map()
+        };
+        for (; offset < length; ) {
+          let subFrame = readFrameHeader(uint8Array.subarray(offset), this.major, this.warningCollector), headerSize = getFrameHeaderLength(this.major);
+          offset += headerSize;
+          let subOutput = this.readData(uint8Array.subarray(offset, offset + subFrame.length), subFrame.id, includeCovers);
+          offset += subFrame.length, toc.frames.set(subFrame.id, subOutput);
+        }
+        output = toc;
+        break;
+      }
+      default:
+        debug(`Warning: unsupported id3v2-tag-type: ${type}`);
+        break;
+    }
+    return output;
+  }
+  static readNullTerminatedString(uint8Array, encoding) {
+    let bomSize = encoding.bom ? 2 : 0, originalLen = uint8Array.length, valueArray = uint8Array.subarray(bomSize), zeroIndex = findZero(valueArray, encoding.encoding);
+    if (zeroIndex >= valueArray.length)
+      return {
+        text: decodeString(uint8Array, encoding.encoding),
+        len: originalLen
+      };
+    let txt = uint8Array.subarray(0, bomSize + zeroIndex);
+    return {
+      text: decodeString(txt, encoding.encoding),
+      len: bomSize + zeroIndex + _FrameParser.getNullTerminatorLength(encoding.encoding)
+    };
+  }
+  static fixPictureMimeType(pictureType) {
+    switch (pictureType = pictureType.toLocaleLowerCase(), pictureType) {
+      case "jpg":
+        return "image/jpeg";
+      case "png":
+        return "image/png";
+    }
+    return pictureType;
+  }
+  /**
+   * Converts TMCL (Musician credits list) or TIPL (Involved people list)
+   * @param entries
+   */
+  static functionList(entries) {
+    let res = {};
+    for (let i = 0; i + 1 < entries.length; i += 2) {
+      let names = entries[i + 1].split(",");
+      res[entries[i]] = res[entries[i]] ? res[entries[i]].concat(names) : names;
+    }
+    return res;
+  }
+  /**
+   * id3v2.4 defines that multiple T* values are separated by 0x00
+   * id3v2.3 defines that TCOM, TEXT, TOLY, TOPE & TPE1 values are separated by /
+   * @param tag - Tag name
+   * @param text - Concatenated tag value
+   * @returns Split tag value
+   */
+  splitValue(tag, text) {
+    let values;
+    return this.major < 4 ? (values = text.split(/\x00/g), values.length > 1 ? this.warningCollector.addWarning(`ID3v2.${this.major} ${tag} uses non standard null-separator.`) : values = text.split(/\//g)) : values = text.split(/\x00/g), _FrameParser.trimArray(values);
+  }
+  static trimArray(values) {
+    return values.map((value) => _FrameParser.trimNullPadding(value).trim());
+  }
+  static trimNullPadding(value) {
+    let end = value.length;
+    for (; end > 0 && value.charCodeAt(end - 1) === 0; )
+      end--;
+    return end === value.length ? value : value.slice(0, end);
+  }
+  static readIdentifierAndData(uint8Array, encoding) {
+    let idStr = _FrameParser.readNullTerminatedString(uint8Array, { encoding, bom: !1 });
+    return { id: idStr.text, data: uint8Array.subarray(idStr.len) };
+  }
+  static getNullTerminatorLength(enc) {
+    return enc.startsWith("utf-16") ? 2 : 1;
+  }
+}, Id3v2ContentError = class extends makeUnexpectedFileContentError("id3v2") {
+};
+function makeUnexpectedMajorVersionError2(majorVer) {
+  throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
+
+// node_modules/music-metadata/lib/id3v2/ID3v2Parser.js
+var ID3v2Parser = class _ID3v2Parser {
+  constructor() {
+    this.tokenizer = void 0, this.id3Header = void 0, this.metadata = void 0, this.headerType = void 0, this.options = void 0;
+  }
+  static removeUnsyncBytes(buffer) {
+    let readI = 0, writeI = 0;
+    for (; readI < buffer.length - 1; )
+      readI !== writeI && (buffer[writeI] = buffer[readI]), readI += buffer[readI] === 255 && buffer[readI + 1] === 0 ? 2 : 1, writeI++;
+    return readI < buffer.length && (buffer[writeI++] = buffer[readI]), buffer.subarray(0, writeI);
+  }
+  static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
+    let frameParser = new FrameParser(majorVer, warningCollector);
+    switch (majorVer) {
+      case 2:
+        return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
+      case 3:
+      case 4:
+        return frameHeader.flags?.format.unsynchronisation && (uint8Array = _ID3v2Parser.removeUnsyncBytes(uint8Array)), frameHeader.flags?.format.data_length_indicator && (uint8Array = uint8Array.subarray(4, uint8Array.length)), frameParser.readData(uint8Array, frameHeader.id, includeCovers);
+      default:
+        throw makeUnexpectedMajorVersionError3(majorVer);
+    }
+  }
+  /**
+   * Create a combined tag key, of tag & description
+   * @param tag e.g.: COM
+   * @param description e.g. iTunPGAP
+   * @returns string e.g. COM:iTunPGAP
+   */
+  static makeDescriptionTagName(tag, description) {
+    return tag + (description ? `:${description}` : "");
+  }
+  async parse(metadata, tokenizer, options) {
+    this.tokenizer = tokenizer, this.metadata = metadata, this.options = options;
+    let id3Header = await this.tokenizer.readToken(ID3v2Header);
+    if (id3Header.fileIdentifier !== "ID3")
+      throw new Id3v2ContentError("expected ID3-header file-identifier 'ID3' was not found");
+    this.id3Header = id3Header, this.headerType = `ID3v2.${id3Header.version.major}`, await (id3Header.flags.isExtendedHeader ? this.parseExtendedHeader() : this.parseId3Data(id3Header.size));
+    let chapters = _ID3v2Parser.mapId3v2Chapters(this.metadata.native[this.headerType]);
+    this.metadata.setFormat("chapters", chapters);
+  }
+  async parseExtendedHeader() {
+    let extendedHeader = await this.tokenizer.readToken(ExtendedHeader), dataRemaining = extendedHeader.size - ExtendedHeader.len;
+    return dataRemaining > 0 ? this.parseExtendedHeaderData(dataRemaining, extendedHeader.size) : this.parseId3Data(this.id3Header.size - extendedHeader.size);
+  }
+  async parseExtendedHeaderData(dataRemaining, extendedHeaderSize) {
+    return await this.tokenizer.ignore(dataRemaining), this.parseId3Data(this.id3Header.size - extendedHeaderSize);
+  }
+  async parseId3Data(dataLen) {
+    let uint8Array = await this.tokenizer.readToken(new Uint8ArrayType(dataLen));
+    for (let tag of this.parseMetadata(uint8Array))
+      tag.id === "TXXX" ? tag.value && await this.handleTag(tag, tag.value.text, () => tag.value.description) : await (Array.isArray(tag.value) ? Promise.all(tag.value.map((value) => this.addTag(tag.id, value))) : this.addTag(tag.id, tag.value));
+  }
+  async handleTag(tag, values, descriptor, resolveValue = (value) => value) {
+    await Promise.all(values.map((value) => this.addTag(_ID3v2Parser.makeDescriptionTagName(tag.id, descriptor(value)), resolveValue(value))));
+  }
+  async addTag(id, value) {
+    await this.metadata.addTag(this.headerType, id, value);
+  }
+  parseMetadata(data) {
+    let offset = 0, tags = [];
+    for (; offset !== data.length; ) {
+      let frameHeaderLength = getFrameHeaderLength(this.id3Header.version.major);
+      if (offset + frameHeaderLength > data.length) {
+        this.metadata.addWarning("Illegal ID3v2 tag length");
+        break;
+      }
+      let frameHeaderBytes = data.subarray(offset, offset + frameHeaderLength);
+      offset += frameHeaderLength;
+      let frameHeader = readFrameHeader(frameHeaderBytes, this.id3Header.version.major, this.metadata), frameDataBytes = data.subarray(offset, offset + frameHeader.length);
+      offset += frameHeader.length;
+      let values = _ID3v2Parser.readFrameData(frameDataBytes, frameHeader, this.id3Header.version.major, !this.options.skipCovers, this.metadata);
+      values && tags.push({ id: frameHeader.id, value: values });
+    }
+    return tags;
+  }
+  /**
+   * Convert parsed ID3v2 chapter frames (CHAP / CTOC) to generic `format.chapters`.
+   *
+   * This function expects the `native` tags already to contain parsed `CHAP` and `CTOC` frame values,
+   * as produced by `FrameParser.readData`.
+   */
+  static mapId3v2Chapters(id3Tags) {
+    if (!id3Tags)
+      return;
+    let chapFrames = id3Tags.filter((t) => t.id === "CHAP");
+    if (!chapFrames?.length)
+      return;
+    let topLevelToc = id3Tags.filter((t) => t.id === "CTOC")?.find((t) => t.value.flags?.topLevel), chapterById = /* @__PURE__ */ new Map();
+    for (let chap of chapFrames)
+      chapterById.set(chap.value.label, chap.value);
+    let orderedIds = topLevelToc?.value.childElementIds, chapters = [], source = orderedIds ?? [...chapterById.keys()];
+    for (let id of source) {
+      let chap = chapterById.get(id);
+      if (!chap)
+        continue;
+      let frames = chap.frames, title = frames.get("TIT2");
+      title && chapters.push({
+        id,
+        title,
+        url: frames.get("WXXX"),
+        start: chap.info.startTime / 1e3,
+        end: chap.info.endTime / 1e3,
+        image: frames.get("APIC")
+      });
+    }
+    return orderedIds || chapters.sort((a, b) => a.start - b.start), chapters.length ? chapters : void 0;
+  }
+};
+function makeUnexpectedMajorVersionError3(majorVer) {
+  throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
+
+export {
+  ID3v2Parser
+};