avatarsniff 0.1.1

package/dist/index.cjs

@@ -0,0 +1,834 @@
+'use strict';
+
+var chunkB5TUEKW2_cjs = require('./chunk-B5TUEKW2.cjs');
+require('./chunk-ESH45ZBG.cjs');
+
+// src/detectors.ts
+function clamp01(value) {
+  return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+var initials = (f, o) => {
+  if (f.isLightBackground || f.isDarkBackground) {
+    return null;
+  }
+  if (f.dominantChroma < 24) {
+    return null;
+  }
+  if (f.coloredOtherFraction > o.maxColoredContent) {
+    return null;
+  }
+  if (f.glyphFraction < o.minGlyphFraction || f.dominantFraction < o.minDominantFraction || f.significantColors > o.maxSignificantColors) {
+    return null;
+  }
+  const dominanceScore = clamp01(
+    (f.dominantFraction - o.minDominantFraction) / (1 - o.minDominantFraction)
+  );
+  const simplicityScore = clamp01(
+    (o.maxSignificantColors + 1 - f.significantColors) / o.maxSignificantColors
+  );
+  const score = clamp01(dominanceScore * 0.6 + simplicityScore * 0.4);
+  if (score < o.scoreThreshold) {
+    return null;
+  }
+  return {
+    name: "initials",
+    score,
+    reason: `coloured background (${(f.dominantFraction * 100).toFixed(0)}% dominant) with a ${(f.glyphFraction * 100).toFixed(1)}% white glyph`
+  };
+};
+var solidColor = (f, o) => {
+  if (f.isLightBackground || f.isDarkBackground) {
+    return null;
+  }
+  if (f.dominantChroma < 24) {
+    return null;
+  }
+  if (f.dominantFraction < o.solidMinDominantFraction || f.significantColors > 1 || f.glyphFraction >= o.minGlyphFraction) {
+    return null;
+  }
+  return {
+    name: "solidColor",
+    score: clamp01(f.dominantFraction),
+    reason: `flat ${(f.dominantFraction * 100).toFixed(0)}% solid colour with no glyph`
+  };
+};
+var personIcon = (f, o) => {
+  if (f.meanChroma > o.maxGrayChroma) {
+    return null;
+  }
+  if (f.symmetry < o.minSymmetry) {
+    return null;
+  }
+  const [r, g, b] = f.dominantRgb;
+  const lightGreyBackground = Math.min(r, g, b) >= 150 && !f.isLightBackground && !f.isDarkBackground;
+  if (!lightGreyBackground) {
+    return null;
+  }
+  if (f.glyphFraction < o.minPersonFigureFraction) {
+    return null;
+  }
+  return {
+    name: "personIcon",
+    score: clamp01((f.symmetry - o.minSymmetry) / (1 - o.minSymmetry)),
+    reason: `grey person silhouette (${(f.glyphFraction * 100).toFixed(0)}% figure) on a light background`
+  };
+};
+var identicon = (f, o) => {
+  if (f.symmetry < o.identiconMinSymmetry) {
+    return null;
+  }
+  if (f.significantColors > o.identiconMaxColors) {
+    return null;
+  }
+  const foreground = 1 - f.dominantFraction;
+  if (foreground < o.identiconMinForeground) {
+    return null;
+  }
+  return {
+    name: "identicon",
+    score: clamp01((f.symmetry - o.identiconMinSymmetry) / (1 - o.identiconMinSymmetry)),
+    reason: `symmetric pattern (${(f.symmetry * 100).toFixed(0)}% mirror, ${(foreground * 100).toFixed(0)}% foreground)`
+  };
+};
+var DETECTORS = [
+  { name: "initials", run: initials },
+  { name: "solidColor", run: solidColor },
+  { name: "personIcon", run: personIcon },
+  { name: "identicon", run: identicon }
+];
+
+// src/features.ts
+function sampleRgb(image, size) {
+  const { data, width, height } = image;
+  const channels = image.channels ?? Math.round(data.length / (width * height));
+  const out = new Uint8Array(size * size * 3);
+  for (let sy = 0; sy < size; sy++) {
+    const srcY = Math.min(height - 1, Math.floor((sy + 0.5) * height / size));
+    for (let sx = 0; sx < size; sx++) {
+      const srcX = Math.min(width - 1, Math.floor((sx + 0.5) * width / size));
+      const si = (srcY * width + srcX) * channels;
+      let r = data[si];
+      let g = data[si + 1];
+      let b = data[si + 2];
+      if (channels === 4) {
+        const alpha = data[si + 3] / 255;
+        r = Math.round(r * alpha + 255 * (1 - alpha));
+        g = Math.round(g * alpha + 255 * (1 - alpha));
+        b = Math.round(b * alpha + 255 * (1 - alpha));
+      }
+      const di = (sy * size + sx) * 3;
+      out[di] = r;
+      out[di + 1] = g;
+      out[di + 2] = b;
+    }
+  }
+  return out;
+}
+function extractFeatures(image, opts) {
+  const { width, height } = image;
+  const channels = image.channels ?? Math.round(image.data.length / (width * height));
+  if (!(width && height) || channels < 3) {
+    return null;
+  }
+  const size = opts.sampleSize;
+  const totalPixels = size * size;
+  const pixels = sampleRgb(image, size);
+  const levels = 2 ** opts.quantizeBits;
+  const divisor = 256 / levels;
+  const counts = /* @__PURE__ */ new Map();
+  let nearWhitePixels = 0;
+  let chromaSum = 0;
+  for (let i = 0; i < pixels.length; i += 3) {
+    const r = pixels[i];
+    const g = pixels[i + 1];
+    const b = pixels[i + 2];
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    chromaSum += max - min;
+    if (min >= opts.glyphWhiteCutoff) {
+      nearWhitePixels += 1;
+    }
+    const key = Math.floor(r / divisor) * levels * levels + Math.floor(g / divisor) * levels + Math.floor(b / divisor);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  let dominantCount = 0;
+  let dominantKey = 0;
+  let significantColors = 0;
+  const noiseThreshold = opts.noiseFloor * totalPixels;
+  for (const [key, count] of counts) {
+    if (count > dominantCount) {
+      dominantCount = count;
+      dominantKey = key;
+    }
+    if (count >= noiseThreshold) {
+      significantColors += 1;
+    }
+  }
+  const dominantB = dominantKey % levels;
+  const dominantG = Math.floor(dominantKey / levels) % levels;
+  const dominantR = Math.floor(dominantKey / (levels * levels)) % levels;
+  const bucketCenter = (bucket) => (bucket + 0.5) * divisor;
+  const dominantRgb = [dominantR, dominantG, dominantB].map(bucketCenter);
+  let coloredOtherPixels = 0;
+  for (let i = 0; i < pixels.length; i += 3) {
+    const r = pixels[i];
+    const g = pixels[i + 1];
+    const b = pixels[i + 2];
+    if (Math.min(r, g, b) >= opts.glyphWhiteCutoff) {
+      continue;
+    }
+    const nearDominant = Math.abs(Math.floor(r / divisor) - dominantR) <= 1 && Math.abs(Math.floor(g / divisor) - dominantG) <= 1 && Math.abs(Math.floor(b / divisor) - dominantB) <= 1;
+    if (!nearDominant) {
+      coloredOtherPixels += 1;
+    }
+  }
+  let symMatches = 0;
+  const tol = 36;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const i = (y * size + x) * 3;
+      const mi = (y * size + (size - 1 - x)) * 3;
+      const diff = Math.abs(pixels[i] - pixels[mi]) + Math.abs(pixels[i + 1] - pixels[mi + 1]) + Math.abs(pixels[i + 2] - pixels[mi + 2]);
+      if (diff <= tol) {
+        symMatches += 1;
+      }
+    }
+  }
+  return {
+    size,
+    totalPixels,
+    pixels,
+    dominantFraction: dominantCount / totalPixels,
+    dominantRgb,
+    dominantChroma: Math.max(...dominantRgb) - Math.min(...dominantRgb),
+    dominantBucket: [dominantR, dominantG, dominantB],
+    significantColors,
+    glyphFraction: nearWhitePixels / totalPixels,
+    coloredOtherFraction: coloredOtherPixels / totalPixels,
+    meanChroma: chromaSum / totalPixels,
+    symmetry: symMatches / totalPixels,
+    isLightBackground: dominantRgb.every((c) => c >= opts.whiteCutoff),
+    isDarkBackground: dominantRgb.every((c) => c <= opts.blackCutoff),
+    levels,
+    divisor
+  };
+}
+
+// src/analyze.ts
+var DEFAULTS = {
+  sampleSize: 48,
+  quantizeBits: 4,
+  noiseFloor: 0.02,
+  minDominantFraction: 0.55,
+  maxSignificantColors: 4,
+  scoreThreshold: 0.6,
+  whiteCutoff: 224,
+  blackCutoff: 40,
+  glyphWhiteCutoff: 200,
+  minGlyphFraction: 8e-3,
+  maxColoredContent: 0.06,
+  solidMinDominantFraction: 0.92,
+  minSymmetry: 0.9,
+  maxGrayChroma: 18,
+  minPersonFigureFraction: 0.1,
+  identiconMinSymmetry: 0.92,
+  identiconMinForeground: 0.12,
+  identiconMaxColors: 6
+  // maxBytes is a decode-layer concern, not used by the pixel analysis.
+};
+function notDefault(reason) {
+  return {
+    isDefault: false,
+    matched: null,
+    score: 0,
+    dominantFraction: 0,
+    significantColors: 0,
+    glyphFraction: 0,
+    coloredOtherFraction: 0,
+    reason
+  };
+}
+function rejectionReason(f, o) {
+  if (f.isLightBackground) {
+    return "near-white background - a logo/drawing/photo, not a default";
+  }
+  if (f.isDarkBackground) {
+    return "near-black background - a dark photo/icon, not a default";
+  }
+  if (f.coloredOtherFraction > o.maxColoredContent) {
+    return `${(f.coloredOtherFraction * 100).toFixed(1)}% coloured content - a photo/illustration, not a default`;
+  }
+  if (f.glyphFraction < o.minGlyphFraction && f.dominantFraction < o.solidMinDominantFraction) {
+    return `no glyph (${(f.glyphFraction * 100).toFixed(1)}%) and not a flat block - not a default`;
+  }
+  return `not a recognised default (${(f.dominantFraction * 100).toFixed(0)}% dominant, ${f.significantColors} significant colours, ${(f.symmetry * 100).toFixed(0)}% symmetry)`;
+}
+function analyzeImage(image, options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  const features = extractFeatures(image, opts);
+  if (!features) {
+    return notDefault("empty or non-RGB image");
+  }
+  const thresholds = opts;
+  const toggles = options.detect ?? {};
+  const base = {
+    dominantFraction: features.dominantFraction,
+    significantColors: features.significantColors,
+    glyphFraction: features.glyphFraction,
+    coloredOtherFraction: features.coloredOtherFraction
+  };
+  for (const { name, run } of DETECTORS) {
+    if (toggles[name] === false) {
+      continue;
+    }
+    const match = run(features, thresholds);
+    if (match) {
+      return {
+        isDefault: true,
+        matched: match.name,
+        score: match.score,
+        reason: match.reason,
+        ...base
+      };
+    }
+  }
+  return {
+    isDefault: false,
+    matched: null,
+    score: 0,
+    reason: rejectionReason(features, opts),
+    ...base
+  };
+}
+
+// src/decode.ts
+var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+function sniffFormat(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80) {
+    return "png";
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) {
+    return "gif";
+  }
+  if (bytes.length >= 12 && bytes[0] === 82 && // R
+  bytes[1] === 73 && // I
+  bytes[2] === 70 && // F
+  bytes[8] === 87 && // W
+  bytes[9] === 69 && // E
+  bytes[10] === 66 && // B
+  bytes[11] === 80) {
+    return "webp";
+  }
+  let i = 0;
+  while (i < bytes.length && bytes[i] <= 32) {
+    i++;
+  }
+  const head = String.fromCharCode(...bytes.subarray(i, i + 5)).toLowerCase();
+  if (head.startsWith("<?xml") || head.startsWith("<svg")) {
+    return "svg";
+  }
+  return "unknown";
+}
+function readUint32(bytes, offset) {
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3];
+}
+async function inflate(data) {
+  const stream = new Response(data).body?.pipeThrough(
+    new DecompressionStream("deflate")
+  );
+  if (!stream) {
+    throw new Error("no readable stream");
+  }
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc) {
+    return a;
+  }
+  return pb <= pc ? b : c;
+}
+var PNG_CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+async function decodePng(bytes) {
+  let pos = 8;
+  let width = 0;
+  let height = 0;
+  let bitDepth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  let palette = null;
+  let transparency = null;
+  const idat = [];
+  while (pos + 8 <= bytes.length) {
+    const length = readUint32(bytes, pos);
+    pos += 4;
+    const type = String.fromCharCode(
+      bytes[pos],
+      bytes[pos + 1],
+      bytes[pos + 2],
+      bytes[pos + 3]
+    );
+    pos += 4;
+    const data = bytes.subarray(pos, pos + length);
+    pos += length + 4;
+    if (type === "IHDR") {
+      width = readUint32(data, 0);
+      height = readUint32(data, 4);
+      bitDepth = data[8];
+      colorType = data[9];
+      interlace = data[12];
+    } else if (type === "PLTE") {
+      palette = data;
+    } else if (type === "tRNS") {
+      transparency = data;
+    } else if (type === "IDAT") {
+      idat.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+  }
+  const srcChannels = PNG_CHANNELS[colorType];
+  if (!(width && height && srcChannels) || bitDepth !== 8 || interlace !== 0) {
+    return null;
+  }
+  let total = 0;
+  for (const c of idat) {
+    total += c.length;
+  }
+  const compressed = new Uint8Array(total);
+  let w = 0;
+  for (const c of idat) {
+    compressed.set(c, w);
+    w += c.length;
+  }
+  const raw = await inflate(compressed);
+  const stride = width * srcChannels;
+  const out = new Uint8Array(height * stride);
+  let rp = 0;
+  for (let y = 0; y < height; y++) {
+    const filter = raw[rp++];
+    for (let x = 0; x < stride; x++) {
+      const cur = raw[rp++];
+      const a = x >= srcChannels ? out[y * stride + x - srcChannels] : 0;
+      const b = y > 0 ? out[(y - 1) * stride + x] : 0;
+      const c = x >= srcChannels && y > 0 ? out[(y - 1) * stride + x - srcChannels] : 0;
+      let v = cur;
+      if (filter === 1) {
+        v = cur + a;
+      } else if (filter === 2) {
+        v = cur + b;
+      } else if (filter === 3) {
+        v = cur + (a + b >> 1);
+      } else if (filter === 4) {
+        v = cur + paeth(a, b, c);
+      }
+      out[y * stride + x] = v & 255;
+    }
+  }
+  const rgba = new Uint8Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const s = i * srcChannels;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let alpha = 255;
+    if (colorType === 0) {
+      r = g = b = out[s];
+    } else if (colorType === 2) {
+      r = out[s];
+      g = out[s + 1];
+      b = out[s + 2];
+    } else if (colorType === 4) {
+      r = g = b = out[s];
+      alpha = out[s + 1];
+    } else if (colorType === 6) {
+      r = out[s];
+      g = out[s + 1];
+      b = out[s + 2];
+      alpha = out[s + 3];
+    } else if (colorType === 3) {
+      if (!palette) {
+        return null;
+      }
+      const idx = out[s];
+      r = palette[idx * 3];
+      g = palette[idx * 3 + 1];
+      b = palette[idx * 3 + 2];
+      if (transparency && idx < transparency.length) {
+        alpha = transparency[idx];
+      }
+    }
+    rgba[i * 4] = r;
+    rgba[i * 4 + 1] = g;
+    rgba[i * 4 + 2] = b;
+    rgba[i * 4 + 3] = alpha;
+  }
+  return { data: rgba, width, height, channels: 4 };
+}
+function lzwDecode(data, minCodeSize, pixelCount) {
+  const out = new Uint8Array(pixelCount);
+  let outPos = 0;
+  const clearCode = 1 << minCodeSize;
+  const eoiCode = clearCode + 1;
+  let codeSize = minCodeSize + 1;
+  let dict = [];
+  const reset = () => {
+    dict = [];
+    for (let i = 0; i < clearCode; i++) {
+      dict[i] = [i];
+    }
+    dict[clearCode] = [];
+    dict[eoiCode] = [];
+    codeSize = minCodeSize + 1;
+  };
+  reset();
+  let bitBuffer = 0;
+  let bitCount = 0;
+  let dataPos = 0;
+  let prev = null;
+  const readCode = () => {
+    while (bitCount < codeSize) {
+      if (dataPos >= data.length) {
+        return eoiCode;
+      }
+      bitBuffer |= data[dataPos++] << bitCount;
+      bitCount += 8;
+    }
+    const code = bitBuffer & (1 << codeSize) - 1;
+    bitBuffer >>= codeSize;
+    bitCount -= codeSize;
+    return code;
+  };
+  for (; ; ) {
+    const code = readCode();
+    if (code === eoiCode) {
+      break;
+    }
+    if (code === clearCode) {
+      reset();
+      prev = null;
+      continue;
+    }
+    let entry;
+    if (dict[code]) {
+      entry = dict[code];
+    } else if (prev) {
+      entry = [...prev, prev[0]];
+    } else {
+      break;
+    }
+    for (const value of entry) {
+      if (outPos < pixelCount) {
+        out[outPos++] = value;
+      }
+    }
+    if (prev) {
+      dict.push([...prev, entry[0]]);
+      if (dict.length === (1 << codeSize) - 1 && codeSize < 12) {
+        codeSize++;
+      }
+    }
+    prev = entry;
+  }
+  return out;
+}
+function deinterlace(pixels, width, height) {
+  const result = new Uint8Array(pixels.length);
+  const passes = [
+    [0, 8],
+    [4, 8],
+    [2, 4],
+    [1, 2]
+  ];
+  let srcRow = 0;
+  for (const [start, step] of passes) {
+    for (let row = start; row < height; row += step) {
+      result.set(
+        pixels.subarray(srcRow * width * 4, (srcRow + 1) * width * 4),
+        row * width * 4
+      );
+      srcRow++;
+    }
+  }
+  pixels.set(result);
+}
+function readUint16LE(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8;
+}
+function decodeGif(bytes) {
+  let p = 6;
+  const packed = bytes[p + 4];
+  const gctFlag = (packed & 128) !== 0;
+  const gctSize = 2 << (packed & 7);
+  p += 7;
+  let gct = null;
+  if (gctFlag) {
+    gct = bytes.subarray(p, p + gctSize * 3);
+    p += gctSize * 3;
+  }
+  let transparentIndex = -1;
+  while (p < bytes.length) {
+    const block = bytes[p++];
+    if (block === 59) {
+      break;
+    }
+    if (block === 33) {
+      const label = bytes[p++];
+      if (label === 249) {
+        const size = bytes[p++];
+        const flags = bytes[p];
+        transparentIndex = flags & 1 ? bytes[p + 3] : -1;
+        p += size;
+        p++;
+      } else {
+        let size = bytes[p++];
+        while (size !== 0) {
+          p += size;
+          size = bytes[p++];
+        }
+      }
+    } else if (block === 44) {
+      const iw = readUint16LE(bytes, p + 4);
+      const ih = readUint16LE(bytes, p + 6);
+      const ipacked = bytes[p + 8];
+      p += 9;
+      const lctFlag = (ipacked & 128) !== 0;
+      const interlaced = (ipacked & 64) !== 0;
+      const lctSize = 2 << (ipacked & 7);
+      let ct = gct;
+      if (lctFlag) {
+        ct = bytes.subarray(p, p + lctSize * 3);
+        p += lctSize * 3;
+      }
+      if (!ct) {
+        return null;
+      }
+      const minCodeSize = bytes[p++];
+      const data = [];
+      let size = bytes[p++];
+      while (size !== 0) {
+        for (let i = 0; i < size; i++) {
+          data.push(bytes[p + i]);
+        }
+        p += size;
+        size = bytes[p++];
+      }
+      const indices = lzwDecode(new Uint8Array(data), minCodeSize, iw * ih);
+      const rgba = new Uint8Array(iw * ih * 4);
+      for (let i = 0; i < iw * ih; i++) {
+        const idx = indices[i];
+        if (idx === transparentIndex) {
+          rgba[i * 4] = 255;
+          rgba[i * 4 + 1] = 255;
+          rgba[i * 4 + 2] = 255;
+          rgba[i * 4 + 3] = 0;
+          continue;
+        }
+        rgba[i * 4] = ct[idx * 3];
+        rgba[i * 4 + 1] = ct[idx * 3 + 1];
+        rgba[i * 4 + 2] = ct[idx * 3 + 2];
+        rgba[i * 4 + 3] = 255;
+      }
+      if (interlaced) {
+        deinterlace(rgba, iw, ih);
+      }
+      return { data: rgba, width: iw, height: ih, channels: 4 };
+    } else {
+      break;
+    }
+  }
+  return null;
+}
+async function decodeJpeg(bytes) {
+  try {
+    const jpeg = (await import('./jpeg-js-H7NYMOHI.cjs')).default;
+    const decoded = jpeg.decode(bytes, {
+      useTArray: true,
+      maxMemoryUsageInMB: 512
+    });
+    return {
+      data: decoded.data,
+      width: decoded.width,
+      height: decoded.height,
+      channels: 4
+    };
+  } catch {
+    return null;
+  }
+}
+function getCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined") {
+    const ctx = new OffscreenCanvas(width, height).getContext("2d");
+    return ctx ? { ctx } : null;
+  }
+  if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    return ctx ? { ctx } : null;
+  }
+  return null;
+}
+function loadSvgImage(bytes) {
+  if (typeof document === "undefined" || typeof Image === "undefined") {
+    return null;
+  }
+  const url = URL.createObjectURL(
+    new Blob([bytes], { type: "image/svg+xml" })
+  );
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve(img);
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("svg load failed"));
+    };
+    img.src = url;
+  });
+}
+async function decodeNative(bytes, format) {
+  try {
+    let width;
+    let height;
+    let source;
+    if (format === "svg") {
+      const pending = loadSvgImage(bytes);
+      if (!pending) {
+        return null;
+      }
+      const img = await pending;
+      width = img.naturalWidth || img.width || 64;
+      height = img.naturalHeight || img.height || 64;
+      source = img;
+    } else if (typeof createImageBitmap === "function") {
+      const bitmap = await createImageBitmap(new Blob([bytes]));
+      width = bitmap.width;
+      height = bitmap.height;
+      source = bitmap;
+    } else {
+      return null;
+    }
+    const canvas = getCanvas(width, height);
+    if (!canvas) {
+      return null;
+    }
+    canvas.ctx.drawImage(source, 0, 0, width, height);
+    const imageData = canvas.ctx.getImageData(0, 0, width, height);
+    return {
+      data: imageData.data,
+      width: imageData.width,
+      height: imageData.height,
+      channels: 4
+    };
+  } catch {
+    return null;
+  }
+}
+async function decodeImage(bytes, options = {}) {
+  const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  if (data.length === 0 || data.length > maxBytes) {
+    return null;
+  }
+  const format = sniffFormat(data);
+  try {
+    const native = await decodeNative(data, format);
+    if (native) {
+      return native;
+    }
+    if (format === "png") {
+      return await decodePng(data);
+    }
+    if (format === "gif") {
+      return decodeGif(data);
+    }
+    if (format === "jpeg") {
+      return await decodeJpeg(data);
+    }
+    const registered = chunkB5TUEKW2_cjs.getDecoder(format);
+    if (registered) {
+      return await registered(data);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/sniff.ts
+function notDefault2(reason) {
+  return {
+    isDefault: false,
+    matched: null,
+    score: 0,
+    dominantFraction: 0,
+    significantColors: 0,
+    glyphFraction: 0,
+    coloredOtherFraction: 0,
+    reason
+  };
+}
+async function sniff(input, options = {}) {
+  if (input == null) {
+    return null;
+  }
+  if (typeof input === "string") {
+    try {
+      const response = await fetch(input);
+      if (!response.ok) {
+        return null;
+      }
+      return await sniff(new Uint8Array(await response.arrayBuffer()), options);
+    } catch {
+      return null;
+    }
+  }
+  if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+    const image = await decodeImage(input, options);
+    if (!image) {
+      return notDefault2(
+        "could not decode image (unsupported format in this runtime)"
+      );
+    }
+    return analyzeImage(image, options);
+  }
+  const pixels = input;
+  return analyzeImage(
+    {
+      data: pixels.data,
+      width: pixels.width,
+      height: pixels.height,
+      channels: pixels.channels
+    },
+    options
+  );
+}
+
+// src/types.ts
+var DETECTOR_NAMES = [
+  "initials",
+  "solidColor",
+  "personIcon",
+  "identicon"
+];
+
+Object.defineProperty(exports, "registerDecoder", {
+  enumerable: true,
+  get: function () { return chunkB5TUEKW2_cjs.registerDecoder; }
+});
+exports.DEFAULT_MAX_BYTES = DEFAULT_MAX_BYTES;
+exports.DETECTOR_NAMES = DETECTOR_NAMES;
+exports.analyzeImage = analyzeImage;
+exports.decodeImage = decodeImage;
+exports.sniff = sniff;
+exports.sniffFormat = sniffFormat;