chroma-panel 0.1.0

package/dist/image/extract.cjs

@@ -0,0 +1,98 @@
+const require_mmcq = require("./mmcq.cjs");
+//#region src/image/extract.ts
+function aborted(signal) {
+	return signal?.aborted === true;
+}
+async function toBlob(source) {
+	if (typeof source !== "string") return source;
+	const response = await fetch(source, { mode: "cors" });
+	if (!response.ok) throw new Error(`chroma-panel: could not load image (${response.status}).`);
+	return await response.blob();
+}
+async function decode(blob, size) {
+	if (typeof createImageBitmap !== "function") throw new Error("chroma-panel: this browser cannot decode images off-thread.");
+	const longest = Math.max(8, Math.round(size));
+	try {
+		const probe = await createImageBitmap(blob);
+		const wide = probe.width >= probe.height;
+		probe.close();
+		return await createImageBitmap(blob, {
+			...wide ? { resizeWidth: longest } : { resizeHeight: longest },
+			resizeQuality: "medium",
+			premultiplyAlpha: "none"
+		});
+	} catch {
+		return await createImageBitmap(blob);
+	}
+}
+function readPixels(bitmap) {
+	const { width, height } = bitmap;
+	const ctx = (typeof OffscreenCanvas === "function" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), {
+		width,
+		height
+	})).getContext("2d", { willReadFrequently: true });
+	if (ctx === null) throw new Error("chroma-panel: could not get a 2D canvas context.");
+	ctx.drawImage(bitmap, 0, 0);
+	return ctx.getImageData(0, 0, width, height).data;
+}
+function runInWorker(worker, data, maxColors, alphaThreshold, signal) {
+	return new Promise((resolve, reject) => {
+		const id = Math.random().toString(36).slice(2);
+		const cleanup = () => {
+			worker.removeEventListener("message", onMessage);
+			worker.removeEventListener("error", onError);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const onMessage = (event) => {
+			const payload = event.data;
+			if (payload.id !== id) return;
+			cleanup();
+			if (payload.error !== void 0) reject(new Error(payload.error));
+			else resolve(payload.swatches ?? []);
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(new Error(event.message));
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		worker.addEventListener("message", onMessage);
+		worker.addEventListener("error", onError);
+		signal?.addEventListener("abort", onAbort);
+		const copy = new Uint8ClampedArray(data);
+		worker.postMessage({
+			id,
+			data: copy,
+			maxColors,
+			alphaThreshold
+		}, [copy.buffer]);
+	});
+}
+async function extractPalette(source, options = {}) {
+	const { maxColors = 8, size = 100, alphaThreshold = 128, worker, signal } = options;
+	if (!Number.isFinite(maxColors) || maxColors < 2) throw new RangeError("chroma-panel: maxColors must be a number of at least 2.");
+	if (!Number.isFinite(size) || size < 8) throw new RangeError("chroma-panel: size must be a number of at least 8.");
+	if (!Number.isFinite(alphaThreshold) || alphaThreshold < 0 || alphaThreshold > 255) throw new RangeError("chroma-panel: alphaThreshold must be between 0 and 255.");
+	if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+	const blob = await toBlob(source);
+	if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+	const bitmap = await decode(blob, size);
+	let data;
+	try {
+		if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+		data = readPixels(bitmap);
+	} finally {
+		bitmap.close();
+	}
+	let sampled = 0;
+	for (let i = 3; i < data.length; i += 4) if (data[i] >= alphaThreshold) sampled++;
+	const instance = typeof worker === "function" ? worker() : worker;
+	return {
+		swatches: instance !== void 0 ? await runInWorker(instance, data, maxColors, alphaThreshold, signal) : require_mmcq.quantize(data, maxColors, alphaThreshold),
+		sampled
+	};
+}
+//#endregion
+exports.extractPalette = extractPalette;

package/dist/image/extract.d.cts

@@ -0,0 +1,16 @@
+import { QuantizedSwatch } from "./mmcq.cjs";
+//#region src/image/extract.d.ts
+export interface ExtractOptions {
+  maxColors?: number;
+  size?: number;
+  alphaThreshold?: number;
+  worker?: Worker | (() => Worker);
+  signal?: AbortSignal;
+}
+export interface ExtractResult {
+  swatches: QuantizedSwatch[];
+  sampled: number;
+}
+export declare function extractPalette(source: Blob | File | string, options?: ExtractOptions): Promise<ExtractResult>;
+//#endregion
+export type { QuantizedSwatch };

package/dist/image/extract.d.ts

@@ -0,0 +1,16 @@
+import { QuantizedSwatch } from "./mmcq.js";
+//#region src/image/extract.d.ts
+export interface ExtractOptions {
+  maxColors?: number;
+  size?: number;
+  alphaThreshold?: number;
+  worker?: Worker | (() => Worker);
+  signal?: AbortSignal;
+}
+export interface ExtractResult {
+  swatches: QuantizedSwatch[];
+  sampled: number;
+}
+export declare function extractPalette(source: Blob | File | string, options?: ExtractOptions): Promise<ExtractResult>;
+//#endregion
+export type { QuantizedSwatch };

package/dist/image/extract.js

@@ -0,0 +1,99 @@
+import { quantize } from "./mmcq.js";
+//#region src/image/extract.ts
+function aborted(signal) {
+	return signal?.aborted === true;
+}
+async function toBlob(source) {
+	if (typeof source !== "string") return source;
+	const response = await fetch(source, { mode: "cors" });
+	if (!response.ok) throw new Error(`chroma-panel: could not load image (${response.status}).`);
+	return await response.blob();
+}
+async function decode(blob, size) {
+	if (typeof createImageBitmap !== "function") throw new Error("chroma-panel: this browser cannot decode images off-thread.");
+	const longest = Math.max(8, Math.round(size));
+	try {
+		const probe = await createImageBitmap(blob);
+		const wide = probe.width >= probe.height;
+		probe.close();
+		return await createImageBitmap(blob, {
+			...wide ? { resizeWidth: longest } : { resizeHeight: longest },
+			resizeQuality: "medium",
+			premultiplyAlpha: "none"
+		});
+	} catch {
+		return await createImageBitmap(blob);
+	}
+}
+function readPixels(bitmap) {
+	const { width, height } = bitmap;
+	const ctx = (typeof OffscreenCanvas === "function" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), {
+		width,
+		height
+	})).getContext("2d", { willReadFrequently: true });
+	if (ctx === null) throw new Error("chroma-panel: could not get a 2D canvas context.");
+	ctx.drawImage(bitmap, 0, 0);
+	return ctx.getImageData(0, 0, width, height).data;
+}
+function runInWorker(worker, data, maxColors, alphaThreshold, signal) {
+	return new Promise((resolve, reject) => {
+		const id = Math.random().toString(36).slice(2);
+		const cleanup = () => {
+			worker.removeEventListener("message", onMessage);
+			worker.removeEventListener("error", onError);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const onMessage = (event) => {
+			const payload = event.data;
+			if (payload.id !== id) return;
+			cleanup();
+			if (payload.error !== void 0) reject(new Error(payload.error));
+			else resolve(payload.swatches ?? []);
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(new Error(event.message));
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		worker.addEventListener("message", onMessage);
+		worker.addEventListener("error", onError);
+		signal?.addEventListener("abort", onAbort);
+		const copy = new Uint8ClampedArray(data);
+		worker.postMessage({
+			id,
+			data: copy,
+			maxColors,
+			alphaThreshold
+		}, [copy.buffer]);
+	});
+}
+async function extractPalette(source, options = {}) {
+	const { maxColors = 8, size = 100, alphaThreshold = 128, worker, signal } = options;
+	if (!Number.isFinite(maxColors) || maxColors < 2) throw new RangeError("chroma-panel: maxColors must be a number of at least 2.");
+	if (!Number.isFinite(size) || size < 8) throw new RangeError("chroma-panel: size must be a number of at least 8.");
+	if (!Number.isFinite(alphaThreshold) || alphaThreshold < 0 || alphaThreshold > 255) throw new RangeError("chroma-panel: alphaThreshold must be between 0 and 255.");
+	if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+	const blob = await toBlob(source);
+	if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+	const bitmap = await decode(blob, size);
+	let data;
+	try {
+		if (aborted(signal)) throw new DOMException("Aborted", "AbortError");
+		data = readPixels(bitmap);
+	} finally {
+		bitmap.close();
+	}
+	let sampled = 0;
+	for (let i = 3; i < data.length; i += 4) if (data[i] >= alphaThreshold) sampled++;
+	const instance = typeof worker === "function" ? worker() : worker;
+	return {
+		swatches: instance !== void 0 ? await runInWorker(instance, data, maxColors, alphaThreshold, signal) : quantize(data, maxColors, alphaThreshold),
+		sampled
+	};
+}
+//#endregion
+export { extractPalette };
+

package/dist/image/mmcq.cjs

@@ -0,0 +1,182 @@
+//#region src/image/mmcq.ts
+const SIGBITS = 5;
+const RSHIFT = 3;
+const HIST_SIZE = 32768;
+const MAX_ITERATIONS = 1e3;
+const FRACT_BY_POPULATIONS = .75;
+function histIndex(r, g, b) {
+	return (r << 10) + (g << SIGBITS) + b;
+}
+function makeVBox(r1, r2, g1, g2, b1, b2) {
+	return {
+		r1,
+		r2,
+		g1,
+		g2,
+		b1,
+		b2,
+		count: 0,
+		countValid: false
+	};
+}
+function copyVBox(v) {
+	return makeVBox(v.r1, v.r2, v.g1, v.g2, v.b1, v.b2);
+}
+function volume(v) {
+	return (v.r2 - v.r1 + 1) * (v.g2 - v.g1 + 1) * (v.b2 - v.b1 + 1);
+}
+function count(v, histo) {
+	if (v.countValid) return v.count;
+	let total = 0;
+	for (let r = v.r1; r <= v.r2; r++) for (let g = v.g1; g <= v.g2; g++) for (let b = v.b1; b <= v.b2; b++) total += histo[histIndex(r, g, b)];
+	v.count = total;
+	v.countValid = true;
+	return total;
+}
+function average(v, h) {
+	const mult = 8;
+	let total = 0;
+	let rSum = 0;
+	let gSum = 0;
+	let bSum = 0;
+	for (let r = v.r1; r <= v.r2; r++) for (let g = v.g1; g <= v.g2; g++) for (let b = v.b1; b <= v.b2; b++) {
+		const index = histIndex(r, g, b);
+		const hval = h.counts[index];
+		if (hval === 0) continue;
+		total += hval;
+		rSum += h.rSum[index];
+		gSum += h.gSum[index];
+		bSum += h.bSum[index];
+	}
+	if (total === 0) return [
+		Math.min(255, Math.round(mult * (v.r1 + v.r2 + 1) / 2)),
+		Math.min(255, Math.round(mult * (v.g1 + v.g2 + 1) / 2)),
+		Math.min(255, Math.round(mult * (v.b1 + v.b2 + 1) / 2))
+	];
+	return [
+		Math.min(255, Math.round(rSum / total)),
+		Math.min(255, Math.round(gSum / total)),
+		Math.min(255, Math.round(bSum / total))
+	];
+}
+function medianCut(histo, vbox) {
+	if (count(vbox, histo) === 0) return [];
+	if (count(vbox, histo) === 1) return [copyVBox(vbox)];
+	const rw = vbox.r2 - vbox.r1 + 1;
+	const gw = vbox.g2 - vbox.g1 + 1;
+	const bw = vbox.b2 - vbox.b1 + 1;
+	const maxw = Math.max(rw, gw, bw);
+	const partial = /* @__PURE__ */ new Int32Array(33);
+	let total = 0;
+	const axis = maxw === rw ? "r" : maxw === gw ? "g" : "b";
+	if (axis === "r") for (let r = vbox.r1; r <= vbox.r2; r++) {
+		let sum = 0;
+		for (let g = vbox.g1; g <= vbox.g2; g++) for (let b = vbox.b1; b <= vbox.b2; b++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[r] = total;
+	}
+	else if (axis === "g") for (let g = vbox.g1; g <= vbox.g2; g++) {
+		let sum = 0;
+		for (let r = vbox.r1; r <= vbox.r2; r++) for (let b = vbox.b1; b <= vbox.b2; b++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[g] = total;
+	}
+	else for (let b = vbox.b1; b <= vbox.b2; b++) {
+		let sum = 0;
+		for (let r = vbox.r1; r <= vbox.r2; r++) for (let g = vbox.g1; g <= vbox.g2; g++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[b] = total;
+	}
+	const lo = axis === "r" ? vbox.r1 : axis === "g" ? vbox.g1 : vbox.b1;
+	const hi = axis === "r" ? vbox.r2 : axis === "g" ? vbox.g2 : vbox.b2;
+	for (let i = lo; i <= hi; i++) {
+		if (partial[i] <= total / 2) continue;
+		const left = i - lo;
+		const right = hi - i;
+		let d2 = left <= right ? Math.min(hi - 1, Math.trunc(i + right / 2)) : Math.max(lo, Math.trunc(i - 1 - left / 2));
+		while (d2 < hi && partial[d2] === 0) d2++;
+		let count2 = total - partial[d2];
+		while (count2 === 0 && d2 > lo && partial[d2 - 1] > 0) {
+			d2--;
+			count2 = total - partial[d2];
+		}
+		const a = copyVBox(vbox);
+		const b = copyVBox(vbox);
+		if (axis === "r") {
+			a.r2 = d2;
+			b.r1 = d2 + 1;
+		} else if (axis === "g") {
+			a.g2 = d2;
+			b.g1 = d2 + 1;
+		} else {
+			a.b2 = d2;
+			b.b1 = d2 + 1;
+		}
+		return [a, b];
+	}
+	return [copyVBox(vbox)];
+}
+function quantize(data, maxColors, alphaThreshold = 128) {
+	const target = Math.max(2, Math.min(256, Math.round(maxColors)));
+	const hist = {
+		counts: new Int32Array(HIST_SIZE),
+		rSum: new Int32Array(HIST_SIZE),
+		gSum: new Int32Array(HIST_SIZE),
+		bSum: new Int32Array(HIST_SIZE)
+	};
+	const histo = hist.counts;
+	let rMin = 1e9, rMax = -1, gMin = 1e9, gMax = -1, bMin = 1e9, bMax = -1;
+	let used = 0;
+	for (let i = 0; i < data.length; i += 4) {
+		if (data[i + 3] < alphaThreshold) continue;
+		const r8 = data[i];
+		const g8 = data[i + 1];
+		const b8 = data[i + 2];
+		const r = r8 >> RSHIFT;
+		const g = g8 >> RSHIFT;
+		const b = b8 >> RSHIFT;
+		const bin = histIndex(r, g, b);
+		histo[bin] = histo[bin] + 1;
+		hist.rSum[bin] = hist.rSum[bin] + r8;
+		hist.gSum[bin] = hist.gSum[bin] + g8;
+		hist.bSum[bin] = hist.bSum[bin] + b8;
+		used++;
+		if (r < rMin) rMin = r;
+		if (r > rMax) rMax = r;
+		if (g < gMin) gMin = g;
+		if (g > gMax) gMax = g;
+		if (b < bMin) bMin = b;
+		if (b > bMax) bMax = b;
+	}
+	if (used === 0) return [];
+	let boxes = [makeVBox(rMin, rMax, gMin, gMax, bMin, bMax)];
+	const split = (limit, byVolume) => {
+		let iterations = 0;
+		while (iterations++ < MAX_ITERATIONS) {
+			if (boxes.length >= limit) return;
+			boxes.sort((a, b) => byVolume ? count(a, histo) * volume(a) - count(b, histo) * volume(b) : count(a, histo) - count(b, histo));
+			const biggest = boxes.pop();
+			if (biggest === void 0) return;
+			if (count(biggest, histo) === 0) {
+				boxes.unshift(biggest);
+				return;
+			}
+			const parts = medianCut(histo, biggest);
+			if (parts.length === 0) return;
+			boxes.push(...parts);
+			if (parts.length === 1) return;
+		}
+	};
+	split(Math.max(2, Math.round(target * FRACT_BY_POPULATIONS)), false);
+	split(target, true);
+	return boxes.map((box) => {
+		const rgb = average(box, hist);
+		return {
+			rgb,
+			population: count(box, histo),
+			hex: "#" + rgb.map((c) => c.toString(16).padStart(2, "0")).join("")
+		};
+	}).filter((s) => s.population > 0).sort((a, b) => b.population - a.population);
+}
+//#endregion
+exports.quantize = quantize;

package/dist/image/mmcq.d.cts

@@ -0,0 +1,8 @@
+//#region src/image/mmcq.d.ts
+export interface QuantizedSwatch {
+  hex: string;
+  rgb: [number, number, number];
+  population: number;
+}
+export declare function quantize(data: Uint8ClampedArray, maxColors: number, alphaThreshold?: number): QuantizedSwatch[];
+//#endregion

package/dist/image/mmcq.d.ts

@@ -0,0 +1,8 @@
+//#region src/image/mmcq.d.ts
+export interface QuantizedSwatch {
+  hex: string;
+  rgb: [number, number, number];
+  population: number;
+}
+export declare function quantize(data: Uint8ClampedArray, maxColors: number, alphaThreshold?: number): QuantizedSwatch[];
+//#endregion

package/dist/image/mmcq.js

@@ -0,0 +1,183 @@
+//#region src/image/mmcq.ts
+const SIGBITS = 5;
+const RSHIFT = 3;
+const HIST_SIZE = 32768;
+const MAX_ITERATIONS = 1e3;
+const FRACT_BY_POPULATIONS = .75;
+function histIndex(r, g, b) {
+	return (r << 10) + (g << SIGBITS) + b;
+}
+function makeVBox(r1, r2, g1, g2, b1, b2) {
+	return {
+		r1,
+		r2,
+		g1,
+		g2,
+		b1,
+		b2,
+		count: 0,
+		countValid: false
+	};
+}
+function copyVBox(v) {
+	return makeVBox(v.r1, v.r2, v.g1, v.g2, v.b1, v.b2);
+}
+function volume(v) {
+	return (v.r2 - v.r1 + 1) * (v.g2 - v.g1 + 1) * (v.b2 - v.b1 + 1);
+}
+function count(v, histo) {
+	if (v.countValid) return v.count;
+	let total = 0;
+	for (let r = v.r1; r <= v.r2; r++) for (let g = v.g1; g <= v.g2; g++) for (let b = v.b1; b <= v.b2; b++) total += histo[histIndex(r, g, b)];
+	v.count = total;
+	v.countValid = true;
+	return total;
+}
+function average(v, h) {
+	const mult = 8;
+	let total = 0;
+	let rSum = 0;
+	let gSum = 0;
+	let bSum = 0;
+	for (let r = v.r1; r <= v.r2; r++) for (let g = v.g1; g <= v.g2; g++) for (let b = v.b1; b <= v.b2; b++) {
+		const index = histIndex(r, g, b);
+		const hval = h.counts[index];
+		if (hval === 0) continue;
+		total += hval;
+		rSum += h.rSum[index];
+		gSum += h.gSum[index];
+		bSum += h.bSum[index];
+	}
+	if (total === 0) return [
+		Math.min(255, Math.round(mult * (v.r1 + v.r2 + 1) / 2)),
+		Math.min(255, Math.round(mult * (v.g1 + v.g2 + 1) / 2)),
+		Math.min(255, Math.round(mult * (v.b1 + v.b2 + 1) / 2))
+	];
+	return [
+		Math.min(255, Math.round(rSum / total)),
+		Math.min(255, Math.round(gSum / total)),
+		Math.min(255, Math.round(bSum / total))
+	];
+}
+function medianCut(histo, vbox) {
+	if (count(vbox, histo) === 0) return [];
+	if (count(vbox, histo) === 1) return [copyVBox(vbox)];
+	const rw = vbox.r2 - vbox.r1 + 1;
+	const gw = vbox.g2 - vbox.g1 + 1;
+	const bw = vbox.b2 - vbox.b1 + 1;
+	const maxw = Math.max(rw, gw, bw);
+	const partial = /* @__PURE__ */ new Int32Array(33);
+	let total = 0;
+	const axis = maxw === rw ? "r" : maxw === gw ? "g" : "b";
+	if (axis === "r") for (let r = vbox.r1; r <= vbox.r2; r++) {
+		let sum = 0;
+		for (let g = vbox.g1; g <= vbox.g2; g++) for (let b = vbox.b1; b <= vbox.b2; b++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[r] = total;
+	}
+	else if (axis === "g") for (let g = vbox.g1; g <= vbox.g2; g++) {
+		let sum = 0;
+		for (let r = vbox.r1; r <= vbox.r2; r++) for (let b = vbox.b1; b <= vbox.b2; b++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[g] = total;
+	}
+	else for (let b = vbox.b1; b <= vbox.b2; b++) {
+		let sum = 0;
+		for (let r = vbox.r1; r <= vbox.r2; r++) for (let g = vbox.g1; g <= vbox.g2; g++) sum += histo[histIndex(r, g, b)];
+		total += sum;
+		partial[b] = total;
+	}
+	const lo = axis === "r" ? vbox.r1 : axis === "g" ? vbox.g1 : vbox.b1;
+	const hi = axis === "r" ? vbox.r2 : axis === "g" ? vbox.g2 : vbox.b2;
+	for (let i = lo; i <= hi; i++) {
+		if (partial[i] <= total / 2) continue;
+		const left = i - lo;
+		const right = hi - i;
+		let d2 = left <= right ? Math.min(hi - 1, Math.trunc(i + right / 2)) : Math.max(lo, Math.trunc(i - 1 - left / 2));
+		while (d2 < hi && partial[d2] === 0) d2++;
+		let count2 = total - partial[d2];
+		while (count2 === 0 && d2 > lo && partial[d2 - 1] > 0) {
+			d2--;
+			count2 = total - partial[d2];
+		}
+		const a = copyVBox(vbox);
+		const b = copyVBox(vbox);
+		if (axis === "r") {
+			a.r2 = d2;
+			b.r1 = d2 + 1;
+		} else if (axis === "g") {
+			a.g2 = d2;
+			b.g1 = d2 + 1;
+		} else {
+			a.b2 = d2;
+			b.b1 = d2 + 1;
+		}
+		return [a, b];
+	}
+	return [copyVBox(vbox)];
+}
+function quantize(data, maxColors, alphaThreshold = 128) {
+	const target = Math.max(2, Math.min(256, Math.round(maxColors)));
+	const hist = {
+		counts: new Int32Array(HIST_SIZE),
+		rSum: new Int32Array(HIST_SIZE),
+		gSum: new Int32Array(HIST_SIZE),
+		bSum: new Int32Array(HIST_SIZE)
+	};
+	const histo = hist.counts;
+	let rMin = 1e9, rMax = -1, gMin = 1e9, gMax = -1, bMin = 1e9, bMax = -1;
+	let used = 0;
+	for (let i = 0; i < data.length; i += 4) {
+		if (data[i + 3] < alphaThreshold) continue;
+		const r8 = data[i];
+		const g8 = data[i + 1];
+		const b8 = data[i + 2];
+		const r = r8 >> RSHIFT;
+		const g = g8 >> RSHIFT;
+		const b = b8 >> RSHIFT;
+		const bin = histIndex(r, g, b);
+		histo[bin] = histo[bin] + 1;
+		hist.rSum[bin] = hist.rSum[bin] + r8;
+		hist.gSum[bin] = hist.gSum[bin] + g8;
+		hist.bSum[bin] = hist.bSum[bin] + b8;
+		used++;
+		if (r < rMin) rMin = r;
+		if (r > rMax) rMax = r;
+		if (g < gMin) gMin = g;
+		if (g > gMax) gMax = g;
+		if (b < bMin) bMin = b;
+		if (b > bMax) bMax = b;
+	}
+	if (used === 0) return [];
+	let boxes = [makeVBox(rMin, rMax, gMin, gMax, bMin, bMax)];
+	const split = (limit, byVolume) => {
+		let iterations = 0;
+		while (iterations++ < MAX_ITERATIONS) {
+			if (boxes.length >= limit) return;
+			boxes.sort((a, b) => byVolume ? count(a, histo) * volume(a) - count(b, histo) * volume(b) : count(a, histo) - count(b, histo));
+			const biggest = boxes.pop();
+			if (biggest === void 0) return;
+			if (count(biggest, histo) === 0) {
+				boxes.unshift(biggest);
+				return;
+			}
+			const parts = medianCut(histo, biggest);
+			if (parts.length === 0) return;
+			boxes.push(...parts);
+			if (parts.length === 1) return;
+		}
+	};
+	split(Math.max(2, Math.round(target * FRACT_BY_POPULATIONS)), false);
+	split(target, true);
+	return boxes.map((box) => {
+		const rgb = average(box, hist);
+		return {
+			rgb,
+			population: count(box, histo),
+			hex: "#" + rgb.map((c) => c.toString(16).padStart(2, "0")).join("")
+		};
+	}).filter((s) => s.population > 0).sort((a, b) => b.population - a.population);
+}
+//#endregion
+export { quantize };
+