splathash 1.0.1

package/README.md

@@ -0,0 +1,115 @@
+# SplatHash — TypeScript / JavaScript
+
+TypeScript implementation of [SplatHash](../../README.md): compress any image to 16 bytes and reconstruct it.
+
+Works in **Node.js** and **browsers** — the library itself has zero runtime dependencies.
+
+## Installation
+
+```bash
+npm install splathash
+```
+
+## Usage
+
+### Node.js
+
+The library works on raw RGBA bytes. Use any image-loading library (e.g. `sharp`) to get them:
+
+```typescript
+import sharp from "sharp";
+import { encode, decode } from "splathash";
+
+const { data, info } = await sharp("photo.jpg")
+  .ensureAlpha()
+  .raw()
+  .toBuffer({ resolveWithObject: true });
+
+// Encode: raw RGBA → 16-byte hash
+const hash = encode(new Uint8ClampedArray(data), info.width, info.height);
+console.log(Buffer.from(hash).toString("hex")); // e.g. a3f1bc...
+
+// Decode: 16-byte hash → 32×32 RGBA
+const result = decode(hash);
+// result.width  = 32
+// result.height = 32
+// result.rgba   = Uint8ClampedArray (32 * 32 * 4 bytes)
+```
+
+### Browser
+
+Same package, same API. Get raw RGBA from a `<canvas>`:
+
+```typescript
+import { encode, decode } from "splathash";
+
+const canvas = document.getElementById("myCanvas") as HTMLCanvasElement;
+const ctx = canvas.getContext("2d")!;
+const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+
+const hash = encode(data, canvas.width, canvas.height);
+```
+
+Or from an `<img>` element:
+
+```typescript
+function hashImage(img: HTMLImageElement): Uint8Array {
+  const canvas = document.createElement("canvas");
+  canvas.width = img.naturalWidth;
+  canvas.height = img.naturalHeight;
+  const ctx = canvas.getContext("2d")!;
+  ctx.drawImage(img, 0, 0);
+  const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+  return encode(data, canvas.width, canvas.height);
+}
+```
+
+See [`examples/simple.ts`](examples/simple.ts) for a full Node.js example.
+
+## API
+
+### `encode(rgba, width, height): Uint8Array`
+
+| Parameter | Type | Description |
+| :-------- | :--- | :---------- |
+| `rgba` | `Uint8ClampedArray \| Uint8Array` | Raw RGBA pixel data (4 bytes per pixel) |
+| `width` | `number` | Image width in pixels |
+| `height` | `number` | Image height in pixels |
+
+Returns a `Uint8Array` of exactly 16 bytes.
+
+### `decode(hash): DecodedImage`
+
+| Parameter | Type | Description |
+| :-------- | :--- | :---------- |
+| `hash` | `Uint8Array` | 16-byte SplatHash |
+
+Returns a `DecodedImage`:
+
+```typescript
+interface DecodedImage {
+  width: number;          // always 32
+  height: number;         // always 32
+  rgba: Uint8ClampedArray; // 32 * 32 * 4 bytes
+}
+```
+
+Throws if the hash is not exactly 16 bytes.
+
+## Building from Source
+
+```bash
+npm install
+npm run build   # emits to dist/
+npm test        # build + run tests
+```
+
+Or via mise from the repo root:
+
+```bash
+mise run test:ts
+```
+
+## How It Works
+
+See [ALGORITHM.md](../../ALGORITHM.md) for the full technical specification.

package/dist/src/SplatHash.d.ts

@@ -0,0 +1,35 @@
+export declare const TARGET_SIZE = 32;
+export declare const RIDGE_LAMBDA = 0.001;
+export declare const SIGMA_TABLE: number[];
+export interface Splat {
+    x: number;
+    y: number;
+    sigma: number;
+    l: number;
+    a: number;
+    b: number;
+    isLepton: boolean;
+}
+export interface DecodedImage {
+    meanL: number;
+    meanA: number;
+    meanB: number;
+    splats: Splat[];
+    width: number;
+    height: number;
+    rgba: Uint8ClampedArray;
+}
+/**
+ * Encodes an RGBA image buffer into a 16-byte SplatHash.
+ * @param rgba Raw RGBA data (Uint8ClampedArray or Uint8Array)
+ * @param width Image width
+ * @param height Image height
+ * @returns 16-byte Uint8Array hash
+ */
+export declare function encode(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Decodes a 16-byte SplatHash back into RGBA pixel data.
+ * @param hash 16-byte Uint8Array
+ * @returns DecodedImage object containing splats and reconstructed buffer (32x32)
+ */
+export declare function decode(hash: Uint8Array): DecodedImage;

package/dist/src/SplatHash.js

@@ -0,0 +1,536 @@
+"use strict";
+// SplatHash V4: The Universal Quantum Brain (TypeScript Edition)
+//
+// SplatHash describes an image using a "Quantum Entanglement" model.
+// It decomposes the image into a background field (Mean) and 6 particles (Splats).
+// The optimal configuration of these particles is found via a global Ridge Regression solver,
+// allowing for extremely high data density (16 bytes).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGMA_TABLE = exports.RIDGE_LAMBDA = exports.TARGET_SIZE = void 0;
+exports.encode = encode;
+exports.decode = decode;
+exports.TARGET_SIZE = 32;
+exports.RIDGE_LAMBDA = 0.001;
+exports.SIGMA_TABLE = [0.025, 0.1, 0.2, 0.35];
+/**
+ * Encodes an RGBA image buffer into a 16-byte SplatHash.
+ * @param rgba Raw RGBA data (Uint8ClampedArray or Uint8Array)
+ * @param width Image width
+ * @param height Image height
+ * @returns 16-byte Uint8Array hash
+ */
+function encode(rgba, width, height) {
+    // 1. Preprocess to Oklab Grid
+    const grid = imageToOklabGrid(rgba, width, height, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    // 2. Compute Mean
+    let meanL = 0, meanA = 0, meanB = 0;
+    const n = Math.floor(grid.length / 3);
+    for (let i = 0; i < n; i++) {
+        meanL += grid[i * 3];
+        meanA += grid[i * 3 + 1];
+        meanB += grid[i * 3 + 2];
+    }
+    meanL /= n;
+    meanA /= n;
+    meanB /= n;
+    // QUANTUM STEP: Optimize against quantized mean
+    const pMean = packMean(meanL, meanA, meanB);
+    const uMean = unpackMean(pMean);
+    meanL = uMean.l;
+    meanA = uMean.a;
+    meanB = uMean.b;
+    // Residuals
+    const targetL = new Float64Array(n);
+    const targetA = new Float64Array(n);
+    const targetB = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        targetL[i] = grid[i * 3] - meanL;
+        targetA[i] = grid[i * 3 + 1] - meanA;
+        targetB[i] = grid[i * 3 + 2] - meanB;
+    }
+    // 3. Basis Search (Greedy)
+    let basis = [];
+    const currentRecon = new Float64Array(exports.TARGET_SIZE * exports.TARGET_SIZE * 3);
+    for (let i = 0; i < 6; i++) {
+        const candidate = findBestSplat(grid, currentRecon, meanL, meanA, meanB, exports.TARGET_SIZE, exports.TARGET_SIZE);
+        if (candidate.score < 0.00001)
+            break;
+        const s = candidate.splat;
+        s.isLepton = (i >= 3); // First 3 are Baryons (Full Color), Next 3 are Leptons (Luma Only)
+        basis.push(s);
+        addSplatToGrid(currentRecon, s, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    }
+    // 4. Global Linear Projection
+    if (basis.length > 0) {
+        basis = solveV4Weights(basis, targetL, targetA, targetB, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    }
+    // 5. Pack
+    return packV4(pMean, basis);
+}
+/**
+ * Decodes a 16-byte SplatHash back into RGBA pixel data.
+ * @param hash 16-byte Uint8Array
+ * @returns DecodedImage object containing splats and reconstructed buffer (32x32)
+ */
+function decode(hash) {
+    if (hash.length !== 16)
+        throw new Error("Invalid SplatHash: Must be 16 bytes.");
+    const { meanL, meanA, meanB, splats } = unpackV4(hash);
+    const w = 32;
+    const h = 32;
+    const grid = new Float64Array(w * h * 3);
+    // Fill background
+    for (let i = 0; i < grid.length; i += 3) {
+        grid[i] = meanL;
+        grid[i + 1] = meanA;
+        grid[i + 2] = meanB;
+    }
+    // Add splats
+    for (const s of splats) {
+        addSplatToGrid(grid, s, w, h);
+    }
+    // Convert to RGBA
+    const rgba = new Uint8ClampedArray(w * h * 4);
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            const idx = (y * w + x) * 3;
+            const l = grid[idx], a = grid[idx + 1], b = grid[idx + 2];
+            const { r, g, b: bl } = oklabToSrgb(l, a, b);
+            const pIdx = (y * w + x) * 4;
+            rgba[pIdx] = clampi(Math.round(r * 255), 0, 255);
+            rgba[pIdx + 1] = clampi(Math.round(g * 255), 0, 255);
+            rgba[pIdx + 2] = clampi(Math.round(bl * 255), 0, 255);
+            rgba[pIdx + 3] = 255;
+        }
+    }
+    return { meanL, meanA, meanB, splats, width: w, height: h, rgba };
+}
+// --- Implementation Details ---
+function solveV4Weights(basis, tL, tA, tB, w, h) {
+    const nTotal = basis.length;
+    let nBaryons = 0;
+    for (const s of basis)
+        if (!s.isLepton)
+            nBaryons++;
+    // Precompute Activations
+    const activations = basis.map(s => computeBasisMap(s, w, h));
+    // Linear Solve
+    const xL = solveChannel(activations, tL, nTotal, exports.RIDGE_LAMBDA);
+    const xA = solveChannel(activations.slice(0, nBaryons), tA, nBaryons, exports.RIDGE_LAMBDA);
+    const xB = solveChannel(activations.slice(0, nBaryons), tB, nBaryons, exports.RIDGE_LAMBDA);
+    // Update Basis
+    for (let i = 0; i < nTotal; i++) {
+        basis[i].l = xL[i];
+        if (i < nBaryons) {
+            basis[i].a = xA[i];
+            basis[i].b = xB[i];
+        }
+        else {
+            basis[i].a = 0;
+            basis[i].b = 0;
+        }
+    }
+    return basis;
+}
+function solveChannel(activations, target, n, lambda) {
+    if (n === 0)
+        return new Float64Array(0);
+    const m = target.length;
+    const ata = new Float64Array(n * n);
+    const atb = new Float64Array(n);
+    // Build Normal Equations (ATA * x = ATb)
+    for (let i = 0; i < n; i++) {
+        for (let j = i; j < n; j++) {
+            let sum = 0.0;
+            const actI = activations[i];
+            const actJ = activations[j];
+            for (let p = 0; p < m; p++)
+                sum += actI[p] * actJ[p];
+            ata[i * n + j] = sum;
+            ata[j * n + i] = sum;
+        }
+        let sumB = 0.0;
+        const actI = activations[i];
+        for (let p = 0; p < m; p++)
+            sumB += actI[p] * target[p];
+        atb[i] = sumB;
+    }
+    // Ridge Regularization
+    for (let i = 0; i < n; i++)
+        ata[i * n + i] += lambda;
+    return solveLinearSystem(ata, atb, n);
+}
+function solveLinearSystem(mat, vec, n) {
+    // Gaussian Elimination
+    const a = new Float64Array(mat); // Copy
+    const b = new Float64Array(vec); // Copy
+    for (let k = 0; k < n - 1; k++) {
+        for (let i = k + 1; i < n; i++) {
+            const factor = a[i * n + k] / a[k * n + k];
+            for (let j = k; j < n; j++)
+                a[i * n + j] -= factor * a[k * n + j];
+            b[i] -= factor * b[k];
+        }
+    }
+    const x = new Float64Array(n);
+    for (let i = n - 1; i >= 0; i--) {
+        let sum = 0.0;
+        for (let j = i + 1; j < n; j++)
+            sum += a[i * n + j] * x[j];
+        x[i] = (b[i] - sum) / a[i * n + i];
+    }
+    return x;
+}
+function findBestSplat(grid, recon, mL, mA, mB, w, h) {
+    let maxScore = -1.0;
+    let bestSplat = { x: 0, y: 0, sigma: 0.1, l: 0, a: 0, b: 0, isLepton: false };
+    // Compute Residuals
+    const n = Math.floor(grid.length / 3);
+    const resL = new Float64Array(n);
+    const resA = new Float64Array(n);
+    const resB = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        resL[i] = grid[i * 3] - mL - recon[i * 3];
+        resA[i] = grid[i * 3 + 1] - mA - recon[i * 3 + 1];
+        resB[i] = grid[i * 3 + 2] - mB - recon[i * 3 + 2];
+    }
+    const step = 2; // Optimization: stride
+    const sigmas = exports.SIGMA_TABLE;
+    for (let y = 0; y < h; y += step) {
+        for (let x = 0; x < w; x += step) {
+            const xf = x / w;
+            const yf = y / h;
+            for (const sigma of sigmas) {
+                let dotL = 0, dotA = 0, dotB = 0, dotG = 0;
+                const rad = Math.floor(sigma * w * 3.5);
+                const y0 = clampi(y - rad, 0, h - 1);
+                const y1 = clampi(y + rad, 0, h - 1);
+                const x0 = clampi(x - rad, 0, w - 1);
+                const x1 = clampi(x + rad, 0, w - 1);
+                for (let sy = y0; sy <= y1; sy++) {
+                    const dy = (sy / h) - yf;
+                    const rowBase = sy * w;
+                    for (let sx = x0; sx <= x1; sx++) {
+                        const dx = (sx / w) - xf;
+                        const distSq = dx * dx + dy * dy;
+                        const weight = Math.exp(-distSq / (2 * sigma * sigma));
+                        const idx = rowBase + sx;
+                        dotL += weight * resL[idx];
+                        dotA += weight * resA[idx];
+                        dotB += weight * resB[idx];
+                        dotG += weight * weight;
+                    }
+                }
+                if (dotG < 1e-9)
+                    continue;
+                // Score based on energy
+                const score = (dotL * dotL + dotA * dotA + dotB * dotB) / dotG;
+                if (score > maxScore) {
+                    maxScore = score;
+                    bestSplat = {
+                        x: xf, y: yf, sigma,
+                        l: dotL / dotG, a: dotA / dotG, b: dotB / dotG,
+                        isLepton: false
+                    };
+                }
+            }
+        }
+    }
+    return { splat: bestSplat, score: maxScore };
+}
+function computeBasisMap(s, w, h) {
+    const out = new Float64Array(w * h);
+    const rad = Math.floor(s.sigma * w * 3.5);
+    const cx = Math.floor(s.x * w);
+    const cy = Math.floor(s.y * h);
+    const y0 = clampi(cy - rad, 0, h - 1);
+    const y1 = clampi(cy + rad, 0, h - 1);
+    const x0 = clampi(cx - rad, 0, w - 1);
+    const x1 = clampi(cx + rad, 0, w - 1);
+    for (let y = y0; y <= y1; y++) {
+        const dy = (y / h) - s.y;
+        for (let x = x0; x <= x1; x++) {
+            const dx = (x / w) - s.x;
+            out[y * w + x] = Math.exp(-(dx * dx + dy * dy) / (2 * s.sigma * s.sigma));
+        }
+    }
+    return out;
+}
+function addSplatToGrid(grid, s, w, h) {
+    const rad = Math.floor(s.sigma * w * 3.5);
+    const cx = Math.floor(s.x * w);
+    const cy = Math.floor(s.y * h);
+    const y0 = clampi(cy - rad, 0, h - 1);
+    const y1 = clampi(cy + rad, 0, h - 1);
+    const x0 = clampi(cx - rad, 0, w - 1);
+    const x1 = clampi(cx + rad, 0, w - 1);
+    for (let y = y0; y <= y1; y++) {
+        const dy = (y / h) - s.y;
+        for (let x = x0; x <= x1; x++) {
+            const dx = (x / w) - s.x;
+            const weight = Math.exp(-(dx * dx + dy * dy) / (2 * s.sigma * s.sigma));
+            const idx = (y * w + x) * 3;
+            grid[idx] += s.l * weight;
+            if (!s.isLepton) {
+                grid[idx + 1] += s.a * weight;
+                grid[idx + 2] += s.b * weight;
+            }
+        }
+    }
+}
+// --- Image Helpers ---
+function imageToOklabGrid(rgba, srcW, srcH, w, h) {
+    const out = new Float64Array(w * h * 3);
+    for (let y = 0; y < h; y++) {
+        const y0 = Math.floor((y * srcH) / h);
+        const y1 = Math.floor(((y + 1) * srcH) / h);
+        for (let x = 0; x < w; x++) {
+            const x0 = Math.floor((x * srcW) / w);
+            const x1 = Math.floor(((x + 1) * srcW) / w);
+            let rSum = 0, gSum = 0, bSum = 0, count = 0;
+            for (let iy = y0; iy < y1; iy++) {
+                if (iy >= srcH)
+                    break;
+                for (let ix = x0; ix < x1; ix++) {
+                    if (ix >= srcW)
+                        break;
+                    const idx = (iy * srcW + ix) * 4;
+                    rSum += rgba[idx];
+                    gSum += rgba[idx + 1];
+                    bSum += rgba[idx + 2];
+                    count++;
+                }
+            }
+            if (count === 0)
+                continue;
+            const r = (rSum / count) / 255.0;
+            const g = (gSum / count) / 255.0;
+            const b = (bSum / count) / 255.0;
+            const lab = srgbToOklab(r, g, b);
+            const idx = (y * w + x) * 3;
+            out[idx] = lab.l;
+            out[idx + 1] = lab.a;
+            out[idx + 2] = lab.b;
+        }
+    }
+    return out;
+}
+function srgbToOklab(r, g, b) {
+    const lin = (c) => (c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
+    r = lin(r);
+    g = lin(g);
+    b = lin(b);
+    const l1 = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m1 = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s1 = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    const l_ = Math.cbrt(l1), m_ = Math.cbrt(m1), s_ = Math.cbrt(s1);
+    return {
+        l: 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_,
+        a: 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_,
+        b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_
+    };
+}
+function oklabToSrgb(l, a, b) {
+    const l_ = l + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = l - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = l - 0.0894841775 * a - 1.2914855480 * b;
+    const l3 = l_ * l_ * l_;
+    const m3 = m_ * m_ * m_;
+    const s3 = s_ * s_ * s_;
+    let r = +4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3;
+    let g = -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3;
+    let bl = -0.0041960863 * l3 - 0.7034186147 * m3 + 1.7076147010 * s3;
+    const srt = (c) => (c <= 0.0031308 ? 12.92 * c : (c < 0 ? 0 : 1.055 * Math.pow(c, 1.0 / 2.4) - 0.055));
+    return { r: srt(r), g: srt(g), b: srt(bl) };
+}
+// --- Bit Packing ---
+class BitStream {
+    constructor() {
+        this.buf = [];
+        this.acc = 0n;
+        this.n = 0;
+    }
+    write(val, bits) {
+        this.acc = (this.acc << BigInt(bits)) | BigInt(val);
+        this.n += bits;
+        while (this.n >= 8) {
+            const shift = BigInt(this.n - 8);
+            const byteVal = Number((this.acc >> shift) & 0xffn);
+            this.buf.push(byteVal);
+            this.n -= 8;
+        }
+    }
+    getBytes() {
+        if (this.n > 0) {
+            this.buf.push(Number((this.acc << BigInt(8 - this.n)) & 0xffn));
+        }
+        return new Uint8Array(this.buf);
+    }
+}
+class BitReader {
+    constructor(data) {
+        this.pos = 0;
+        this.rem = 0;
+        this.curr = 0;
+        this.data = data;
+    }
+    read(bits) {
+        let val = 0;
+        let bitsRemaining = bits;
+        while (bitsRemaining > 0) {
+            if (this.rem === 0) {
+                if (this.pos >= this.data.length)
+                    return val << bitsRemaining; // EOF
+                this.curr = this.data[this.pos++];
+                this.rem = 8;
+            }
+            // Optimization for partial read
+            const take = Math.min(this.rem, bitsRemaining);
+            const shift = this.rem - take;
+            const mask = (1 << take) - 1;
+            const chunk = (this.curr >> shift) & mask;
+            val = (val << take) | chunk;
+            this.rem -= take;
+            bitsRemaining -= take;
+        }
+        return val;
+    }
+}
+function packV4(mean, splats) {
+    const bw = new BitStream();
+    // Header (16 bits)
+    bw.write(mean, 16);
+    // Baryons (3x)
+    let count = 0;
+    for (const s of splats) {
+        if (s.isLepton)
+            continue;
+        if (count >= 3)
+            break;
+        const xi = clampi(Math.round(s.x * 15.0), 0, 15);
+        const yi = clampi(Math.round(s.y * 15.0), 0, 15);
+        const sigI = getSigmaIdx(s.sigma);
+        const lQ = quant(s.l, -0.8, 0.8, 4);
+        const aQ = quant(s.a, -0.4, 0.4, 4);
+        const bQ = quant(s.b, -0.4, 0.4, 4);
+        bw.write(xi, 4);
+        bw.write(yi, 4);
+        bw.write(sigI, 2);
+        bw.write(lQ, 4);
+        bw.write(aQ, 4);
+        bw.write(bQ, 4);
+        count++;
+    }
+    while (count < 3) {
+        bw.write(0, 22);
+        count++;
+    }
+    // Leptons (3x)
+    count = 0;
+    for (const s of splats) {
+        if (!s.isLepton)
+            continue;
+        if (count >= 3)
+            break;
+        const xi = clampi(Math.round(s.x * 15.0), 0, 15);
+        const yi = clampi(Math.round(s.y * 15.0), 0, 15);
+        const sigI = getSigmaIdx(s.sigma);
+        const lQ = quant(s.l, -0.8, 0.8, 5);
+        bw.write(xi, 4);
+        bw.write(yi, 4);
+        bw.write(sigI, 2);
+        bw.write(lQ, 5);
+        count++;
+    }
+    while (count < 3) {
+        bw.write(0, 15);
+        count++;
+    }
+    bw.write(0, 1); // Pad
+    return bw.getBytes();
+}
+function unpackV4(hash) {
+    const br = new BitReader(hash);
+    const meanMap = br.read(16);
+    const { l, a, b } = unpackMean(meanMap);
+    const splats = [];
+    // Baryons
+    for (let i = 0; i < 3; i++) {
+        const xi = br.read(4);
+        const yi = br.read(4);
+        const sigI = br.read(2);
+        const lQ = br.read(4);
+        const aQ = br.read(4);
+        const bQ = br.read(4);
+        if (xi === 0 && yi === 0 && lQ === 0 && aQ === 0 && bQ === 0)
+            continue;
+        splats.push({
+            x: xi / 15.0,
+            y: yi / 15.0,
+            sigma: exports.SIGMA_TABLE[sigI],
+            l: unquant(lQ, -0.8, 0.8, 4),
+            a: unquant(aQ, -0.4, 0.4, 4),
+            b: unquant(bQ, -0.4, 0.4, 4),
+            isLepton: false
+        });
+    }
+    // Leptons
+    for (let i = 0; i < 3; i++) {
+        const xi = br.read(4);
+        const yi = br.read(4);
+        const sigI = br.read(2);
+        const lQ = br.read(5);
+        if (xi === 0 && yi === 0 && lQ === 0)
+            continue;
+        splats.push({
+            x: xi / 15.0,
+            y: yi / 15.0,
+            sigma: exports.SIGMA_TABLE[sigI],
+            l: unquant(lQ, -0.8, 0.8, 5),
+            a: 0, b: 0,
+            isLepton: true
+        });
+    }
+    return { meanL: l, meanA: a, meanB: b, splats };
+}
+function getSigmaIdx(s) {
+    let minD = 100.0;
+    let idx = 0;
+    for (let i = 0; i < exports.SIGMA_TABLE.length; i++) {
+        const d = Math.abs(exports.SIGMA_TABLE[i] - s);
+        if (d < minD) {
+            minD = d;
+            idx = i;
+        }
+    }
+    return idx;
+}
+function packMean(l, a, b) {
+    const li = clampi(Math.floor(l * 63.5), 0, 63);
+    const ai = clampi(Math.floor(((a + 0.2) / 0.4) * 31.5), 0, 31);
+    const bi = clampi(Math.floor(((b + 0.2) / 0.4) * 31.5), 0, 31);
+    return (li << 10) | (ai << 5) | bi;
+}
+function unpackMean(p) {
+    const li = (p >> 10) & 0x3F;
+    const ai = (p >> 5) & 0x1F;
+    const bi = p & 0x1F;
+    return {
+        l: li / 63.0,
+        a: (ai / 31.0 * 0.4) - 0.2,
+        b: (bi / 31.0 * 0.4) - 0.2
+    };
+}
+function quant(v, min, max, bits) {
+    const steps = (1 << bits) - 1;
+    const norm = (v - min) / (max - min);
+    return clampi(Math.round(norm * steps), 0, steps);
+}
+function unquant(v, min, max, bits) {
+    const steps = (1 << bits) - 1;
+    const norm = v / steps;
+    return norm * (max - min) + min;
+}
+function clampi(v, min, max) {
+    return v < min ? min : (v > max ? max : v);
+}

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./splathash";

package/dist/src/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./splathash"), exports);

package/dist/src/splathash.d.ts

@@ -0,0 +1,31 @@
+export declare const TARGET_SIZE = 32;
+export declare const RIDGE_LAMBDA = 0.001;
+export declare const SIGMA_TABLE: number[];
+export interface Splat {
+    x: number;
+    y: number;
+    sigma: number;
+    l: number;
+    a: number;
+    b: number;
+    isLepton: boolean;
+}
+export interface DecodedImage {
+    width: number;
+    height: number;
+    rgba: Uint8ClampedArray;
+}
+/**
+ * Encodes an RGBA image buffer into a 16-byte SplatHash.
+ * @param rgba Raw RGBA data (Uint8ClampedArray or Uint8Array)
+ * @param width Image width
+ * @param height Image height
+ * @returns 16-byte Uint8Array hash
+ */
+export declare function encode(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Decodes a 16-byte SplatHash back into RGBA pixel data.
+ * @param hash 16-byte Uint8Array
+ * @returns DecodedImage object containing splats and reconstructed buffer (32x32)
+ */
+export declare function decode(hash: Uint8Array): DecodedImage;

package/dist/src/splathash.js

@@ -0,0 +1,556 @@
+"use strict";
+// SplatHash — TypeScript implementation
+//
+// Encodes any image into 16 bytes and reconstructs a 32x32 preview.
+// An image is decomposed into a background color (Mean) and six Gaussian blobs (Splats):
+//   - 3 Baryons: full-color Splats for dominant features
+//   - 3 Leptons: luma-only Splats for texture and detail
+//
+// Splat positions are found greedily; Ridge Regression then refines all weights together.
+// All computation is done in Oklab. The hash fits into exactly 128 bits.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGMA_TABLE = exports.RIDGE_LAMBDA = exports.TARGET_SIZE = void 0;
+exports.encode = encode;
+exports.decode = decode;
+exports.TARGET_SIZE = 32;
+exports.RIDGE_LAMBDA = 0.001;
+exports.SIGMA_TABLE = [0.025, 0.1, 0.2, 0.35];
+/**
+ * Encodes an RGBA image buffer into a 16-byte SplatHash.
+ * @param rgba Raw RGBA data (Uint8ClampedArray or Uint8Array)
+ * @param width Image width
+ * @param height Image height
+ * @returns 16-byte Uint8Array hash
+ */
+function encode(rgba, width, height) {
+    // 1. Preprocess to Oklab Grid
+    const grid = imageToOklabGrid(rgba, width, height, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    // 2. Compute Mean
+    let meanL = 0, meanA = 0, meanB = 0;
+    const n = Math.floor(grid.length / 3);
+    for (let i = 0; i < n; i++) {
+        meanL += grid[i * 3];
+        meanA += grid[i * 3 + 1];
+        meanB += grid[i * 3 + 2];
+    }
+    meanL /= n;
+    meanA /= n;
+    meanB /= n;
+    // 3. Quantize Mean immediately so the solver optimizes against the reconstructed mean.
+    const pMean = packMean(meanL, meanA, meanB);
+    const uMean = unpackMean(pMean);
+    meanL = uMean.l;
+    meanA = uMean.a;
+    meanB = uMean.b;
+    // Residuals
+    const targetL = new Float64Array(n);
+    const targetA = new Float64Array(n);
+    const targetB = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        targetL[i] = grid[i * 3] - meanL;
+        targetA[i] = grid[i * 3 + 1] - meanA;
+        targetB[i] = grid[i * 3 + 2] - meanB;
+    }
+    // 3. Basis Search (Greedy)
+    let basis = [];
+    const currentRecon = new Float64Array(exports.TARGET_SIZE * exports.TARGET_SIZE * 3);
+    for (let i = 0; i < 6; i++) {
+        const candidate = findBestSplat(grid, currentRecon, meanL, meanA, meanB, exports.TARGET_SIZE, exports.TARGET_SIZE);
+        if (candidate.score < 0.00001)
+            break;
+        const s = candidate.splat;
+        s.isLepton = i >= 3; // First 3 are Baryons (Full Color), Next 3 are Leptons (Luma Only)
+        basis.push(s);
+        addSplatToGrid(currentRecon, s, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    }
+    // 4. Global Linear Projection
+    if (basis.length > 0) {
+        basis = solveV4Weights(basis, targetL, targetA, targetB, exports.TARGET_SIZE, exports.TARGET_SIZE);
+    }
+    // 5. Pack
+    return packV4(pMean, basis);
+}
+/**
+ * Decodes a 16-byte SplatHash back into RGBA pixel data.
+ * @param hash 16-byte Uint8Array
+ * @returns DecodedImage object containing splats and reconstructed buffer (32x32)
+ */
+function decode(hash) {
+    if (hash.length !== 16)
+        throw new Error("Invalid SplatHash: Must be 16 bytes.");
+    const { meanL, meanA, meanB, splats } = unpackV4(hash);
+    const w = 32;
+    const h = 32;
+    const grid = new Float64Array(w * h * 3);
+    // Fill background
+    for (let i = 0; i < grid.length; i += 3) {
+        grid[i] = meanL;
+        grid[i + 1] = meanA;
+        grid[i + 2] = meanB;
+    }
+    // Add splats
+    for (const s of splats) {
+        addSplatToGrid(grid, s, w, h);
+    }
+    // Convert to RGBA
+    const rgba = new Uint8ClampedArray(w * h * 4);
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            const idx = (y * w + x) * 3;
+            const l = grid[idx], a = grid[idx + 1], b = grid[idx + 2];
+            const { r, g, b: bl } = oklabToSrgb(l, a, b);
+            const pIdx = (y * w + x) * 4;
+            rgba[pIdx] = clampi(Math.round(r * 255), 0, 255);
+            rgba[pIdx + 1] = clampi(Math.round(g * 255), 0, 255);
+            rgba[pIdx + 2] = clampi(Math.round(bl * 255), 0, 255);
+            rgba[pIdx + 3] = 255;
+        }
+    }
+    return { width: w, height: h, rgba };
+}
+// --- Implementation Details ---
+function solveV4Weights(basis, tL, tA, tB, w, h) {
+    const nTotal = basis.length;
+    let nBaryons = 0;
+    for (const s of basis)
+        if (!s.isLepton)
+            nBaryons++;
+    // Precompute Activations
+    const activations = basis.map((s) => computeBasisMap(s, w, h));
+    // Linear Solve
+    const xL = solveChannel(activations, tL, nTotal, exports.RIDGE_LAMBDA);
+    const xA = solveChannel(activations.slice(0, nBaryons), tA, nBaryons, exports.RIDGE_LAMBDA);
+    const xB = solveChannel(activations.slice(0, nBaryons), tB, nBaryons, exports.RIDGE_LAMBDA);
+    // Update Basis
+    for (let i = 0; i < nTotal; i++) {
+        basis[i].l = xL[i];
+        if (i < nBaryons) {
+            basis[i].a = xA[i];
+            basis[i].b = xB[i];
+        }
+        else {
+            basis[i].a = 0;
+            basis[i].b = 0;
+        }
+    }
+    return basis;
+}
+function solveChannel(activations, target, n, lambda) {
+    if (n === 0)
+        return new Float64Array(0);
+    const m = target.length;
+    const ata = new Float64Array(n * n);
+    const atb = new Float64Array(n);
+    // Build Normal Equations (ATA * x = ATb)
+    for (let i = 0; i < n; i++) {
+        for (let j = i; j < n; j++) {
+            let sum = 0.0;
+            const actI = activations[i];
+            const actJ = activations[j];
+            for (let p = 0; p < m; p++)
+                sum += actI[p] * actJ[p];
+            ata[i * n + j] = sum;
+            ata[j * n + i] = sum;
+        }
+        let sumB = 0.0;
+        const actI = activations[i];
+        for (let p = 0; p < m; p++)
+            sumB += actI[p] * target[p];
+        atb[i] = sumB;
+    }
+    // Ridge Regularization
+    for (let i = 0; i < n; i++)
+        ata[i * n + i] += lambda;
+    return solveLinearSystem(ata, atb, n);
+}
+function solveLinearSystem(mat, vec, n) {
+    // Gaussian Elimination
+    const a = new Float64Array(mat); // Copy
+    const b = new Float64Array(vec); // Copy
+    for (let k = 0; k < n - 1; k++) {
+        for (let i = k + 1; i < n; i++) {
+            const factor = a[i * n + k] / a[k * n + k];
+            for (let j = k; j < n; j++)
+                a[i * n + j] -= factor * a[k * n + j];
+            b[i] -= factor * b[k];
+        }
+    }
+    const x = new Float64Array(n);
+    for (let i = n - 1; i >= 0; i--) {
+        let sum = 0.0;
+        for (let j = i + 1; j < n; j++)
+            sum += a[i * n + j] * x[j];
+        x[i] = (b[i] - sum) / a[i * n + i];
+    }
+    return x;
+}
+function findBestSplat(grid, recon, mL, mA, mB, w, h) {
+    let maxScore = -1.0;
+    let bestSplat = {
+        x: 0,
+        y: 0,
+        sigma: 0.1,
+        l: 0,
+        a: 0,
+        b: 0,
+        isLepton: false,
+    };
+    // Compute Residuals
+    const n = Math.floor(grid.length / 3);
+    const resL = new Float64Array(n);
+    const resA = new Float64Array(n);
+    const resB = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        resL[i] = grid[i * 3] - mL - recon[i * 3];
+        resA[i] = grid[i * 3 + 1] - mA - recon[i * 3 + 1];
+        resB[i] = grid[i * 3 + 2] - mB - recon[i * 3 + 2];
+    }
+    const step = 2; // Optimization: stride
+    const sigmas = exports.SIGMA_TABLE;
+    for (let y = 0; y < h; y += step) {
+        for (let x = 0; x < w; x += step) {
+            const xf = x / w;
+            const yf = y / h;
+            for (const sigma of sigmas) {
+                let dotL = 0, dotA = 0, dotB = 0, dotG = 0;
+                const rad = Math.floor(sigma * w * 3.5);
+                const y0 = clampi(y - rad, 0, h - 1);
+                const y1 = clampi(y + rad, 0, h - 1);
+                const x0 = clampi(x - rad, 0, w - 1);
+                const x1 = clampi(x + rad, 0, w - 1);
+                for (let sy = y0; sy <= y1; sy++) {
+                    const dy = sy / h - yf;
+                    const rowBase = sy * w;
+                    for (let sx = x0; sx <= x1; sx++) {
+                        const dx = sx / w - xf;
+                        const distSq = dx * dx + dy * dy;
+                        const weight = Math.exp(-distSq / (2 * sigma * sigma));
+                        const idx = rowBase + sx;
+                        dotL += weight * resL[idx];
+                        dotA += weight * resA[idx];
+                        dotB += weight * resB[idx];
+                        dotG += weight * weight;
+                    }
+                }
+                if (dotG < 1e-9)
+                    continue;
+                // Score based on energy
+                const score = (dotL * dotL + dotA * dotA + dotB * dotB) / dotG;
+                if (score > maxScore) {
+                    maxScore = score;
+                    bestSplat = {
+                        x: xf,
+                        y: yf,
+                        sigma,
+                        l: dotL / dotG,
+                        a: dotA / dotG,
+                        b: dotB / dotG,
+                        isLepton: false,
+                    };
+                }
+            }
+        }
+    }
+    return { splat: bestSplat, score: maxScore };
+}
+function computeBasisMap(s, w, h) {
+    const out = new Float64Array(w * h);
+    const rad = Math.floor(s.sigma * w * 3.5);
+    const cx = Math.floor(s.x * w);
+    const cy = Math.floor(s.y * h);
+    const y0 = clampi(cy - rad, 0, h - 1);
+    const y1 = clampi(cy + rad, 0, h - 1);
+    const x0 = clampi(cx - rad, 0, w - 1);
+    const x1 = clampi(cx + rad, 0, w - 1);
+    for (let y = y0; y <= y1; y++) {
+        const dy = y / h - s.y;
+        for (let x = x0; x <= x1; x++) {
+            const dx = x / w - s.x;
+            out[y * w + x] = Math.exp(-(dx * dx + dy * dy) / (2 * s.sigma * s.sigma));
+        }
+    }
+    return out;
+}
+function addSplatToGrid(grid, s, w, h) {
+    const rad = Math.floor(s.sigma * w * 3.5);
+    const cx = Math.floor(s.x * w);
+    const cy = Math.floor(s.y * h);
+    const y0 = clampi(cy - rad, 0, h - 1);
+    const y1 = clampi(cy + rad, 0, h - 1);
+    const x0 = clampi(cx - rad, 0, w - 1);
+    const x1 = clampi(cx + rad, 0, w - 1);
+    for (let y = y0; y <= y1; y++) {
+        const dy = y / h - s.y;
+        for (let x = x0; x <= x1; x++) {
+            const dx = x / w - s.x;
+            const weight = Math.exp(-(dx * dx + dy * dy) / (2 * s.sigma * s.sigma));
+            const idx = (y * w + x) * 3;
+            grid[idx] += s.l * weight;
+            if (!s.isLepton) {
+                grid[idx + 1] += s.a * weight;
+                grid[idx + 2] += s.b * weight;
+            }
+        }
+    }
+}
+// --- Image Helpers ---
+function imageToOklabGrid(rgba, srcW, srcH, w, h) {
+    const out = new Float64Array(w * h * 3);
+    for (let y = 0; y < h; y++) {
+        const y0 = Math.floor((y * srcH) / h);
+        const y1 = Math.ceil(((y + 1) * srcH) / h);
+        for (let x = 0; x < w; x++) {
+            const x0 = Math.floor((x * srcW) / w);
+            const x1 = Math.ceil(((x + 1) * srcW) / w);
+            let rSum = 0, gSum = 0, bSum = 0, count = 0;
+            for (let iy = y0; iy < y1; iy++) {
+                if (iy >= srcH)
+                    break;
+                for (let ix = x0; ix < x1; ix++) {
+                    if (ix >= srcW)
+                        break;
+                    const idx = (iy * srcW + ix) * 4;
+                    rSum += rgba[idx];
+                    gSum += rgba[idx + 1];
+                    bSum += rgba[idx + 2];
+                    count++;
+                }
+            }
+            if (count === 0)
+                continue;
+            const r = rSum / count / 255.0;
+            const g = gSum / count / 255.0;
+            const b = bSum / count / 255.0;
+            const lab = srgbToOklab(r, g, b);
+            const idx = (y * w + x) * 3;
+            out[idx] = lab.l;
+            out[idx + 1] = lab.a;
+            out[idx + 2] = lab.b;
+        }
+    }
+    return out;
+}
+function srgbToOklab(r, g, b) {
+    const lin = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    r = lin(r);
+    g = lin(g);
+    b = lin(b);
+    const l1 = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m1 = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s1 = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    const l_ = Math.cbrt(l1), m_ = Math.cbrt(m1), s_ = Math.cbrt(s1);
+    return {
+        l: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+        a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+        b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_,
+    };
+}
+function oklabToSrgb(l, a, b) {
+    const l_ = l + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = l - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = l - 0.0894841775 * a - 1.291485548 * b;
+    const l3 = l_ * l_ * l_;
+    const m3 = m_ * m_ * m_;
+    const s3 = s_ * s_ * s_;
+    let r = +4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3;
+    let g = -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3;
+    let bl = -0.0041960863 * l3 - 0.7034186147 * m3 + 1.707614701 * s3;
+    const srt = (c) => c <= 0.0031308
+        ? 12.92 * c
+        : c < 0
+            ? 0
+            : 1.055 * Math.pow(c, 1.0 / 2.4) - 0.055;
+    return { r: srt(r), g: srt(g), b: srt(bl) };
+}
+// --- Bit Packing ---
+class BitStream {
+    constructor() {
+        this.buf = [];
+        this.acc = 0n;
+        this.n = 0;
+    }
+    write(val, bits) {
+        this.acc = (this.acc << BigInt(bits)) | BigInt(val);
+        this.n += bits;
+        while (this.n >= 8) {
+            const shift = BigInt(this.n - 8);
+            const byteVal = Number((this.acc >> shift) & 0xffn);
+            this.buf.push(byteVal);
+            this.n -= 8;
+        }
+    }
+    getBytes() {
+        if (this.n > 0) {
+            this.buf.push(Number((this.acc << BigInt(8 - this.n)) & 0xffn));
+        }
+        return new Uint8Array(this.buf);
+    }
+}
+class BitReader {
+    constructor(data) {
+        this.pos = 0;
+        this.rem = 0;
+        this.curr = 0;
+        this.data = data;
+    }
+    read(bits) {
+        let val = 0;
+        let bitsRemaining = bits;
+        while (bitsRemaining > 0) {
+            if (this.rem === 0) {
+                if (this.pos >= this.data.length)
+                    return val << bitsRemaining; // EOF
+                this.curr = this.data[this.pos++];
+                this.rem = 8;
+            }
+            // Optimization for partial read
+            const take = Math.min(this.rem, bitsRemaining);
+            const shift = this.rem - take;
+            const mask = (1 << take) - 1;
+            const chunk = (this.curr >> shift) & mask;
+            val = (val << take) | chunk;
+            this.rem -= take;
+            bitsRemaining -= take;
+        }
+        return val;
+    }
+}
+function packV4(mean, splats) {
+    const bw = new BitStream();
+    // Header (16 bits)
+    bw.write(mean, 16);
+    // Baryons (3x)
+    let count = 0;
+    for (const s of splats) {
+        if (s.isLepton)
+            continue;
+        if (count >= 3)
+            break;
+        const xi = clampi(Math.round(s.x * 15.0), 0, 15);
+        const yi = clampi(Math.round(s.y * 15.0), 0, 15);
+        const sigI = getSigmaIdx(s.sigma);
+        const lQ = quant(s.l, -0.8, 0.8, 4);
+        const aQ = quant(s.a, -0.4, 0.4, 4);
+        const bQ = quant(s.b, -0.4, 0.4, 4);
+        bw.write(xi, 4);
+        bw.write(yi, 4);
+        bw.write(sigI, 2);
+        bw.write(lQ, 4);
+        bw.write(aQ, 4);
+        bw.write(bQ, 4);
+        count++;
+    }
+    while (count < 3) {
+        bw.write(0, 22);
+        count++;
+    }
+    // Leptons (3x)
+    count = 0;
+    for (const s of splats) {
+        if (!s.isLepton)
+            continue;
+        if (count >= 3)
+            break;
+        const xi = clampi(Math.round(s.x * 15.0), 0, 15);
+        const yi = clampi(Math.round(s.y * 15.0), 0, 15);
+        const sigI = getSigmaIdx(s.sigma);
+        const lQ = quant(s.l, -0.8, 0.8, 5);
+        bw.write(xi, 4);
+        bw.write(yi, 4);
+        bw.write(sigI, 2);
+        bw.write(lQ, 5);
+        count++;
+    }
+    while (count < 3) {
+        bw.write(0, 15);
+        count++;
+    }
+    bw.write(0, 1); // Pad
+    return bw.getBytes();
+}
+function unpackV4(hash) {
+    const br = new BitReader(hash);
+    const meanMap = br.read(16);
+    const { l, a, b } = unpackMean(meanMap);
+    const splats = [];
+    // Baryons
+    for (let i = 0; i < 3; i++) {
+        const xi = br.read(4);
+        const yi = br.read(4);
+        const sigI = br.read(2);
+        const lQ = br.read(4);
+        const aQ = br.read(4);
+        const bQ = br.read(4);
+        if (xi === 0 && yi === 0 && lQ === 0 && aQ === 0 && bQ === 0)
+            continue;
+        splats.push({
+            x: xi / 15.0,
+            y: yi / 15.0,
+            sigma: exports.SIGMA_TABLE[sigI],
+            l: unquant(lQ, -0.8, 0.8, 4),
+            a: unquant(aQ, -0.4, 0.4, 4),
+            b: unquant(bQ, -0.4, 0.4, 4),
+            isLepton: false,
+        });
+    }
+    // Leptons
+    for (let i = 0; i < 3; i++) {
+        const xi = br.read(4);
+        const yi = br.read(4);
+        const sigI = br.read(2);
+        const lQ = br.read(5);
+        if (xi === 0 && yi === 0 && lQ === 0)
+            continue;
+        splats.push({
+            x: xi / 15.0,
+            y: yi / 15.0,
+            sigma: exports.SIGMA_TABLE[sigI],
+            l: unquant(lQ, -0.8, 0.8, 5),
+            a: 0,
+            b: 0,
+            isLepton: true,
+        });
+    }
+    return { meanL: l, meanA: a, meanB: b, splats };
+}
+function getSigmaIdx(s) {
+    let minD = 100.0;
+    let idx = 0;
+    for (let i = 0; i < exports.SIGMA_TABLE.length; i++) {
+        const d = Math.abs(exports.SIGMA_TABLE[i] - s);
+        if (d < minD) {
+            minD = d;
+            idx = i;
+        }
+    }
+    return idx;
+}
+function packMean(l, a, b) {
+    const li = clampi(Math.floor(l * 63.5), 0, 63);
+    const ai = clampi(Math.floor(((a + 0.2) / 0.4) * 31.5), 0, 31);
+    const bi = clampi(Math.floor(((b + 0.2) / 0.4) * 31.5), 0, 31);
+    return (li << 10) | (ai << 5) | bi;
+}
+function unpackMean(p) {
+    const li = (p >> 10) & 0x3f;
+    const ai = (p >> 5) & 0x1f;
+    const bi = p & 0x1f;
+    return {
+        l: li / 63.0,
+        a: (ai / 31.0) * 0.4 - 0.2,
+        b: (bi / 31.0) * 0.4 - 0.2,
+    };
+}
+function quant(v, min, max, bits) {
+    const steps = (1 << bits) - 1;
+    const norm = (v - min) / (max - min);
+    return clampi(Math.round(norm * steps), 0, steps);
+}
+function unquant(v, min, max, bits) {
+    const steps = (1 << bits) - 1;
+    const norm = v / steps;
+    return norm * (max - min) + min;
+}
+function clampi(v, min, max) {
+    return v < min ? min : v > max ? max : v;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "splathash",
+  "version": "1.0.1",
+  "description": "SplatHash: compress any image to 16 bytes and reconstruct it",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/src",
+    "README.md"
+  ],
+  "keywords": [
+    "image",
+    "hash",
+    "perceptual",
+    "thumbnail",
+    "blurhash"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/junevm/splathash"
+  },
+  "scripts": {
+    "test": "tsc && node --test dist/test/test.js",
+    "build": "tsc",
+    "example": "ts-node examples/simple.ts"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/sharp": "^0.31.1",
+    "sharp": "^0.34.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0"
+  }
+}