@ranx729/ducktape-assets 0.0.0 → 1.1.0

package/src/thumbhash.mjs

@@ -0,0 +1,163 @@
+// ThumbHash decoder, vendored so the resolver has no dependency.
+// thumbHashToRGBA and thumbHashToApproximateAspectRatio are adapted from
+// https://github.com/evanw/thumbhash (c) 2023 Evan Wallace, MIT licence.
+// The PNG encoder below (stored deflate, no compression) is ours.
+
+export function thumbHashToApproximateAspectRatio(hash) {
+  const header = hash[3];
+  const hasAlpha = hash[2] & 0x80;
+  const isLandscape = hash[4] & 0x80;
+  const lx = isLandscape ? (hasAlpha ? 5 : 7) : header & 7;
+  const ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7;
+  return lx / ly;
+}
+
+export function thumbHashToRGBA(hash) {
+  const { PI, min, max, cos, round } = Math;
+  const header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16);
+  const header16 = hash[3] | (hash[4] << 8);
+  const lDc = (header24 & 63) / 63;
+  const pDc = ((header24 >> 6) & 63) / 31.5 - 1;
+  const qDc = ((header24 >> 12) & 63) / 31.5 - 1;
+  const lScale = ((header24 >> 18) & 31) / 31;
+  const hasAlpha = header24 >> 23;
+  const pScale = ((header16 >> 3) & 63) / 63;
+  const qScale = ((header16 >> 9) & 63) / 63;
+  const isLandscape = header16 >> 15;
+  const lx = max(3, isLandscape ? (hasAlpha ? 5 : 7) : header16 & 7);
+  const ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+  const aDc = hasAlpha ? (hash[5] & 15) / 15 : 1;
+  const aScale = (hash[5] >> 4) / 15;
+
+  const acStart = hasAlpha ? 6 : 5;
+  let acIndex = 0;
+  const decodeChannel = (nx, ny, scale) => {
+    const ac = [];
+    for (let cy = 0; cy < ny; cy++)
+      for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+        ac.push(((((hash[acStart + (acIndex >> 1)] >> ((acIndex++ & 1) << 2)) & 15) / 7.5) - 1) * scale);
+    return ac;
+  };
+  const lAc = decodeChannel(lx, ly, lScale);
+  const pAc = decodeChannel(3, 3, pScale * 1.25);
+  const qAc = decodeChannel(3, 3, qScale * 1.25);
+  const aAc = hasAlpha && decodeChannel(5, 5, aScale);
+
+  const ratio = thumbHashToApproximateAspectRatio(hash);
+  const w = round(ratio > 1 ? 32 : 32 * ratio);
+  const h = round(ratio > 1 ? 32 / ratio : 32);
+  const rgba = new Uint8Array(w * h * 4);
+  const fx = [];
+  const fy = [];
+  for (let y = 0, i = 0; y < h; y++) {
+    for (let x = 0; x < w; x++, i += 4) {
+      let l = lDc, p = pDc, q = qDc, a = aDc;
+      for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++) fx[cx] = cos((PI / w) * (x + 0.5) * cx);
+      for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++) fy[cy] = cos((PI / h) * (y + 0.5) * cy);
+      for (let cy = 0, j = 0; cy < ly; cy++)
+        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++) l += lAc[j] * fx[cx] * fy2;
+      for (let cy = 0, j = 0; cy < 3; cy++) {
+        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+          const f = fx[cx] * fy2;
+          p += pAc[j] * f;
+          q += qAc[j] * f;
+        }
+      }
+      if (hasAlpha)
+        for (let cy = 0, j = 0; cy < 5; cy++)
+          for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++) a += aAc[j] * fx[cx] * fy2;
+      const b = l - (2 / 3) * p;
+      const r = (3 * l - b + q) / 2;
+      const g = r - q;
+      rgba[i] = max(0, 255 * min(1, r));
+      rgba[i + 1] = max(0, 255 * min(1, g));
+      rgba[i + 2] = max(0, 255 * min(1, b));
+      rgba[i + 3] = max(0, 255 * min(1, a));
+    }
+  }
+  return { w, h, rgba };
+}
+
+const CRC = (() => {
+  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 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (const b of bytes) c = CRC[(c ^ b) & 255] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function adler32(bytes) {
+  let a = 1, b = 0;
+  for (const x of bytes) {
+    a = (a + x) % 65521;
+    b = (b + a) % 65521;
+  }
+  return ((b << 16) | a) >>> 0;
+}
+
+function chunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(data, 8);
+  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+
+export function rgbaToPng(w, h, rgba) {
+  const raw = new Uint8Array(h * (1 + w * 4));
+  for (let y = 0; y < h; y++) raw.set(rgba.subarray(y * w * 4, (y + 1) * w * 4), y * (1 + w * 4) + 1);
+  const blocks = Math.ceil(raw.length / 65535);
+  const z = new Uint8Array(2 + raw.length + blocks * 5 + 4);
+  z[0] = 0x78;
+  z[1] = 0x01;
+  let o = 2;
+  for (let off = 0; off < raw.length; off += 65535) {
+    const len = Math.min(65535, raw.length - off);
+    z[o++] = off + len >= raw.length ? 1 : 0;
+    z[o++] = len & 255;
+    z[o++] = len >> 8;
+    z[o++] = ~len & 255;
+    z[o++] = (~len >> 8) & 255;
+    z.set(raw.subarray(off, off + len), o);
+    o += len;
+  }
+  new DataView(z.buffer).setUint32(o, adler32(raw));
+  const ihdr = new Uint8Array(13);
+  const v = new DataView(ihdr.buffer);
+  v.setUint32(0, w);
+  v.setUint32(4, h);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 6; // RGBA
+  const parts = [Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10), chunk('IHDR', ihdr), chunk('IDAT', z), chunk('IEND', new Uint8Array(0))];
+  const png = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let p = 0;
+  for (const part of parts) {
+    png.set(part, p);
+    p += part.length;
+  }
+  return png;
+}
+
+function toBase64(bytes) {
+  let s = '';
+  for (let i = 0; i < bytes.length; i += 8192) s += String.fromCharCode(...bytes.subarray(i, i + 8192));
+  return btoa(s);
+}
+
+/** Base64 thumbhash (as stored in manifests) to a `data:image/png` URL. */
+export function thumbHashToDataUrl(b64) {
+  const bin = atob(b64.replace(/-/g, '+').replace(/_/g, '/'));
+  const hash = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  const { w, h, rgba } = thumbHashToRGBA(hash);
+  return `data:image/png;base64,${toBase64(rgbaToPng(w, h, rgba))}`;
+}

package/src/urls.mjs

@@ -0,0 +1,34 @@
+// The one place URLs are built. Used by the resolver, the copy command and the catalog generator,
+// so they cannot disagree. The host is only the `cdn` base of an index.json set entry.
+
+const PART = /^part\d+$/;
+
+function join(base, ...rest) {
+  return [base.replace(/\/+$/, ''), ...rest].join('/');
+}
+
+/** Base URL (ending in a slash) of the package that holds a file, for a file's `package` field. */
+export function packageCdn(entry, pkg, version = entry.version) {
+  let cdn = entry.cdn, from = entry.package, to = entry.package;
+  if (pkg?.startsWith('masters')) {
+    const part = pkg.slice('masters'.length).replace(/^-/, '');
+    cdn = entry.mastersCdn;
+    from = entry.mastersPackage;
+    to = part ? (entry.mastersParts ?? []).find((p) => p.endsWith(`-${part}`)) ?? `${from}-${part}` : from;
+  } else if (pkg) {
+    if (!PART.test(pkg)) throw new Error(`unknown package "${pkg}"`);
+    to = (entry.parts ?? []).find((p) => p.endsWith(`-${pkg}`)) ?? `${from}-${pkg}`;
+  }
+  if (version !== entry.version) cdn = cdn.replace(`@${entry.version}/`, `@${version}/`);
+  // Hosts that fold volume packages into one tree (see CDN contingency) have no package name in the base.
+  return from !== to && cdn.includes(`${from}@`) ? cdn.replace(`${from}@`, `${to}@`) : cdn;
+}
+
+/**
+ * URL of a manifest file entry. With `base` (a self-hosted or copied tree, laid out as `<base>/<set>/<path>`)
+ * the package is irrelevant; otherwise the package's CDN base is used.
+ */
+export function fileUrl(entry, file, { setId, base, version } = {}) {
+  if (base) return join(base, setId, file.path);
+  return packageCdn(entry, file.package, version ?? entry.version) + file.path;
+}