@utilix-tech/sdk 0.28.0 → 0.30.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Full release notes for all Utilix surfaces (browser tools, REST API, SDKs, MCP server) live at [utilix.tech/changelog](https://utilix.tech/changelog). This file tracks just this package.
 
+## 0.30.0
+- Add `jsonSchemaToTypescript` (json-schema-to-typescript): convert a JSON Schema document into TypeScript interfaces/types, reading `required`/`enum`/`oneOf`/`anyOf`/`allOf`/`$ref` directly instead of inferring from an example payload.
+- Add `estimatePasswordEntropy` (password-entropy-estimator): bits of entropy from a password's character pool, a strength label, and crack-time estimates across four guess-rate scenarios.
+
+## 0.29.0
+- Add `readPdfPageDimensions` (pdf-page-dimensions): each page's MediaBox width/height (points and inches), rotation, and orientation, walking the Root -> Pages -> Kids tree and inheriting from ancestor nodes, plus a common paper size match (Letter, A4, etc.).
+- Add `parseIpv6Address` (ipv6-compressor): expand an IPv6 address to its full 8-group form or compress it to its RFC 5952 canonical shortest form, classify its address type, and handle an embedded IPv4 suffix or zone ID.
+
 ## 0.28.0
 - Add `readVideoInfo` (mp4-webm-video-info): duration, resolution, and video/audio codec identifiers from an MP4 (ISO BMFF moov box) or WebM (EBML/Matroska Segment) container header, with no frame decoding or transcoding.
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/sdk
 
-**579 developer utility functions for Node.js: runs locally, no API key required.**
+**583 developer utility functions for Node.js: runs locally, no API key required.**
 
 [![npm version](https://img.shields.io/npm/v/@utilix-tech/sdk?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@utilix-tech/sdk)
 [![npm downloads](https://img.shields.io/npm/dm/@utilix-tech/sdk?style=flat-square)](https://www.npmjs.com/package/@utilix-tech/sdk)
@@ -65,7 +65,7 @@ const { formatJson } = require("@utilix-tech/sdk/json");
 ### `/json`: JSON Tools
 
 ```ts
-import { formatJson, minifyJson, diffJson, jsonToTypescript, validateJson,
+import { formatJson, minifyJson, diffJson, jsonToTypescript, jsonSchemaToTypescript, validateJson,
          evaluateJsonPath, resolveJsonPointer, jsonToCsv, yamlToJson, jsonToYaml, getJsonStats } from "@utilix-tech/sdk/json";
 
 // Format with 2-space indent
@@ -77,6 +77,9 @@ diffJson(jsonA, jsonB);
 // Generate TypeScript interface from JSON
 jsonToTypescript('{"id":1,"name":"Alice"}', { rootName: "User" });
 
+// Generate TypeScript interfaces from a JSON Schema (reads required/enum/$ref directly)
+jsonSchemaToTypescript('{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}', { rootName: "User" });
+
 // Query with JSONPath
 evaluateJsonPath(obj, "$.users[*].name");
 
@@ -222,14 +225,17 @@ shiftSubtitles("1\n00:00:01,000 --> 00:00:04,000\nHi\n", -2.5);
 
 ```ts
 import { generateUuid, generateV4, generateV7, generateUlid,
-         generatePassword, checkStrength, generateData } from "@utilix-tech/sdk/generators";
+         generatePassword, checkStrength, estimatePasswordEntropy, generateData } from "@utilix-tech/sdk/generators";
 
 generateUuid();       // "f47ac10b-58cc-4372-a567-0e02b2c3d479"  (v4)
 generateV7();         // time-ordered UUID v7
 generateUlid();       // "01ARZ3NDEKTSV4RRFFQ69G5FAV"
 
 generatePassword({ length: 16, symbols: true, numbers: true });
-checkStrength("P@ssw0rd!");  // { score: 4, label: "Strong", entropy: 52.4 }
+checkStrength("P@ssw0rd!");  // { score: 4, label: "Strong", color: "#16a34a" }
+
+// Actual bits of entropy from the character pool, plus crack-time estimates
+estimatePasswordEntropy("Tr0ub4dor&3xyzKL9!");  // { entropyBits: 118.26, strength: "strong", crackTimes: [...] }
 
 // Generate fake data rows
 generateData([
@@ -372,7 +378,7 @@ calculateRuleOf72(8, "rate-to-years");
 import { getStatusCode, isValidIp, isValidIpv4, isValidIpv6,
          searchStatusCodes, buildGeoUrl, countryCodeToFlag,
          parseHar, validateSitemap, validateRobotsTxt,
-         parseUserAgent, buildCacheControl } from "@utilix-tech/sdk/network";
+         parseUserAgent, buildCacheControl, parseIpv6Address } from "@utilix-tech/sdk/network";
 
 getStatusCode(404);
 // { code: 404, text: "Not Found", description: "...", category: "Client Error" }
@@ -406,6 +412,11 @@ validateRobotsTxt("User-agent: *\nDisallow: /admin\nSitemap: https://example.com
 // Build and explain a Cache-Control response header from directives
 buildCacheControl({ visibility: "public", maxAge: 3600, mustRevalidate: true });
 // { header: "public, max-age=3600, must-revalidate", directives: [...], warnings: [] }
+
+// Expand/compress an IPv6 address (RFC 5952) and classify its address type
+parseIpv6Address("2001:db8::ff00:42:8329");
+// { expanded: "2001:0db8:0000:0000:0000:ff00:0042:8329", compressed: "2001:db8::ff00:42:8329",
+//   groups: [...], zoneId: null, addressType: "documentation" }
 ```
 
 ---
@@ -561,10 +572,10 @@ analyzeString("café");          // { length: 4, codePoints: [...], ... }
 
 ---
 
-### `/media`: Image Header Parsing, EXIF, PDF, WAV, ID3, ICO, FLAC & Video Metadata
+### `/media`: Image Header Parsing, EXIF, PDF Metadata & Page Dimensions, WAV, ID3, ICO, FLAC & Video Metadata
 
 ```ts
-import { readImageInfo, readExifData, readPdfMetadata, readWavInfo, readId3Tags, readIcoInfo, readFlacInfo, readVideoInfo } from "@utilix-tech/sdk/media";
+import { readImageInfo, readExifData, readPdfMetadata, readPdfPageDimensions, readWavInfo, readId3Tags, readIcoInfo, readFlacInfo, readVideoInfo } from "@utilix-tech/sdk/media";
 
 // Reads format, dimensions, bit depth, and alpha channel straight from
 // file bytes: no decoding, no canvas, no image library.
@@ -584,6 +595,12 @@ const pdfBytes = await fs.promises.readFile("report.pdf");
 readPdfMetadata(new Uint8Array(pdfBytes));
 // { version: "1.7", pageCount: 12, title: "Q3 Report", author: "Jane Doe", ... }
 
+// Lists each page's MediaBox width/height (points and inches), rotation, and
+// orientation by walking the Root -> Pages -> Kids tree, inheriting from
+// ancestor nodes as the PDF spec requires. Also flags common paper sizes.
+readPdfPageDimensions(new Uint8Array(pdfBytes));
+// { version: "1.7", pageCount: 12, pages: [{ pageNumber: 1, widthPt: 612, heightPt: 792, rotation: 0, orientation: "portrait", paperSize: "Letter" }, ...] }
+
 // Reads sample rate, channels, bit depth, and duration from a WAV file's
 // RIFF/fmt/data chunk headers: no audio library required.
 const wavBytes = await fs.promises.readFile("recording.wav");
@@ -626,22 +643,22 @@ readVideoInfo(new Uint8Array(videoBytes));
 
 | Import | What it does |
 |---|---|
-| `@utilix-tech/sdk/json` | Format, minify, diff, validate, JSONPath, CSV↔JSON, YAML↔JSON, TS types |
+| `@utilix-tech/sdk/json` | Format, minify, diff, validate, JSONPath, CSV↔JSON, YAML↔JSON, TS types from data or from a JSON Schema |
 | `@utilix-tech/sdk/encoding` | Base64, URL, HTML entities, Base32/Base58/Base62 encode/decode |
 | `@utilix-tech/sdk/hashing` | MD5, SHA-1/256/512, bcrypt, HMAC, .htpasswd |
 | `@utilix-tech/sdk/text` | Case convert, slugify, word count, lorem ipsum, line ops, HTML→Markdown, Levenshtein/Damerau string distance |
 | `@utilix-tech/sdk/data` | CSV, YAML, TOML, XML, INI, NDJSON parse and convert, SRT/WebVTT subtitles |
-| `@utilix-tech/sdk/generators` | UUID v4/v7, ULID, passwords, strength check, fake data |
+| `@utilix-tech/sdk/generators` | UUID v4/v7, ULID, passwords, strength check, entropy estimator, fake data |
 | `@utilix-tech/sdk/time` | Date diff, timezone convert, cron parse, relative time |
 | `@utilix-tech/sdk/units` | Bytes, CSS px/rem, number bases, currency format, credit card/IBAN/barcode/ISBN validation, loan calculator, compound/simple interest calculators, VAT/sales tax calculator, tip/bill split calculator, break-even point calculator, Rule of 72 calculator |
-| `@utilix-tech/sdk/network` | HTTP status codes, IP validation, country flags, geolocation URLs, HAR file parsing, User-Agent parsing |
+| `@utilix-tech/sdk/network` | HTTP status codes, IP validation, country flags, geolocation URLs, HAR file parsing, User-Agent parsing, IPv6 address compress/expand |
 | `@utilix-tech/sdk/api` | cURL build/parse, JWT decode/sign, JWKS parse, CORS headers, CSP header |
 | `@utilix-tech/sdk/code` | SQL format/minify, HTML format/minify, regex tester, GraphQL format, MIME type lookup, GitHub URL parsing |
 | `@utilix-tech/sdk/color` | Hex/RGB/HSL/HSV/CMYK convert, palette generation, contrast check |
 | `@utilix-tech/sdk/css` | CSS gradient, box-shadow, border-radius, keyframe animation generators |
 | `@utilix-tech/sdk/misc` | SVG optimize/sanitize, file size format, Unicode inspector |
 | `@utilix-tech/sdk/ai_agent` | Token estimate/trim, chunk text, extract URLs/JSON/keywords, sanitize HTML, flatten/merge JSON, dedupe lines, validate schema, PII/secret/injection detect, vector similarity |
-| `@utilix-tech/sdk/media` | Image format & dimension reading from raw bytes (PNG, JPEG, GIF, WebP, BMP); PDF metadata reading; WAV audio info; ID3 tags; ICO favicon inspection; FLAC metadata reading; MP4/WebM video info |
+| `@utilix-tech/sdk/media` | Image format & dimension reading from raw bytes (PNG, JPEG, GIF, WebP, BMP); PDF metadata reading; PDF page dimension/orientation listing; WAV audio info; ID3 tags; ICO favicon inspection; FLAC metadata reading; MP4/WebM video info |
 
 ---
 

package/dist/{chunk-2CJSLYWI.js → chunk-3TYWIX3B.js}

@@ -12,6 +12,7 @@ __export(generators_exports, {
   SYMBOL_CHARS: () => SYMBOL_CHARS,
   ULID_REGEX: () => ULID_REGEX,
   checkStrength: () => checkStrength,
+  estimatePasswordEntropy: () => estimatePasswordEntropy,
   generateBulk: () => generateBulk,
   generateBulkPasswords: () => generateBulkPasswords,
   generateBulkUlids: () => generateBulkUlids,
@@ -228,6 +229,111 @@ function checkStrength(password) {
     color: levels[score].color
   };
 }
+var _SYMBOL_POOL_CHARS = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var _SYMBOL_POOL_SET = new Set(_SYMBOL_POOL_CHARS.split(""));
+function _hasSymbolChar(password) {
+  for (const ch of password) {
+    if (_SYMBOL_POOL_SET.has(ch)) return true;
+  }
+  return false;
+}
+function _hasSequentialRun(password, minRun) {
+  let ascRun = 1;
+  let descRun = 1;
+  for (let i = 1; i < password.length; i++) {
+    const prev = password.charCodeAt(i - 1);
+    const curr = password.charCodeAt(i);
+    if (curr === prev + 1) {
+      ascRun++;
+      descRun = 1;
+    } else if (curr === prev - 1) {
+      descRun++;
+      ascRun = 1;
+    } else {
+      ascRun = 1;
+      descRun = 1;
+    }
+    if (ascRun >= minRun || descRun >= minRun) return true;
+  }
+  return false;
+}
+function _formatCrackDuration(seconds) {
+  if (!isFinite(seconds)) return "effectively never";
+  if (seconds < 1) return "instantly";
+  const units = [
+    ["century", 315576e4],
+    ["year", 31557600],
+    ["month", 2629800],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1]
+  ];
+  for (const [name, unitSeconds] of units) {
+    if (seconds >= unitSeconds) {
+      const value = seconds / unitSeconds;
+      if (name === "century" && value > 1e3) return "longer than the age of the universe";
+      const rounded = value >= 100 ? Math.round(value) : Math.round(value * 10) / 10;
+      const plural = name === "century" ? "centuries" : `${name}s`;
+      return `${rounded} ${rounded === 1 ? name : plural}`;
+    }
+  }
+  return "instantly";
+}
+function estimatePasswordEntropy(password) {
+  if (!password) return { error: "Password is required" };
+  const hasLowercase = /[a-z]/.test(password);
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasDigits = /[0-9]/.test(password);
+  const hasSymbols = _hasSymbolChar(password);
+  const hasOther = /[^\x20-\x7e]/.test(password);
+  let poolSize = 0;
+  if (hasLowercase) poolSize += 26;
+  if (hasUppercase) poolSize += 26;
+  if (hasDigits) poolSize += 10;
+  if (hasSymbols) poolSize += _SYMBOL_POOL_CHARS.length;
+  if (hasOther) poolSize += 100;
+  const entropyBits = Math.round(password.length * Math.log2(poolSize) * 100) / 100;
+  let strength;
+  if (entropyBits < 28) strength = "very-weak";
+  else if (entropyBits < 36) strength = "weak";
+  else if (entropyBits < 60) strength = "fair";
+  else if (entropyBits < 128) strength = "strong";
+  else strength = "very-strong";
+  const averageGuesses = Math.pow(2, entropyBits) / 2;
+  const scenarios = [
+    { scenario: "Online, throttled (100 guesses/hour)", guessesPerSecond: 100 / 3600 },
+    { scenario: "Online, unthrottled (10 guesses/sec)", guessesPerSecond: 10 },
+    { scenario: "Offline, slow hash e.g. bcrypt (10k guesses/sec)", guessesPerSecond: 1e4 },
+    { scenario: "Offline, fast hash / GPU cluster (10B guesses/sec)", guessesPerSecond: 1e10 }
+  ];
+  const crackTimes = scenarios.map((s) => ({
+    scenario: s.scenario,
+    guessesPerSecond: s.guessesPerSecond,
+    humanReadable: _formatCrackDuration(averageGuesses / s.guessesPerSecond)
+  }));
+  const warnings = [];
+  if (password.length < 8) {
+    warnings.push("Shorter than 8 characters \u2014 most sites and cracking tools treat this as trivially weak regardless of entropy.");
+  }
+  if (/(.)\1{2,}/.test(password)) {
+    warnings.push('Contains a repeated character run (e.g. "aaa"), which is easier to guess than the entropy figure implies.');
+  }
+  if (_hasSequentialRun(password, 3)) {
+    warnings.push('Contains a sequential run (e.g. "abc" or "321"), which is easier to guess than the entropy figure implies.');
+  }
+  if (poolSize <= 26) {
+    warnings.push("Uses only one character class \u2014 mixing in uppercase, digits, or symbols raises the character pool and entropy.");
+  }
+  return {
+    length: password.length,
+    charset: { hasLowercase, hasUppercase, hasDigits, hasSymbols, hasOther, poolSize },
+    entropyBits,
+    strength,
+    crackTimes,
+    warnings
+  };
+}
 var DATA_TYPES = [
   { value: "name", label: "Full Name", example: "John Smith" },
   { value: "email", label: "Email Address", example: "john.smith@gmail.com" },
@@ -517,4 +623,4 @@ async function generateQrDataUrl(text, options) {
   });
 }
 
-export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, generators_exports, isValidUlid, isValidUuid, parseUlid, parseUuidVersion };
+export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, estimatePasswordEntropy, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, generators_exports, isValidUlid, isValidUuid, parseUlid, parseUuidVersion };

package/dist/{chunk-Y5OOP6WN.js → chunk-CSNTHZHF.js}

@@ -27,6 +27,7 @@ __export(network_exports, {
   parseDnsResponse: () => parseDnsResponse,
   parseGeoResponse: () => parseGeoResponse,
   parseHar: () => parseHar,
+  parseIpv6Address: () => parseIpv6Address,
   parseUserAgent: () => parseUserAgent,
   searchHeaders: () => searchHeaders,
   searchStatusCodes: () => searchStatusCodes,
@@ -1814,5 +1815,93 @@ function buildCacheControl(options = {}) {
   const snippet = `Cache-Control: ${header}`;
   return { header, headerName: "Cache-Control", snippet, directives, warnings };
 }
+function isValidIpv6HexGroup(g) {
+  return /^[0-9a-fA-F]{1,4}$/.test(g);
+}
+function isValidIpv6Ipv4Quad(quad) {
+  const parts = quad.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((p) => /^\d{1,3}$/.test(p) && Number(p) <= 255);
+}
+function classifyIpv6(groups) {
+  const first = parseInt(groups[0], 16);
+  if (groups.every((g) => g === "0000")) return "unspecified";
+  if (groups.slice(0, 7).every((g) => g === "0000") && groups[7] === "0001") return "loopback";
+  if (groups.slice(0, 4).every((g) => g === "0000") && groups[4] === "0000" && groups[5] === "ffff") return "ipv4-mapped";
+  if (groups[0] === "2001" && groups[1] === "0db8") return "documentation";
+  if ((first & 65280) === 65280) return "multicast";
+  if ((first & 65472) === 65152) return "link-local";
+  if ((first & 65024) === 64512) return "unique-local";
+  return "global-unicast";
+}
+function compressIpv6Groups(groups) {
+  const short = groups.map((g) => g.replace(/^0+(?=.)/, ""));
+  let bestStart = -1;
+  let bestLen = 0;
+  let curStart = -1;
+  let curLen = 0;
+  for (let i = 0; i < short.length; i++) {
+    if (short[i] === "0") {
+      if (curStart === -1) curStart = i;
+      curLen++;
+      if (curLen > bestLen) {
+        bestLen = curLen;
+        bestStart = curStart;
+      }
+    } else {
+      curStart = -1;
+      curLen = 0;
+    }
+  }
+  if (bestLen < 2) return short.join(":");
+  const before = short.slice(0, bestStart).join(":");
+  const after = short.slice(bestStart + bestLen).join(":");
+  return `${before}::${after}`;
+}
+function parseIpv6Address(input) {
+  let s = input.trim();
+  if (s.startsWith("[") && s.includes("]")) s = s.slice(1, s.indexOf("]"));
+  let zoneId = null;
+  const pctIdx = s.indexOf("%");
+  if (pctIdx !== -1) {
+    zoneId = s.slice(pctIdx + 1);
+    s = s.slice(0, pctIdx);
+  }
+  if (!s) return { error: "Empty address" };
+  const doubleColonCount = (s.match(/::/g) ?? []).length;
+  if (doubleColonCount > 1) return { error: 'Address contains more than one "::"' };
+  const ipv4Match = s.match(/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+  if (ipv4Match) {
+    const quad = ipv4Match[1];
+    if (!isValidIpv6Ipv4Quad(quad)) return { error: `Invalid embedded IPv4 address: ${quad}` };
+    const parts = quad.split(".").map(Number);
+    const hi = (parts[0] << 8 | parts[1]).toString(16);
+    const lo = (parts[2] << 8 | parts[3]).toString(16);
+    s = s.slice(0, s.length - quad.length) + `${hi}:${lo}`;
+  }
+  let groups;
+  if (s.includes("::")) {
+    const [left, right] = s.split("::");
+    const leftGroups = left ? left.split(":") : [];
+    const rightGroups = right ? right.split(":") : [];
+    const missing = 8 - (leftGroups.length + rightGroups.length);
+    if (missing < 1) return { error: 'The "::" shorthand must represent at least one group of zeros' };
+    if (![...leftGroups, ...rightGroups].every(isValidIpv6HexGroup)) return { error: "Invalid hex group in address" };
+    groups = [...leftGroups, ...Array(missing).fill("0"), ...rightGroups];
+  } else {
+    groups = s.split(":");
+    if (groups.length !== 8) return { error: `Expected 8 groups, got ${groups.length}` };
+    if (!groups.every(isValidIpv6HexGroup)) return { error: "Invalid hex group in address" };
+  }
+  const expandedGroups = groups.map((g) => g.padStart(4, "0").toLowerCase());
+  const suffix = zoneId ? `%${zoneId}` : "";
+  return {
+    expanded: expandedGroups.join(":") + suffix,
+    compressed: compressIpv6Groups(expandedGroups) + suffix,
+    groups: expandedGroups,
+    zoneId,
+    addressType: classifyIpv6(expandedGroups)
+  };
+}
 
-export { DNS_RECORD_TYPES, HTTP_HEADERS, STATUS_CODES, buildCacheControl, buildDnsQueryUrl, buildGeoUrl, buildMapUrl, countryCodeToFlag, formatCoordinates, formatTtl, getByCategory, getHeader, getHeadersByCategory, getStatusByCategory, getStatusCode, isClientError, isServerError, isSuccess, isValidIp, isValidIpv4, isValidIpv6, network_exports, parseDnsResponse, parseGeoResponse, parseHar, parseUserAgent, searchHeaders, searchStatusCodes, statusCodeToText, typeNumberToLabel, validateDomain, validateHeaderName, validateHeaderValue, validateRobotsTxt, validateSitemap };
+export { DNS_RECORD_TYPES, HTTP_HEADERS, STATUS_CODES, buildCacheControl, buildDnsQueryUrl, buildGeoUrl, buildMapUrl, countryCodeToFlag, formatCoordinates, formatTtl, getByCategory, getHeader, getHeadersByCategory, getStatusByCategory, getStatusCode, isClientError, isServerError, isSuccess, isValidIp, isValidIpv4, isValidIpv6, network_exports, parseDnsResponse, parseGeoResponse, parseHar, parseIpv6Address, parseUserAgent, searchHeaders, searchStatusCodes, statusCodeToText, typeNumberToLabel, validateDomain, validateHeaderName, validateHeaderValue, validateRobotsTxt, validateSitemap };

package/dist/{chunk-47DTCCQJ.js → chunk-L6V4W4SU.js}

@@ -9,6 +9,7 @@ __export(media_exports, {
   readId3Tags: () => readId3Tags,
   readImageInfo: () => readImageInfo,
   readPdfMetadata: () => readPdfMetadata,
+  readPdfPageDimensions: () => readPdfPageDimensions,
   readVideoInfo: () => readVideoInfo,
   readWavInfo: () => readWavInfo
 });
@@ -468,6 +469,116 @@ function readPdfMetadata(bytes) {
     encrypted
   };
 }
+var PDF_COMMON_PAPER_SIZES = [
+  { name: "Letter", widthPt: 612, heightPt: 792 },
+  { name: "Legal", widthPt: 612, heightPt: 1008 },
+  { name: "Tabloid", widthPt: 792, heightPt: 1224 },
+  { name: "A3", widthPt: 842, heightPt: 1191 },
+  { name: "A4", widthPt: 595, heightPt: 842 },
+  { name: "A5", widthPt: 420, heightPt: 595 },
+  { name: "B5", widthPt: 499, heightPt: 709 }
+];
+function matchPaperSize(widthPt, heightPt) {
+  for (const size of PDF_COMMON_PAPER_SIZES) {
+    const w = Math.abs(widthPt - size.widthPt) <= 1;
+    const h = Math.abs(heightPt - size.heightPt) <= 1;
+    const wSwapped = Math.abs(widthPt - size.heightPt) <= 1;
+    const hSwapped = Math.abs(heightPt - size.widthPt) <= 1;
+    if (w && h || wSwapped && hSwapped) return size.name;
+  }
+  return null;
+}
+function parsePdfMediaBox(dict) {
+  const m = dict.match(/\/MediaBox\s*\[\s*(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s*\]/);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+}
+function parsePdfRotate(dict) {
+  const m = dict.match(/\/Rotate\s+(-?\d+)/);
+  return m ? Number(m[1]) : null;
+}
+function buildPdfPageDimension(pageNumber, mediaBox, rotate) {
+  const rotation = (rotate % 360 + 360) % 360;
+  if (!mediaBox) {
+    return { pageNumber, widthPt: null, heightPt: null, widthIn: null, heightIn: null, rotation, orientation: null, paperSize: null };
+  }
+  const [llx, lly, urx, ury] = mediaBox;
+  let widthPt = Math.abs(urx - llx);
+  let heightPt = Math.abs(ury - lly);
+  if (rotation === 90 || rotation === 270) [widthPt, heightPt] = [heightPt, widthPt];
+  const orientation = widthPt === heightPt ? "square" : widthPt > heightPt ? "landscape" : "portrait";
+  return {
+    pageNumber,
+    widthPt: round2(widthPt),
+    heightPt: round2(heightPt),
+    widthIn: round2(widthPt / 72),
+    heightIn: round2(heightPt / 72),
+    rotation,
+    orientation,
+    paperSize: matchPaperSize(widthPt, heightPt)
+  };
+}
+function walkPdfPageTree(objMap, nodeBody, inherited, visited, nodeKey, out) {
+  if (visited.has(nodeKey)) return;
+  visited.add(nodeKey);
+  const mediaBox = parsePdfMediaBox(nodeBody) ?? inherited.mediaBox;
+  const rotateMatch = parsePdfRotate(nodeBody);
+  const rotate = rotateMatch !== null ? rotateMatch : inherited.rotate;
+  if (/\/Type\s*\/Page(?!s)\b/.test(nodeBody)) {
+    out.push(buildPdfPageDimension(out.length + 1, mediaBox, rotate));
+    return;
+  }
+  const kidsMatch = nodeBody.match(/\/Kids\s*\[([^\]]*)\]/);
+  if (!kidsMatch) return;
+  const kidRefs = [...kidsMatch[1].matchAll(/(\d+)\s+(\d+)\s+R/g)];
+  for (const ref of kidRefs) {
+    const key = `${ref[1]} ${ref[2]}`;
+    const body = objMap.get(key);
+    if (body) walkPdfPageTree(objMap, body, { mediaBox, rotate }, visited, key, out);
+  }
+}
+function readPdfPageDimensions(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 version = versionMatch[1];
+  const text = bytesToLatin1(bytes);
+  const objBlocks = [...text.matchAll(/(\d+)\s+(\d+)\s+obj([\s\S]*?)endobj/g)];
+  const objMap = /* @__PURE__ */ new Map();
+  for (const b of objBlocks) objMap.set(`${b[1]} ${b[2]}`, b[3]);
+  const out = [];
+  const visited = /* @__PURE__ */ new Set();
+  let pagesRootBody = null;
+  const trailerMatches = [...text.matchAll(/trailer\s*<<([\s\S]*?)>>/g)];
+  if (trailerMatches.length > 0) {
+    const trailer = trailerMatches[trailerMatches.length - 1][1];
+    const rootRef = trailer.match(/\/Root\s+(\d+)\s+(\d+)\s+R/);
+    if (rootRef) {
+      const catalogBody = objMap.get(`${rootRef[1]} ${rootRef[2]}`);
+      const pagesRef = catalogBody?.match(/\/Pages\s+(\d+)\s+(\d+)\s+R/);
+      if (pagesRef) pagesRootBody = objMap.get(`${pagesRef[1]} ${pagesRef[2]}`) ?? null;
+    }
+  }
+  if (!pagesRootBody) {
+    for (const b of objBlocks) {
+      if (/\/Type\s*\/Pages\b/.test(b[3]) && !/\/Parent\s+\d+\s+\d+\s+R/.test(b[3])) {
+        pagesRootBody = b[3];
+        break;
+      }
+    }
+  }
+  if (pagesRootBody) walkPdfPageTree(objMap, pagesRootBody, { mediaBox: null, rotate: 0 }, visited, "root", out);
+  if (out.length === 0) {
+    for (const b of objBlocks) {
+      if (/\/Type\s*\/Page(?!s)\b/.test(b[3])) {
+        out.push(buildPdfPageDimension(out.length + 1, parsePdfMediaBox(b[3]), parsePdfRotate(b[3]) ?? 0));
+      }
+    }
+  }
+  if (out.length === 0) return { error: "Could not locate any page objects in this PDF" };
+  return { version, pageCount: out.length, pages: out };
+}
 var AUDIO_FORMAT_LABELS = {
   1: "PCM",
   3: "IEEE float",
@@ -1110,4 +1221,4 @@ function parseWebm(bytes) {
   return result;
 }
 
-export { media_exports, readExifData, readFlacInfo, readIcoInfo, readId3Tags, readImageInfo, readPdfMetadata, readVideoInfo, readWavInfo };
+export { media_exports, readExifData, readFlacInfo, readIcoInfo, readId3Tags, readImageInfo, readPdfMetadata, readPdfPageDimensions, readVideoInfo, readWavInfo };

package/dist/{chunk-WO3LJMVV.js → chunk-WVEKRKGU.js}

@@ -15,6 +15,7 @@ __export(json_exports, {
   inferGoType: () => inferGoType,
   inferPythonType: () => inferPythonType,
   inferType: () => inferType,
+  jsonSchemaToTypescript: () => jsonSchemaToTypescript,
   jsonToCsv: () => jsonToCsv,
   jsonToGo: () => jsonToGo,
   jsonToPython: () => jsonToPython,
@@ -1302,5 +1303,104 @@ function resolveJsonPointer(json, pointer) {
   }
   return { pointer, found: true, value: current, tokens };
 }
+function _schemaRefName(ref) {
+  const parts = ref.split("/");
+  return _capitalize(parts[parts.length - 1] || "Ref");
+}
+function _schemaLiteralType(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return JSON.stringify(value);
+}
+function _safePropertyKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function _schemaToTsType(schema, name, interfaces) {
+  if (schema.$ref) return _schemaRefName(schema.$ref);
+  if (schema.const !== void 0) return _schemaLiteralType(schema.const);
+  if (schema.enum) return schema.enum.map(_schemaLiteralType).join(" | ");
+  if (schema.oneOf) return schema.oneOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.anyOf) return schema.anyOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.allOf) return schema.allOf.map((s, i) => _schemaToTsType(s, `${name}Part${i}`, interfaces)).join(" & ");
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  const nullable = types.includes("null");
+  const nonNullTypes = types.filter((t) => t !== "null");
+  const primaryType = nonNullTypes[0] ?? (schema.properties || schema.additionalProperties !== void 0 ? "object" : void 0);
+  let result;
+  switch (primaryType) {
+    case "string":
+      result = "string";
+      break;
+    case "number":
+    case "integer":
+      result = "number";
+      break;
+    case "boolean":
+      result = "boolean";
+      break;
+    case "array": {
+      const itemsSchema = Array.isArray(schema.items) ? schema.items[0] : schema.items;
+      const itemType = itemsSchema ? _schemaToTsType(itemsSchema, `${name}Item`, interfaces) : "unknown";
+      result = `${itemType}[]`;
+      break;
+    }
+    case "object": {
+      _buildSchemaInterface(schema, name, interfaces);
+      result = name;
+      break;
+    }
+    default:
+      result = "unknown";
+  }
+  return nullable ? `${result} | null` : result;
+}
+function _buildSchemaInterface(schema, name, interfaces) {
+  if (interfaces.has(name)) return;
+  const required = new Set(schema.required ?? []);
+  const lines = [`interface ${name} {`];
+  for (const [key, propSchema] of Object.entries(schema.properties ?? {})) {
+    if (propSchema.description) lines.push(`  /** ${propSchema.description} */`);
+    const optional = required.has(key) ? "" : "?";
+    const propType = _schemaToTsType(propSchema, _capitalize(key), interfaces);
+    lines.push(`  ${_safePropertyKey(key)}${optional}: ${propType};`);
+  }
+  if (schema.additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    const addType = _schemaToTsType(schema.additionalProperties, `${name}Value`, interfaces);
+    lines.push(`  [key: string]: ${addType};`);
+  }
+  lines.push("}");
+  interfaces.set(name, lines.join("\n"));
+}
+function jsonSchemaToTypescript(schemaJson, options) {
+  let schema;
+  try {
+    schema = JSON.parse(schemaJson);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return { error: "Schema must be a JSON object" };
+  }
+  const rootName = options?.rootName ?? "Root";
+  const typedSchema = schema;
+  const interfaces = /* @__PURE__ */ new Map();
+  const defs = { ...typedSchema.$defs ?? {}, ...typedSchema.definitions ?? {} };
+  for (const [defName, defSchema] of Object.entries(defs)) {
+    const defTypeName = _capitalize(defName);
+    const defType = _schemaToTsType(defSchema, defTypeName, interfaces);
+    if (!interfaces.has(defTypeName)) {
+      interfaces.set(defTypeName, `type ${defTypeName} = ${defType};`);
+    }
+  }
+  const rootType = _schemaToTsType(typedSchema, rootName, interfaces);
+  const parts = [...interfaces.values()];
+  if (!interfaces.has(rootName)) {
+    parts.push(`type ${rootName} = ${rootType};`);
+  }
+  return parts.join("\n\n");
+}
 
-export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson };
+export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonSchemaToTypescript, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson };