agdi 3.3.5 → 3.3.7

package/dist/chunk-YIHDW7JC.js

@@ -0,0 +1,314 @@
+import {
+  fromBuffer
+} from "./chunk-HNLU36CC.js";
+import {
+  a2hex,
+  findZero
+} from "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  FieldDecodingError,
+  InternalParserError,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  require_src,
+  textDecode,
+  textEncode
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/apev2/APEv2Parser.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/common/FourCC.js
+var validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
+var FourCcToken = {
+  len: 4,
+  get: (buf, off) => {
+    const id = textDecode(buf.subarray(off, off + FourCcToken.len), "latin1");
+    if (!id.match(validFourCC)) {
+      throw new FieldDecodingError(`FourCC contains invalid characters: ${a2hex(id)} "${id}"`);
+    }
+    return id;
+  },
+  put: (buffer, offset, id) => {
+    const str = textEncode(id, "latin1");
+    if (str.length !== 4)
+      throw new InternalParserError("Invalid length");
+    buffer.set(str, offset);
+    return offset + 4;
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/apev2/APEv2Token.js
+var DataType = {
+  text_utf8: 0,
+  binary: 1,
+  external_info: 2,
+  reserved: 3
+};
+var DescriptorParser = {
+  len: 52,
+  get: (buf, off) => {
+    return {
+      // should equal 'MAC '
+      ID: FourCcToken.get(buf, off),
+      // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
+      version: UINT32_LE.get(buf, off + 4) / 1e3,
+      // the number of descriptor bytes (allows later expansion of this header)
+      descriptorBytes: UINT32_LE.get(buf, off + 8),
+      // the number of header APE_HEADER bytes
+      headerBytes: UINT32_LE.get(buf, off + 12),
+      // the number of header APE_HEADER bytes
+      seekTableBytes: UINT32_LE.get(buf, off + 16),
+      // the number of header data bytes (from original file)
+      headerDataBytes: UINT32_LE.get(buf, off + 20),
+      // the number of bytes of APE frame data
+      apeFrameDataBytes: UINT32_LE.get(buf, off + 24),
+      // the high order number of APE frame data bytes
+      apeFrameDataBytesHigh: UINT32_LE.get(buf, off + 28),
+      // the terminating data of the file (not including tag data)
+      terminatingDataBytes: UINT32_LE.get(buf, off + 32),
+      // the MD5 hash of the file (see notes for usage... it's a little tricky)
+      fileMD5: new Uint8ArrayType(16).get(buf, off + 36)
+    };
+  }
+};
+var Header = {
+  len: 24,
+  get: (buf, off) => {
+    return {
+      // the compression level (see defines I.E. COMPRESSION_LEVEL_FAST)
+      compressionLevel: UINT16_LE.get(buf, off),
+      // any format flags (for future use)
+      formatFlags: UINT16_LE.get(buf, off + 2),
+      // the number of audio blocks in one frame
+      blocksPerFrame: UINT32_LE.get(buf, off + 4),
+      // the number of audio blocks in the final frame
+      finalFrameBlocks: UINT32_LE.get(buf, off + 8),
+      // the total number of frames
+      totalFrames: UINT32_LE.get(buf, off + 12),
+      // the bits per sample (typically 16)
+      bitsPerSample: UINT16_LE.get(buf, off + 16),
+      // the number of channels (1 or 2)
+      channel: UINT16_LE.get(buf, off + 18),
+      // the sample rate (typically 44100)
+      sampleRate: UINT32_LE.get(buf, off + 20)
+    };
+  }
+};
+var TagFooter = {
+  len: 32,
+  get: (buf, off) => {
+    return {
+      // should equal 'APETAGEX'
+      ID: new StringType(8, "ascii").get(buf, off),
+      // equals CURRENT_APE_TAG_VERSION
+      version: UINT32_LE.get(buf, off + 8),
+      // the complete size of the tag, including this footer (excludes header)
+      size: UINT32_LE.get(buf, off + 12),
+      // the number of fields in the tag
+      fields: UINT32_LE.get(buf, off + 16),
+      // reserved for later use (must be zero),
+      flags: parseTagFlags(UINT32_LE.get(buf, off + 20))
+    };
+  }
+};
+var TagItemHeader = {
+  len: 8,
+  get: (buf, off) => {
+    return {
+      // Length of assigned value in bytes
+      size: UINT32_LE.get(buf, off),
+      // reserved for later use (must be zero),
+      flags: parseTagFlags(UINT32_LE.get(buf, off + 4))
+    };
+  }
+};
+function parseTagFlags(flags) {
+  return {
+    containsHeader: isBitSet(flags, 31),
+    containsFooter: isBitSet(flags, 30),
+    isHeader: isBitSet(flags, 29),
+    readOnly: isBitSet(flags, 0),
+    dataType: (flags & 6) >> 1
+  };
+}
+function isBitSet(num, bit) {
+  return (num & 1 << bit) !== 0;
+}
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/apev2/APEv2Parser.js
+var debug = (0, import_debug.default)("music-metadata:parser:APEv2");
+var tagFormat = "APEv2";
+var preamble = "APETAGEX";
+var ApeContentError = class extends makeUnexpectedFileContentError("APEv2") {
+};
+function tryParseApeHeader(metadata, tokenizer, options) {
+  const apeParser = new APEv2Parser(metadata, tokenizer, options);
+  return apeParser.tryParseApeHeader();
+}
+var APEv2Parser = class _APEv2Parser extends BasicParser {
+  constructor() {
+    super(...arguments);
+    this.ape = {};
+  }
+  /**
+   * Calculate the media file duration
+   * @param ah ApeHeader
+   * @return {number} duration in seconds
+   */
+  static calculateDuration(ah) {
+    let duration = ah.totalFrames > 1 ? ah.blocksPerFrame * (ah.totalFrames - 1) : 0;
+    duration += ah.finalFrameBlocks;
+    return duration / ah.sampleRate;
+  }
+  /**
+   * Calculates the APEv1 / APEv2 first field offset
+   * @param tokenizer
+   * @param offset
+   */
+  static async findApeFooterOffset(tokenizer, offset) {
+    const apeBuf = new Uint8Array(TagFooter.len);
+    const position = tokenizer.position;
+    if (offset <= TagFooter.len) {
+      debug(`Offset is too small to read APE footer: offset=${offset}`);
+      return void 0;
+    }
+    if (offset > TagFooter.len) {
+      await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len });
+      tokenizer.setPosition(position);
+      const tagFooter = TagFooter.get(apeBuf, 0);
+      if (tagFooter.ID === "APETAGEX") {
+        if (tagFooter.flags.isHeader) {
+          debug(`APE Header found at offset=${offset - TagFooter.len}`);
+        } else {
+          debug(`APE Footer found at offset=${offset - TagFooter.len}`);
+          offset -= tagFooter.size;
+        }
+        return { footer: tagFooter, offset };
+      }
+    }
+  }
+  static parseTagFooter(metadata, buffer, options) {
+    const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
+    if (footer.ID !== preamble)
+      throw new ApeContentError("Unexpected APEv2 Footer ID preamble value");
+    fromBuffer(buffer);
+    const apeParser = new _APEv2Parser(metadata, fromBuffer(buffer), options);
+    return apeParser.parseTags(footer);
+  }
+  /**
+   * Parse APEv1 / APEv2 header if header signature found
+   */
+  async tryParseApeHeader() {
+    if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
+      debug("No APEv2 header found, end-of-file reached");
+      return;
+    }
+    const footer = await this.tokenizer.peekToken(TagFooter);
+    if (footer.ID === preamble) {
+      await this.tokenizer.ignore(TagFooter.len);
+      return this.parseTags(footer);
+    }
+    debug(`APEv2 header not found at offset=${this.tokenizer.position}`);
+    if (this.tokenizer.fileInfo.size) {
+      const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position;
+      const buffer = new Uint8Array(remaining);
+      await this.tokenizer.readBuffer(buffer);
+      return _APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
+    }
+  }
+  async parse() {
+    const descriptor = await this.tokenizer.readToken(DescriptorParser);
+    if (descriptor.ID !== "MAC ")
+      throw new ApeContentError("Unexpected descriptor ID");
+    this.ape.descriptor = descriptor;
+    const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
+    const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
+    this.metadata.setAudioOnly();
+    await this.tokenizer.ignore(header.forwardBytes);
+    return this.tryParseApeHeader();
+  }
+  async parseTags(footer) {
+    const keyBuffer = new Uint8Array(256);
+    let bytesRemaining = footer.size - TagFooter.len;
+    debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
+    for (let i = 0; i < footer.fields; i++) {
+      if (bytesRemaining < TagItemHeader.len) {
+        this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
+        break;
+      }
+      const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
+      bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
+      await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
+      let zero = findZero(keyBuffer);
+      const key = await this.tokenizer.readToken(new StringType(zero, "ascii"));
+      await this.tokenizer.ignore(1);
+      bytesRemaining -= key.length + 1;
+      switch (tagItemHeader.flags.dataType) {
+        case DataType.text_utf8: {
+          const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, "utf8"));
+          const values = value.split(/\x00/g);
+          await Promise.all(values.map((val) => this.metadata.addTag(tagFormat, key, val)));
+          break;
+        }
+        case DataType.binary:
+          if (this.options.skipCovers) {
+            await this.tokenizer.ignore(tagItemHeader.size);
+          } else {
+            const picData = new Uint8Array(tagItemHeader.size);
+            await this.tokenizer.readBuffer(picData);
+            zero = findZero(picData);
+            const description = textDecode(picData.subarray(0, zero), "utf-8");
+            const data = picData.subarray(zero + 1);
+            await this.metadata.addTag(tagFormat, key, {
+              description,
+              data
+            });
+          }
+          break;
+        case DataType.external_info:
+          debug(`Ignore external info ${key}`);
+          await this.tokenizer.ignore(tagItemHeader.size);
+          break;
+        case DataType.reserved:
+          debug(`Ignore external info ${key}`);
+          this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`);
+          await this.tokenizer.ignore(tagItemHeader.size);
+          break;
+      }
+    }
+  }
+  async parseDescriptorExpansion(lenExp) {
+    await this.tokenizer.ignore(lenExp);
+    return this.parseHeader();
+  }
+  async parseHeader() {
+    const header = await this.tokenizer.readToken(Header);
+    this.metadata.setFormat("lossless", true);
+    this.metadata.setFormat("container", "Monkey's Audio");
+    this.metadata.setFormat("bitsPerSample", header.bitsPerSample);
+    this.metadata.setFormat("sampleRate", header.sampleRate);
+    this.metadata.setFormat("numberOfChannels", header.channel);
+    this.metadata.setFormat("duration", _APEv2Parser.calculateDuration(header));
+    if (!this.ape.descriptor) {
+      throw new ApeContentError("Missing APE descriptor");
+    }
+    return {
+      forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes + this.ape.descriptor.apeFrameDataBytes + this.ape.descriptor.terminatingDataBytes
+    };
+  }
+};
+
+export {
+  FourCcToken,
+  ApeContentError,
+  tryParseApeHeader,
+  APEv2Parser
+};

package/dist/config-D3QBUN2Y.js

@@ -0,0 +1,13 @@
+import {
+  getConfigDir,
+  loadConfig,
+  saveConfig,
+  secureDeleteConfig
+} from "./chunk-OPFFFAQC.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  getConfigDir,
+  loadConfig,
+  saveConfig,
+  secureDeleteConfig
+};

package/dist/{config-ZFU7TSU2.js → config-K2XM6D4Z.js}

@@ -5,8 +5,9 @@ import {
   isTelemetryEnabled,
   markConsentAsked,
   setTelemetryConsent
-} from "./chunk-M2FF7ETI.js";
-import "./chunk-S45VXJEO.js";
+} from "./chunk-J6OLLWVT.js";
+import "./chunk-OPFFFAQC.js";
+import "./chunk-4VNS5WPM.js";
 export {
   getAnonymousId,
   getTelemetryConfig,

package/dist/{event-bus-Q3WCETQQ.js → event-bus-MO5SFUME.js}

@@ -3,6 +3,7 @@ import {
   cleanupEventBus,
   emitAgentEvent
 } from "./chunk-A5UTYKKM.js";
+import "./chunk-4VNS5WPM.js";
 export {
   agentEventBus,
   cleanupEventBus,