@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-7T2YMTWL.mjs

@@ -0,0 +1,374 @@
+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 {
+  AbstractID3Parser
+} from "./chunk-62NE4LG4.mjs";
+import {
+  AttachedPictureType
+} from "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  getBit,
+  getBitAllignedNumber
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  StringType,
+  UINT16_BE,
+  UINT24_BE,
+  UINT32_BE,
+  UINT32_LE,
+  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/flac/FlacParser.js
+var import_debug2 = __toESM(require_src(), 1);
+
+// 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) {
+    return new _VorbisPictureToken(buffer.length).get(buffer, 0);
+  }
+  constructor(len) {
+    this.len = len;
+  }
+  get(buffer, offset) {
+    let type = AttachedPictureType[UINT32_BE.get(buffer, offset)];
+    offset += 4;
+    let mimeLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let format = new StringType(mimeLen, "utf-8").get(buffer, offset);
+    offset += mimeLen;
+    let descLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let description = new StringType(descLen, "utf-8").get(buffer, offset);
+    offset += descLen;
+    let width = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let height = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let colour_depth = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let indexed_color = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let picDataLen = UINT32_BE.get(buffer, offset);
+    offset += 4;
+    let data = buffer.slice(offset, offset + picDataLen);
+    return {
+      type,
+      format,
+      description,
+      width,
+      height,
+      colour_depth,
+      indexed_color,
+      data
+    };
+  }
+}, CommonHeader = {
+  len: 7,
+  get: (buf, off) => ({
+    packetType: UINT8.get(buf, off),
+    vorbis: new StringType(6, "ascii").get(buf, off + 1)
+  })
+}, IdentificationHeader = {
+  len: 23,
+  get: (uint8Array, off) => ({
+    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/music-metadata/lib/ogg/vorbis/VorbisStream.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.js
+var VorbisDecoder = class {
+  constructor(data, offset) {
+    this.data = data, this.offset = offset;
+  }
+  readInt32() {
+    let value = UINT32_LE.get(this.data, this.offset);
+    return this.offset += 4, value;
+  }
+  readStringUtf8() {
+    let len = this.readInt32(), value = textDecode(this.data.subarray(this.offset, this.offset + len), "utf-8");
+    return this.offset += len, value;
+  }
+  parseUserComment() {
+    let offset0 = this.offset, v = this.readStringUtf8(), idx = v.indexOf("=");
+    return {
+      key: v.substring(0, idx).toUpperCase(),
+      value: v.substring(idx + 1),
+      len: this.offset - offset0
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.js
+var debug = (0, import_debug.default)("music-metadata:parser:ogg:vorbis1"), VorbisContentError = class extends makeUnexpectedFileContentError("Vorbis") {
+}, VorbisStream = class _VorbisStream {
+  constructor(metadata, options) {
+    this.pageSegments = [], this.durationOnLastPage = !0, this.metadata = metadata, this.options = options;
+  }
+  /**
+   * Vorbis 1 parser
+   * @param header Ogg Page Header
+   * @param pageData Page data
+   */
+  async parsePage(header, pageData) {
+    if (this.lastPageHeader = header, 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) {
+          let fullPage = _VorbisStream.mergeUint8Arrays(this.pageSegments);
+          await this.parseFullPage(fullPage);
+        }
+        this.pageSegments = header.headerType.lastPage ? [] : [pageData];
+      }
+    }
+  }
+  static mergeUint8Arrays(arrays) {
+    let totalSize = arrays.reduce((acc, e) => acc + e.length, 0), merged = new Uint8Array(totalSize);
+    return arrays.forEach((array, i, _arrays) => {
+      let offset = _arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
+      merged.set(array, offset);
+    }), merged;
+  }
+  async flush() {
+    await this.parseFullPage(_VorbisStream.mergeUint8Arrays(this.pageSegments));
+  }
+  async parseUserComment(pageData, offset) {
+    let tag = new VorbisDecoder(pageData, offset).parseUserComment();
+    return await this.addTag(tag.key, tag.value), 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) {
+    this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && 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", !0), debug("Parse first page");
+    let commonHeader = CommonHeader.get(pageData, 0);
+    if (commonHeader.vorbis !== "vorbis")
+      throw new VorbisContentError("Metadata does not look like Vorbis");
+    if (commonHeader.packetType === 1) {
+      let 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) {
+    let commonHeader = CommonHeader.get(pageData, 0);
+    switch (debug("Parse full page: type=%s, byteLength=%s", commonHeader.packetType, pageData.byteLength), 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) {
+    let strLen = UINT32_LE.get(pageData, offset);
+    offset += 4, offset += strLen;
+    let userCommentListLength = UINT32_LE.get(pageData, offset);
+    for (offset += 4; userCommentListLength-- > 0; )
+      offset += await this.parseUserComment(pageData, offset);
+  }
+};
+
+// 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
+}, BlockHeader = {
+  len: 4,
+  get: (buf, off) => ({
+    lastBlock: getBit(buf, off, 7),
+    type: getBitAllignedNumber(buf, off, 1, 7),
+    length: UINT24_BE.get(buf, off + 1)
+  })
+}, BlockStreamInfo = {
+  len: 34,
+  get: (buf, off) => ({
+    // 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/music-metadata/lib/flac/FlacParser.js
+var debug2 = (0, import_debug2.default)("music-metadata:parser:FLAC"), FlacContentError = class extends makeUnexpectedFileContentError("FLAC") {
+}, FlacParser = class extends AbstractID3Parser {
+  constructor() {
+    super(...arguments), this.vorbisParser = new VorbisStream(this.metadata, this.options);
+  }
+  async postId3v2Parse() {
+    if ((await this.tokenizer.readToken(FourCcToken)).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) {
+      let dataSize = this.tokenizer.fileInfo.size - this.tokenizer.position;
+      this.metadata.setFormat("bitrate", 8 * dataSize / this.metadata.format.duration);
+    }
+  }
+  async parseDataBlock(blockHeader) {
+    switch (debug2(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`), 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");
+    let 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", !0), this.metadata.setFormat("lossless", !0), this.metadata.setFormat("numberOfChannels", streamInfo.channels), this.metadata.setFormat("bitsPerSample", streamInfo.bitsPerSample), this.metadata.setFormat("sampleRate", streamInfo.sampleRate), 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) {
+    let 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) {
+    let decoder = new VorbisDecoder(data, 0), vendor = decoder.readStringUtf8();
+    vendor.length > 0 && this.metadata.setFormat("tool", vendor);
+    let commentListLength = decoder.readInt32(), tags = new Array(commentListLength);
+    for (let i = 0; i < commentListLength; i++)
+      tags[i] = decoder.parseUserComment();
+    await Promise.all(tags.map((tag) => (tag.key === "ENCODER" && this.metadata.setFormat("tool", tag.value), this.addTag(tag.key, tag.value))));
+  }
+  async parsePicture(dataLen) {
+    return this.options.skipCovers ? this.tokenizer.ignore(dataLen) : 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/chunks/chunk-7XYNI52E.mjs

@@ -0,0 +1,149 @@
+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 {
+  require_react
+} from "./chunk-6GJ4QHRI.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/tui/app/terminal.ts
+var import_react = __toESM(require_react(), 1), MOUSE_ON = "\x1B[?1002h\x1B[?1006h", MOUSE_OFF = "\x1B[?1006l\x1B[?1002l\x1B[?1000l", ALT_SCROLL_ON = "\x1B[?1007h", ALT_SCROLL_OFF = "\x1B[?1007l", KITTY_ON = /\u001b\[>\d+u/, KITTY_OFF = "\x1B[<u", caps = { kitty: !1, shiftEnterSeen: !1, shiftEnterForced: !1, mouseWanted: !1, mouseActive: !1, altScrollActive: !1, altScreen: !1 }, listeners = /* @__PURE__ */ new Set(), out = null, rawMode = !1, writeTap = null, lastRaw = "";
+function setWriteTap(tap) {
+  writeTap = tap;
+}
+function writeTerminal(data) {
+  if (!out) return !1;
+  try {
+    out.write(data);
+  } catch {
+    return !1;
+  }
+  return !0;
+}
+function noteRawInput(data) {
+  lastRaw = data;
+}
+function lastRawInput() {
+  return lastRaw;
+}
+function superArrow(raw = lastRaw) {
+  let m = /^\u001b\[1;(\d+)([CD])$/.exec(raw);
+  return !m || (Number(m[1]) - 1 & 8) === 0 ? null : m[2] === "D" ? "left" : "right";
+}
+function set(patch) {
+  let next = { ...caps, ...patch };
+  if (!Object.keys(patch).every((k) => next[k] === caps[k])) {
+    caps = next;
+    for (let listener of listeners) listener();
+  }
+}
+function terminalCaps() {
+  return caps;
+}
+function useTerminalCaps() {
+  return (0, import_react.useSyncExternalStore)(
+    (listener) => (listeners.add(listener), () => {
+      listeners.delete(listener);
+    }),
+    () => caps,
+    () => caps
+  );
+}
+function shiftEnterWorks(c = caps) {
+  return c.kitty || c.shiftEnterSeen || c.shiftEnterForced;
+}
+function newlineKey(c = caps) {
+  return shiftEnterWorks(c) ? "shift+enter" : "alt+enter";
+}
+function noteShiftEnter() {
+  caps.shiftEnterSeen || set({ shiftEnterSeen: !0 });
+}
+function syncMouse() {
+  if (!out) return;
+  let live = caps.altScreen && rawMode, mouse = caps.mouseWanted && live, altScroll = !caps.mouseWanted && live, seq = "";
+  if (mouse !== caps.mouseActive && (seq += mouse ? MOUSE_ON : MOUSE_OFF), altScroll !== caps.altScrollActive && (seq += altScroll ? ALT_SCROLL_ON : ALT_SCROLL_OFF), !!seq) {
+    try {
+      out.write(seq);
+    } catch {
+    }
+    set({ mouseActive: mouse, altScrollActive: altScroll });
+  }
+}
+function setMouseWanted(on) {
+  set({ mouseWanted: on }), syncMouse();
+}
+function installTerminalModes(options) {
+  let { stdin, stdout } = options;
+  out = { write: (data) => originalWrite(data) }, caps = { kitty: !1, shiftEnterSeen: !1, shiftEnterForced: !!options.shiftEnterForced, mouseWanted: options.mouse, mouseActive: !1, altScrollActive: !1, altScreen: options.altScreen }, rawMode = !1;
+  let originalWrite = stdout.write.bind(stdout), patchedWrite = (data, ...rest) => {
+    typeof data == "string" && data.includes("\x1B[") && (data.includes(KITTY_OFF) ? set({ kitty: !1 }) : KITTY_ON.test(data) && set({ kitty: !0 }));
+    let result = originalWrite(data, ...rest);
+    if (writeTap)
+      try {
+        writeTap(typeof data == "string" ? data : Buffer.from(data).toString("utf8"));
+      } catch {
+      }
+    return result;
+  };
+  stdout.write = patchedWrite;
+  let originalSetRawMode = typeof stdin.setRawMode == "function" ? stdin.setRawMode.bind(stdin) : null;
+  originalSetRawMode && (stdin.setRawMode = (on) => {
+    on || (rawMode = !1, syncMouse());
+    let result = originalSetRawMode(on);
+    return on && (rawMode = !0, syncMouse()), result;
+  });
+  let restore = () => (caps.mouseActive ? MOUSE_OFF : "") + (caps.altScrollActive ? ALT_SCROLL_OFF : ""), onExit = () => {
+    let seq = restore();
+    if (seq)
+      try {
+        originalWrite(seq);
+      } catch {
+      }
+  };
+  return process.on("exit", onExit), () => {
+    process.off("exit", onExit);
+    let seq = restore();
+    if (seq)
+      try {
+        originalWrite(seq);
+      } catch {
+      }
+    stdout.write = originalWrite, originalSetRawMode && (stdin.setRawMode = originalSetRawMode), rawMode = !1, out = null, set({ mouseActive: !1, altScrollActive: !1, kitty: !1 });
+  };
+}
+var SGR_MOUSE = /^\u001b?\[<(\d+);(\d+);(\d+)([Mm])$/;
+function parseMouse(input) {
+  let match = SGR_MOUSE.exec(input);
+  if (!match) return null;
+  let code = Number(match[1]), x = Math.max(0, Number(match[2]) - 1), y = Math.max(0, Number(match[3]) - 1), mods = { shift: (code & 4) !== 0, alt: (code & 8) !== 0, ctrl: (code & 16) !== 0 }, base = code & -29;
+  return base >= 64 && base < 128 ? { kind: "wheel", delta: base === 64 ? -1 : base === 65 ? 1 : 0, button: -1, x, y, ...mods } : base & 32 ? { kind: "drag", delta: 0, button: base & 3, x, y, ...mods } : { kind: match[4] === "m" ? "release" : "press", delta: 0, button: base & 3, x, y, ...mods };
+}
+function isMouseGarbage(input) {
+  return /^\u001b?\[<\d+;\d+;\d+[Mm]/.test(input);
+}
+
+export {
+  MOUSE_ON,
+  MOUSE_OFF,
+  ALT_SCROLL_ON,
+  ALT_SCROLL_OFF,
+  setWriteTap,
+  writeTerminal,
+  noteRawInput,
+  lastRawInput,
+  superArrow,
+  terminalCaps,
+  useTerminalCaps,
+  shiftEnterWorks,
+  newlineKey,
+  noteShiftEnter,
+  setMouseWanted,
+  installTerminalModes,
+  parseMouse,
+  isMouseGarbage
+};