@utilix-tech/sdk 0.5.0 → 0.7.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);
@@ -1851,6 +1845,7 @@ __export(text_exports, {
   readabilityScore: () => readabilityScore,
   renderMarkdown: () => renderMarkdown,
   romanToNumber: () => romanToNumber,
+  scoreReadability: () => scoreReadability,
   sentenceCount: () => sentenceCount,
   slugify: () => slugify,
   slugifyAll: () => slugifyAll,
@@ -4189,6 +4184,73 @@ function detectPassiveVoice(text) {
   const passivePercent = totalSentences > 0 ? Math.round(passiveSentences / totalSentences * 1e3) / 10 : 0;
   return { sentences: analyzed, totalSentences, passiveSentences, passivePercent };
 }
+function countSyllables(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (w.length === 0) return 0;
+  if (w.length <= 3) return 1;
+  let count = 0;
+  let prevWasVowel = false;
+  for (const ch of w) {
+    const isVowel = "aeiouy".includes(ch);
+    if (isVowel && !prevWasVowel) count++;
+    prevWasVowel = isVowel;
+  }
+  if (w.endsWith("e") && !w.endsWith("le") && count > 1) count--;
+  if (w.endsWith("le") && w.length > 2 && !"aeiouy".includes(w[w.length - 3])) count++;
+  return Math.max(count, 1);
+}
+function readabilityGradeLabel(fleschReadingEase) {
+  if (fleschReadingEase >= 90) return "Very easy (5th grade)";
+  if (fleschReadingEase >= 80) return "Easy (6th grade)";
+  if (fleschReadingEase >= 70) return "Fairly easy (7th grade)";
+  if (fleschReadingEase >= 60) return "Standard (8th-9th grade)";
+  if (fleschReadingEase >= 50) return "Fairly difficult (10th-12th grade)";
+  if (fleschReadingEase >= 30) return "Difficult (college)";
+  return "Very difficult (college graduate)";
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+function scoreReadability(text) {
+  const sentences = splitIntoSentences(text);
+  const words = text.match(/[a-zA-Z']+/g) ?? [];
+  const sentenceCount2 = Math.max(sentences.length, 1);
+  const wordCount = words.length;
+  const syllableCounts = words.map(countSyllables);
+  const syllableCount2 = syllableCounts.reduce((a, b) => a + b, 0);
+  const complexWordCount = syllableCounts.filter((c) => c >= 3).length;
+  if (wordCount === 0) {
+    return {
+      wordCount: 0,
+      sentenceCount: 0,
+      syllableCount: 0,
+      complexWordCount: 0,
+      avgWordsPerSentence: 0,
+      avgSyllablesPerWord: 0,
+      fleschReadingEase: 0,
+      fleschKincaidGrade: 0,
+      gunningFog: 0,
+      readingLevel: "No text to score"
+    };
+  }
+  const avgWordsPerSentence = wordCount / sentenceCount2;
+  const avgSyllablesPerWord = syllableCount2 / wordCount;
+  const fleschReadingEase = round1(206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord);
+  const fleschKincaidGrade = round1(0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59);
+  const gunningFog = round1(0.4 * (avgWordsPerSentence + 100 * (complexWordCount / wordCount)));
+  return {
+    wordCount,
+    sentenceCount: sentences.length,
+    syllableCount: syllableCount2,
+    complexWordCount,
+    avgWordsPerSentence: round1(avgWordsPerSentence),
+    avgSyllablesPerWord: round1(avgSyllablesPerWord),
+    fleschReadingEase,
+    fleschKincaidGrade,
+    gunningFog,
+    readingLevel: readabilityGradeLabel(fleschReadingEase)
+  };
+}
 
 // src/tools/data.ts
 var data_exports = {};
@@ -16934,8 +16996,10 @@ function summarizeForLlm(text, maxTokens = 200, strategy = "extractive") {
 // src/tools/media.ts
 var media_exports = {};
 __export(media_exports, {
+  readExifData: () => readExifData,
   readImageInfo: () => readImageInfo,
-  readPdfMetadata: () => readPdfMetadata
+  readPdfMetadata: () => readPdfMetadata,
+  readWavInfo: () => readWavInfo
 });
 function readU32BE(bytes, offset) {
   return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
@@ -17062,6 +17126,195 @@ 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;
@@ -17204,6 +17457,62 @@ function readPdfMetadata(bytes) {
     encrypted
   };
 }
+var AUDIO_FORMAT_LABELS = {
+  1: "PCM",
+  3: "IEEE float",
+  6: "A-law",
+  7: "mu-law",
+  65534: "Extensible"
+};
+function readAscii4(bytes, offset) {
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function readWavInfo(bytes) {
+  if (bytes.length < 12) return { error: "File is too small to be a valid WAV file" };
+  if (readAscii4(bytes, 0) !== "RIFF") return { error: 'Not a RIFF file (missing "RIFF" header)' };
+  if (readAscii4(bytes, 8) !== "WAVE") return { error: 'Not a WAVE file (missing "WAVE" format marker)' };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const fileSize = view.getUint32(4, true) + 8;
+  let offset = 12;
+  let fmt = null;
+  let dataSize = null;
+  while (offset + 8 <= bytes.length) {
+    const chunkId = readAscii4(bytes, offset);
+    const chunkSize = view.getUint32(offset + 4, true);
+    const dataOffset = offset + 8;
+    if (chunkId === "fmt ") {
+      if (dataOffset + 16 > bytes.length) return { error: 'Truncated "fmt " chunk' };
+      fmt = {
+        audioFormat: view.getUint16(dataOffset, true),
+        channels: view.getUint16(dataOffset + 2, true),
+        sampleRate: view.getUint32(dataOffset + 4, true),
+        byteRate: view.getUint32(dataOffset + 8, true),
+        blockAlign: view.getUint16(dataOffset + 12, true),
+        bitsPerSample: view.getUint16(dataOffset + 14, true)
+      };
+    } else if (chunkId === "data") {
+      dataSize = Math.min(chunkSize, bytes.length - dataOffset);
+    }
+    offset = dataOffset + chunkSize + chunkSize % 2;
+    if (fmt && dataSize !== null) break;
+  }
+  if (!fmt) return { error: 'No "fmt " chunk found in this WAV file' };
+  if (dataSize === null) return { error: 'No "data" chunk found in this WAV file' };
+  if (fmt.byteRate <= 0) return { error: 'Invalid byte rate in "fmt " chunk' };
+  const durationSeconds = Math.round(dataSize / fmt.byteRate * 1e3) / 1e3;
+  return {
+    audioFormat: fmt.audioFormat,
+    audioFormatLabel: AUDIO_FORMAT_LABELS[fmt.audioFormat] ?? `Unknown (0x${fmt.audioFormat.toString(16)})`,
+    channels: fmt.channels,
+    sampleRate: fmt.sampleRate,
+    byteRate: fmt.byteRate,
+    blockAlign: fmt.blockAlign,
+    bitsPerSample: fmt.bitsPerSample,
+    dataSize,
+    durationSeconds,
+    fileSize
+  };
+}
 
 // src/index.ts
 var version = "0.1.0";

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 export { j as json } from './json-BjSoIS1h.cjs';
 export { e as encoding } from './encoding-7gmq-vkV.cjs';
 export { h as hashing } from './hashing-CnetQFD_.cjs';
-export { t as text } from './text-CI7JAl7F.cjs';
+export { t as text } from './text-Bbx-tZ43.cjs';
 export { d as data } from './data-CakDxAcT.cjs';
 export { g as generators } from './generators-BGtRGpJZ.cjs';
 export { t as time } from './time-DbT8fjaF.cjs';
@@ -13,7 +13,7 @@ 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-D-K5aZnq.cjs';
+export { m as media } from './media-D66WnthC.cjs';
 
 declare const version = "0.1.0";
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { j as json } from './json-BjSoIS1h.js';
 export { e as encoding } from './encoding-7gmq-vkV.js';
 export { h as hashing } from './hashing-CnetQFD_.js';
-export { t as text } from './text-CI7JAl7F.js';
+export { t as text } from './text-Bbx-tZ43.js';
 export { d as data } from './data-CakDxAcT.js';
 export { g as generators } from './generators-BGtRGpJZ.js';
 export { t as time } from './time-DbT8fjaF.js';
@@ -13,7 +13,7 @@ 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-D-K5aZnq.js';
+export { m as media } from './media-D66WnthC.js';
 
 declare const version = "0.1.0";
 

package/dist/index.js

@@ -1,4 +1,4 @@
-export { media_exports as media } from './chunk-WWKPLYEP.js';
+export { media_exports as media } from './chunk-5CKOJXFU.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-Q3B3YWOA.js';
@@ -9,8 +9,8 @@ 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 { text_exports as text } from './chunk-YBBYFAOV.js';
+export { hashing_exports as hashing } from './chunk-GEFVMGZR.js';
+export { text_exports as text } from './chunk-F57WMKZO.js';
 export { data_exports as data } from './chunk-DNCOIO5N.js';
 export { generators_exports as generators } from './chunk-2CJSLYWI.js';
 export { time_exports as time } from './chunk-ZPQZEIXP.js';

package/dist/media-D66WnthC.d.cts

@@ -0,0 +1,107 @@
+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;
+interface WavInfo {
+    audioFormat: number;
+    audioFormatLabel: string;
+    channels: number;
+    sampleRate: number;
+    byteRate: number;
+    blockAlign: number;
+    bitsPerSample: number;
+    dataSize: number;
+    durationSeconds: number;
+    fileSize: number;
+}
+interface WavInfoError {
+    error: string;
+}
+/**
+ * Read a WAV file's RIFF/fmt/data chunk headers to report sample rate,
+ * channel count, bit depth, and duration, without decoding any audio
+ * samples. Only the canonical RIFF/WAVE container is supported (not the
+ * rarer RF64 variant used for files over 4GB).
+ */
+declare function readWavInfo(bytes: Uint8Array): WavInfo | WavInfoError;
+
+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;
+type media_WavInfo = WavInfo;
+type media_WavInfoError = WavInfoError;
+declare const media_readExifData: typeof readExifData;
+declare const media_readImageInfo: typeof readImageInfo;
+declare const media_readPdfMetadata: typeof readPdfMetadata;
+declare const media_readWavInfo: typeof readWavInfo;
+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, type media_WavInfo as WavInfo, type media_WavInfoError as WavInfoError, media_readExifData as readExifData, media_readImageInfo as readImageInfo, media_readPdfMetadata as readPdfMetadata, media_readWavInfo as readWavInfo };
+}
+
+export { type ExifData as E, type ImageFormat as I, type PdfMetadata as P, type WavInfo as W, type ExifError as a, type ImageInfo as b, type ImageInfoError as c, type PdfMetadataError as d, type WavInfoError as e, readImageInfo as f, readPdfMetadata as g, readWavInfo as h, media as m, readExifData as r };

package/dist/media-D66WnthC.d.ts

@@ -0,0 +1,107 @@
+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;
+interface WavInfo {
+    audioFormat: number;
+    audioFormatLabel: string;
+    channels: number;
+    sampleRate: number;
+    byteRate: number;
+    blockAlign: number;
+    bitsPerSample: number;
+    dataSize: number;
+    durationSeconds: number;
+    fileSize: number;
+}
+interface WavInfoError {
+    error: string;
+}
+/**
+ * Read a WAV file's RIFF/fmt/data chunk headers to report sample rate,
+ * channel count, bit depth, and duration, without decoding any audio
+ * samples. Only the canonical RIFF/WAVE container is supported (not the
+ * rarer RF64 variant used for files over 4GB).
+ */
+declare function readWavInfo(bytes: Uint8Array): WavInfo | WavInfoError;
+
+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;
+type media_WavInfo = WavInfo;
+type media_WavInfoError = WavInfoError;
+declare const media_readExifData: typeof readExifData;
+declare const media_readImageInfo: typeof readImageInfo;
+declare const media_readPdfMetadata: typeof readPdfMetadata;
+declare const media_readWavInfo: typeof readWavInfo;
+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, type media_WavInfo as WavInfo, type media_WavInfoError as WavInfoError, media_readExifData as readExifData, media_readImageInfo as readImageInfo, media_readPdfMetadata as readPdfMetadata, media_readWavInfo as readWavInfo };
+}
+
+export { type ExifData as E, type ImageFormat as I, type PdfMetadata as P, type WavInfo as W, type ExifError as a, type ImageInfo as b, type ImageInfoError as c, type PdfMetadataError as d, type WavInfoError as e, readImageInfo as f, readPdfMetadata as g, readWavInfo as h, media as m, readExifData as r };