@utilix-tech/sdk 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -1845,6 +1845,7 @@ __export(text_exports, {
   readabilityScore: () => readabilityScore,
   renderMarkdown: () => renderMarkdown,
   romanToNumber: () => romanToNumber,
+  scoreReadability: () => scoreReadability,
   sentenceCount: () => sentenceCount,
   slugify: () => slugify,
   slugifyAll: () => slugifyAll,
@@ -4183,12 +4184,80 @@ 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 = {};
 __export(data_exports, {
   csvToJson: () => csvToJson2,
   detectDelimiter: () => detectDelimiter2,
+  diffEnvExample: () => diffEnvExample,
   envToExport: () => envToExport,
   envToJson: () => envToJson,
   formatNdjson: () => formatNdjson,
@@ -5263,6 +5332,23 @@ function envToExport(input) {
 function validateEnvKey(key) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
 }
+function diffEnvExample(envInput, exampleInput) {
+  const envParsed = parseEnv(envInput);
+  if (envParsed.errors.length > 0) {
+    return { error: `.env: ${envParsed.errors.map((e) => `Line ${e.line}: ${e.message}`).join("; ")}` };
+  }
+  const exampleParsed = parseEnv(exampleInput);
+  if (exampleParsed.errors.length > 0) {
+    return { error: `.env.example: ${exampleParsed.errors.map((e) => `Line ${e.line}: ${e.message}`).join("; ")}` };
+  }
+  const envKeys = new Set(envParsed.entries.map((e) => e.key));
+  const exampleValues = new Map(exampleParsed.entries.map((e) => [e.key, e.value]));
+  const missingInExample = [...envKeys].filter((k) => !exampleValues.has(k)).sort();
+  const missingInEnv = [...exampleValues.keys()].filter((k) => !envKeys.has(k)).sort();
+  const emptyValueInExample = [...exampleValues.entries()].filter(([k, v]) => envKeys.has(k) && v === "").map(([k]) => k).sort();
+  const keysInBoth = [...envKeys].filter((k) => exampleValues.has(k)).length;
+  return { missingInExample, missingInEnv, emptyValueInExample, keysInBoth };
+}
 function validateNdjson(input) {
   const rawLines = input.split("\n");
   const lines = [];
@@ -16929,8 +17015,10 @@ function summarizeForLlm(text, maxTokens = 200, strategy = "extractive") {
 var media_exports = {};
 __export(media_exports, {
   readExifData: () => readExifData,
+  readId3Tags: () => readId3Tags,
   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;
@@ -17388,6 +17476,271 @@ 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
+  };
+}
+var ID3V1_GENRES = [
+  "Blues",
+  "Classic Rock",
+  "Country",
+  "Dance",
+  "Disco",
+  "Funk",
+  "Grunge",
+  "Hip-Hop",
+  "Jazz",
+  "Metal",
+  "New Age",
+  "Oldies",
+  "Other",
+  "Pop",
+  "R&B",
+  "Rap",
+  "Reggae",
+  "Rock",
+  "Techno",
+  "Industrial",
+  "Alternative",
+  "Ska",
+  "Death Metal",
+  "Pranks",
+  "Soundtrack",
+  "Euro-Techno",
+  "Ambient",
+  "Trip-Hop",
+  "Vocal",
+  "Jazz+Funk",
+  "Fusion",
+  "Trance",
+  "Classical",
+  "Instrumental",
+  "Acid",
+  "House",
+  "Game",
+  "Sound Clip",
+  "Gospel",
+  "Noise",
+  "AlternRock",
+  "Bass",
+  "Soul",
+  "Punk",
+  "Space",
+  "Meditative",
+  "Instrumental Pop",
+  "Instrumental Rock",
+  "Ethnic",
+  "Gothic",
+  "Darkwave",
+  "Techno-Industrial",
+  "Electronic",
+  "Pop-Folk",
+  "Eurodance",
+  "Dream",
+  "Southern Rock",
+  "Comedy",
+  "Cult",
+  "Gangsta",
+  "Top 40",
+  "Christian Rap",
+  "Pop/Funk",
+  "Jungle",
+  "Native American",
+  "Cabaret",
+  "New Wave",
+  "Psychedelic",
+  "Rave",
+  "Showtunes",
+  "Trailer",
+  "Lo-Fi",
+  "Tribal",
+  "Acid Punk",
+  "Acid Jazz",
+  "Polka",
+  "Retro",
+  "Musical",
+  "Rock & Roll",
+  "Hard Rock"
+];
+function readSynchsafeUInt32(bytes, offset) {
+  return (bytes[offset] & 127) << 21 | (bytes[offset + 1] & 127) << 14 | (bytes[offset + 2] & 127) << 7 | bytes[offset + 3] & 127;
+}
+function readUInt32BE(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function decodeId3Text(frameBytes) {
+  if (frameBytes.length === 0) return "";
+  const encodingByte = frameBytes[0];
+  const content = frameBytes.subarray(1);
+  let out = "";
+  if (encodingByte === 3) {
+    out = Buffer.from(content).toString("utf8");
+  } else if (encodingByte === 1 || encodingByte === 2) {
+    let little = encodingByte === 1;
+    let start = 0;
+    if (encodingByte === 1 && content.length >= 2) {
+      if (content[0] === 255 && content[1] === 254) {
+        little = true;
+        start = 2;
+      } else if (content[0] === 254 && content[1] === 255) {
+        little = false;
+        start = 2;
+      }
+    }
+    for (let i = start; i + 1 < content.length; i += 2) {
+      const code = little ? content[i] | content[i + 1] << 8 : content[i] << 8 | content[i + 1];
+      if (code === 0) break;
+      out += String.fromCharCode(code);
+    }
+  } else {
+    for (const b of content) {
+      if (b === 0) break;
+      out += String.fromCharCode(b);
+    }
+  }
+  return out.replace(/\0+$/, "").trim();
+}
+function readId3v2(bytes) {
+  if (bytes.length < 10 || bytes[0] !== 73 || bytes[1] !== 68 || bytes[2] !== 51) return null;
+  const majorVersion = bytes[3];
+  const revision = bytes[4];
+  const tagSize = readSynchsafeUInt32(bytes, 6);
+  const version2 = `ID3v2.${majorVersion}.${revision}`;
+  if (majorVersion !== 3 && majorVersion !== 4) {
+    return { version: version2, frames: {}, frameCount: 0 };
+  }
+  const frames = {};
+  let offset = 10;
+  const end = Math.min(10 + tagSize, bytes.length);
+  let frameCount = 0;
+  while (offset + 10 <= end) {
+    const frameId = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+    if (frameId === "\0\0\0\0") break;
+    const frameSize = majorVersion === 4 ? readSynchsafeUInt32(bytes, offset + 4) : readUInt32BE(bytes, offset + 4);
+    const frameStart = offset + 10;
+    if (frameSize <= 0 || frameStart + frameSize > bytes.length) break;
+    const frameBytes = bytes.subarray(frameStart, frameStart + frameSize);
+    if (frameId[0] === "T" && frameId !== "TXXX") {
+      frames[frameId] = decodeId3Text(frameBytes);
+    } else if (frameId === "COMM" && frameBytes.length > 4) {
+      const rebuilt = new Uint8Array(frameBytes.length - 3);
+      rebuilt[0] = frameBytes[0];
+      rebuilt.set(frameBytes.subarray(4), 1);
+      const decoded = decodeId3Text(rebuilt);
+      const parts = decoded.split("\0");
+      frames["COMM"] = (parts[parts.length - 1] || decoded).trim();
+    }
+    frameCount++;
+    offset = frameStart + frameSize;
+  }
+  return { version: version2, frames, frameCount };
+}
+function readId3v1(bytes) {
+  if (bytes.length < 128) return null;
+  const start = bytes.length - 128;
+  if (String.fromCharCode(bytes[start], bytes[start + 1], bytes[start + 2]) !== "TAG") return null;
+  const readField = (offset, length) => {
+    let s = "";
+    for (let i = 0; i < length; i++) {
+      const b = bytes[start + offset + i];
+      if (b === 0) break;
+      s += String.fromCharCode(b);
+    }
+    return s.trim();
+  };
+  const title = readField(3, 30);
+  const artist = readField(33, 30);
+  const album = readField(63, 30);
+  const year = readField(93, 4);
+  const isV11 = bytes[start + 125] === 0 && bytes[start + 126] !== 0;
+  const comment = readField(97, isV11 ? 28 : 30);
+  const genreIndex = bytes[start + 127];
+  const genre = ID3V1_GENRES[genreIndex] ?? `Unknown (${genreIndex})`;
+  const result = { genre };
+  if (title) result.title = title;
+  if (artist) result.artist = artist;
+  if (album) result.album = album;
+  if (year) result.year = year;
+  if (comment) result.comment = comment;
+  if (isV11) result.trackNumber = String(bytes[start + 126]);
+  return result;
+}
+function readId3Tags(bytes) {
+  const v2 = readId3v2(bytes);
+  const v1 = readId3v1(bytes);
+  if (v2 && Object.keys(v2.frames).length > 0) {
+    const f = v2.frames;
+    const result = { version: v2.version, frameCount: v2.frameCount };
+    if (f["TIT2"]) result.title = f["TIT2"];
+    if (f["TPE1"]) result.artist = f["TPE1"];
+    if (f["TALB"]) result.album = f["TALB"];
+    const year = f["TYER"] || f["TDRC"];
+    if (year) result.year = year;
+    if (f["TCON"]) result.genre = f["TCON"];
+    if (f["COMM"]) result.comment = f["COMM"];
+    if (f["TRCK"]) result.trackNumber = f["TRCK"];
+    return result;
+  }
+  if (v1) {
+    return { version: v1.trackNumber !== void 0 ? "ID3v1.1" : "ID3v1", ...v1 };
+  }
+  if (v2) {
+    return { error: `Unsupported ID3 tag version: ${v2.version} (only ID3v2.3, ID3v2.4, and ID3v1/1.1 are supported)` };
+  }
+  return { error: "No ID3v1 or ID3v2.3/2.4 tags found in this file" };
+}
 
 // src/index.ts
 var version = "0.1.0";

package/dist/index.d.cts

@@ -1,8 +1,8 @@
 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 { d as data } from './data-CakDxAcT.cjs';
+export { t as text } from './text-Bbx-tZ43.cjs';
+export { d as data } from './data-D8XTI7Du.cjs';
 export { g as generators } from './generators-BGtRGpJZ.cjs';
 export { t as time } from './time-DbT8fjaF.cjs';
 export { u as units } from './units-6lwDYBvX.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-CHaBS1dI.cjs';
+export { m as media } from './media-C3ZvGyKc.cjs';
 
 declare const version = "0.1.0";
 

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 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 { d as data } from './data-CakDxAcT.js';
+export { t as text } from './text-Bbx-tZ43.js';
+export { d as data } from './data-D8XTI7Du.js';
 export { g as generators } from './generators-BGtRGpJZ.js';
 export { t as time } from './time-DbT8fjaF.js';
 export { u as units } from './units-6lwDYBvX.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-CHaBS1dI.js';
+export { m as media } from './media-C3ZvGyKc.js';
 
 declare const version = "0.1.0";
 

package/dist/index.js

@@ -1,4 +1,4 @@
-export { media_exports as media } from './chunk-FXBB7O5A.js';
+export { media_exports as media } from './chunk-GUUYEIU6.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';
@@ -10,8 +10,8 @@ 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-GEFVMGZR.js';
-export { text_exports as text } from './chunk-YBBYFAOV.js';
-export { data_exports as data } from './chunk-DNCOIO5N.js';
+export { text_exports as text } from './chunk-F57WMKZO.js';
+export { data_exports as data } from './chunk-TINQFTLO.js';
 export { generators_exports as generators } from './chunk-2CJSLYWI.js';
 export { time_exports as time } from './chunk-ZPQZEIXP.js';
 import './chunk-MLKGABMK.js';

package/dist/media-C3ZvGyKc.d.cts

@@ -0,0 +1,132 @@
+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;
+interface Id3Tags {
+    version: string;
+    title?: string;
+    artist?: string;
+    album?: string;
+    year?: string;
+    genre?: string;
+    comment?: string;
+    trackNumber?: string;
+    frameCount?: number;
+}
+interface Id3TagsError {
+    error: string;
+}
+/**
+ * Read ID3 tags (title, artist, album, year, genre, comment, track number)
+ * directly from an MP3 file's bytes, without any audio-decoding library.
+ * Prefers an ID3v2.3/2.4 header at the start of the file; falls back to a
+ * classic ID3v1/1.1 128-byte trailer if no ID3v2 text frames are found.
+ * ID3v2.2 tags are detected but their 3-character frame IDs are not decoded.
+ */
+declare function readId3Tags(bytes: Uint8Array): Id3Tags | Id3TagsError;
+
+type media_ExifData = ExifData;
+type media_ExifError = ExifError;
+type media_Id3Tags = Id3Tags;
+type media_Id3TagsError = Id3TagsError;
+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_readId3Tags: typeof readId3Tags;
+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_Id3Tags as Id3Tags, type media_Id3TagsError as Id3TagsError, 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_readId3Tags as readId3Tags, media_readImageInfo as readImageInfo, media_readPdfMetadata as readPdfMetadata, media_readWavInfo as readWavInfo };
+}
+
+export { type ExifData as E, type Id3Tags as I, type PdfMetadata as P, type WavInfo as W, type ExifError as a, type Id3TagsError as b, type ImageFormat as c, type ImageInfo as d, type ImageInfoError as e, type PdfMetadataError as f, type WavInfoError as g, readId3Tags as h, readImageInfo as i, readPdfMetadata as j, readWavInfo as k, media as m, readExifData as r };