agdi 3.3.5 → 3.3.7

package/dist/chunk-AGSFUVRG.js

@@ -0,0 +1,439 @@
+import {
+  AbstractID3Parser
+} from "./chunk-3JKZUGPJ.js";
+import {
+  FourCcToken
+} from "./chunk-YIHDW7JC.js";
+import {
+  AttachedPictureType
+} from "./chunk-LREP5CZP.js";
+import {
+  getBit,
+  getBitAllignedNumber
+} from "./chunk-GD35BJSH.js";
+import {
+  StringType,
+  UINT16_BE,
+  UINT24_BE,
+  UINT32_BE,
+  UINT32_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  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/flac/FlacParser.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.js
+var VorbisPictureToken = class _VorbisPictureToken {
+  static fromBase64(base64str) {
+    return _VorbisPictureToken.fromBuffer(Uint8Array.from(atob(base64str), (c) => c.charCodeAt(0)));
+  }
+  static fromBuffer(buffer) {
+    const pic = new _VorbisPictureToken(buffer.length);
+    return pic.get(buffer, 0);
+  }
+  constructor(len) {
+    this.len = len;
+  }
+  get(buffer, offset) {
+    const type = AttachedPictureType[UINT32_BE.get(buffer, offset)];
+    offset += 4;
+    const mimeLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const format = new StringType(mimeLen, "utf-8").get(buffer, offset);
+    offset += mimeLen;
+    const descLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const description = new StringType(descLen, "utf-8").get(buffer, offset);
+    offset += descLen;
+    const width = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const height = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const colour_depth = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const indexed_color = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const picDataLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    const data = buffer.slice(offset, offset + picDataLen);
+    return {
+      type,
+      format,
+      description,
+      width,
+      height,
+      colour_depth,
+      indexed_color,
+      data
+    };
+  }
+};
+var CommonHeader = {
+  len: 7,
+  get: (buf, off) => {
+    return {
+      packetType: UINT8.get(buf, off),
+      vorbis: new StringType(6, "ascii").get(buf, off + 1)
+    };
+  }
+};
+var IdentificationHeader = {
+  len: 23,
+  get: (uint8Array, off) => {
+    return {
+      version: UINT32_LE.get(uint8Array, off + 0),
+      channelMode: UINT8.get(uint8Array, off + 4),
+      sampleRate: UINT32_LE.get(uint8Array, off + 5),
+      bitrateMax: UINT32_LE.get(uint8Array, off + 9),
+      bitrateNominal: UINT32_LE.get(uint8Array, off + 13),
+      bitrateMin: UINT32_LE.get(uint8Array, off + 17)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.js
+var VorbisDecoder = class {
+  constructor(data, offset) {
+    this.data = data;
+    this.offset = offset;
+  }
+  readInt32() {
+    const value = UINT32_LE.get(this.data, this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readStringUtf8() {
+    const len = this.readInt32();
+    const value = textDecode(this.data.subarray(this.offset, this.offset + len), "utf-8");
+    this.offset += len;
+    return value;
+  }
+  parseUserComment() {
+    const offset0 = this.offset;
+    const v = this.readStringUtf8();
+    const idx = v.indexOf("=");
+    return {
+      key: v.substring(0, idx).toUpperCase(),
+      value: v.substring(idx + 1),
+      len: this.offset - offset0
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.js
+var debug = (0, import_debug.default)("music-metadata:parser:ogg:vorbis1");
+var VorbisContentError = class extends makeUnexpectedFileContentError("Vorbis") {
+};
+var VorbisStream = class _VorbisStream {
+  constructor(metadata, options) {
+    this.pageSegments = [];
+    this.durationOnLastPage = true;
+    this.metadata = metadata;
+    this.options = options;
+  }
+  /**
+   * Vorbis 1 parser
+   * @param header Ogg Page Header
+   * @param pageData Page data
+   */
+  async parsePage(header, pageData) {
+    this.lastPageHeader = header;
+    if (header.headerType.firstPage) {
+      this.parseFirstPage(header, pageData);
+    } else {
+      if (header.headerType.continued) {
+        if (this.pageSegments.length === 0) {
+          throw new VorbisContentError("Cannot continue on previous page");
+        }
+        this.pageSegments.push(pageData);
+      }
+      if (header.headerType.lastPage || !header.headerType.continued) {
+        if (this.pageSegments.length > 0) {
+          const fullPage = _VorbisStream.mergeUint8Arrays(this.pageSegments);
+          await this.parseFullPage(fullPage);
+        }
+        this.pageSegments = header.headerType.lastPage ? [] : [pageData];
+      }
+    }
+  }
+  static mergeUint8Arrays(arrays) {
+    const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
+    const merged = new Uint8Array(totalSize);
+    arrays.forEach((array, i, _arrays) => {
+      const offset = _arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
+      merged.set(array, offset);
+    });
+    return merged;
+  }
+  async flush() {
+    await this.parseFullPage(_VorbisStream.mergeUint8Arrays(this.pageSegments));
+  }
+  async parseUserComment(pageData, offset) {
+    const decoder = new VorbisDecoder(pageData, offset);
+    const tag = decoder.parseUserComment();
+    await this.addTag(tag.key, tag.value);
+    return tag.len;
+  }
+  async addTag(id, value) {
+    if (id === "METADATA_BLOCK_PICTURE" && typeof value === "string") {
+      if (this.options.skipCovers) {
+        debug("Ignore picture");
+        return;
+      }
+      value = VorbisPictureToken.fromBase64(value);
+      debug(`Push picture: id=${id}, format=${value.format}`);
+    } else {
+      debug(`Push tag: id=${id}, value=${value}`);
+    }
+    await this.metadata.addTag("vorbis", id, value);
+  }
+  calculateDuration(_enfOfStream) {
+    if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+      this.metadata.setFormat("numberOfSamples", this.lastPageHeader.absoluteGranulePosition);
+      this.metadata.setFormat("duration", this.lastPageHeader.absoluteGranulePosition / this.metadata.format.sampleRate);
+    }
+  }
+  /**
+   * Parse first Ogg/Vorbis page
+   * @param _header
+   * @param pageData
+   */
+  parseFirstPage(_header, pageData) {
+    this.metadata.setFormat("codec", "Vorbis I");
+    this.metadata.setFormat("hasAudio", true);
+    debug("Parse first page");
+    const commonHeader = CommonHeader.get(pageData, 0);
+    if (commonHeader.vorbis !== "vorbis")
+      throw new VorbisContentError("Metadata does not look like Vorbis");
+    if (commonHeader.packetType === 1) {
+      const idHeader = IdentificationHeader.get(pageData, CommonHeader.len);
+      this.metadata.setFormat("sampleRate", idHeader.sampleRate);
+      this.metadata.setFormat("bitrate", idHeader.bitrateNominal);
+      this.metadata.setFormat("numberOfChannels", idHeader.channelMode);
+      debug("sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s", idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
+    } else
+      throw new VorbisContentError("First Ogg page should be type 1: the identification header");
+  }
+  async parseFullPage(pageData) {
+    const commonHeader = CommonHeader.get(pageData, 0);
+    debug("Parse full page: type=%s, byteLength=%s", commonHeader.packetType, pageData.byteLength);
+    switch (commonHeader.packetType) {
+      case 3:
+        return this.parseUserCommentList(pageData, CommonHeader.len);
+      case 1:
+      // type 1: the identification header
+      case 5:
+        break;
+    }
+  }
+  /**
+   * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+   */
+  async parseUserCommentList(pageData, offset) {
+    const strLen = UINT32_LE.get(pageData, offset);
+    offset += 4;
+    offset += strLen;
+    let userCommentListLength = UINT32_LE.get(pageData, offset);
+    offset += 4;
+    while (userCommentListLength-- > 0) {
+      offset += await this.parseUserComment(pageData, offset);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/flac/FlacToken.js
+var BlockType = {
+  STREAMINFO: 0,
+  // STREAMINFO
+  PADDING: 1,
+  // PADDING
+  APPLICATION: 2,
+  // APPLICATION
+  SEEKTABLE: 3,
+  // SEEKTABLE
+  VORBIS_COMMENT: 4,
+  // VORBIS_COMMENT
+  CUESHEET: 5,
+  // CUESHEET
+  PICTURE: 6
+  // PICTURE
+};
+var BlockHeader = {
+  len: 4,
+  get: (buf, off) => {
+    return {
+      lastBlock: getBit(buf, off, 7),
+      type: getBitAllignedNumber(buf, off, 1, 7),
+      length: UINT24_BE.get(buf, off + 1)
+    };
+  }
+};
+var BlockStreamInfo = {
+  len: 34,
+  get: (buf, off) => {
+    return {
+      // The minimum block size (in samples) used in the stream.
+      minimumBlockSize: UINT16_BE.get(buf, off),
+      // The maximum block size (in samples) used in the stream.
+      // (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
+      maximumBlockSize: UINT16_BE.get(buf, off + 2) / 1e3,
+      // The minimum frame size (in bytes) used in the stream.
+      // May be 0 to imply the value is not known.
+      minimumFrameSize: UINT24_BE.get(buf, off + 4),
+      // The maximum frame size (in bytes) used in the stream.
+      // May be 0 to imply the value is not known.
+      maximumFrameSize: UINT24_BE.get(buf, off + 7),
+      // Sample rate in Hz. Though 20 bits are available,
+      // the maximum sample rate is limited by the structure of frame headers to 655350Hz.
+      // Also, a value of 0 is invalid.
+      sampleRate: UINT24_BE.get(buf, off + 10) >> 4,
+      // probably slower: sampleRate: common.getBitAllignedNumber(buf, off + 10, 0, 20),
+      // (number of channels)-1. FLAC supports from 1 to 8 channels
+      channels: getBitAllignedNumber(buf, off + 12, 4, 3) + 1,
+      // bits per sample)-1.
+      // FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
+      bitsPerSample: getBitAllignedNumber(buf, off + 12, 7, 5) + 1,
+      // Total samples in stream.
+      // 'Samples' means inter-channel sample, i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
+      // A value of zero here means the number of total samples is unknown.
+      totalSamples: getBitAllignedNumber(buf, off + 13, 4, 36),
+      // the MD5 hash of the file (see notes for usage... it's a littly tricky)
+      fileMD5: new Uint8ArrayType(16).get(buf, off + 18)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/flac/FlacParser.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:FLAC");
+var FlacContentError = class extends makeUnexpectedFileContentError("FLAC") {
+};
+var FlacParser = class extends AbstractID3Parser {
+  constructor() {
+    super(...arguments);
+    this.vorbisParser = new VorbisStream(this.metadata, this.options);
+  }
+  async postId3v2Parse() {
+    const fourCC = await this.tokenizer.readToken(FourCcToken);
+    if (fourCC.toString() !== "fLaC") {
+      throw new FlacContentError("Invalid FLAC preamble");
+    }
+    let blockHeader;
+    do {
+      blockHeader = await this.tokenizer.readToken(BlockHeader);
+      await this.parseDataBlock(blockHeader);
+    } while (!blockHeader.lastBlock);
+    if (this.tokenizer.fileInfo.size && this.metadata.format.duration) {
+      const dataSize = this.tokenizer.fileInfo.size - this.tokenizer.position;
+      this.metadata.setFormat("bitrate", 8 * dataSize / this.metadata.format.duration);
+    }
+  }
+  async parseDataBlock(blockHeader) {
+    debug2(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
+    switch (blockHeader.type) {
+      case BlockType.STREAMINFO:
+        return this.readBlockStreamInfo(blockHeader.length);
+      case BlockType.PADDING:
+        break;
+      case BlockType.APPLICATION:
+        break;
+      case BlockType.SEEKTABLE:
+        break;
+      case BlockType.VORBIS_COMMENT:
+        return this.readComment(blockHeader.length);
+      case BlockType.CUESHEET:
+        break;
+      case BlockType.PICTURE:
+        await this.parsePicture(blockHeader.length);
+        return;
+      default:
+        this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+    }
+    return this.tokenizer.ignore(blockHeader.length).then();
+  }
+  /**
+   * Parse STREAMINFO
+   */
+  async readBlockStreamInfo(dataLen) {
+    if (dataLen !== BlockStreamInfo.len)
+      throw new FlacContentError("Unexpected block-stream-info length");
+    const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
+    this.metadata.setFormat("container", "FLAC");
+    this.processsStreamInfo(streamInfo);
+  }
+  /**
+   * Parse STREAMINFO
+   */
+  processsStreamInfo(streamInfo) {
+    this.metadata.setFormat("codec", "FLAC");
+    this.metadata.setFormat("hasAudio", true);
+    this.metadata.setFormat("lossless", true);
+    this.metadata.setFormat("numberOfChannels", streamInfo.channels);
+    this.metadata.setFormat("bitsPerSample", streamInfo.bitsPerSample);
+    this.metadata.setFormat("sampleRate", streamInfo.sampleRate);
+    if (streamInfo.totalSamples > 0) {
+      this.metadata.setFormat("duration", streamInfo.totalSamples / streamInfo.sampleRate);
+    }
+  }
+  /**
+   * Read VORBIS_COMMENT from tokenizer
+   * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+   */
+  async readComment(dataLen) {
+    const data = await this.tokenizer.readToken(new Uint8ArrayType(dataLen));
+    return this.parseComment(data);
+  }
+  /**
+   * Parse VORBIS_COMMENT
+   * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+   */
+  async parseComment(data) {
+    const decoder = new VorbisDecoder(data, 0);
+    const vendor = decoder.readStringUtf8();
+    if (vendor.length > 0) {
+      this.metadata.setFormat("tool", vendor);
+    }
+    const commentListLength = decoder.readInt32();
+    const tags = new Array(commentListLength);
+    for (let i = 0; i < commentListLength; i++) {
+      tags[i] = decoder.parseUserComment();
+    }
+    await Promise.all(tags.map((tag) => {
+      if (tag.key === "ENCODER") {
+        this.metadata.setFormat("tool", tag.value);
+      }
+      return this.addTag(tag.key, tag.value);
+    }));
+  }
+  async parsePicture(dataLen) {
+    if (this.options.skipCovers) {
+      return this.tokenizer.ignore(dataLen);
+    }
+    return this.addPictureTag(await this.tokenizer.readToken(new VorbisPictureToken(dataLen)));
+  }
+  addPictureTag(picture) {
+    return this.addTag("METADATA_BLOCK_PICTURE", picture);
+  }
+  addTag(id, value) {
+    return this.vorbisParser.addTag(id, value);
+  }
+};
+
+export {
+  VorbisPictureToken,
+  VorbisStream,
+  BlockType,
+  BlockHeader,
+  BlockStreamInfo,
+  FlacParser
+};

package/dist/chunk-GD35BJSH.js

@@ -0,0 +1,177 @@
+import {
+  FieldDecodingError,
+  StringType
+} from "./chunk-VGOIHW7D.js";
+
+// ../../node_modules/.pnpm/uint8array-extras@1.5.0/node_modules/uint8array-extras/index.js
+var objectToString = Object.prototype.toString;
+var uint8ArrayStringified = "[object Uint8Array]";
+function isType(value, typeConstructor, typeStringified) {
+  if (!value) {
+    return false;
+  }
+  if (value.constructor === typeConstructor) {
+    return true;
+  }
+  return objectToString.call(value) === typeStringified;
+}
+function isUint8Array(value) {
+  return isType(value, Uint8Array, uint8ArrayStringified);
+}
+function assertUint8Array(value) {
+  if (!isUint8Array(value)) {
+    throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+  }
+}
+var cachedDecoders = {
+  utf8: new globalThis.TextDecoder("utf8")
+};
+var cachedEncoder = new globalThis.TextEncoder();
+var byteToHexLookupTable = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0"));
+function uint8ArrayToHex(array) {
+  assertUint8Array(array);
+  let hexString = "";
+  for (let index = 0; index < array.length; index++) {
+    hexString += byteToHexLookupTable[array[index]];
+  }
+  return hexString;
+}
+function getUintBE(view) {
+  const { byteLength } = view;
+  if (byteLength === 6) {
+    return view.getUint16(0) * 2 ** 32 + view.getUint32(2);
+  }
+  if (byteLength === 5) {
+    return view.getUint8(0) * 2 ** 32 + view.getUint32(1);
+  }
+  if (byteLength === 4) {
+    return view.getUint32(0);
+  }
+  if (byteLength === 3) {
+    return view.getUint8(0) * 2 ** 16 + view.getUint16(1);
+  }
+  if (byteLength === 2) {
+    return view.getUint16(0);
+  }
+  if (byteLength === 1) {
+    return view.getUint8(0);
+  }
+}
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/common/Util.js
+function getBit(buf, off, bit) {
+  return (buf[off] & 1 << bit) !== 0;
+}
+function findZero(uint8Array, encoding) {
+  const len = uint8Array.length;
+  if (encoding === "utf-16le") {
+    for (let i = 0; i + 1 < len; i += 2) {
+      if (uint8Array[i] === 0 && uint8Array[i + 1] === 0)
+        return i;
+    }
+    return len;
+  }
+  for (let i = 0; i < len; i++) {
+    if (uint8Array[i] === 0)
+      return i;
+  }
+  return len;
+}
+function trimRightNull(x) {
+  const pos0 = x.indexOf("\0");
+  return pos0 === -1 ? x : x.substring(0, pos0);
+}
+function swapBytes(uint8Array) {
+  const l = uint8Array.length;
+  if ((l & 1) !== 0)
+    throw new FieldDecodingError("Buffer length must be even");
+  for (let i = 0; i < l; i += 2) {
+    const a = uint8Array[i];
+    uint8Array[i] = uint8Array[i + 1];
+    uint8Array[i + 1] = a;
+  }
+  return uint8Array;
+}
+function decodeString(uint8Array, encoding) {
+  if (uint8Array[0] === 255 && uint8Array[1] === 254) {
+    return decodeString(uint8Array.subarray(2), encoding);
+  }
+  if (encoding === "utf-16le" && uint8Array[0] === 254 && uint8Array[1] === 255) {
+    if ((uint8Array.length & 1) !== 0)
+      throw new FieldDecodingError("Expected even number of octets for 16-bit unicode string");
+    return decodeString(swapBytes(uint8Array), encoding);
+  }
+  return new StringType(uint8Array.length, encoding).get(uint8Array, 0);
+}
+function stripNulls(str) {
+  str = str.replace(/^\x00+/g, "");
+  str = str.replace(/\x00+$/g, "");
+  return str;
+}
+function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
+  const byteOff = byteOffset + ~~(bitOffset / 8);
+  const bitOff = bitOffset % 8;
+  let value = source[byteOff];
+  value &= 255 >> bitOff;
+  const bitsRead = 8 - bitOff;
+  const bitsLeft = len - bitsRead;
+  if (bitsLeft < 0) {
+    value >>= 8 - bitOff - len;
+  } else if (bitsLeft > 0) {
+    value <<= bitsLeft;
+    value |= getBitAllignedNumber(source, byteOffset, bitOffset + bitsRead, bitsLeft);
+  }
+  return value;
+}
+function isBitSet(source, byteOffset, bitOffset) {
+  return getBitAllignedNumber(source, byteOffset, bitOffset, 1) === 1;
+}
+function a2hex(str) {
+  const arr = [];
+  for (let i = 0, l = str.length; i < l; i++) {
+    const hex = Number(str.charCodeAt(i)).toString(16);
+    arr.push(hex.length === 1 ? `0${hex}` : hex);
+  }
+  return arr.join(" ");
+}
+function ratioToDb(ratio) {
+  return 10 * Math.log10(ratio);
+}
+function dbToRatio(dB) {
+  return 10 ** (dB / 10);
+}
+function toRatio(value) {
+  const ps = value.split(" ").map((p) => p.trim().toLowerCase());
+  if (ps.length >= 1) {
+    const v = Number.parseFloat(ps[0]);
+    return ps.length === 2 && ps[1] === "db" ? {
+      dB: v,
+      ratio: dbToRatio(v)
+    } : {
+      dB: ratioToDb(v),
+      ratio: v
+    };
+  }
+}
+function decodeUintBE(uint8Array) {
+  if (uint8Array.length === 0) {
+    throw new Error("decodeUintBE: empty Uint8Array");
+  }
+  const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+  return getUintBE(view);
+}
+
+export {
+  uint8ArrayToHex,
+  getUintBE,
+  getBit,
+  findZero,
+  trimRightNull,
+  decodeString,
+  stripNulls,
+  getBitAllignedNumber,
+  isBitSet,
+  a2hex,
+  toRatio,
+  decodeUintBE
+};