@utilix-tech/sdk 0.4.0 → 0.6.0

package/dist/chunk-FXBB7O5A.js

@@ -0,0 +1,467 @@
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/tools/media.ts
+var media_exports = {};
+__export(media_exports, {
+  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;
+}
+function readI32LE(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24;
+}
+var PNG_COLOR_TYPES = {
+  0: "grayscale",
+  2: "rgb",
+  3: "palette",
+  4: "grayscale+alpha",
+  6: "rgba"
+};
+function readPng(bytes) {
+  if (bytes.length < 33) return { error: "Truncated PNG file" };
+  const width = readU32BE(bytes, 16);
+  const height = readU32BE(bytes, 20);
+  const bitDepth = bytes[24];
+  const colorTypeNum = bytes[25];
+  const colorType = PNG_COLOR_TYPES[colorTypeNum] ?? "unknown";
+  const hasAlpha = colorTypeNum === 4 || colorTypeNum === 6;
+  return { format: "png", width, height, bitDepth, colorType, hasAlpha };
+}
+function readGif(bytes) {
+  if (bytes.length < 10) return { error: "Truncated GIF file" };
+  const width = bytes[6] | bytes[7] << 8;
+  const height = bytes[8] | bytes[9] << 8;
+  return { format: "gif", width, height };
+}
+function readBmp(bytes) {
+  if (bytes.length < 30) return { error: "Truncated BMP file" };
+  const width = readI32LE(bytes, 18);
+  const heightRaw = readI32LE(bytes, 22);
+  const bitDepth = bytes[28] | bytes[29] << 8;
+  return { format: "bmp", width: Math.abs(width), height: Math.abs(heightRaw), bitDepth };
+}
+function readWebp(bytes) {
+  if (bytes.length < 16) return { error: "Truncated WebP file" };
+  const fourCC = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+  if (fourCC === "VP8 ") {
+    if (bytes.length < 30) return { error: "Truncated WebP file" };
+    const width = (bytes[26] | bytes[27] << 8) & 16383;
+    const height = (bytes[28] | bytes[29] << 8) & 16383;
+    return { format: "webp", width, height };
+  }
+  if (fourCC === "VP8L") {
+    if (bytes.length < 25) return { error: "Truncated WebP file" };
+    const bits = bytes[21] | bytes[22] << 8 | bytes[23] << 16 | bytes[24] << 24;
+    const width = (bits & 16383) + 1;
+    const height = (bits >>> 14 & 16383) + 1;
+    const hasAlpha = !!(bits >>> 28 & 1);
+    return { format: "webp", width, height, hasAlpha };
+  }
+  if (fourCC === "VP8X") {
+    if (bytes.length < 30) return { error: "Truncated WebP file" };
+    const flags = bytes[20];
+    const hasAlpha = !!(flags & 16);
+    const width = (bytes[24] | bytes[25] << 8 | bytes[26] << 16) + 1;
+    const height = (bytes[27] | bytes[28] << 8 | bytes[29] << 16) + 1;
+    return { format: "webp", width, height, hasAlpha };
+  }
+  return { error: "Unrecognized WebP chunk format" };
+}
+var JPEG_SOF_MARKERS = /* @__PURE__ */ new Set([
+  192,
+  193,
+  194,
+  195,
+  197,
+  198,
+  199,
+  201,
+  202,
+  203,
+  205,
+  206,
+  207
+]);
+function readJpeg(bytes) {
+  let offset = 2;
+  while (offset < bytes.length - 1) {
+    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) break;
+    if (offset + 3 >= bytes.length) break;
+    const segmentLength = bytes[offset + 2] << 8 | bytes[offset + 3];
+    if (JPEG_SOF_MARKERS.has(marker)) {
+      if (offset + 9 >= bytes.length) return { error: "Truncated JPEG SOF segment" };
+      const bitDepth = bytes[offset + 4];
+      const height = bytes[offset + 5] << 8 | bytes[offset + 6];
+      const width = bytes[offset + 7] << 8 | bytes[offset + 8];
+      const components = bytes[offset + 9];
+      const colorType = components === 1 ? "grayscale" : components === 3 ? "rgb" : components === 4 ? "cmyk" : "unknown";
+      return { format: "jpeg", width, height, bitDepth, colorType };
+    }
+    offset += 2 + segmentLength;
+  }
+  return { error: "No SOF marker found in JPEG (file may be corrupt)" };
+}
+function readImageInfo(bytes) {
+  if (bytes.length < 10) return { error: "File too small to determine format" };
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) {
+    return readPng(bytes);
+  }
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) {
+    return readGif(bytes);
+  }
+  if (bytes[0] === 66 && bytes[1] === 77) {
+    return readBmp(bytes);
+  }
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) {
+    return readWebp(bytes);
+  }
+  if (bytes[0] === 255 && bytes[1] === 216) {
+    return readJpeg(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 gcd(a, b) {
+  return b === 0 ? a : gcd(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 = gcd(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 version = 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,
+    pageCount,
+    title,
+    author,
+    subject,
+    keywords,
+    creator,
+    producer,
+    creationDate: creationDateRaw ? parsePdfDate(creationDateRaw) ?? creationDateRaw : null,
+    modDate: modDateRaw ? parsePdfDate(modDateRaw) ?? modDateRaw : null,
+    encrypted
+  };
+}
+
+export { media_exports, readExifData, readImageInfo, readPdfMetadata };

package/dist/{chunk-FL53T24A.js → chunk-GEFVMGZR.js}

@@ -189,13 +189,7 @@ function generateMd5Hash(password) {
   return "$apr1$" + md5(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.hashSync(password, rounds);
 }
 function generatePlain(password) {
   return password;
@@ -204,7 +198,7 @@ function createEntry(username, password, algorithm = "bcrypt") {
   let hashedPassword;
   switch (algorithm) {
     case "bcrypt":
-      hashedPassword = generateBcryptHash();
+      hashedPassword = generateBcryptHash(password);
       break;
     case "sha1":
       hashedPassword = generateSha1Hash(password);

package/dist/{chunk-HFRTZE7T.js → chunk-Q3B3YWOA.js}

@@ -36,6 +36,7 @@ __export(api_exports, {
   parseCspHeader: () => parseCspHeader,
   parseCurl: () => parseCurl,
   parseCurlCommand: () => parseCurlCommand,
+  parseJwks: () => parseJwks,
   parseMetaTags: () => parseMetaTags,
   parseUrl: () => parseUrl,
   removeParam: () => removeParam,
@@ -485,6 +486,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",
@@ -1216,4 +1266,4 @@ function generateMetaHtml(tags) {
   return lines.join("\n");
 }
 
-export { COMMON_HEADERS, COMMON_PRESETS, CORS_COMMON_HEADERS, DEFAULT_CORS_CONFIG, DIRECTIVE_DESCRIPTIONS, HTTP_METHODS, SUPPORTED_LANGUAGES, addParam, api_exports, base64urlDecode, base64urlEncode, buildCurl, buildCurlMultiline, buildUrl, convertToCode, decodeJwt, decodeUrlComponent, detectFormat, encodeUrlComponent, extractJsonPaths, formatJwtJson, formatResponse, generateCors, generateCspHeader, generateFullHeader, generateMetaHtml, getParam, getStats, isValidUrl, normalizeUrl, parseCspHeader, parseCurl, parseCurlCommand, parseMetaTags, parseUrl, removeParam, signJwt, validateCorsConfig, validateCspConfig, validateOgTags };
+export { COMMON_HEADERS, COMMON_PRESETS, CORS_COMMON_HEADERS, DEFAULT_CORS_CONFIG, DIRECTIVE_DESCRIPTIONS, HTTP_METHODS, SUPPORTED_LANGUAGES, addParam, api_exports, base64urlDecode, base64urlEncode, buildCurl, buildCurlMultiline, buildUrl, convertToCode, decodeJwt, decodeUrlComponent, detectFormat, encodeUrlComponent, extractJsonPaths, formatJwtJson, formatResponse, generateCors, generateCspHeader, generateFullHeader, generateMetaHtml, getParam, getStats, isValidUrl, normalizeUrl, parseCspHeader, parseCurl, parseCurlCommand, parseJwks, parseMetaTags, parseUrl, removeParam, signJwt, validateCorsConfig, validateCspConfig, validateOgTags };