agdi 3.3.6 → 3.3.8

package/dist/WaveParser-27IS2RAI.js

@@ -0,0 +1,294 @@
+import {
+  ID3v2Parser
+} from "./chunk-65JVFJ3X.js";
+import "./chunk-2B4QMSZW.js";
+import {
+  FourCcToken
+} from "./chunk-YIHDW7JC.js";
+import {
+  EndOfStreamError,
+  fromBuffer
+} from "./chunk-HNLU36CC.js";
+import "./chunk-LREP5CZP.js";
+import {
+  stripNulls
+} from "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wav/WaveParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/riff/RiffChunk.js
+var Header = {
+  len: 8,
+  get: (buf, off) => {
+    return {
+      // Group-ID
+      chunkID: new StringType(4, "latin1").get(buf, off),
+      // Size
+      chunkSize: UINT32_LE.get(buf, off + 4)
+    };
+  }
+};
+var ListInfoTagValue = class {
+  constructor(tagHeader) {
+    this.tagHeader = tagHeader;
+    this.len = tagHeader.chunkSize;
+    this.len += this.len & 1;
+  }
+  get(buf, off) {
+    return new StringType(this.tagHeader.chunkSize, "ascii").get(buf, off);
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wav/WaveChunk.js
+var WaveContentError = class extends makeUnexpectedFileContentError("Wave") {
+};
+var WaveFormat = {
+  PCM: 1,
+  // MPEG-4 and AAC Audio Types
+  ADPCM: 2,
+  IEEE_FLOAT: 3,
+  MPEG_ADTS_AAC: 5632,
+  MPEG_LOAS: 5634,
+  RAW_AAC1: 255,
+  // Dolby Audio Types
+  DOLBY_AC3_SPDIF: 146,
+  DVM: 8192,
+  RAW_SPORT: 576,
+  ESST_AC3: 577,
+  DRM: 9,
+  DTS2: 8193,
+  MPEG: 80
+};
+var WaveFormatNameMap = {
+  [WaveFormat.PCM]: "PCM",
+  [WaveFormat.ADPCM]: "ADPCM",
+  [WaveFormat.IEEE_FLOAT]: "IEEE_FLOAT",
+  [WaveFormat.MPEG_ADTS_AAC]: "MPEG_ADTS_AAC",
+  [WaveFormat.MPEG_LOAS]: "MPEG_LOAS",
+  [WaveFormat.RAW_AAC1]: "RAW_AAC1",
+  [WaveFormat.DOLBY_AC3_SPDIF]: "DOLBY_AC3_SPDIF",
+  [WaveFormat.DVM]: "DVM",
+  [WaveFormat.RAW_SPORT]: "RAW_SPORT",
+  [WaveFormat.ESST_AC3]: "ESST_AC3",
+  [WaveFormat.DRM]: "DRM",
+  [WaveFormat.DTS2]: "DTS2",
+  [WaveFormat.MPEG]: "MPEG"
+};
+var Format = class {
+  constructor(header) {
+    if (header.chunkSize < 16)
+      throw new WaveContentError("Invalid chunk size");
+    this.len = header.chunkSize;
+  }
+  get(buf, off) {
+    return {
+      wFormatTag: UINT16_LE.get(buf, off),
+      nChannels: UINT16_LE.get(buf, off + 2),
+      nSamplesPerSec: UINT32_LE.get(buf, off + 4),
+      nAvgBytesPerSec: UINT32_LE.get(buf, off + 8),
+      nBlockAlign: UINT16_LE.get(buf, off + 12),
+      wBitsPerSample: UINT16_LE.get(buf, off + 14)
+    };
+  }
+};
+var FactChunk = class {
+  constructor(header) {
+    if (header.chunkSize < 4) {
+      throw new WaveContentError("Invalid fact chunk size.");
+    }
+    this.len = header.chunkSize;
+  }
+  get(buf, off) {
+    return {
+      dwSampleLength: UINT32_LE.get(buf, off)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wav/BwfChunk.js
+var BroadcastAudioExtensionChunk = {
+  len: 420,
+  get: (uint8array, off) => {
+    return {
+      description: stripNulls(new StringType(256, "ascii").get(uint8array, off)).trim(),
+      originator: stripNulls(new StringType(32, "ascii").get(uint8array, off + 256)).trim(),
+      originatorReference: stripNulls(new StringType(32, "ascii").get(uint8array, off + 288)).trim(),
+      originationDate: stripNulls(new StringType(10, "ascii").get(uint8array, off + 320)).trim(),
+      originationTime: stripNulls(new StringType(8, "ascii").get(uint8array, off + 330)).trim(),
+      timeReferenceLow: UINT32_LE.get(uint8array, off + 338),
+      timeReferenceHigh: UINT32_LE.get(uint8array, off + 342),
+      version: UINT16_LE.get(uint8array, off + 346),
+      umid: new Uint8ArrayType(64).get(uint8array, off + 348),
+      loudnessValue: UINT16_LE.get(uint8array, off + 412),
+      maxTruePeakLevel: UINT16_LE.get(uint8array, off + 414),
+      maxMomentaryLoudness: UINT16_LE.get(uint8array, off + 416),
+      maxShortTermLoudness: UINT16_LE.get(uint8array, off + 418)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/wav/WaveParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:RIFF");
+var WaveParser = class extends BasicParser {
+  constructor() {
+    super(...arguments);
+    this.blockAlign = 0;
+  }
+  async parse() {
+    const riffHeader = await this.tokenizer.readToken(Header);
+    debug(`pos=${this.tokenizer.position}, parse: chunkID=${riffHeader.chunkID}`);
+    if (riffHeader.chunkID !== "RIFF")
+      return;
+    this.metadata.setAudioOnly();
+    return this.parseRiffChunk(riffHeader.chunkSize).catch((err) => {
+      if (!(err instanceof EndOfStreamError)) {
+        throw err;
+      }
+    });
+  }
+  async parseRiffChunk(chunkSize) {
+    const type = await this.tokenizer.readToken(FourCcToken);
+    this.metadata.setFormat("container", type);
+    switch (type) {
+      case "WAVE":
+        return this.readWaveChunk(chunkSize - FourCcToken.len);
+      default:
+        throw new WaveContentError(`Unsupported RIFF format: RIFF/${type}`);
+    }
+  }
+  async readWaveChunk(remaining) {
+    while (remaining >= Header.len) {
+      const header = await this.tokenizer.readToken(Header);
+      remaining -= Header.len + header.chunkSize;
+      if (header.chunkSize > remaining) {
+        this.metadata.addWarning("Data chunk size exceeds file size");
+      }
+      this.header = header;
+      debug(`pos=${this.tokenizer.position}, readChunk: chunkID=RIFF/WAVE/${header.chunkID}`);
+      switch (header.chunkID) {
+        case "LIST":
+          await this.parseListTag(header);
+          break;
+        case "fact":
+          this.metadata.setFormat("lossless", false);
+          this.fact = await this.tokenizer.readToken(new FactChunk(header));
+          break;
+        case "fmt ": {
+          const fmt = await this.tokenizer.readToken(new Format(header));
+          let subFormat = WaveFormatNameMap[fmt.wFormatTag];
+          if (!subFormat) {
+            debug(`WAVE/non-PCM format=${fmt.wFormatTag}`);
+            subFormat = `non-PCM (${fmt.wFormatTag})`;
+          }
+          this.metadata.setFormat("codec", subFormat);
+          this.metadata.setFormat("bitsPerSample", fmt.wBitsPerSample);
+          this.metadata.setFormat("sampleRate", fmt.nSamplesPerSec);
+          this.metadata.setFormat("numberOfChannels", fmt.nChannels);
+          this.metadata.setFormat("bitrate", fmt.nBlockAlign * fmt.nSamplesPerSec * 8);
+          this.blockAlign = fmt.nBlockAlign;
+          break;
+        }
+        case "id3 ":
+        // The way Picard, FooBar currently stores, ID3 meta-data
+        case "ID3 ": {
+          const id3_data = await this.tokenizer.readToken(new Uint8ArrayType(header.chunkSize));
+          const rst = fromBuffer(id3_data);
+          await new ID3v2Parser().parse(this.metadata, rst, this.options);
+          break;
+        }
+        case "data": {
+          if (this.metadata.format.lossless !== false) {
+            this.metadata.setFormat("lossless", true);
+          }
+          let chunkSize = header.chunkSize;
+          if (this.tokenizer.fileInfo.size) {
+            const calcRemaining = this.tokenizer.fileInfo.size - this.tokenizer.position;
+            if (calcRemaining < chunkSize) {
+              this.metadata.addWarning("data chunk length exceeding file length");
+              chunkSize = calcRemaining;
+            }
+          }
+          const numberOfSamples = this.fact ? this.fact.dwSampleLength : chunkSize === 4294967295 ? void 0 : chunkSize / this.blockAlign;
+          if (numberOfSamples) {
+            this.metadata.setFormat("numberOfSamples", numberOfSamples);
+            if (this.metadata.format.sampleRate) {
+              this.metadata.setFormat("duration", numberOfSamples / this.metadata.format.sampleRate);
+            }
+          }
+          if (this.metadata.format.codec === "ADPCM") {
+            this.metadata.setFormat("bitrate", 352e3);
+          } else if (this.metadata.format.sampleRate) {
+            this.metadata.setFormat("bitrate", this.blockAlign * this.metadata.format.sampleRate * 8);
+          }
+          await this.tokenizer.ignore(header.chunkSize);
+          break;
+        }
+        case "bext": {
+          const bext = await this.tokenizer.readToken(BroadcastAudioExtensionChunk);
+          Object.keys(bext).forEach((key) => {
+            this.metadata.addTag("exif", `bext.${key}`, bext[key]);
+          });
+          const bextRemaining = header.chunkSize - BroadcastAudioExtensionChunk.len;
+          await this.tokenizer.ignore(bextRemaining);
+          break;
+        }
+        case "\0\0\0\0":
+          debug(`Ignore padding chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
+          this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`);
+          await this.tokenizer.ignore(header.chunkSize);
+          break;
+        default:
+          debug(`Ignore chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
+          this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`);
+          await this.tokenizer.ignore(header.chunkSize);
+      }
+      if (this.header.chunkSize % 2 === 1) {
+        debug("Read odd padding byte");
+        await this.tokenizer.ignore(1);
+      }
+    }
+  }
+  async parseListTag(listHeader) {
+    const listType = await this.tokenizer.readToken(new StringType(4, "latin1"));
+    debug("pos=%s, parseListTag: chunkID=RIFF/WAVE/LIST/%s", this.tokenizer.position, listType);
+    switch (listType) {
+      case "INFO":
+        return this.parseRiffInfoTags(listHeader.chunkSize - 4);
+      default:
+        this.metadata.addWarning(`Ignore chunk: RIFF/WAVE/LIST/${listType}`);
+        debug(`Ignoring chunkID=RIFF/WAVE/LIST/${listType}`);
+        return this.tokenizer.ignore(listHeader.chunkSize - 4).then();
+    }
+  }
+  async parseRiffInfoTags(chunkSize) {
+    while (chunkSize >= 8) {
+      const header = await this.tokenizer.readToken(Header);
+      const valueToken = new ListInfoTagValue(header);
+      const value = await this.tokenizer.readToken(valueToken);
+      this.addTag(header.chunkID, stripNulls(value));
+      chunkSize -= 8 + valueToken.len;
+    }
+    if (chunkSize !== 0) {
+      throw new WaveContentError(`Illegal remaining size: ${chunkSize}`);
+    }
+  }
+  addTag(id, value) {
+    this.metadata.addTag("exif", id, value);
+  }
+};
+export {
+  WaveParser
+};

package/dist/chunk-2B4QMSZW.js

@@ -0,0 +1,311 @@
+import {
+  APEv2Parser
+} from "./chunk-YIHDW7JC.js";
+import {
+  trimRightNull
+} from "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  StringType,
+  UINT8,
+  require_src,
+  textDecode
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/id3v1/ID3v1Parser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:ID3v1");
+var Genres = [
+  "Blues",
+  "Classic Rock",
+  "Country",
+  "Dance",
+  "Disco",
+  "Funk",
+  "Grunge",
+  "Hip-Hop",
+  "Jazz",
+  "Metal",
+  "New Age",
+  "Oldies",
+  "Other",
+  "Pop",
+  "R&B",
+  "Rap",
+  "Reggae",
+  "Rock",
+  "Techno",
+  "Industrial",
+  "Alternative",
+  "Ska",
+  "Death Metal",
+  "Pranks",
+  "Soundtrack",
+  "Euro-Techno",
+  "Ambient",
+  "Trip-Hop",
+  "Vocal",
+  "Jazz+Funk",
+  "Fusion",
+  "Trance",
+  "Classical",
+  "Instrumental",
+  "Acid",
+  "House",
+  "Game",
+  "Sound Clip",
+  "Gospel",
+  "Noise",
+  "Alt. Rock",
+  "Bass",
+  "Soul",
+  "Punk",
+  "Space",
+  "Meditative",
+  "Instrumental Pop",
+  "Instrumental Rock",
+  "Ethnic",
+  "Gothic",
+  "Darkwave",
+  "Techno-Industrial",
+  "Electronic",
+  "Pop-Folk",
+  "Eurodance",
+  "Dream",
+  "Southern Rock",
+  "Comedy",
+  "Cult",
+  "Gangsta Rap",
+  "Top 40",
+  "Christian Rap",
+  "Pop/Funk",
+  "Jungle",
+  "Native American",
+  "Cabaret",
+  "New Wave",
+  "Psychedelic",
+  "Rave",
+  "Showtunes",
+  "Trailer",
+  "Lo-Fi",
+  "Tribal",
+  "Acid Punk",
+  "Acid Jazz",
+  "Polka",
+  "Retro",
+  "Musical",
+  "Rock & Roll",
+  "Hard Rock",
+  "Folk",
+  "Folk/Rock",
+  "National Folk",
+  "Swing",
+  "Fast-Fusion",
+  "Bebob",
+  "Latin",
+  "Revival",
+  "Celtic",
+  "Bluegrass",
+  "Avantgarde",
+  "Gothic Rock",
+  "Progressive Rock",
+  "Psychedelic Rock",
+  "Symphonic Rock",
+  "Slow Rock",
+  "Big Band",
+  "Chorus",
+  "Easy Listening",
+  "Acoustic",
+  "Humour",
+  "Speech",
+  "Chanson",
+  "Opera",
+  "Chamber Music",
+  "Sonata",
+  "Symphony",
+  "Booty Bass",
+  "Primus",
+  "Porn Groove",
+  "Satire",
+  "Slow Jam",
+  "Club",
+  "Tango",
+  "Samba",
+  "Folklore",
+  "Ballad",
+  "Power Ballad",
+  "Rhythmic Soul",
+  "Freestyle",
+  "Duet",
+  "Punk Rock",
+  "Drum Solo",
+  "A Cappella",
+  "Euro-House",
+  "Dance Hall",
+  "Goa",
+  "Drum & Bass",
+  "Club-House",
+  "Hardcore",
+  "Terror",
+  "Indie",
+  "BritPop",
+  "Negerpunk",
+  "Polsk Punk",
+  "Beat",
+  "Christian Gangsta Rap",
+  "Heavy Metal",
+  "Black Metal",
+  "Crossover",
+  "Contemporary Christian",
+  "Christian Rock",
+  "Merengue",
+  "Salsa",
+  "Thrash Metal",
+  "Anime",
+  "JPop",
+  "Synthpop",
+  "Abstract",
+  "Art Rock",
+  "Baroque",
+  "Bhangra",
+  "Big Beat",
+  "Breakbeat",
+  "Chillout",
+  "Downtempo",
+  "Dub",
+  "EBM",
+  "Eclectic",
+  "Electro",
+  "Electroclash",
+  "Emo",
+  "Experimental",
+  "Garage",
+  "Global",
+  "IDM",
+  "Illbient",
+  "Industro-Goth",
+  "Jam Band",
+  "Krautrock",
+  "Leftfield",
+  "Lounge",
+  "Math Rock",
+  "New Romantic",
+  "Nu-Breakz",
+  "Post-Punk",
+  "Post-Rock",
+  "Psytrance",
+  "Shoegaze",
+  "Space Rock",
+  "Trop Rock",
+  "World Music",
+  "Neoclassical",
+  "Audiobook",
+  "Audio Theatre",
+  "Neue Deutsche Welle",
+  "Podcast",
+  "Indie Rock",
+  "G-Funk",
+  "Dubstep",
+  "Garage Rock",
+  "Psybient"
+];
+var Iid3v1Token = {
+  len: 128,
+  /**
+   * @param buf Buffer possibly holding the 128 bytes ID3v1.1 metadata header
+   * @param off Offset in buffer in bytes
+   * @returns ID3v1.1 header if first 3 bytes equals 'TAG', otherwise null is returned
+   */
+  get: (buf, off) => {
+    const header = new Id3v1StringType(3).get(buf, off);
+    return header === "TAG" ? {
+      header,
+      title: new Id3v1StringType(30).get(buf, off + 3),
+      artist: new Id3v1StringType(30).get(buf, off + 33),
+      album: new Id3v1StringType(30).get(buf, off + 63),
+      year: new Id3v1StringType(4).get(buf, off + 93),
+      comment: new Id3v1StringType(28).get(buf, off + 97),
+      // ID3v1.1 separator for track
+      zeroByte: UINT8.get(buf, off + 127),
+      // track: ID3v1.1 field added by Michael Mutschler
+      track: UINT8.get(buf, off + 126),
+      genre: UINT8.get(buf, off + 127)
+    } : null;
+  }
+};
+var Id3v1StringType = class {
+  constructor(len) {
+    this.len = len;
+    this.stringType = new StringType(len, "latin1");
+  }
+  get(buf, off) {
+    let value = this.stringType.get(buf, off);
+    value = trimRightNull(value);
+    value = value.trim();
+    return value.length > 0 ? value : void 0;
+  }
+};
+var ID3v1Parser = class _ID3v1Parser extends BasicParser {
+  constructor(metadata, tokenizer, options) {
+    super(metadata, tokenizer, options);
+    this.apeHeader = options.apeHeader;
+  }
+  static getGenre(genreIndex) {
+    if (genreIndex < Genres.length) {
+      return Genres[genreIndex];
+    }
+    return void 0;
+  }
+  async parse() {
+    if (!this.tokenizer.fileInfo.size) {
+      debug("Skip checking for ID3v1 because the file-size is unknown");
+      return;
+    }
+    if (this.apeHeader) {
+      this.tokenizer.ignore(this.apeHeader.offset - this.tokenizer.position);
+      const apeParser = new APEv2Parser(this.metadata, this.tokenizer, this.options);
+      await apeParser.parseTags(this.apeHeader.footer);
+    }
+    const offset = this.tokenizer.fileInfo.size - Iid3v1Token.len;
+    if (this.tokenizer.position > offset) {
+      debug("Already consumed the last 128 bytes");
+      return;
+    }
+    const header = await this.tokenizer.readToken(Iid3v1Token, offset);
+    if (header) {
+      debug("ID3v1 header found at: pos=%s", this.tokenizer.fileInfo.size - Iid3v1Token.len);
+      const props = ["title", "artist", "album", "comment", "track", "year"];
+      for (const id of props) {
+        if (header[id] && header[id] !== "")
+          await this.addTag(id, header[id]);
+      }
+      const genre = _ID3v1Parser.getGenre(header.genre);
+      if (genre)
+        await this.addTag("genre", genre);
+    } else {
+      debug("ID3v1 header not found at: pos=%s", this.tokenizer.fileInfo.size - Iid3v1Token.len);
+    }
+  }
+  async addTag(id, value) {
+    await this.metadata.addTag("ID3v1", id, value);
+  }
+};
+async function hasID3v1Header(tokenizer) {
+  if (tokenizer.fileInfo.size >= 128) {
+    const tag = new Uint8Array(3);
+    const position = tokenizer.position;
+    await tokenizer.readBuffer(tag, { position: tokenizer.fileInfo.size - 128 });
+    tokenizer.setPosition(position);
+    return textDecode(tag, "latin1") === "TAG";
+  }
+  return false;
+}
+
+export {
+  Genres,
+  ID3v1Parser,
+  hasID3v1Header
+};

package/dist/chunk-3JKZUGPJ.js

@@ -0,0 +1,70 @@
+import {
+  ID3v2Parser
+} from "./chunk-65JVFJ3X.js";
+import {
+  ID3v1Parser
+} from "./chunk-2B4QMSZW.js";
+import {
+  EndOfStreamError
+} from "./chunk-HNLU36CC.js";
+import {
+  ID3v2Header
+} from "./chunk-LREP5CZP.js";
+import {
+  BasicParser,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/id3v2/AbstractID3Parser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:ID3");
+var AbstractID3Parser = class extends BasicParser {
+  constructor() {
+    super(...arguments);
+    this.id3parser = new ID3v2Parser();
+  }
+  static async startsWithID3v2Header(tokenizer) {
+    return (await tokenizer.peekToken(ID3v2Header)).fileIdentifier === "ID3";
+  }
+  async parse() {
+    try {
+      await this.parseID3v2();
+    } catch (err) {
+      if (err instanceof EndOfStreamError) {
+        debug("End-of-stream");
+      } else {
+        throw err;
+      }
+    }
+  }
+  finalize() {
+    return;
+  }
+  async parseID3v2() {
+    await this.tryReadId3v2Headers();
+    debug("End of ID3v2 header, go to MPEG-parser: pos=%s", this.tokenizer.position);
+    await this.postId3v2Parse();
+    if (this.options.skipPostHeaders && this.metadata.hasAny()) {
+      this.finalize();
+    } else {
+      const id3v1parser = new ID3v1Parser(this.metadata, this.tokenizer, this.options);
+      await id3v1parser.parse();
+      this.finalize();
+    }
+  }
+  async tryReadId3v2Headers() {
+    const id3Header = await this.tokenizer.peekToken(ID3v2Header);
+    if (id3Header.fileIdentifier === "ID3") {
+      debug("Found ID3v2 header, pos=%s", this.tokenizer.position);
+      await this.id3parser.parse(this.metadata, this.tokenizer, this.options);
+      return this.tryReadId3v2Headers();
+    }
+  }
+};
+
+export {
+  AbstractID3Parser
+};