@lacspace/image 1.0.0

package/dist/index.js

@@ -0,0 +1,1582 @@
+// src/color.ts
+var NAMED = {
+  transparent: [0, 0, 0, 0],
+  black: [0, 0, 0, 255],
+  white: [255, 255, 255, 255],
+  red: [255, 0, 0, 255],
+  green: [0, 128, 0, 255],
+  blue: [0, 0, 255, 255]
+};
+function clampByte(n) {
+  n = Math.round(n);
+  return n < 0 ? 0 : n > 255 ? 255 : n;
+}
+function parseColor(input) {
+  const s = String(input).trim().toLowerCase();
+  if (s in NAMED) return [...NAMED[s]];
+  if (s[0] === "#") {
+    const hex = s.slice(1);
+    if (hex.length === 3 || hex.length === 4) {
+      const r = parseInt(hex[0] + hex[0], 16);
+      const g = parseInt(hex[1] + hex[1], 16);
+      const b = parseInt(hex[2] + hex[2], 16);
+      const a = hex.length === 4 ? parseInt(hex[3] + hex[3], 16) : 255;
+      return [r, g, b, a];
+    }
+    if (hex.length === 6 || hex.length === 8) {
+      const r = parseInt(hex.slice(0, 2), 16);
+      const g = parseInt(hex.slice(2, 4), 16);
+      const b = parseInt(hex.slice(4, 6), 16);
+      const a = hex.length === 8 ? parseInt(hex.slice(6, 8), 16) : 255;
+      return [r, g, b, a];
+    }
+  }
+  const m = s.match(/^rgba?\(([^)]+)\)$/);
+  if (m) {
+    const parts = m[1].split(/[,/\s]+/).filter(Boolean);
+    const r = clampByte(parseFloat(parts[0] ?? "0"));
+    const g = clampByte(parseFloat(parts[1] ?? "0"));
+    const b = clampByte(parseFloat(parts[2] ?? "0"));
+    let a = 255;
+    if (parts[3] != null) {
+      const av = parseFloat(parts[3]);
+      a = parts[3].includes("%") ? clampByte(av / 100 * 255) : clampByte(av <= 1 ? av * 255 : av);
+    }
+    return [r, g, b, a];
+  }
+  return [0, 0, 0, 255];
+}
+function blendOver(dst, src) {
+  const sa = src[3] / 255;
+  const da = dst[3] / 255;
+  const outA = sa + da * (1 - sa);
+  if (outA === 0) return [0, 0, 0, 0];
+  const r = (src[0] * sa + dst[0] * da * (1 - sa)) / outA;
+  const g = (src[1] * sa + dst[1] * da * (1 - sa)) / outA;
+  const b = (src[2] * sa + dst[2] * da * (1 - sa)) / outA;
+  return [clampByte(r), clampByte(g), clampByte(b), clampByte(outA * 255)];
+}
+function mix(a, b, t) {
+  return [
+    clampByte(a[0] + (b[0] - a[0]) * t),
+    clampByte(a[1] + (b[1] - a[1]) * t),
+    clampByte(a[2] + (b[2] - a[2]) * t),
+    clampByte(a[3] + (b[3] - a[3]) * t)
+  ];
+}
+
+// src/surface.ts
+function sortStops(stops) {
+  return stops.map((s) => ({ offset: Math.max(0, Math.min(1, s.offset)), rgba: parseColor(s.color) })).sort((a, b) => a.offset - b.offset);
+}
+function sampleStops(stops, t) {
+  if (stops.length === 0) return [0, 0, 0, 0];
+  if (t <= stops[0].offset) return stops[0].rgba;
+  const last = stops[stops.length - 1];
+  if (t >= last.offset) return last.rgba;
+  for (let i = 1; i < stops.length; i++) {
+    const a = stops[i - 1];
+    const b = stops[i];
+    if (t <= b.offset) {
+      const span = b.offset - a.offset || 1;
+      return mix(a.rgba, b.rgba, (t - a.offset) / span);
+    }
+  }
+  return last.rgba;
+}
+function rng(seed) {
+  let s = seed >>> 0 || 1;
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var Surface = class _Surface {
+  constructor(width, height, data) {
+    this.width = Math.max(1, Math.floor(width));
+    this.height = Math.max(1, Math.floor(height));
+    this.data = data ?? new Uint8ClampedArray(this.width * this.height * 4);
+  }
+  /** Wrap an existing RGBA source (e.g. a Canvas ImageData) without copying. */
+  static from(src) {
+    return new _Surface(src.width, src.height, src.data);
+  }
+  idx(x, y) {
+    return (y * this.width + x) * 4;
+  }
+  set(x, y, c) {
+    const i = this.idx(x, y);
+    const d = this.data;
+    if (c[3] === 255) {
+      d[i] = c[0];
+      d[i + 1] = c[1];
+      d[i + 2] = c[2];
+      d[i + 3] = 255;
+    } else {
+      const dst = [d[i], d[i + 1], d[i + 2], d[i + 3]];
+      const out = blendOver(dst, c);
+      d[i] = out[0];
+      d[i + 1] = out[1];
+      d[i + 2] = out[2];
+      d[i + 3] = out[3];
+    }
+  }
+  /** Paint the whole surface a solid colour (replaces, does not blend). */
+  fill(color) {
+    const [r, g, b, a] = parseColor(color);
+    const d = this.data;
+    for (let i = 0; i < d.length; i += 4) {
+      d[i] = r;
+      d[i + 1] = g;
+      d[i + 2] = b;
+      d[i + 3] = a;
+    }
+    return this;
+  }
+  /** Blend a rectangle of colour over the surface. */
+  rect(x, y, w, h, color) {
+    const c = parseColor(color);
+    const x0 = Math.max(0, Math.floor(x));
+    const y0 = Math.max(0, Math.floor(y));
+    const x1 = Math.min(this.width, Math.floor(x + w));
+    const y1 = Math.min(this.height, Math.floor(y + h));
+    for (let py = y0; py < y1; py++) for (let px = x0; px < x1; px++) this.set(px, py, c);
+    return this;
+  }
+  linearGradient(opts) {
+    const stops = sortStops(opts.stops);
+    const angle = (opts.angle ?? 0) * Math.PI / 180;
+    const dx = Math.cos(angle);
+    const dy = Math.sin(angle);
+    const w = this.width;
+    const h = this.height;
+    const projs = [0, w * dx, h * dy, w * dx + h * dy];
+    const min = Math.min(...projs);
+    const span = Math.max(...projs) - min || 1;
+    for (let py = 0; py < h; py++) {
+      for (let px = 0; px < w; px++) {
+        const t = ((px + 0.5) * dx + (py + 0.5) * dy - min) / span;
+        this.set(px, py, sampleStops(stops, t));
+      }
+    }
+    return this;
+  }
+  radialGradient(opts) {
+    const stops = sortStops(opts.stops);
+    const w = this.width;
+    const h = this.height;
+    const cx = (opts.cx ?? 0.5) * w;
+    const cy = (opts.cy ?? 0.5) * h;
+    const radius = (opts.radius ?? 0.75) * Math.max(w, h);
+    for (let py = 0; py < h; py++) {
+      for (let px = 0; px < w; px++) {
+        const dx = px + 0.5 - cx;
+        const dy = py + 0.5 - cy;
+        const t = Math.sqrt(dx * dx + dy * dy) / (radius || 1);
+        this.set(px, py, sampleStops(stops, t));
+      }
+    }
+    return this;
+  }
+  pattern(kind, opts = {}) {
+    const size = Math.max(1, opts.size ?? 24);
+    const color = parseColor(opts.color ?? "rgba(255,255,255,0.13)");
+    const w = this.width;
+    const h = this.height;
+    if (kind === "noise") {
+      const rand = rng(opts.seed ?? 1);
+      const strength = opts.strength ?? 0.06;
+      const d = this.data;
+      for (let i = 0; i < d.length; i += 4) {
+        const n = (rand() - 0.5) * 2 * strength * 255;
+        d[i] = d[i] + n;
+        d[i + 1] = d[i + 1] + n;
+        d[i + 2] = d[i + 2] + n;
+      }
+      return this;
+    }
+    if (kind === "dots") {
+      const r = Math.max(1, size / 6);
+      for (let cy = size / 2; cy < h; cy += size)
+        for (let cx = size / 2; cx < w; cx += size)
+          for (let py = -r; py <= r; py++)
+            for (let px = -r; px <= r; px++)
+              if (px * px + py * py <= r * r) this.set(Math.round(cx + px), Math.round(cy + py), color);
+      return this;
+    }
+    if (kind === "grid") {
+      for (let x = 0; x < w; x += size) this.rect(x, 0, 1, h, opts.color ?? "rgba(255,255,255,0.13)");
+      for (let y = 0; y < h; y += size) this.rect(0, y, w, 1, opts.color ?? "rgba(255,255,255,0.13)");
+      return this;
+    }
+    if (kind === "stripes") {
+      const angle = opts.angle ?? 45;
+      for (let py = 0; py < h; py++) {
+        for (let px = 0; px < w; px++) {
+          let coord;
+          if (angle === 0) coord = px;
+          else if (angle === 90) coord = py;
+          else coord = px + py;
+          if (Math.floor(coord / size) % 2 === 0) this.set(px, py, color);
+        }
+      }
+      return this;
+    }
+    for (let py = 0; py < h; py++) {
+      for (let px = 0; px < w; px++) {
+        const on = (Math.floor(px / size) + Math.floor(py / size)) % 2 === 0;
+        if (on) this.set(px, py, color);
+      }
+    }
+    return this;
+  }
+  /** Bilinear sample of a source at fractional (u,v) in source pixel space. */
+  static sampleBilinear(src, u, v) {
+    const x = Math.max(0, Math.min(src.width - 1, u));
+    const y = Math.max(0, Math.min(src.height - 1, v));
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const x1 = Math.min(src.width - 1, x0 + 1);
+    const y1 = Math.min(src.height - 1, y0 + 1);
+    const fx = x - x0;
+    const fy = y - y0;
+    const at = (px, py) => {
+      const i = (py * src.width + px) * 4;
+      return [src.data[i], src.data[i + 1], src.data[i + 2], src.data[i + 3]];
+    };
+    const top = mix(at(x0, y0), at(x1, y0), fx);
+    const bot = mix(at(x0, y1), at(x1, y1), fx);
+    return mix(top, bot, fy);
+  }
+  /** Place another image/surface onto this one, with fit + resampling. */
+  drawImage(src, o = {}) {
+    const dx = o.x ?? 0;
+    const dy = o.y ?? 0;
+    const dw = o.width ?? src.width;
+    const dh = o.height ?? src.height;
+    const fit2 = o.fit ?? "cover";
+    const nearest = o.resample === "nearest";
+    let scaleX = src.width / dw;
+    let scaleY = src.height / dh;
+    let offU = 0;
+    let offV = 0;
+    if (fit2 === "cover" || fit2 === "contain") {
+      const s = fit2 === "cover" ? Math.min(scaleX, scaleY) : Math.max(scaleX, scaleY);
+      scaleX = scaleY = s;
+      offU = (src.width - dw * s) / 2;
+      offV = (src.height - dh * s) / 2;
+    }
+    const x0 = Math.max(0, Math.floor(dx));
+    const y0 = Math.max(0, Math.floor(dy));
+    const x1 = Math.min(this.width, Math.floor(dx + dw));
+    const y1 = Math.min(this.height, Math.floor(dy + dh));
+    for (let py = y0; py < y1; py++) {
+      for (let px = x0; px < x1; px++) {
+        const u = (px - dx) * scaleX + offU;
+        const v = (py - dy) * scaleY + offV;
+        if (fit2 === "contain" && (u < 0 || v < 0 || u >= src.width || v >= src.height)) continue;
+        const c = nearest ? (() => {
+          const i = (Math.min(src.height - 1, Math.max(0, Math.round(v))) * src.width + Math.min(src.width - 1, Math.max(0, Math.round(u)))) * 4;
+          return [src.data[i], src.data[i + 1], src.data[i + 2], src.data[i + 3]];
+        })() : _Surface.sampleBilinear(src, u, v);
+        this.set(px, py, c);
+      }
+    }
+    return this;
+  }
+  /** Return a NEW surface resampled to the given dimensions (bilinear). */
+  resize(width, height) {
+    const out = new _Surface(width, height);
+    const sx = this.width / out.width;
+    const sy = this.height / out.height;
+    for (let py = 0; py < out.height; py++) {
+      for (let px = 0; px < out.width; px++) {
+        const c = _Surface.sampleBilinear(this, (px + 0.5) * sx - 0.5, (py + 0.5) * sy - 0.5);
+        const i = (py * out.width + px) * 4;
+        out.data[i] = c[0];
+        out.data[i + 1] = c[1];
+        out.data[i + 2] = c[2];
+        out.data[i + 3] = c[3];
+      }
+    }
+    return out;
+  }
+  /** Return a NEW surface cropped to the given rectangle. */
+  crop(x, y, w, h) {
+    const out = new _Surface(w, h);
+    for (let py = 0; py < out.height; py++) {
+      for (let px = 0; px < out.width; px++) {
+        const srcX = Math.min(this.width - 1, Math.max(0, x + px));
+        const srcY = Math.min(this.height - 1, Math.max(0, y + py));
+        const si = (srcY * this.width + srcX) * 4;
+        const di = (py * out.width + px) * 4;
+        out.data[di] = this.data[si];
+        out.data[di + 1] = this.data[si + 1];
+        out.data[di + 2] = this.data[si + 2];
+        out.data[di + 3] = this.data[si + 3];
+      }
+    }
+    return out;
+  }
+  /** Flatten transparency onto a solid background, returning a NEW opaque surface. */
+  flatten(background = "#ffffff") {
+    const bg = parseColor(background);
+    const out = new _Surface(this.width, this.height);
+    for (let i = 0; i < this.data.length; i += 4) {
+      const src = [this.data[i], this.data[i + 1], this.data[i + 2], this.data[i + 3]];
+      const c = blendOver([bg[0], bg[1], bg[2], 255], src);
+      out.data[i] = c[0];
+      out.data[i + 1] = c[1];
+      out.data[i + 2] = c[2];
+      out.data[i + 3] = 255;
+    }
+    return out;
+  }
+  /**
+   * Return a NEW surface with each channel reduced to `bits` bits (2..8).
+   * Fewer distinct values compress far better as lossless PNG — the main lever
+   * for hitting a PNG size budget on noisy/photographic content.
+   */
+  posterize(bits) {
+    const b = Math.max(1, Math.min(8, Math.floor(bits)));
+    if (b >= 8) return this.clone();
+    const levels = (1 << b) - 1;
+    const out = new _Surface(this.width, this.height, new Uint8ClampedArray(this.data));
+    const d = out.data;
+    for (let i = 0; i < d.length; i += 4) {
+      d[i] = Math.round(Math.round(d[i] / 255 * levels) / levels * 255);
+      d[i + 1] = Math.round(Math.round(d[i + 1] / 255 * levels) / levels * 255);
+      d[i + 2] = Math.round(Math.round(d[i + 2] / 255 * levels) / levels * 255);
+    }
+    return out;
+  }
+  clone() {
+    return new _Surface(this.width, this.height, new Uint8ClampedArray(this.data));
+  }
+};
+function gradient(width, height, opts) {
+  return new Surface(width, height).linearGradient(opts);
+}
+function radial(width, height, opts) {
+  return new Surface(width, height).radialGradient(opts);
+}
+function pattern(width, height, base, kind, opts) {
+  return new Surface(width, height).fill(base).pattern(kind, opts);
+}
+
+// src/env.ts
+function hasCanvas() {
+  if (typeof OffscreenCanvas !== "undefined") return true;
+  return typeof document !== "undefined" && typeof document.createElement === "function";
+}
+function makeCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(width, height);
+  const el = document.createElement("canvas");
+  el.width = width;
+  el.height = height;
+  return el;
+}
+var MIME = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+async function canvasToBytes(canvas, format, quality) {
+  const type = MIME[format];
+  const q = quality != null ? Math.max(0, Math.min(1, quality / 100)) : void 0;
+  let blob;
+  if (canvas.convertToBlob) {
+    blob = await canvas.convertToBlob({ type, quality: q });
+  } else if (canvas.toBlob) {
+    blob = await new Promise((res) => canvas.toBlob((b) => res(b), type, q));
+  } else {
+    throw new Error("Canvas has no toBlob/convertToBlob");
+  }
+  if (!blob) throw new Error(`Canvas failed to encode ${format}`);
+  return new Uint8Array(await blob.arrayBuffer());
+}
+async function encodeViaCanvas(source, format, quality) {
+  if (!hasCanvas()) throw new Error("No canvas available in this runtime");
+  const canvas = makeCanvas(source.width, source.height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("Could not get a 2D context");
+  const img = new ImageData(new Uint8ClampedArray(source.data), source.width, source.height);
+  ctx.putImageData(img, 0, 0);
+  return canvasToBytes(canvas, format, quality);
+}
+async function canvasSupports(format) {
+  if (!hasCanvas()) return false;
+  try {
+    const test = makeCanvas(2, 2);
+    const bytes = await canvasToBytes(test, format, 80);
+    if (format === "webp") return bytes[0] !== 137;
+    return bytes.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/png.ts
+var SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function adler32(bytes) {
+  let a = 1;
+  let b = 0;
+  const MOD = 65521;
+  for (let i = 0; i < bytes.length; i++) {
+    a = (a + bytes[i]) % MOD;
+    b = (b + a) % MOD;
+  }
+  return (b << 16 | a) >>> 0;
+}
+function u32(n) {
+  return new Uint8Array([n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255]);
+}
+function chunk(type, data) {
+  const typeBytes = new Uint8Array([type.charCodeAt(0), type.charCodeAt(1), type.charCodeAt(2), type.charCodeAt(3)]);
+  const body = new Uint8Array(typeBytes.length + data.length);
+  body.set(typeBytes, 0);
+  body.set(data, typeBytes.length);
+  const out = new Uint8Array(4 + body.length + 4);
+  out.set(u32(data.length), 0);
+  out.set(body, 4);
+  out.set(u32(crc32(body)), 4 + body.length);
+  return out;
+}
+function storedZlib(data) {
+  const MAX = 65535;
+  const blocks = [];
+  let offset = 0;
+  if (data.length === 0) {
+    blocks.push(new Uint8Array([1, 0, 0, 255, 255]));
+  }
+  while (offset < data.length) {
+    const len = Math.min(MAX, data.length - offset);
+    const final = offset + len >= data.length ? 1 : 0;
+    const header = new Uint8Array(5);
+    header[0] = final;
+    header[1] = len & 255;
+    header[2] = len >>> 8 & 255;
+    header[3] = ~len & 255;
+    header[4] = ~len >>> 8 & 255;
+    blocks.push(header, data.subarray(offset, offset + len));
+    offset += len;
+  }
+  const bodyLen = blocks.reduce((n, b) => n + b.length, 0);
+  const out = new Uint8Array(2 + bodyLen + 4);
+  out[0] = 120;
+  out[1] = 1;
+  let p = 2;
+  for (const b of blocks) {
+    out.set(b, p);
+    p += b.length;
+  }
+  out.set(u32(adler32(data)), p);
+  return out;
+}
+function isNode() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+async function deflate(data, level) {
+  if (isNode()) {
+    try {
+      const z = await import(
+        /* @vite-ignore */
+        'zlib'
+      );
+      return new Uint8Array(z.deflateSync(data, { level }));
+    } catch {
+    }
+  }
+  return storedZlib(data);
+}
+function filterScanlines(src) {
+  const { width, height, data } = src;
+  const rowBytes = width * 4;
+  const out = new Uint8Array(height * (rowBytes + 1));
+  for (let y = 0; y < height; y++) {
+    const o = y * (rowBytes + 1);
+    out[o] = 0;
+    out.set(data.subarray(y * rowBytes, y * rowBytes + rowBytes), o + 1);
+  }
+  return out;
+}
+function assemble(source, idat) {
+  const ihdrData = new Uint8Array(13);
+  ihdrData.set(u32(source.width), 0);
+  ihdrData.set(u32(source.height), 4);
+  ihdrData[8] = 8;
+  ihdrData[9] = 6;
+  ihdrData[10] = 0;
+  ihdrData[11] = 0;
+  ihdrData[12] = 0;
+  const ihdr = chunk("IHDR", ihdrData);
+  const idatChunk = chunk("IDAT", idat);
+  const iend = chunk("IEND", new Uint8Array(0));
+  const out = new Uint8Array(SIGNATURE.length + ihdr.length + idatChunk.length + iend.length);
+  let p = 0;
+  for (const part of [SIGNATURE, ihdr, idatChunk, iend]) {
+    out.set(part, p);
+    p += part.length;
+  }
+  return out;
+}
+async function encodePng(source, level = 9) {
+  const idat = await deflate(filterScanlines(source), level);
+  return assemble(source, idat);
+}
+function encodePngSync(source) {
+  return assemble(source, storedZlib(filterScanlines(source)));
+}
+
+// src/jpeg.ts
+var ZIGZAG = Int32Array.of(
+  0,
+  1,
+  5,
+  6,
+  14,
+  15,
+  27,
+  28,
+  2,
+  4,
+  7,
+  13,
+  16,
+  26,
+  29,
+  42,
+  3,
+  8,
+  12,
+  17,
+  25,
+  30,
+  41,
+  43,
+  9,
+  11,
+  18,
+  24,
+  31,
+  40,
+  44,
+  53,
+  10,
+  19,
+  23,
+  32,
+  39,
+  45,
+  52,
+  54,
+  20,
+  22,
+  33,
+  38,
+  46,
+  51,
+  55,
+  60,
+  21,
+  34,
+  37,
+  47,
+  50,
+  56,
+  59,
+  61,
+  35,
+  36,
+  48,
+  49,
+  57,
+  58,
+  62,
+  63
+);
+var STD_DC_LUM_CODES = Int32Array.of(0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0);
+var STD_DC_LUM_VALUES = Int32Array.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+var STD_AC_LUM_CODES = Int32Array.of(0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125);
+var STD_AC_LUM_VALUES = Int32Array.of(
+  1,
+  2,
+  3,
+  0,
+  4,
+  17,
+  5,
+  18,
+  33,
+  49,
+  65,
+  6,
+  19,
+  81,
+  97,
+  7,
+  34,
+  113,
+  20,
+  50,
+  129,
+  145,
+  161,
+  8,
+  35,
+  66,
+  177,
+  193,
+  21,
+  82,
+  209,
+  240,
+  36,
+  51,
+  98,
+  114,
+  130,
+  9,
+  10,
+  22,
+  23,
+  24,
+  25,
+  26,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  99,
+  100,
+  101,
+  102,
+  103,
+  104,
+  105,
+  106,
+  115,
+  116,
+  117,
+  118,
+  119,
+  120,
+  121,
+  122,
+  131,
+  132,
+  133,
+  134,
+  135,
+  136,
+  137,
+  138,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  152,
+  153,
+  154,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  178,
+  179,
+  180,
+  181,
+  182,
+  183,
+  184,
+  185,
+  186,
+  194,
+  195,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215,
+  216,
+  217,
+  218,
+  225,
+  226,
+  227,
+  228,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  241,
+  242,
+  243,
+  244,
+  245,
+  246,
+  247,
+  248,
+  249,
+  250
+);
+var STD_DC_CHR_CODES = Int32Array.of(0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0);
+var STD_DC_CHR_VALUES = Int32Array.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+var STD_AC_CHR_CODES = Int32Array.of(0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119);
+var STD_AC_CHR_VALUES = Int32Array.of(
+  0,
+  1,
+  2,
+  3,
+  17,
+  4,
+  5,
+  33,
+  49,
+  6,
+  18,
+  65,
+  81,
+  7,
+  97,
+  113,
+  19,
+  34,
+  50,
+  129,
+  8,
+  20,
+  66,
+  145,
+  161,
+  177,
+  193,
+  9,
+  35,
+  51,
+  82,
+  240,
+  21,
+  98,
+  114,
+  209,
+  10,
+  22,
+  36,
+  52,
+  225,
+  37,
+  241,
+  23,
+  24,
+  25,
+  26,
+  38,
+  39,
+  40,
+  41,
+  42,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  99,
+  100,
+  101,
+  102,
+  103,
+  104,
+  105,
+  106,
+  115,
+  116,
+  117,
+  118,
+  119,
+  120,
+  121,
+  122,
+  130,
+  131,
+  132,
+  133,
+  134,
+  135,
+  136,
+  137,
+  138,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  152,
+  153,
+  154,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  178,
+  179,
+  180,
+  181,
+  182,
+  183,
+  184,
+  185,
+  186,
+  194,
+  195,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215,
+  216,
+  217,
+  218,
+  226,
+  227,
+  228,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  242,
+  243,
+  244,
+  245,
+  246,
+  247,
+  248,
+  249,
+  250
+);
+var YQT = Int32Array.of(
+  16,
+  11,
+  10,
+  16,
+  24,
+  40,
+  51,
+  61,
+  12,
+  12,
+  14,
+  19,
+  26,
+  58,
+  60,
+  55,
+  14,
+  13,
+  16,
+  24,
+  40,
+  57,
+  69,
+  56,
+  14,
+  17,
+  22,
+  29,
+  51,
+  87,
+  80,
+  62,
+  18,
+  22,
+  37,
+  56,
+  68,
+  109,
+  103,
+  77,
+  24,
+  35,
+  55,
+  64,
+  81,
+  104,
+  113,
+  92,
+  49,
+  64,
+  78,
+  87,
+  103,
+  121,
+  120,
+  101,
+  72,
+  92,
+  95,
+  98,
+  112,
+  100,
+  103,
+  99
+);
+var UVQT = Int32Array.of(
+  17,
+  18,
+  24,
+  47,
+  99,
+  99,
+  99,
+  99,
+  18,
+  21,
+  26,
+  66,
+  99,
+  99,
+  99,
+  99,
+  24,
+  26,
+  56,
+  99,
+  99,
+  99,
+  99,
+  99,
+  47,
+  66,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99,
+  99
+);
+var AASF = Float64Array.of(1, 1.387039845, 1.306562965, 1.175875602, 1, 0.785694958, 0.5411961, 0.275899379);
+function computeHuffTable(nrcodes, values) {
+  const code = new Int32Array(256);
+  const len = new Int32Array(256);
+  let codeValue = 0;
+  let pos = 0;
+  for (let k = 1; k <= 16; k++) {
+    for (let j = 1; j <= nrcodes[k]; j++) {
+      const v = values[pos];
+      code[v] = codeValue;
+      len[v] = k;
+      pos++;
+      codeValue++;
+    }
+    codeValue *= 2;
+  }
+  return { code, len };
+}
+function encodeJpeg(source, quality = 82) {
+  const q = Math.max(1, Math.min(100, Math.round(quality)));
+  const sf = q < 50 ? Math.floor(5e3 / q) : 200 - q * 2;
+  const YTable = new Int32Array(64);
+  const UVTable = new Int32Array(64);
+  const fdtblY = new Float64Array(64);
+  const fdtblUV = new Float64Array(64);
+  for (let i = 0; i < 64; i++) {
+    YTable[ZIGZAG[i]] = Math.min(255, Math.max(1, Math.floor((YQT[i] * sf + 50) / 100)));
+    UVTable[ZIGZAG[i]] = Math.min(255, Math.max(1, Math.floor((UVQT[i] * sf + 50) / 100)));
+  }
+  {
+    let i = 0;
+    for (let row = 0; row < 8; row++) {
+      for (let col = 0; col < 8; col++) {
+        fdtblY[i] = 1 / (YTable[ZIGZAG[i]] * AASF[row] * AASF[col] * 8);
+        fdtblUV[i] = 1 / (UVTable[ZIGZAG[i]] * AASF[row] * AASF[col] * 8);
+        i++;
+      }
+    }
+  }
+  const YDC = computeHuffTable(STD_DC_LUM_CODES, STD_DC_LUM_VALUES);
+  const YAC = computeHuffTable(STD_AC_LUM_CODES, STD_AC_LUM_VALUES);
+  const UVDC = computeHuffTable(STD_DC_CHR_CODES, STD_DC_CHR_VALUES);
+  const UVAC = computeHuffTable(STD_AC_CHR_CODES, STD_AC_CHR_VALUES);
+  const category = new Int32Array(65536);
+  const bitCode = new Int32Array(65536);
+  const bitLen = new Int32Array(65536);
+  {
+    let nrlower = 1;
+    let nrupper = 2;
+    for (let cat = 1; cat <= 15; cat++) {
+      for (let nr = nrlower; nr < nrupper; nr++) {
+        category[32767 + nr] = cat;
+        bitLen[32767 + nr] = cat;
+        bitCode[32767 + nr] = nr;
+      }
+      for (let nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
+        category[32767 + nrneg] = cat;
+        bitLen[32767 + nrneg] = cat;
+        bitCode[32767 + nrneg] = nrupper - 1 + nrneg;
+      }
+      nrlower <<= 1;
+      nrupper <<= 1;
+    }
+  }
+  const out = [];
+  let byteNew = 0;
+  let bytePos = 7;
+  const writeByte = (v) => out.push(v & 255);
+  const writeWord = (v) => {
+    out.push(v >>> 8 & 255);
+    out.push(v & 255);
+  };
+  const writeBits = (value, length) => {
+    let posval = length - 1;
+    while (posval >= 0) {
+      if (value & 1 << posval) byteNew |= 1 << bytePos;
+      posval--;
+      bytePos--;
+      if (bytePos < 0) {
+        if (byteNew === 255) {
+          writeByte(255);
+          writeByte(0);
+        } else {
+          writeByte(byteNew);
+        }
+        bytePos = 7;
+        byteNew = 0;
+      }
+    }
+  };
+  const data = new Float64Array(64);
+  const outDU = new Int32Array(64);
+  const DU = new Int32Array(64);
+  const fDCTQuant = (fdtbl) => {
+    let off = 0;
+    for (let i = 0; i < 8; i++) {
+      const d0 = data[off], d1 = data[off + 1], d2 = data[off + 2], d3 = data[off + 3];
+      const d4 = data[off + 4], d5 = data[off + 5], d6 = data[off + 6], d7 = data[off + 7];
+      const t0 = d0 + d7, t7 = d0 - d7, t1 = d1 + d6, t6 = d1 - d6;
+      const t2 = d2 + d5, t5 = d2 - d5, t3 = d3 + d4, t4 = d3 - d4;
+      let t10 = t0 + t3;
+      const t13 = t0 - t3;
+      let t11 = t1 + t2;
+      const t12 = t1 - t2;
+      data[off] = t10 + t11;
+      data[off + 4] = t10 - t11;
+      const z1 = (t12 + t13) * 0.707106781;
+      data[off + 2] = t13 + z1;
+      data[off + 6] = t13 - z1;
+      t10 = t4 + t5;
+      t11 = t5 + t6;
+      const t12b = t6 + t7;
+      const z5 = (t10 - t12b) * 0.382683433;
+      const z2 = 0.5411961 * t10 + z5;
+      const z4 = 1.306562965 * t12b + z5;
+      const z3 = t11 * 0.707106781;
+      const z11 = t7 + z3;
+      const z13 = t7 - z3;
+      data[off + 5] = z13 + z2;
+      data[off + 3] = z13 - z2;
+      data[off + 1] = z11 + z4;
+      data[off + 7] = z11 - z4;
+      off += 8;
+    }
+    off = 0;
+    for (let i = 0; i < 8; i++) {
+      const d0 = data[off], d1 = data[off + 8], d2 = data[off + 16], d3 = data[off + 24];
+      const d4 = data[off + 32], d5 = data[off + 40], d6 = data[off + 48], d7 = data[off + 56];
+      const t0 = d0 + d7, t7 = d0 - d7, t1 = d1 + d6, t6 = d1 - d6;
+      const t2 = d2 + d5, t5 = d2 - d5, t3 = d3 + d4, t4 = d3 - d4;
+      let t10 = t0 + t3;
+      const t13 = t0 - t3;
+      let t11 = t1 + t2;
+      const t12 = t1 - t2;
+      data[off] = t10 + t11;
+      data[off + 32] = t10 - t11;
+      const z1 = (t12 + t13) * 0.707106781;
+      data[off + 16] = t13 + z1;
+      data[off + 48] = t13 - z1;
+      t10 = t4 + t5;
+      t11 = t5 + t6;
+      const t12b = t6 + t7;
+      const z5 = (t10 - t12b) * 0.382683433;
+      const z2 = 0.5411961 * t10 + z5;
+      const z4 = 1.306562965 * t12b + z5;
+      const z3 = t11 * 0.707106781;
+      const z11 = t7 + z3;
+      const z13 = t7 - z3;
+      data[off + 40] = z13 + z2;
+      data[off + 24] = z13 - z2;
+      data[off + 8] = z11 + z4;
+      data[off + 56] = z11 - z4;
+      off++;
+    }
+    for (let i = 0; i < 64; i++) {
+      const v = data[i] * fdtbl[i];
+      outDU[i] = v > 0 ? v + 0.5 | 0 : v - 0.5 | 0;
+    }
+    return outDU;
+  };
+  const processDU = (fdtbl, dc, HTDC, HTAC) => {
+    const duDct = fDCTQuant(fdtbl);
+    for (let j = 0; j < 64; j++) DU[ZIGZAG[j]] = duDct[j];
+    const diff = DU[0] - dc;
+    const newDc = DU[0];
+    if (diff === 0) {
+      writeBits(HTDC.code[0], HTDC.len[0]);
+    } else {
+      const pos = 32767 + diff;
+      writeBits(HTDC.code[category[pos]], HTDC.len[category[pos]]);
+      writeBits(bitCode[pos], bitLen[pos]);
+    }
+    let end0 = 63;
+    while (end0 > 0 && DU[end0] === 0) end0--;
+    if (end0 === 0) {
+      writeBits(HTAC.code[0], HTAC.len[0]);
+      return newDc;
+    }
+    let i = 1;
+    while (i <= end0) {
+      const start = i;
+      while (DU[i] === 0 && i <= end0) i++;
+      let nrzeroes = i - start;
+      if (nrzeroes >= 16) {
+        const lng = nrzeroes >> 4;
+        for (let m = 1; m <= lng; m++) writeBits(HTAC.code[240], HTAC.len[240]);
+        nrzeroes &= 15;
+      }
+      const pos = 32767 + DU[i];
+      const sym = (nrzeroes << 4) + category[pos];
+      writeBits(HTAC.code[sym], HTAC.len[sym]);
+      writeBits(bitCode[pos], bitLen[pos]);
+      i++;
+    }
+    if (end0 !== 63) writeBits(HTAC.code[0], HTAC.len[0]);
+    return newDc;
+  };
+  const { width, height, data: px } = source;
+  writeWord(65496);
+  writeWord(65504);
+  writeWord(16);
+  for (const c of [74, 70, 73, 70, 0]) writeByte(c);
+  writeByte(1);
+  writeByte(1);
+  writeByte(0);
+  writeWord(1);
+  writeWord(1);
+  writeByte(0);
+  writeByte(0);
+  writeWord(65499);
+  writeWord(132);
+  writeByte(0);
+  for (let i = 0; i < 64; i++) writeByte(YTable[i]);
+  writeByte(1);
+  for (let i = 0; i < 64; i++) writeByte(UVTable[i]);
+  writeWord(65472);
+  writeWord(17);
+  writeByte(8);
+  writeWord(height);
+  writeWord(width);
+  writeByte(3);
+  writeByte(1);
+  writeByte(17);
+  writeByte(0);
+  writeByte(2);
+  writeByte(17);
+  writeByte(1);
+  writeByte(3);
+  writeByte(17);
+  writeByte(1);
+  writeWord(65476);
+  writeWord(418);
+  const writeHuffSpec = (cls, codes, values) => {
+    writeByte(cls);
+    for (let i = 1; i <= 16; i++) writeByte(codes[i]);
+    for (let i = 0; i < values.length; i++) writeByte(values[i]);
+  };
+  writeHuffSpec(0, STD_DC_LUM_CODES, STD_DC_LUM_VALUES);
+  writeHuffSpec(16, STD_AC_LUM_CODES, STD_AC_LUM_VALUES);
+  writeHuffSpec(1, STD_DC_CHR_CODES, STD_DC_CHR_VALUES);
+  writeHuffSpec(17, STD_AC_CHR_CODES, STD_AC_CHR_VALUES);
+  writeWord(65498);
+  writeWord(12);
+  writeByte(3);
+  writeByte(1);
+  writeByte(0);
+  writeByte(2);
+  writeByte(17);
+  writeByte(3);
+  writeByte(17);
+  writeByte(0);
+  writeByte(63);
+  writeByte(0);
+  let dcY = 0;
+  let dcU = 0;
+  let dcV = 0;
+  byteNew = 0;
+  bytePos = 7;
+  const clampX = (x) => x < 0 ? 0 : x >= width ? width - 1 : x;
+  const clampY = (y) => y < 0 ? 0 : y >= height ? height - 1 : y;
+  for (let by = 0; by < height; by += 8) {
+    for (let bx = 0; bx < width; bx += 8) {
+      let k = 0;
+      for (let r = 0; r < 8; r++) {
+        for (let c = 0; c < 8; c++) {
+          const i = (clampY(by + r) * width + clampX(bx + c)) * 4;
+          const R = px[i], G = px[i + 1], B = px[i + 2];
+          data[k++] = 0.299 * R + 0.587 * G + 0.114 * B - 128;
+        }
+      }
+      dcY = processDU(fdtblY, dcY, YDC, YAC);
+      k = 0;
+      for (let r = 0; r < 8; r++) {
+        for (let c = 0; c < 8; c++) {
+          const i = (clampY(by + r) * width + clampX(bx + c)) * 4;
+          const R = px[i], G = px[i + 1], B = px[i + 2];
+          data[k++] = -0.16874 * R - 0.33126 * G + 0.5 * B;
+        }
+      }
+      dcU = processDU(fdtblUV, dcU, UVDC, UVAC);
+      k = 0;
+      for (let r = 0; r < 8; r++) {
+        for (let c = 0; c < 8; c++) {
+          const i = (clampY(by + r) * width + clampX(bx + c)) * 4;
+          const R = px[i], G = px[i + 1], B = px[i + 2];
+          data[k++] = 0.5 * R - 0.41869 * G - 0.08131 * B;
+        }
+      }
+      dcV = processDU(fdtblUV, dcV, UVDC, UVAC);
+    }
+  }
+  if (bytePos !== 7) writeBits(127, 7);
+  writeWord(65497);
+  return Uint8Array.from(out);
+}
+
+// src/encode.ts
+function hasAlpha(src) {
+  const d = src.data;
+  for (let i = 3; i < d.length; i += 4) if (d[i] < 255) return true;
+  return false;
+}
+async function encode(source, opts) {
+  const format = opts.format;
+  const quality = opts.quality ?? 82;
+  let bytes;
+  if (format === "jpeg") {
+    const flat = hasAlpha(source) ? Surface.from(source).flatten(opts.background ?? "#ffffff") : source;
+    if (hasCanvas()) {
+      try {
+        bytes = await encodeViaCanvas(flat, "jpeg", quality);
+      } catch {
+        bytes = encodeJpeg(flat, quality);
+      }
+    } else {
+      bytes = encodeJpeg(flat, quality);
+    }
+  } else if (format === "png") {
+    if (hasCanvas()) {
+      try {
+        bytes = await encodeViaCanvas(source, "png");
+      } catch {
+        bytes = await encodePng(source);
+      }
+    } else {
+      bytes = await encodePng(source);
+    }
+  } else if (format === "webp") {
+    if (!hasCanvas()) {
+      throw new Error(
+        "WebP encoding needs a Canvas runtime (browser or a Worker with OffscreenCanvas). In Node, export png or jpeg instead."
+      );
+    }
+    bytes = await encodeViaCanvas(source, "webp", quality);
+  } else {
+    throw new Error(`Unsupported format: ${String(format)}`);
+  }
+  return {
+    bytes,
+    format,
+    width: source.width,
+    height: source.height,
+    quality: format === "png" ? void 0 : quality,
+    size: bytes.length
+  };
+}
+
+// src/bytes.ts
+var UNITS = {
+  b: 1,
+  kb: 1024,
+  k: 1024,
+  kib: 1024,
+  mb: 1024 * 1024,
+  m: 1024 * 1024,
+  mib: 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+  g: 1024 * 1024 * 1024,
+  gib: 1024 * 1024 * 1024
+};
+function parseSize(input) {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input) || input <= 0) throw new Error(`Invalid size: ${input}`);
+    return Math.floor(input);
+  }
+  const m = String(input).trim().toLowerCase().match(/^([0-9]*\.?[0-9]+)\s*([a-z]*)$/);
+  if (!m) throw new Error(`Cannot parse size: "${input}"`);
+  const value = parseFloat(m[1]);
+  const unit = m[2] || "b";
+  const mult = UNITS[unit];
+  if (mult == null) throw new Error(`Unknown size unit: "${unit}"`);
+  return Math.floor(value * mult);
+}
+function formatBytes(bytes, decimals = 1) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let n = bytes / 1024;
+  let u = 0;
+  while (n >= 1024 && u < units.length - 1) {
+    n /= 1024;
+    u++;
+  }
+  return `${n.toFixed(decimals).replace(/\.0$/, "")} ${units[u]}`;
+}
+
+// src/fit.ts
+function toSurface(src) {
+  return src instanceof Surface ? src : Surface.from(src);
+}
+async function fit(source, opts) {
+  const maxBytes = opts.maxBytes ?? (opts.maxSize != null ? parseSize(opts.maxSize) : void 0);
+  if (!maxBytes || maxBytes <= 0) throw new Error("fit() needs a positive `maxBytes` or `maxSize`.");
+  const { format } = opts;
+  const minQuality = opts.minQuality ?? 30;
+  const maxQuality = opts.maxQuality ?? 92;
+  const allowResize = opts.allowResize ?? true;
+  const minScale = opts.minScale ?? 0.35;
+  const background = opts.background;
+  const base = toSurface(source);
+  if (format === "png") {
+    let best = await encode(base, { format, background });
+    if (best.size <= maxBytes) return best;
+    if (!allowResize) return best;
+    const scales = [1, 0.85, 0.7, 0.55, minScale];
+    const bitsSteps = [8, 6, 5, 4, 3, 2];
+    for (const scale of scales) {
+      const w = Math.max(1, Math.round(base.width * scale));
+      const h = Math.max(1, Math.round(base.height * scale));
+      const scaled = scale === 1 ? base : base.resize(w, h);
+      for (const bits of bitsSteps) {
+        const surf = bits >= 8 ? scaled : scaled.posterize(bits);
+        const r = await encode(surf, { format, background });
+        if (r.size < best.size) best = r;
+        if (r.size <= maxBytes) return r;
+      }
+    }
+    return best;
+  }
+  const qualitySearch = async (surface) => {
+    let lo = minQuality;
+    let hi = maxQuality;
+    let best = null;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const r = await encode(surface, { format, quality: mid, background });
+      if (r.size <= maxBytes) {
+        best = r;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return best;
+  };
+  const atFull = await qualitySearch(base);
+  if (atFull) return atFull;
+  if (allowResize) {
+    for (let scale = 0.85; scale >= minScale; scale -= 0.12) {
+      const w2 = Math.max(1, Math.round(base.width * scale));
+      const h2 = Math.max(1, Math.round(base.height * scale));
+      const found = await qualitySearch(base.resize(w2, h2));
+      if (found) return found;
+    }
+    const w = Math.max(1, Math.round(base.width * minScale));
+    const h = Math.max(1, Math.round(base.height * minScale));
+    return encode(base.resize(w, h), { format, quality: minQuality, background });
+  }
+  return encode(base, { format, quality: minQuality, background });
+}
+
+// src/svg.ts
+async function svgToSurfaceBrowser(svg, opts) {
+  const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  try {
+    const img = await new Promise((resolve, reject) => {
+      const el = new Image();
+      el.onload = () => resolve(el);
+      el.onerror = () => reject(new Error("Failed to load SVG"));
+      el.src = url;
+    });
+    const w = opts.width ?? img.naturalWidth ?? 512;
+    const h = opts.height ?? img.naturalHeight ?? 512;
+    const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(w, h) : Object.assign(document.createElement("canvas"), { width: w, height: h });
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("No 2D context for SVG rasterization");
+    if (opts.background) {
+      ctx.fillStyle = opts.background;
+      ctx.fillRect(0, 0, w, h);
+    }
+    ctx.drawImage(img, 0, 0, w, h);
+    const data = ctx.getImageData(0, 0, w, h);
+    return new Surface(w, h, data.data);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+async function svgToSurfaceNode(svg, opts) {
+  let sharp;
+  try {
+    const mod = await import('sharp');
+    sharp = mod.default;
+  } catch {
+    throw new Error(
+      "SVG rasterization in Node requires the optional peer `sharp`. Install it (npm i sharp) or run rasterizeSvg() in the browser, where it uses the native Canvas with no extra deps."
+    );
+  }
+  let pipe = sharp(Buffer.from(svg));
+  if (opts.width || opts.height) pipe = pipe.resize(opts.width, opts.height, { fit: "fill" });
+  if (opts.background) pipe = pipe.flatten({ background: opts.background });
+  const { data, info } = await pipe.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return new Surface(info.width, info.height, new Uint8ClampedArray(data));
+}
+async function rasterizeSvg(svg, opts = {}) {
+  const isNode2 = typeof process !== "undefined" && !!process.versions?.node;
+  if (!isNode2 && typeof Image !== "undefined") return svgToSurfaceBrowser(svg, opts);
+  return svgToSurfaceNode(svg, opts);
+}
+
+export { Surface, canvasSupports, encode, encodeJpeg, encodePng, encodePngSync, fit, formatBytes, gradient, hasCanvas, parseColor, parseSize, pattern, radial, rasterizeSvg };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map