@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-XNPZBLYL.mjs

@@ -0,0 +1,33 @@
+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);
+
+// src/main/tui/api/types.ts
+var MAIN_LOOP = "main", DaemonError = class extends Error {
+  constructor(message, status, body = null) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "DaemonError";
+  }
+  status;
+  body;
+  /** True when the daemon could not be reached at all (vs. answered with an error). */
+  get unreachable() {
+    return this.status === null;
+  }
+};
+function isCredentialsLocked(err) {
+  if (!(err instanceof DaemonError) || err.status !== 409) return !1;
+  let body = err.body;
+  return !!body && typeof body == "object" && body.code === "credentials_locked";
+}
+
+export {
+  MAIN_LOOP,
+  DaemonError,
+  isCredentialsLocked
+};

package/dist/chunks/chunk-XX7OSWTO.mjs

@@ -0,0 +1,157 @@
+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 {
+  FieldDecodingError,
+  StringType
+} from "./chunk-I2HJYHFT.mjs";
+
+// node_modules/uint8array-extras/index.js
+var objectToString = Object.prototype.toString, uint8ArrayStringified = "[object Uint8Array]";
+function isType(value, typeConstructor, typeStringified) {
+  return value ? value.constructor === typeConstructor ? !0 : objectToString.call(value) === typeStringified : !1;
+}
+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) {
+  let { 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/music-metadata/lib/common/Util.js
+function getBit(buf, off, bit) {
+  return (buf[off] & 1 << bit) !== 0;
+}
+function findZero(uint8Array, encoding) {
+  let len = uint8Array.length;
+  if (encoding === "utf-16le" || encoding === "utf-16be") {
+    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) {
+  let pos0 = x.indexOf("\0");
+  return pos0 === -1 ? x : x.substring(0, pos0);
+}
+function swapBytes(uint8Array) {
+  let l = uint8Array.length;
+  if ((l & 1) !== 0)
+    throw new FieldDecodingError("Buffer length must be even");
+  for (let i = 0; i < l; i += 2) {
+    let 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);
+  }
+  if (encoding === "utf-16be") {
+    if ((uint8Array.length & 1) !== 0)
+      throw new FieldDecodingError("Expected even number of octets for 16-bit unicode string");
+    return new StringType(uint8Array.length, "utf-16le").get(swapBytes(Uint8Array.from(uint8Array)), 0);
+  }
+  return new StringType(uint8Array.length, encoding).get(uint8Array, 0);
+}
+function stripNulls(str) {
+  return str = str.replace(/^\x00+/g, ""), str = str.replace(/\x00+$/g, ""), str;
+}
+function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
+  let byteOff = byteOffset + ~~(bitOffset / 8), bitOff = bitOffset % 8, value = source[byteOff];
+  value &= 255 >> bitOff;
+  let bitsRead = 8 - bitOff, bitsLeft = len - bitsRead;
+  return bitsLeft < 0 ? value >>= 8 - bitOff - len : bitsLeft > 0 && (value <<= bitsLeft, value |= getBitAllignedNumber(source, byteOffset, bitOffset + bitsRead, bitsLeft)), value;
+}
+function isBitSet(source, byteOffset, bitOffset) {
+  return getBitAllignedNumber(source, byteOffset, bitOffset, 1) === 1;
+}
+function a2hex(str) {
+  let arr = [];
+  for (let i = 0, l = str.length; i < l; i++) {
+    let 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) {
+  let ps = value.split(" ").map((p) => p.trim().toLowerCase());
+  if (ps.length >= 1) {
+    let 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");
+  let 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
+};