@utilix-tech/sdk 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -1736,13 +1736,7 @@ function generateMd5Hash(password) {
   return "$apr1$" + md5__default.default(password);
 }
 function generateBcryptHash(password, rounds = 10) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./";
-  let salt = "";
-  for (let i = 0; i < 22; i++) salt += chars[Math.floor(Math.random() * chars.length)];
-  const roundStr = rounds.toString().padStart(2, "0");
-  let hash = "";
-  for (let i = 0; i < 31; i++) hash += chars[Math.floor(Math.random() * chars.length)];
-  return `$2b$${roundStr}$${salt}${hash}`;
+  return bcrypt__default.default.hashSync(password, rounds);
 }
 function generatePlain(password) {
   return password;
@@ -1751,7 +1745,7 @@ function createEntry(username, password, algorithm = "bcrypt") {
   let hashedPassword;
   switch (algorithm) {
     case "bcrypt":
-      hashedPassword = generateBcryptHash();
+      hashedPassword = generateBcryptHash(password);
       break;
     case "sha1":
       hashedPassword = generateSha1Hash(password);
@@ -8894,6 +8888,7 @@ __export(api_exports, {
   parseCspHeader: () => parseCspHeader,
   parseCurl: () => parseCurl,
   parseCurlCommand: () => parseCurlCommand,
+  parseJwks: () => parseJwks,
   parseMetaTags: () => parseMetaTags,
   parseUrl: () => parseUrl,
   removeParam: () => removeParam,
@@ -9343,6 +9338,55 @@ function decodeJwt(token) {
 function formatJwtJson(obj) {
   return JSON.stringify(obj, null, 2);
 }
+function base64urlByteLength(s) {
+  const clean = s.replace(/=+$/, "");
+  return Math.floor(clean.length * 6 / 8);
+}
+function parseJwks(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: false, error: "No input provided" };
+  let data;
+  try {
+    data = JSON.parse(trimmed);
+  } catch (e) {
+    return { ok: false, error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  let rawKeys;
+  if (data && typeof data === "object" && Array.isArray(data.keys)) {
+    rawKeys = data.keys;
+  } else if (data && typeof data === "object" && typeof data.kty === "string") {
+    rawKeys = [data];
+  } else {
+    return { ok: false, error: 'Input must be a JWKS object with a "keys" array, or a single JWK object with a "kty" field' };
+  }
+  const keys = rawKeys.map((k) => {
+    const key = k ?? {};
+    const kty = typeof key.kty === "string" ? key.kty : "unknown";
+    let keySize = null;
+    let curve;
+    if (kty === "RSA" && typeof key.n === "string") {
+      keySize = base64urlByteLength(key.n) * 8;
+    } else if ((kty === "EC" || kty === "OKP") && typeof key.crv === "string") {
+      curve = key.crv;
+    } else if (kty === "oct" && typeof key.k === "string") {
+      keySize = base64urlByteLength(key.k) * 8;
+    }
+    return {
+      kty,
+      use: typeof key.use === "string" ? key.use : void 0,
+      keyOps: Array.isArray(key.key_ops) ? key.key_ops.filter((x) => typeof x === "string") : void 0,
+      alg: typeof key.alg === "string" ? key.alg : void 0,
+      kid: typeof key.kid === "string" ? key.kid : void 0,
+      keySize,
+      curve,
+      raw: key
+    };
+  });
+  const kidCounts = /* @__PURE__ */ new Map();
+  for (const k of keys) if (k.kid) kidCounts.set(k.kid, (kidCounts.get(k.kid) ?? 0) + 1);
+  const duplicateKids = [...kidCounts.entries()].filter(([, c]) => c > 1).map(([kid]) => kid);
+  return { ok: true, keys, count: keys.length, duplicateKids };
+}
 var ALG_TO_NODE_HASH = {
   HS256: "sha256",
   HS384: "sha384",
@@ -16884,7 +16928,9 @@ function summarizeForLlm(text, maxTokens = 200, strategy = "extractive") {
 // src/tools/media.ts
 var media_exports = {};
 __export(media_exports, {
-  readImageInfo: () => readImageInfo
+  readExifData: () => readExifData,
+  readImageInfo: () => readImageInfo,
+  readPdfMetadata: () => readPdfMetadata
 });
 function readU32BE(bytes, offset) {
   return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
@@ -17011,6 +17057,337 @@ function readImageInfo(bytes) {
   }
   return { error: "Unrecognized image format. Supported formats: PNG, JPEG, GIF, WebP, BMP" };
 }
+var ORIENTATION_LABELS = {
+  1: "Normal",
+  2: "Mirrored horizontal",
+  3: "Rotated 180\xB0",
+  4: "Mirrored vertical",
+  5: "Mirrored horizontal, rotated 90\xB0 CCW",
+  6: "Rotated 90\xB0 CW",
+  7: "Mirrored horizontal, rotated 90\xB0 CW",
+  8: "Rotated 90\xB0 CCW"
+};
+function tu16(r, o) {
+  return r.view.getUint16(o, r.little);
+}
+function tu32(r, o) {
+  return r.view.getUint32(o, r.little);
+}
+function readIfdEntries(r, ifdOffset) {
+  if (ifdOffset < 0 || ifdOffset + 2 > r.bytes.length) return null;
+  const numEntries = tu16(r, ifdOffset);
+  const entries = [];
+  for (let i = 0; i < numEntries; i++) {
+    const entryOffset = ifdOffset + 2 + i * 12;
+    if (entryOffset + 12 > r.bytes.length) break;
+    entries.push({
+      tag: tu16(r, entryOffset),
+      type: tu16(r, entryOffset + 2),
+      count: tu32(r, entryOffset + 4),
+      valueOffsetField: entryOffset + 8
+    });
+  }
+  return { entries };
+}
+function findEntry(entries, tag) {
+  return entries.find((e) => e.tag === tag);
+}
+function readAscii(r, entry) {
+  const size = entry.count;
+  const inline = size <= 4;
+  const dataOffset = inline ? entry.valueOffsetField : r.tiffStart + tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + size > r.bytes.length) return null;
+  let out = "";
+  for (let i = 0; i < size; i++) {
+    const c = r.bytes[dataOffset + i];
+    if (c === 0) break;
+    out += String.fromCharCode(c);
+  }
+  const trimmed = out.trim();
+  return trimmed || null;
+}
+function readRational(r, entry) {
+  const dataOffset = r.tiffStart + tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 8 > r.bytes.length) return null;
+  return { num: tu32(r, dataOffset), den: tu32(r, dataOffset + 4) };
+}
+function readGpsCoordinate(r, entries, valueTag, refTag) {
+  const valueEntry = findEntry(entries, valueTag);
+  if (!valueEntry) return null;
+  const dataOffset = r.tiffStart + tu32(r, valueEntry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 24 > r.bytes.length) return null;
+  const deg = tu32(r, dataOffset) / (tu32(r, dataOffset + 4) || 1);
+  const min = tu32(r, dataOffset + 8) / (tu32(r, dataOffset + 12) || 1);
+  const sec = tu32(r, dataOffset + 16) / (tu32(r, dataOffset + 20) || 1);
+  let decimal = deg + min / 60 + sec / 3600;
+  const refEntry = findEntry(entries, refTag);
+  const ref = refEntry ? readAscii(r, refEntry) : null;
+  if (ref === "S" || ref === "W") decimal = -decimal;
+  return Math.round(decimal * 1e6) / 1e6;
+}
+function gcd2(a, b) {
+  return b === 0 ? a : gcd2(b, a % b);
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function formatExposureTime(num, den) {
+  if (num === 0) return "0s";
+  if (num >= den) return `${round2(num / den)}s`;
+  const divisor = gcd2(num, den) || 1;
+  const n = num / divisor;
+  const d = den / divisor;
+  return `1/${Math.round(d / n)}`;
+}
+function readExifData(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return { error: "Not a JPEG file (EXIF is only read from JPEG files)" };
+  }
+  let offset = 2;
+  let exifStart = -1;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    if (marker === 217 || marker === 218) break;
+    const segmentLength = bytes[offset + 2] << 8 | bytes[offset + 3];
+    if (marker === 225) {
+      const idOffset = offset + 4;
+      if (idOffset + 6 <= bytes.length && bytes[idOffset] === 69 && bytes[idOffset + 1] === 120 && bytes[idOffset + 2] === 105 && bytes[idOffset + 3] === 102 && bytes[idOffset + 4] === 0 && bytes[idOffset + 5] === 0) {
+        exifStart = idOffset + 6;
+        break;
+      }
+    }
+    offset += 2 + segmentLength;
+  }
+  if (exifStart === -1) return { error: "No EXIF segment found in this JPEG" };
+  if (exifStart + 8 > bytes.length) return { error: "Truncated EXIF segment" };
+  const byteOrder = String.fromCharCode(bytes[exifStart], bytes[exifStart + 1]);
+  if (byteOrder !== "II" && byteOrder !== "MM") return { error: "Invalid TIFF byte order marker in EXIF data" };
+  const little = byteOrder === "II";
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const r = { bytes, view, little, tiffStart: exifStart };
+  if (tu16(r, exifStart + 2) !== 42) return { error: "Invalid TIFF magic number in EXIF data" };
+  const ifd0Offset = exifStart + tu32(r, exifStart + 4);
+  const ifd0 = readIfdEntries(r, ifd0Offset);
+  if (!ifd0) return { error: "Could not read IFD0 from EXIF data" };
+  const result = { tagCount: ifd0.entries.length };
+  const makeEntry = findEntry(ifd0.entries, 271);
+  if (makeEntry) {
+    const v = readAscii(r, makeEntry);
+    if (v) result.make = v;
+  }
+  const modelEntry = findEntry(ifd0.entries, 272);
+  if (modelEntry) {
+    const v = readAscii(r, modelEntry);
+    if (v) result.model = v;
+  }
+  const softwareEntry = findEntry(ifd0.entries, 305);
+  if (softwareEntry) {
+    const v = readAscii(r, softwareEntry);
+    if (v) result.software = v;
+  }
+  const dateTimeEntry = findEntry(ifd0.entries, 306);
+  if (dateTimeEntry) {
+    const v = readAscii(r, dateTimeEntry);
+    if (v) result.dateTime = v;
+  }
+  const orientEntry = findEntry(ifd0.entries, 274);
+  if (orientEntry) {
+    const v = tu16(r, orientEntry.valueOffsetField);
+    result.orientation = v;
+    result.orientationLabel = ORIENTATION_LABELS[v] ?? "Unknown";
+  }
+  const exifIfdPtr = findEntry(ifd0.entries, 34665);
+  if (exifIfdPtr) {
+    const subOffset = exifStart + tu32(r, exifIfdPtr.valueOffsetField);
+    const sub = readIfdEntries(r, subOffset);
+    if (sub) {
+      const dtoEntry = findEntry(sub.entries, 36867);
+      if (dtoEntry) {
+        const v = readAscii(r, dtoEntry);
+        if (v) result.dateTimeOriginal = v;
+      }
+      const expEntry = findEntry(sub.entries, 33434);
+      if (expEntry) {
+        const rat = readRational(r, expEntry);
+        if (rat && rat.den !== 0) result.exposureTime = formatExposureTime(rat.num, rat.den);
+      }
+      const fEntry = findEntry(sub.entries, 33437);
+      if (fEntry) {
+        const rat = readRational(r, fEntry);
+        if (rat && rat.den !== 0) result.fNumber = round2(rat.num / rat.den);
+      }
+      const isoEntry = findEntry(sub.entries, 34855);
+      if (isoEntry) result.isoSpeed = tu16(r, isoEntry.valueOffsetField);
+      const focalEntry = findEntry(sub.entries, 37386);
+      if (focalEntry) {
+        const rat = readRational(r, focalEntry);
+        if (rat && rat.den !== 0) result.focalLength = round2(rat.num / rat.den);
+      }
+    }
+  }
+  const gpsIfdPtr = findEntry(ifd0.entries, 34853);
+  if (gpsIfdPtr) {
+    const gpsOffset = exifStart + tu32(r, gpsIfdPtr.valueOffsetField);
+    const gps = readIfdEntries(r, gpsOffset);
+    if (gps) {
+      const lat = readGpsCoordinate(r, gps.entries, 2, 1);
+      const lon = readGpsCoordinate(r, gps.entries, 4, 3);
+      if (lat !== null) result.gpsLatitude = lat;
+      if (lon !== null) result.gpsLongitude = lon;
+    }
+  }
+  return result;
+}
+function bytesToLatin1(bytes) {
+  let out = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    out += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return out;
+}
+function decodePdfString(raw, isHex) {
+  const bytes = [];
+  if (isHex) {
+    const hex = raw.replace(/\s+/g, "");
+    const padded = hex.length % 2 === 0 ? hex : hex + "0";
+    for (let i = 0; i < padded.length; i += 2) bytes.push(parseInt(padded.slice(i, i + 2), 16));
+  } else {
+    const s = raw.replace(/\\\r\n|\\\r|\\\n/g, "");
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      if (ch === "\\" && i + 1 < s.length) {
+        const next = s[i + 1];
+        if (next === "n") {
+          bytes.push(10);
+          i++;
+        } else if (next === "r") {
+          bytes.push(13);
+          i++;
+        } else if (next === "t") {
+          bytes.push(9);
+          i++;
+        } else if (next === "b") {
+          bytes.push(8);
+          i++;
+        } else if (next === "f") {
+          bytes.push(12);
+          i++;
+        } else if (next === "(" || next === ")" || next === "\\") {
+          bytes.push(next.charCodeAt(0));
+          i++;
+        } else if (/[0-7]/.test(next)) {
+          let oct = next;
+          i++;
+          for (let k = 0; k < 2 && i + 1 < s.length && /[0-7]/.test(s[i + 1]); k++) {
+            i++;
+            oct += s[i];
+          }
+          bytes.push(parseInt(oct, 8) & 255);
+        } else {
+          bytes.push(next.charCodeAt(0));
+          i++;
+        }
+      } else {
+        bytes.push(ch.charCodeAt(0) & 255);
+      }
+    }
+  }
+  if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+    let out = "";
+    for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode(bytes[i] << 8 | bytes[i + 1]);
+    return out;
+  }
+  return bytes.map((b) => String.fromCharCode(b)).join("");
+}
+function extractDictField(dict, key) {
+  const litMatch = dict.match(new RegExp(`/${key}\\s*\\(((?:\\\\.|[^\\\\()])*)\\)`));
+  if (litMatch) return decodePdfString(litMatch[1], false);
+  const hexMatch = dict.match(new RegExp(`/${key}\\s*<([0-9A-Fa-f\\s]*)>`));
+  if (hexMatch) return decodePdfString(hexMatch[1], true);
+  return null;
+}
+function findObject(text, objNum, gen) {
+  const m = text.match(new RegExp(`(?:^|[^0-9])${objNum}\\s+${gen}\\s+obj([\\s\\S]*?)endobj`));
+  return m ? m[1] : null;
+}
+function parsePdfDate(raw) {
+  const m = raw.match(/^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([Z+-])?(\d{2})?'?(\d{2})?'?/);
+  if (!m) return null;
+  const [, y, mo = "01", d = "01", h = "00", mi = "00", s = "00", tz, tzh, tzm] = m;
+  let iso = `${y}-${mo}-${d}T${h}:${mi}:${s}`;
+  if (tz === "Z") iso += "Z";
+  else if (tz === "+" || tz === "-") iso += `${tz}${tzh ?? "00"}:${tzm ?? "00"}`;
+  return iso;
+}
+function readPdfMetadata(bytes) {
+  if (bytes.length < 8) return { error: "File too small to be a PDF" };
+  const header = bytesToLatin1(bytes.subarray(0, 16));
+  const versionMatch = header.match(/%PDF-(\d\.\d)/);
+  if (!versionMatch) return { error: "Not a valid PDF file (missing %PDF header)" };
+  const version2 = versionMatch[1];
+  const text = bytesToLatin1(bytes);
+  const trailerMatches = [...text.matchAll(/trailer\s*<<([\s\S]*?)>>/g)];
+  let infoDict = null;
+  let encrypted = false;
+  if (trailerMatches.length > 0) {
+    const trailer = trailerMatches[trailerMatches.length - 1][1];
+    encrypted = /\/Encrypt\s+\d+\s+\d+\s+R/.test(trailer);
+    const infoRef = trailer.match(/\/Info\s+(\d+)\s+(\d+)\s+R/);
+    if (infoRef) infoDict = findObject(text, Number(infoRef[1]), Number(infoRef[2]));
+  }
+  const objBlocks = [...text.matchAll(/(\d+)\s+(\d+)\s+obj([\s\S]*?)endobj/g)];
+  if (!infoDict) {
+    for (const b of objBlocks) {
+      if (/\/(Title|Author|Producer|Creator|CreationDate)\b/.test(b[3]) && !/\/Type\s*\/(Page|Pages|Catalog|Font)\b/.test(b[3])) {
+        infoDict = b[3];
+        break;
+      }
+    }
+  }
+  const title = infoDict ? extractDictField(infoDict, "Title") : null;
+  const author = infoDict ? extractDictField(infoDict, "Author") : null;
+  const subject = infoDict ? extractDictField(infoDict, "Subject") : null;
+  const keywords = infoDict ? extractDictField(infoDict, "Keywords") : null;
+  const creator = infoDict ? extractDictField(infoDict, "Creator") : null;
+  const producer = infoDict ? extractDictField(infoDict, "Producer") : null;
+  const creationDateRaw = infoDict ? extractDictField(infoDict, "CreationDate") : null;
+  const modDateRaw = infoDict ? extractDictField(infoDict, "ModDate") : null;
+  let pageCount = null;
+  for (const b of objBlocks) {
+    if (!/\/Type\s*\/Pages\b/.test(b[3])) continue;
+    const countMatch = b[3].match(/\/Count\s+(\d+)/);
+    if (countMatch) {
+      const c = Number(countMatch[1]);
+      if (pageCount === null || c > pageCount) pageCount = c;
+    }
+  }
+  if (pageCount === null) {
+    const pageMatches = text.match(/\/Type\s*\/Page(?!s)\b/g);
+    if (pageMatches) pageCount = pageMatches.length;
+  }
+  return {
+    version: version2,
+    pageCount,
+    title,
+    author,
+    subject,
+    keywords,
+    creator,
+    producer,
+    creationDate: creationDateRaw ? parsePdfDate(creationDateRaw) ?? creationDateRaw : null,
+    modDate: modDateRaw ? parsePdfDate(modDateRaw) ?? modDateRaw : null,
+    encrypted
+  };
+}
 
 // src/index.ts
 var version = "0.1.0";

package/dist/index.d.cts

@@ -7,13 +7,13 @@ export { g as generators } from './generators-BGtRGpJZ.cjs';
 export { t as time } from './time-DbT8fjaF.cjs';
 export { u as units } from './units-6lwDYBvX.cjs';
 export { n as network } from './network-DwyAjwJS.cjs';
-export { a as api } from './api-8aZtWhSj.cjs';
+export { a as api } from './api-Xl7OzIgq.cjs';
 export { c as code } from './code-BUqyaofO.cjs';
 export { c as color } from './color-tPwZCr9H.cjs';
 export { c as css } from './css-Cf7AMGM-.cjs';
 export { m as misc } from './misc-CA3N198T.cjs';
 export { a as ai_agent } from './ai_agent-CcpkV2DR.cjs';
-export { m as media } from './media-DF2cx3pK.cjs';
+export { m as media } from './media-CHaBS1dI.cjs';
 
 declare const version = "0.1.0";
 

package/dist/index.d.ts

@@ -7,13 +7,13 @@ export { g as generators } from './generators-BGtRGpJZ.js';
 export { t as time } from './time-DbT8fjaF.js';
 export { u as units } from './units-6lwDYBvX.js';
 export { n as network } from './network-DwyAjwJS.js';
-export { a as api } from './api-8aZtWhSj.js';
+export { a as api } from './api-Xl7OzIgq.js';
 export { c as code } from './code-BUqyaofO.js';
 export { c as color } from './color-tPwZCr9H.js';
 export { c as css } from './css-Cf7AMGM-.js';
 export { m as misc } from './misc-CA3N198T.js';
 export { a as ai_agent } from './ai_agent-CcpkV2DR.js';
-export { m as media } from './media-DF2cx3pK.js';
+export { m as media } from './media-CHaBS1dI.js';
 
 declare const version = "0.1.0";
 

package/dist/index.js

@@ -1,7 +1,7 @@
-export { media_exports as media } from './chunk-N7C52YGL.js';
+export { media_exports as media } from './chunk-FXBB7O5A.js';
 export { units_exports as units } from './chunk-QJE743LY.js';
 export { network_exports as network } from './chunk-V5JKVDBA.js';
-export { api_exports as api } from './chunk-HFRTZE7T.js';
+export { api_exports as api } from './chunk-Q3B3YWOA.js';
 export { code_exports as code } from './chunk-V5S6OJ4A.js';
 export { color_exports as color } from './chunk-BPVAB4P2.js';
 export { css_exports as css } from './chunk-6YPV2AB5.js';
@@ -9,7 +9,7 @@ export { misc_exports as misc } from './chunk-GX7H6TAX.js';
 export { ai_agent_exports as ai_agent } from './chunk-M35VJETW.js';
 export { json_exports as json } from './chunk-TSAGO3XP.js';
 export { encoding_exports as encoding } from './chunk-IPR7FSX4.js';
-export { hashing_exports as hashing } from './chunk-FL53T24A.js';
+export { hashing_exports as hashing } from './chunk-GEFVMGZR.js';
 export { text_exports as text } from './chunk-YBBYFAOV.js';
 export { data_exports as data } from './chunk-DNCOIO5N.js';
 export { generators_exports as generators } from './chunk-2CJSLYWI.js';

package/dist/media-CHaBS1dI.d.cts

@@ -0,0 +1,82 @@
+type ImageFormat = 'png' | 'jpeg' | 'gif' | 'webp' | 'bmp';
+interface ImageInfo {
+    format: ImageFormat;
+    width: number;
+    height: number;
+    bitDepth?: number;
+    colorType?: string;
+    hasAlpha?: boolean;
+}
+interface ImageInfoError {
+    error: string;
+}
+/**
+ * Read image format, dimensions, and basic color info straight from file
+ * bytes — no decoding, no image library, no canvas. Supports PNG, JPEG,
+ * GIF, WebP, and BMP.
+ */
+declare function readImageInfo(bytes: Uint8Array): ImageInfo | ImageInfoError;
+interface ExifData {
+    make?: string;
+    model?: string;
+    software?: string;
+    orientation?: number;
+    orientationLabel?: string;
+    dateTime?: string;
+    dateTimeOriginal?: string;
+    exposureTime?: string;
+    fNumber?: number;
+    isoSpeed?: number;
+    focalLength?: number;
+    gpsLatitude?: number;
+    gpsLongitude?: number;
+    tagCount: number;
+}
+interface ExifError {
+    error: string;
+}
+/**
+ * Read common EXIF tags (make, model, orientation, timestamps, exposure
+ * settings, GPS coordinates) directly from a JPEG's APP1 segment. Only
+ * JPEG is supported: PNG, WebP, and other formats don't carry EXIF the
+ * same way and are rejected with an error.
+ */
+declare function readExifData(bytes: Uint8Array): ExifData | ExifError;
+interface PdfMetadata {
+    version: string | null;
+    pageCount: number | null;
+    title: string | null;
+    author: string | null;
+    subject: string | null;
+    keywords: string | null;
+    creator: string | null;
+    producer: string | null;
+    creationDate: string | null;
+    modDate: string | null;
+    encrypted: boolean;
+}
+interface PdfMetadataError {
+    error: string;
+}
+/**
+ * Read PDF metadata (title, author, dates, page count, encryption flag)
+ * straight from the file's trailer/Info dictionary and page tree — no
+ * pdf.js or other PDF rendering library required.
+ */
+declare function readPdfMetadata(bytes: Uint8Array): PdfMetadata | PdfMetadataError;
+
+type media_ExifData = ExifData;
+type media_ExifError = ExifError;
+type media_ImageFormat = ImageFormat;
+type media_ImageInfo = ImageInfo;
+type media_ImageInfoError = ImageInfoError;
+type media_PdfMetadata = PdfMetadata;
+type media_PdfMetadataError = PdfMetadataError;
+declare const media_readExifData: typeof readExifData;
+declare const media_readImageInfo: typeof readImageInfo;
+declare const media_readPdfMetadata: typeof readPdfMetadata;
+declare namespace media {
+  export { type media_ExifData as ExifData, type media_ExifError as ExifError, type media_ImageFormat as ImageFormat, type media_ImageInfo as ImageInfo, type media_ImageInfoError as ImageInfoError, type media_PdfMetadata as PdfMetadata, type media_PdfMetadataError as PdfMetadataError, media_readExifData as readExifData, media_readImageInfo as readImageInfo, media_readPdfMetadata as readPdfMetadata };
+}
+
+export { type ExifData as E, type ImageFormat as I, type PdfMetadata as P, type ExifError as a, type ImageInfo as b, type ImageInfoError as c, type PdfMetadataError as d, readImageInfo as e, readPdfMetadata as f, media as m, readExifData as r };

package/dist/media-CHaBS1dI.d.ts

@@ -0,0 +1,82 @@
+type ImageFormat = 'png' | 'jpeg' | 'gif' | 'webp' | 'bmp';
+interface ImageInfo {
+    format: ImageFormat;
+    width: number;
+    height: number;
+    bitDepth?: number;
+    colorType?: string;
+    hasAlpha?: boolean;
+}
+interface ImageInfoError {
+    error: string;
+}
+/**
+ * Read image format, dimensions, and basic color info straight from file
+ * bytes — no decoding, no image library, no canvas. Supports PNG, JPEG,
+ * GIF, WebP, and BMP.
+ */
+declare function readImageInfo(bytes: Uint8Array): ImageInfo | ImageInfoError;
+interface ExifData {
+    make?: string;
+    model?: string;
+    software?: string;
+    orientation?: number;
+    orientationLabel?: string;
+    dateTime?: string;
+    dateTimeOriginal?: string;
+    exposureTime?: string;
+    fNumber?: number;
+    isoSpeed?: number;
+    focalLength?: number;
+    gpsLatitude?: number;
+    gpsLongitude?: number;
+    tagCount: number;
+}
+interface ExifError {
+    error: string;
+}
+/**
+ * Read common EXIF tags (make, model, orientation, timestamps, exposure
+ * settings, GPS coordinates) directly from a JPEG's APP1 segment. Only
+ * JPEG is supported: PNG, WebP, and other formats don't carry EXIF the
+ * same way and are rejected with an error.
+ */
+declare function readExifData(bytes: Uint8Array): ExifData | ExifError;
+interface PdfMetadata {
+    version: string | null;
+    pageCount: number | null;
+    title: string | null;
+    author: string | null;
+    subject: string | null;
+    keywords: string | null;
+    creator: string | null;
+    producer: string | null;
+    creationDate: string | null;
+    modDate: string | null;
+    encrypted: boolean;
+}
+interface PdfMetadataError {
+    error: string;
+}
+/**
+ * Read PDF metadata (title, author, dates, page count, encryption flag)
+ * straight from the file's trailer/Info dictionary and page tree — no
+ * pdf.js or other PDF rendering library required.
+ */
+declare function readPdfMetadata(bytes: Uint8Array): PdfMetadata | PdfMetadataError;
+
+type media_ExifData = ExifData;
+type media_ExifError = ExifError;
+type media_ImageFormat = ImageFormat;
+type media_ImageInfo = ImageInfo;
+type media_ImageInfoError = ImageInfoError;
+type media_PdfMetadata = PdfMetadata;
+type media_PdfMetadataError = PdfMetadataError;
+declare const media_readExifData: typeof readExifData;
+declare const media_readImageInfo: typeof readImageInfo;
+declare const media_readPdfMetadata: typeof readPdfMetadata;
+declare namespace media {
+  export { type media_ExifData as ExifData, type media_ExifError as ExifError, type media_ImageFormat as ImageFormat, type media_ImageInfo as ImageInfo, type media_ImageInfoError as ImageInfoError, type media_PdfMetadata as PdfMetadata, type media_PdfMetadataError as PdfMetadataError, media_readExifData as readExifData, media_readImageInfo as readImageInfo, media_readPdfMetadata as readPdfMetadata };
+}
+
+export { type ExifData as E, type ImageFormat as I, type PdfMetadata as P, type ExifError as a, type ImageInfo as b, type ImageInfoError as c, type PdfMetadataError as d, readImageInfo as e, readPdfMetadata as f, media as m, readExifData as r };