@eightshift/ui-components 6.3.0 → 7.0.0

package/dist/general-D-7dwhuF.js

@@ -0,0 +1,4277 @@
+import { cyrb64Hash } from "./utilities/hash.js";
+//#region node_modules/@thi.ng/pixel/api.js
+var Lane = ((Lane2) => {
+	Lane2[Lane2["ALPHA"] = 0] = "ALPHA";
+	Lane2[Lane2["BLUE"] = 1] = "BLUE";
+	Lane2[Lane2["GREEN"] = 2] = "GREEN";
+	Lane2[Lane2["RED"] = 3] = "RED";
+	return Lane2;
+})(Lane || {});
+var ROT_IDS = [
+	"rotateCW",
+	"rotate180",
+	"rotateCCW"
+];
+//#endregion
+//#region node_modules/@thi.ng/canvas/index.js
+var adaptiveCanvas2d = (width, height = width, parent, opts = {}) => {
+	const canvas = document.createElement("canvas");
+	adaptDPI(canvas, width, height, opts.dpr);
+	opts.pixelated && (canvas.style.imageRendering = "pixelated");
+	parent?.appendChild(canvas);
+	return {
+		canvas,
+		ctx: canvas.getContext("2d", opts.ctx)
+	};
+};
+var canvas2d = (width, height = width, parent, opts) => adaptiveCanvas2d(width, height, parent, {
+	dpr: 1,
+	...opts
+});
+var adaptDPI = (canvas, width, height, dpr = window.devicePixelRatio || 1) => {
+	if (dpr !== 1) {
+		canvas.style.width = `${width}px`;
+		canvas.style.height = `${height}px`;
+	}
+	canvas.dataset.origWidth = String(width);
+	canvas.dataset.origHeight = String(height);
+	canvas.dataset.dpr = String(dpr);
+	canvas.width = width * dpr;
+	canvas.height = height * dpr;
+	return dpr;
+};
+//#endregion
+//#region node_modules/@thi.ng/checks/is-number.js
+var isNumber = (x) => typeof x === "number";
+//#endregion
+//#region node_modules/@thi.ng/pixel/canvas.js
+function canvasPixels(width, height, parent, opts) {
+	let canvas;
+	let ctx;
+	if (isNumber(width)) {
+		const c = canvas2d(width, height, parent, opts);
+		canvas = c.canvas;
+		ctx = c.ctx;
+	} else {
+		canvas = width;
+		ctx = canvas.getContext("2d");
+	}
+	if (parent && canvas instanceof HTMLCanvasElement) parent.appendChild(canvas);
+	const img = ctx.getImageData(0, 0, canvas.width, canvas.height);
+	const data = new Uint32Array(img.data.buffer);
+	return {
+		canvas,
+		ctx,
+		img,
+		data
+	};
+}
+//#endregion
+//#region node_modules/@thi.ng/api/decorators/nomixin.js
+var nomixin = (_, __, descriptor) => {
+	descriptor.configurable = false;
+};
+//#endregion
+//#region node_modules/@thi.ng/api/mixin.js
+var mixin = (behaviour, sharedBehaviour = {}) => {
+	const instanceKeys = Reflect.ownKeys(behaviour);
+	const sharedKeys = Reflect.ownKeys(sharedBehaviour);
+	const typeTag = Symbol("isa");
+	function _mixin(clazz) {
+		for (const key of instanceKeys) {
+			const existing = Object.getOwnPropertyDescriptor(clazz.prototype, key);
+			if (!existing || existing.configurable) Object.defineProperty(clazz.prototype, key, {
+				value: behaviour[key],
+				writable: true
+			});
+		}
+		Object.defineProperty(clazz.prototype, typeTag, { value: true });
+		return clazz;
+	}
+	for (const key of sharedKeys) Object.defineProperty(_mixin, key, {
+		value: sharedBehaviour[key],
+		enumerable: sharedBehaviour.propertyIsEnumerable(key)
+	});
+	Object.defineProperty(_mixin, Symbol.hasInstance, { value: (x) => !!x[typeTag] });
+	return _mixin;
+};
+//#endregion
+//#region node_modules/@thi.ng/api/mixins/igrid.js
+var IGrid1DMixin = mixin({
+	order() {
+		return [0];
+	},
+	includes(x) {
+		return x >= 0 && x < this.size[0];
+	},
+	indexAt(x) {
+		return this.includes(x) ? this.indexAtUnsafe(x) : -1;
+	},
+	indexAtUnsafe(x) {
+		return this.offset + (x | 0) * this.stride[0];
+	},
+	getAt(x) {
+		return this.includes(x) ? this.data[this.indexAtUnsafe(x)] : 0;
+	},
+	getAtUnsafe(x) {
+		return this.data[this.indexAtUnsafe(x)];
+	},
+	setAt(x, val) {
+		return this.includes(x) ? (this.data[this.indexAtUnsafe(x)] = val, true) : false;
+	},
+	setAtUnsafe(x, val) {
+		this.data[this.indexAtUnsafe(x)] = val;
+		return true;
+	}
+});
+var IGrid2DMixin = mixin({
+	order() {
+		return Math.abs(this.stride[1]) > Math.abs(this.stride[0]) ? [1, 0] : [0, 1];
+	},
+	includes(x, y) {
+		const size = this.size;
+		return x >= 0 && x < size[0] && y >= 0 && y < size[1];
+	},
+	indexAt(x, y) {
+		return this.includes(x, y) ? this.indexAtUnsafe(x, y) : -1;
+	},
+	indexAtUnsafe(x, y) {
+		return this.offset + (x | 0) * this.stride[0] + (y | 0) * this.stride[1];
+	},
+	getAt(x, y) {
+		return this.includes(x, y) ? this.data[this.indexAtUnsafe(x, y)] : 0;
+	},
+	getAtUnsafe(x, y) {
+		return this.data[this.indexAtUnsafe(x, y)];
+	},
+	setAt(x, y, val) {
+		return this.includes(x, y) ? (this.data[this.indexAtUnsafe(x, y)] = val, true) : false;
+	},
+	setAtUnsafe(x, y, val) {
+		this.data[this.indexAtUnsafe(x, y)] = val;
+		return true;
+	}
+});
+var IGrid3DMixin = mixin({
+	order() {
+		return __strideOrder(this.stride);
+	},
+	includes(x, y, z) {
+		const size = this.size;
+		return x >= 0 && x < size[0] && y >= 0 && y < size[1] && z >= 0 && z < size[2];
+	},
+	indexAt(x, y, z) {
+		return this.includes(x, y, z) ? this.indexAtUnsafe(x, y, z) : -1;
+	},
+	indexAtUnsafe(x, y, z) {
+		const stride = this.stride;
+		return this.offset + (x | 0) * stride[0] + (y | 0) * stride[1] + (z | 0) * stride[2];
+	},
+	getAt(x, y, z) {
+		return this.includes(x, y, z) ? this.data[this.indexAtUnsafe(x, y, z)] : 0;
+	},
+	getAtUnsafe(x, y, z) {
+		return this.data[this.indexAtUnsafe(x, y, z)];
+	},
+	setAt(x, y, z, val) {
+		return this.includes(x, y, z) ? (this.data[this.indexAtUnsafe(x, y, z)] = val, true) : false;
+	},
+	setAtUnsafe(x, y, z, val) {
+		this.data[this.indexAtUnsafe(x, y, z)] = val;
+		return true;
+	}
+});
+var IGrid4DMixin = mixin({
+	order() {
+		return __strideOrder(this.stride);
+	},
+	includes(x, y, z, w) {
+		const size = this.size;
+		return x >= 0 && x < size[0] && y >= 0 && y < size[1] && z >= 0 && z < size[2] && w >= 0 && w < size[3];
+	},
+	indexAt(x, y, z, w) {
+		return this.includes(x, y, z, w) ? this.indexAtUnsafe(x, y, z, w) : -1;
+	},
+	indexAtUnsafe(x, y, z, w) {
+		const stride = this.stride;
+		return this.offset + (x | 0) * stride[0] + (y | 0) * stride[1] + (z | 0) * stride[2] + (w | 0) * stride[3];
+	},
+	getAt(x, y, z, w) {
+		return this.includes(x, y, z, w) ? this.data[this.indexAtUnsafe(x, y, z, w)] : 0;
+	},
+	getAtUnsafe(x, y, z, w) {
+		return this.data[this.indexAtUnsafe(x, y, z, w)];
+	},
+	setAt(x, y, z, w, val) {
+		return this.includes(x, y, z, w) ? (this.data[this.indexAtUnsafe(x, y, z, w)] = val, true) : false;
+	},
+	setAtUnsafe(x, y, z, w, val) {
+		this.data[this.indexAtUnsafe(x, y, z, w)] = val;
+		return true;
+	}
+});
+var __strideOrder = (strides) => [...strides].map((x, i) => [x, i]).sort((a, b) => Math.abs(b[0]) - Math.abs(a[0])).map((x) => x[1]);
+//#endregion
+//#region node_modules/@thi.ng/checks/is-string.js
+var isString = (x) => typeof x === "string";
+//#endregion
+//#region node_modules/@thi.ng/errors/deferror.js
+var defError = (prefix, suffix = (msg) => msg !== void 0 ? ": " + msg : "") => class extends Error {
+	origMessage;
+	constructor(msg) {
+		super(prefix(msg) + suffix(msg));
+		this.origMessage = msg !== void 0 ? String(msg) : "";
+	}
+};
+//#endregion
+//#region node_modules/@thi.ng/errors/assert.js
+var AssertionError = defError(() => "Assertion failed");
+var assert = (typeof process !== "undefined" && process.env !== void 0 ? process.env.NODE_ENV !== "production" || !!process.env.UMBRELLA_ASSERTS : false) ? (test, msg) => {
+	if (typeof test === "function" && !test() || !test) throw new AssertionError(typeof msg === "function" ? msg() : msg);
+} : () => {};
+//#endregion
+//#region node_modules/@thi.ng/math/interval.js
+var clamp$1 = (x, min, max) => x < min ? min : x > max ? max : x;
+var clamp0 = (x) => x > 0 ? x : 0;
+var clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+//#endregion
+//#region node_modules/@thi.ng/porter-duff/utils.js
+var setC4$1 = (out, a, b, c, d) => (out[0] = a, out[1] = b, out[2] = c, out[3] = d, out);
+var setV4 = (out, a) => setC4$1(out, a[0], a[1], a[2], a[3]);
+//#endregion
+//#region node_modules/@thi.ng/porter-duff/premultiply.js
+var premultiply = (out, src) => {
+	const a = src[3];
+	return setC4$1(out || src, src[0] * a, src[1] * a, src[2] * a, a);
+};
+var premultiplyInt = (src) => {
+	const a = (src >>> 24) / 255;
+	return src & 4278190080 | (src >>> 16 & 255) * a << 16 | (src >>> 8 & 255) * a << 8 | (src & 255) * a;
+};
+var postmultiply = (out, src) => {
+	const a = src[3];
+	return a > 0 ? setC4$1(out || src, src[0] / a, src[1] / a, src[2] / a, a) : out && out != src ? setV4(out, src) : src;
+};
+var postmultiplyInt = (src) => {
+	const a = (src >>> 24) / 255;
+	return a > 0 ? (src & 4278190080 | Math.min(255, (src >>> 16 & 255) / a) << 16 | Math.min(255, (src >>> 8 & 255) / a) << 8 | Math.min(255, (src & 255) / a)) >>> 0 : src;
+};
+var isPremultiplied = (src) => {
+	const a = src[3];
+	return src[0] <= a && src[1] <= a || src[2] <= a;
+};
+var isPremultipliedInt = (src) => {
+	const a = src >>> 24;
+	return (src >>> 16 & 255) <= a && (src >>> 8 & 255) <= a && (src & 255) <= a;
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel/checks.js
+var ensureSize = (data, width, height, stride = 1) => assert(data.length >= width * height * stride, "pixel buffer too small");
+var ensureImageData = (data, width, height) => data ? (ensureImageDataSize(data, width, height), data) : new ImageData(width, height);
+var ensureImageDataSize = (data, width, height) => assert(data.width === width && data.height === height, "imagedata has wrong dimensions");
+var ensureChannel = (fmt, id) => {
+	const chan = fmt.channels[id];
+	assert(chan != null, `invalid channel ID: ${id}`);
+	return chan;
+};
+var ensureAlpha = (fmt) => assert(!!fmt.alpha, "missing alpha channel");
+//#endregion
+//#region node_modules/@thi.ng/api/fn.js
+var identity$1 = (x) => x;
+//#endregion
+//#region node_modules/@thi.ng/pixel/internal/utils.js
+var __luminanceABGR = (c) => ((c >>> 16 & 255) * 29 + (c >>> 8 & 255) * 150 + (c & 255) * 76) / 255;
+var __clampRegion = (sx, sy, w, h, maxw, maxh, dx = 0, dy = 0) => {
+	sx |= 0;
+	sy |= 0;
+	w |= 0;
+	h |= 0;
+	sx < 0 && (w += sx, dx -= sx, sx = 0);
+	sy < 0 && (h += sy, dy -= sy, sy = 0);
+	return [
+		sx,
+		sy,
+		clamp$1(w, 0, maxw - sx),
+		clamp$1(h, 0, maxh - sy),
+		dx,
+		dy
+	];
+};
+var __prepRegions = (src, dest, opts = {}) => {
+	const sw = src.width;
+	const dw = dest.width;
+	let sx, sy;
+	let dx, dy;
+	let rw, rh;
+	[sx, sy, rw, rh] = __clampRegion(opts.sx || 0, opts.sy || 0, opts.w || sw, opts.h || src.height, sw, src.height);
+	[dx, dy, rw, rh, sx, sy] = __clampRegion(opts.dx || 0, opts.dy || 0, rw, rh, dw, dest.height, sx, sy);
+	return {
+		sx,
+		sy,
+		dx,
+		dy,
+		rw,
+		rh
+	};
+};
+var __setChannelUni = (dbuf, src, set) => {
+	for (let i = dbuf.length; i-- > 0;) dbuf[i] = set(dbuf[i], src);
+};
+var __setChannelSame = (dbuf, sbuf, get, set) => {
+	for (let i = dbuf.length; i-- > 0;) dbuf[i] = set(dbuf[i], get(sbuf[i]));
+};
+var __setChannelConvert = (dbuf, sbuf, from, sto, mask) => {
+	const invMask = ~mask;
+	for (let i = dbuf.length; i-- > 0;) dbuf[i] = dbuf[i] & invMask | from(sto(sbuf[i])) & mask;
+};
+var __transformABGR = (pix, format, fn) => {
+	const from = format.fromABGR;
+	const to = format.toABGR;
+	for (let i = pix.length; i-- > 0;) pix[i] = from(fn(to(pix[i])));
+};
+var __blitCanvas = (buf, canvas, opts = {}) => (canvas instanceof HTMLCanvasElement || canvas instanceof OffscreenCanvas ? canvas.getContext("2d") : canvas).putImageData(buf.toImageData(opts.data), opts.x || 0, opts.y || 0);
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/float-format.js
+var defFloatFormat = (fmt) => {
+	const chan = fmt.channels;
+	const chanShift = chan.reduce((acc, ch) => (acc[ch] = 3 - ch << 3, acc), {});
+	const res = {
+		...fmt,
+		__float: true,
+		size: chan.length,
+		shift: chanShift,
+		range: [0, 1],
+		normalized: clamp01,
+		fromNormalized: identity$1
+	};
+	if (fmt.convert) {
+		Object.assign(res, fmt.convert);
+		return res;
+	}
+	const to = (col, i) => (clamp01(col[i]) * 255 + .5 | 0) << chanShift[chan[i]];
+	const from = (col, i) => (col >>> chanShift[chan[i]] & 255) / 255;
+	switch (chan.length) {
+		case 1:
+			fmt.gray ? __defConvert1Gray(res) : __defConvert1(res, from, to);
+			break;
+		case 2:
+			fmt.gray ? __defConvert2Gray(res, from) : __defConvert2(res, from, to);
+			break;
+		case 3:
+			__defConvert3(res, from, to);
+			break;
+		case 4:
+			__defConvert4(res, from, to);
+			break;
+	}
+	return res;
+};
+var __defConvert1 = (res, from, to) => {
+	res.toABGR = (col) => {
+		let out = res.alpha ? 0 : 4278190080;
+		out |= to(col, 0);
+		return out >>> 0;
+	};
+	res.fromABGR = (col, out = []) => {
+		out[0] = from(col, 0);
+		return out;
+	};
+};
+var __defConvert1Gray = (res) => {
+	res.toABGR = (col) => ((clamp01(col[0]) * 255 + .5 | 0) * 65793 | 4278190080) >>> 0;
+	res.fromABGR = (col, out = []) => (out[0] = __luminanceABGR(col) / 255, out);
+};
+var __defConvert2 = (res, from, to) => {
+	res.toABGR = (col) => {
+		let out = res.alpha ? 0 : 4278190080;
+		out |= to(col, 0);
+		out |= to(col, 1);
+		return out >>> 0;
+	};
+	res.fromABGR = (col, out = []) => {
+		out[0] = from(col, 0);
+		out[1] = from(col, 1);
+		return out;
+	};
+};
+var __defConvert2Gray = (res, from) => {
+	const gray = ~~(res.channels[0] === Lane.ALPHA);
+	const alpha = gray ^ 1;
+	res.toABGR = (col) => {
+		let out = (clamp01(col[gray]) * 255 + .5 | 0) * 65793;
+		out |= (col[alpha] * 255 + .5 | 0) << 24;
+		return out >>> 0;
+	};
+	res.fromABGR = (col, out = []) => {
+		out[gray] = __luminanceABGR(col) / 255;
+		out[alpha] = from(col, alpha);
+		return out;
+	};
+};
+var __defConvert3 = (res, from, to) => {
+	res.toABGR = (col) => {
+		let out = res.alpha ? 0 : 4278190080;
+		out |= to(col, 0);
+		out |= to(col, 1);
+		out |= to(col, 2);
+		return out >>> 0;
+	};
+	res.fromABGR = (col, out = []) => {
+		out[0] = from(col, 0);
+		out[1] = from(col, 1);
+		out[2] = from(col, 2);
+		return out;
+	};
+};
+var __defConvert4 = (res, from, to) => {
+	res.toABGR = (col) => {
+		let out = res.alpha ? 0 : 4278190080;
+		out |= to(col, 0);
+		out |= to(col, 1);
+		out |= to(col, 2);
+		out |= to(col, 3);
+		return out >>> 0;
+	};
+	res.fromABGR = (col, out = []) => {
+		out[0] = from(col, 0);
+		out[1] = from(col, 1);
+		out[2] = from(col, 2);
+		out[3] = from(col, 3);
+		return out;
+	};
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/float-gray.js
+var FLOAT_GRAY = defFloatFormat({
+	gray: true,
+	channels: [Lane.RED]
+});
+//#endregion
+//#region node_modules/@thi.ng/api/typedarray.js
+var GL2TYPE = {
+	[5120]: "i8",
+	[5121]: "u8",
+	[5122]: "i16",
+	[5123]: "u16",
+	[5124]: "i32",
+	[5125]: "u32",
+	[5126]: "f32"
+};
+var FLOAT_ARRAY_CTORS = {
+	f32: Float32Array,
+	f64: Float64Array
+};
+var INT_ARRAY_CTORS = {
+	i8: Int8Array,
+	i16: Int16Array,
+	i32: Int32Array
+};
+var UINT_ARRAY_CTORS = {
+	u8: Uint8Array,
+	u8c: Uint8ClampedArray,
+	u16: Uint16Array,
+	u32: Uint32Array
+};
+var BIGINT_ARRAY_CTORS = {
+	i64: BigInt64Array,
+	u64: BigUint64Array
+};
+var TYPEDARRAY_CTORS = {
+	...FLOAT_ARRAY_CTORS,
+	...INT_ARRAY_CTORS,
+	...UINT_ARRAY_CTORS
+};
+var asNativeType = (type) => {
+	const t = GL2TYPE[type];
+	return t !== void 0 ? t : type;
+};
+function typedArray(type, ...args) {
+	return new (BIGINT_ARRAY_CTORS[type] || TYPEDARRAY_CTORS[asNativeType(type)])(...args);
+}
+var uintTypeForBits = (x) => x > 16 ? "u32" : x > 8 ? "u16" : "u8";
+//#endregion
+//#region node_modules/@thi.ng/pixel/internal/codegen.js
+var __compileLShift = (x, shift) => shift > 0 ? `(${x} << ${shift})` : shift < 0 ? `(${x} >>> ${-shift})` : `${x}`;
+var __compileRShift = (x, shift) => __compileLShift(x, -shift);
+var __hex = (x) => `0x${x.toString(16)}`;
+var __compileGrayFromABGR = (size) => {
+	const shift = 8 - size;
+	const mask = (1 << size) - 1;
+	return new Function("luma", `return (x) => ${__compileRShift("luma(x)", shift)} & ${mask};`)(__luminanceABGR);
+};
+var __compileGrayToABGR = (size) => {
+	let body;
+	if (size !== 8) {
+		const mask = (1 << size) - 1;
+		body = `(((x & ${mask}) * ${255 / mask}) | 0)`;
+	} else body = "x";
+	return new Function("x", `return 0xff000000 | (${body} * 0x010101);`);
+};
+var __compileFromABGR = (chans) => new Function("x", "return (" + chans.map((ch) => {
+	return `(${__compileRShift("x", ch.abgrShift + (8 - ch.size))} & ${__hex(ch.maskA)})`;
+}).join(" | ") + ") >>> 0;");
+var __compileToABGR = (chans, hasAlpha) => {
+	const body = chans.map((ch) => {
+		if (ch.size !== 8) {
+			const mask = ch.mask0;
+			const scale = 255 / mask;
+			return __compileLShift(`((${__compileRShift("x", ch.shift)} & ${mask}) * ${scale})`, 24 - ch.lane * 8);
+		} else return __compileLShift(`(x & ${__hex(ch.maskA)})`, ch.abgrShift);
+	}).join(" | ");
+	const alpha = !hasAlpha ? `0xff000000 | ` : "";
+	return new Function("x", `return (${alpha}${body}) >>> 0;`);
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/int-format.js
+var __defChannel = (ch, idx, shift) => {
+	const num = 1 << ch.size;
+	const mask0 = num - 1;
+	const maskA = mask0 << shift >>> 0;
+	const invMask = ~maskA >>> 0;
+	const lane = ch.lane != null ? ch.lane : idx;
+	const int = (x) => x >>> shift & mask0;
+	const setInt = (src, x) => src & invMask | (x & mask0) << shift;
+	return {
+		size: ch.size,
+		num,
+		abgrShift: 24 - lane * 8 - shift,
+		lane,
+		shift,
+		mask0,
+		maskA,
+		int,
+		setInt,
+		float: (x) => int(x) / mask0,
+		setFloat: (src, x) => setInt(src, clamp01(x) * mask0)
+	};
+};
+var defIntFormat = (fmt) => {
+	assert(fmt.channels.length > 0, "no channel specs given");
+	const channels = fmt.channels.reduce(([defs, shift], ch, i) => {
+		shift -= ch.size;
+		defs.push(__defChannel(ch, i, shift));
+		return [defs, shift];
+	}, [[], fmt.size])[0];
+	return {
+		__packed: true,
+		type: fmt.type,
+		size: fmt.size,
+		alpha: fmt.alpha || 0,
+		channels,
+		fromABGR: fmt.fromABGR || __compileFromABGR(channels),
+		toABGR: fmt.toABGR || __compileToABGR(channels, !!fmt.alpha)
+	};
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/abgr8888.js
+var ABGR8888 = defIntFormat({
+	type: "u32",
+	size: 32,
+	alpha: 8,
+	channels: [
+		{
+			size: 8,
+			lane: Lane.ALPHA
+		},
+		{
+			size: 8,
+			lane: Lane.BLUE
+		},
+		{
+			size: 8,
+			lane: Lane.GREEN
+		},
+		{
+			size: 8,
+			lane: Lane.RED
+		}
+	],
+	fromABGR: identity$1,
+	toABGR: identity$1
+});
+//#endregion
+//#region node_modules/@thi.ng/math/api.js
+var PI = Math.PI;
+var TAU = PI * 2;
+var HALF_PI = PI / 2;
+var THIRD_PI = PI / 3;
+var QUARTER_PI = PI / 4;
+var SIXTH_PI = PI / 6;
+var INV_PI = 1 / PI;
+var INV_TAU = 1 / TAU;
+var INV_HALF_PI = 1 / HALF_PI;
+var DEG2RAD = PI / 180;
+var RAD2DEG = 180 / PI;
+var PHI = (1 + Math.sqrt(5)) / 2;
+var SQRT2 = Math.SQRT2;
+var SQRT3 = Math.sqrt(3);
+var SQRT2_2 = SQRT2 / 2;
+var SQRT3_2 = SQRT3 / 2;
+var THIRD = 1 / 3;
+var TWO_THIRD = 2 / 3;
+var SIXTH = 1 / 6;
+var EPS$1 = 1e-6;
+//#endregion
+//#region node_modules/@thi.ng/math/mix.js
+var mixBilinear = (a, b, c, d, u, v) => {
+	const iu = 1 - u;
+	const iv = 1 - v;
+	return a * iu * iv + b * u * iv + c * iu * v + d * u * v;
+};
+var mixCubicHermiteFromPoints = (a, b, c, d, t) => {
+	d *= .5;
+	const aa = -.5 * a + 1.5 * b - 1.5 * c + d;
+	const bb = a - 2.5 * b + 2 * c - d;
+	const cc = -.5 * a + .5 * c;
+	const dd = b;
+	const t2 = t * t;
+	return t * t2 * aa + t2 * bb + t * cc + dd;
+};
+var mixBicubic = (s00, s01, s02, s03, s10, s11, s12, s13, s20, s21, s22, s23, s30, s31, s32, s33, u, v) => mixCubicHermiteFromPoints(mixCubicHermiteFromPoints(s00, s01, s02, s03, u), mixCubicHermiteFromPoints(s10, s11, s12, s13, u), mixCubicHermiteFromPoints(s20, s21, s22, s23, u), mixCubicHermiteFromPoints(s30, s31, s32, s33, u), v);
+//#endregion
+//#region node_modules/@thi.ng/math/prec.js
+var mod = (a, b) => a - b * Math.floor(a / b);
+var fract = (x) => x - Math.floor(x);
+var roundTo = (x, prec = 1) => Math.round(x / prec) * prec;
+//#endregion
+//#region node_modules/@thi.ng/pixel/sample.js
+function defSampler(src, filter = "linear", wrap = "clamp") {
+	const isFloat = !!src.format.__float;
+	const suffix = src.format.channels.length === 1 ? "1" : "";
+	const id = `${filter[0]}${wrap[0]}${suffix}`;
+	const impl = (isFloat ? {
+		nc1: __sampleFNC,
+		nw1: __sampleFNW,
+		nr1: __sampleFNR,
+		nc: __sampleFNC,
+		nw: __sampleFNW,
+		nr: __sampleFNR,
+		lc1: (src2) => __bilinearGrayF(__sampleINC(src2)),
+		lw1: (src2) => __bilinearGrayF(__sampleINW(src2)),
+		lr1: (src2) => __bilinearGrayF(__sampleINR(src2)),
+		lc: (src2) => __bilinearFloat(src2, __sampleFNC(src2)),
+		lw: (src2) => __bilinearFloat(src2, __sampleFNW(src2)),
+		lr: (src2) => __bilinearFloat(src2, __sampleFNR(src2)),
+		cc1: (src2) => __bicubicGrayF(__sampleINC(src2)),
+		cw1: (src2) => __bicubicGrayF(__sampleINW(src2)),
+		cr1: (src2) => __bicubicGrayF(__sampleINR(src2)),
+		cc: (src2) => __bicubicFloat(src2, __sampleFNC(src2)),
+		cw: (src2) => __bicubicFloat(src2, __sampleFNW(src2)),
+		cr: (src2) => __bicubicFloat(src2, __sampleFNR(src2))
+	} : {
+		nc1: __sampleINC,
+		nw1: __sampleINW,
+		nr1: __sampleINR,
+		nc: __sampleINC,
+		nw: __sampleINW,
+		nr: __sampleINR,
+		lc1: (src2) => __bilinearGray(__sampleINC(src2)),
+		lw1: (src2) => __bilinearGray(__sampleINW(src2)),
+		lr1: (src2) => __bilinearGray(__sampleINR(src2)),
+		lc: (src2) => __bilinearABGR(src2, __sampleINC(src2)),
+		lw: (src2) => __bilinearABGR(src2, __sampleINW(src2)),
+		lr: (src2) => __bilinearABGR(src2, __sampleINR(src2)),
+		cc1: (src2) => __bicubicGrayI(src2, __sampleINC(src2)),
+		cw1: (src2) => __bicubicGrayI(src2, __sampleINW(src2)),
+		cr1: (src2) => __bicubicGrayI(src2, __sampleINR(src2)),
+		cc: (src2) => __bicubicABGR(src2, __sampleINC(src2)),
+		cw: (src2) => __bicubicABGR(src2, __sampleINW(src2)),
+		cr: (src2) => __bicubicABGR(src2, __sampleINR(src2))
+	})[id];
+	assert(!!impl, `missing impl for ${id}`);
+	return impl(src);
+}
+var __sampleINC = ({ data, width, height }) => (x, y) => x >= 0 && x < width && y >= 0 && y < height ? data[(y | 0) * width + (x | 0)] : 0;
+var __sampleINW = ({ data, width, height }) => (x, y) => data[mod(y | 0, height) * width + mod(x | 0, width)];
+var __sampleINR = ({ data, width, height }) => {
+	const w1 = width - 1;
+	const h1 = height - 1;
+	return (x, y) => data[clamp$1(y | 0, 0, h1) * width + clamp$1(x | 0, 0, w1)];
+};
+var __sampleFNC = ({ data, width, height, stride: [stride, rowStride] }) => (x, y) => {
+	let i;
+	return x >= 0 && x < width && y >= 0 && y < height ? (i = (y | 0) * rowStride + (x | 0) * stride, data.slice(i, i + stride)) : [0];
+};
+var __sampleFNW = ({ data, width, height, stride: [stride, rowStride] }) => (x, y) => {
+	let i = mod(y | 0, height) * rowStride + mod(x | 0, width) * stride;
+	return data.slice(i, i + stride);
+};
+var __sampleFNR = ({ data, width, height, stride: [stride, rowStride] }) => {
+	const w1 = width - 1;
+	const h1 = height - 1;
+	return (x, y) => {
+		let i = clamp$1(y | 0, 0, h1) * rowStride + clamp$1(x | 0, 0, w1) * stride;
+		return data.slice(i, i + stride);
+	};
+};
+var __mixBilinearChan = (buf, u, v, i, s = 4) => mixBilinear(buf[i], buf[i + s], buf[i + 2 * s], buf[i + 3 * s], u, v);
+var __bilinearGray = (sample) => (x, y) => {
+	x -= .5;
+	y -= .5;
+	return mixBilinear(sample(x, y), sample(x + 1, y), sample(x, y + 1), sample(x + 1, y + 1), fract(x), fract(y));
+};
+var __bilinearGrayF = (sample) => {
+	sample = __bilinearGray(sample);
+	return (x, y) => [sample(x, y)];
+};
+var __bilinearABGR = (src, sample1) => {
+	const { fromABGR, toABGR } = src.format;
+	const u32 = new Uint32Array(4);
+	const u8 = new Uint8Array(u32.buffer);
+	return (x, y) => {
+		x -= .5;
+		y -= .5;
+		u32[0] = toABGR(sample1(x, y));
+		u32[1] = toABGR(sample1(x + 1, y));
+		u32[2] = toABGR(sample1(x, y + 1));
+		u32[3] = toABGR(sample1(x + 1, y + 1));
+		const u = fract(x);
+		const v = fract(y);
+		return fromABGR(__mixBilinearChan(u8, u, v, 0) | __mixBilinearChan(u8, u, v, 1) << 8 | __mixBilinearChan(u8, u, v, 2) << 16 | __mixBilinearChan(u8, u, v, 3) << 24) >>> 0;
+	};
+};
+var __bilinearFloat = ({ stride: [stride] }, sample1) => {
+	const f32 = new Float32Array(stride * 4);
+	return (x, y) => {
+		x -= .5;
+		y -= .5;
+		f32.set(sample1(x, y), 0);
+		f32.set(sample1(x + 1, y), stride);
+		f32.set(sample1(x, y + 1), stride * 2);
+		f32.set(sample1(x + 1, y + 1), stride * 3);
+		const u = fract(x);
+		const v = fract(y);
+		let res = [];
+		for (let i = 0; i < stride; i++) res.push(__mixBilinearChan(f32, u, v, i, stride));
+		return res;
+	};
+};
+var __bicubicGray = (sample) => (x, y) => {
+	x -= .5;
+	y -= .5;
+	const x1 = x - 1;
+	const x2 = x + 1;
+	const x3 = x + 2;
+	const y1 = y - 1;
+	const y2 = y + 1;
+	const y3 = y + 2;
+	return mixBicubic(sample(x1, y1), sample(x, y1), sample(x2, y1), sample(x3, y1), sample(x1, y), sample(x, y), sample(x2, y), sample(x3, y), sample(x1, y2), sample(x, y2), sample(x2, y2), sample(x3, y2), sample(x1, y3), sample(x, y3), sample(x2, y3), sample(x3, y3), fract(x), fract(y));
+};
+var __bicubicGrayI = (src, sample) => {
+	const max = src.format.channels[0].mask0;
+	sample = __bicubicGray(sample);
+	return (x, y) => clamp$1(sample(x, y), 0, max);
+};
+var __bicubicGrayF = (sample) => {
+	sample = __bicubicGray(sample);
+	return (x, y) => [sample(x, y)];
+};
+var __mixBicubicChan = (buf, u, v, i, s = 4) => mixBicubic(buf[i], buf[i + s], buf[i + 2 * s], buf[i + 3 * s], buf[i + 4 * s], buf[i + 5 * s], buf[i + 6 * s], buf[i + 7 * s], buf[i + 8 * s], buf[i + 9 * s], buf[i + 10 * s], buf[i + 11 * s], buf[i + 12 * s], buf[i + 13 * s], buf[i + 14 * s], buf[i + 15 * s], u, v);
+var __mixBicubicChanClamped = (buf, u, v, i, s = 4) => clamp$1(__mixBicubicChan(buf, u, v, i, s), 0, 255);
+var __bicubicABGR = (src, sample) => {
+	const { fromABGR, toABGR } = src.format;
+	const u32 = new Uint32Array(16);
+	const u8 = new Uint8Array(u32.buffer);
+	return (x, y) => {
+		x -= .5;
+		y -= .5;
+		const x1 = x - 1;
+		const x2 = x + 1;
+		const x3 = x + 2;
+		const y1 = y - 1;
+		const y2 = y + 1;
+		const y3 = y + 2;
+		const u = fract(x);
+		const v = fract(y);
+		u32[0] = toABGR(sample(x1, y1));
+		u32[1] = toABGR(sample(x, y1));
+		u32[2] = toABGR(sample(x2, y1));
+		u32[3] = toABGR(sample(x3, y1));
+		u32[4] = toABGR(sample(x1, y));
+		u32[5] = toABGR(sample(x, y));
+		u32[6] = toABGR(sample(x2, y));
+		u32[7] = toABGR(sample(x3, y));
+		u32[8] = toABGR(sample(x1, y2));
+		u32[9] = toABGR(sample(x, y2));
+		u32[10] = toABGR(sample(x2, y2));
+		u32[11] = toABGR(sample(x3, y2));
+		u32[12] = toABGR(sample(x1, y3));
+		u32[13] = toABGR(sample(x, y3));
+		u32[14] = toABGR(sample(x2, y3));
+		u32[15] = toABGR(sample(x3, y3));
+		return fromABGR(__mixBicubicChanClamped(u8, u, v, 0) | __mixBicubicChanClamped(u8, u, v, 1) << 8 | __mixBicubicChanClamped(u8, u, v, 2) << 16 | __mixBicubicChanClamped(u8, u, v, 3) << 24) >>> 0;
+	};
+};
+var __bicubicFloat = ({ stride: [stride] }, sample) => {
+	const f32 = new Float32Array(stride * 16);
+	return (x, y) => {
+		x -= .5;
+		y -= .5;
+		const x1 = x - 1;
+		const x2 = x + 1;
+		const x3 = x + 2;
+		const y1 = y - 1;
+		const y2 = y + 1;
+		const y3 = y + 2;
+		const u = fract(x);
+		const v = fract(y);
+		f32.set(sample(x1, y1), 0);
+		f32.set(sample(x, y1), stride);
+		f32.set(sample(x2, y1), 2 * stride);
+		f32.set(sample(x3, y1), 3 * stride);
+		f32.set(sample(x1, y), 4 * stride);
+		f32.set(sample(x, y), 5 * stride);
+		f32.set(sample(x2, y), 6 * stride);
+		f32.set(sample(x3, y), 7 * stride);
+		f32.set(sample(x1, y2), 8 * stride);
+		f32.set(sample(x, y2), 9 * stride);
+		f32.set(sample(x2, y2), 10 * stride);
+		f32.set(sample(x3, y2), 11 * stride);
+		f32.set(sample(x1, y3), 12 * stride);
+		f32.set(sample(x, y3), 13 * stride);
+		f32.set(sample(x2, y3), 14 * stride);
+		f32.set(sample(x3, y3), 15 * stride);
+		let res = [];
+		for (let i = 0; i < stride; i++) res.push(__mixBicubicChan(f32, u, v, i, stride));
+		return res;
+	};
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel/int.js
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+function intBuffer(...args) {
+	return args[0] instanceof IntBuffer ? args[0].as(args[1]) : new IntBuffer(...args);
+}
+var intBufferFromCanvas = (canvas, fmt = ABGR8888) => {
+	const { data } = canvasPixels(canvas);
+	const w = canvas.width;
+	const h = canvas.height;
+	let dest;
+	if (fmt === ABGR8888) dest = data;
+	else {
+		dest = typedArray(fmt.type, w * h);
+		const src = data;
+		const from = fmt.fromABGR;
+		for (let i = dest.length; i-- > 0;) dest[i] = from(src[i]);
+	}
+	return new IntBuffer(w, h, fmt, dest);
+};
+var IntBuffer = class {
+	size;
+	stride;
+	format;
+	data;
+	constructor(w, h, fmt = ABGR8888, data) {
+		this.size = [w, h];
+		this.stride = [1, w];
+		this.format = fmt.__packed ? fmt : defIntFormat(fmt);
+		this.data = data || typedArray(fmt.type, w * h);
+	}
+	/** @deprecated use `.data` instead */
+	get pixels() {
+		return this.data;
+	}
+	get width() {
+		return this.size[0];
+	}
+	get height() {
+		return this.size[1];
+	}
+	get offset() {
+		return 0;
+	}
+	get dim() {
+		return 2;
+	}
+	*[Symbol.iterator]() {
+		yield* this.data;
+	}
+	as(fmt) {
+		if (!fmt.__float) return this.getRegion(0, 0, this.width, this.height, fmt);
+		const dest = new FloatBuffer(this.width, this.height, fmt);
+		const { data: dbuf, format: dfmt, stride: [stride] } = dest;
+		const { data: sbuf, format: sfmt } = this;
+		for (let i = sbuf.length; i-- > 0;) dbuf.set(dfmt.fromABGR(sfmt.toABGR(sbuf[i])), i * stride);
+		return dest;
+	}
+	copy() {
+		const dest = this.empty();
+		dest.data.set(this.data);
+		return dest;
+	}
+	empty() {
+		return new IntBuffer(this.width, this.height, this.format);
+	}
+	order() {}
+	includes(x, y) {}
+	indexAt(x, y) {}
+	indexAtUnsafe(x, y) {}
+	getAt(x, y) {}
+	getAtUnsafe(x, y) {}
+	setAt(x, y, col) {}
+	setAtUnsafe(x, y, col) {}
+	getChannelAt(x, y, id, normalized = false) {
+		const chan = ensureChannel(this.format, id);
+		const col = this.getAt(x, y);
+		return normalized ? chan.float(col) : chan.int(col);
+	}
+	setChannelAt(x, y, id, col, normalized = false) {
+		const chan = ensureChannel(this.format, id);
+		const src = this.getAt(x, y);
+		normalized ? chan.setFloat(src, col) : chan.setInt(src, col);
+		return this;
+	}
+	blend(op, dest, opts) {
+		let sw = this.width;
+		let dw = dest.width;
+		const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
+		if (rw < 1 || rh < 1) return dest;
+		const sbuf = this.data;
+		const dbuf = dest.data;
+		const sf = this.format.toABGR;
+		const df1 = dest.format.toABGR;
+		const df2 = dest.format.fromABGR;
+		for (let si = (sx | 0) + (sy | 0) * sw, di = (dx | 0) + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) for (let xx = 0; xx < rw; xx++) dbuf[di + xx] = df2(op(sf(sbuf[si + xx]), df1(dbuf[di + xx])));
+		return dest;
+	}
+	blit(dest, opts) {
+		let sw = this.width;
+		let dw = dest.width;
+		const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
+		if (rw < 1 || rh < 1) return dest;
+		const sbuf = this.data;
+		const dbuf = dest.data;
+		const sf = this.format.toABGR;
+		const df = dest.format.fromABGR;
+		const blitRow = this.format !== dest.format ? (si, di) => {
+			for (let xx = 0; xx < rw; xx++) dbuf[di + xx] = df(sf(sbuf[si + xx]));
+		} : (si, di) => dbuf.set(sbuf.subarray(si, si + rw), di);
+		for (let si = (sx | 0) + (sy | 0) * sw, di = (dx | 0) + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) blitRow(si, di);
+		return dest;
+	}
+	blitCanvas(canvas, opts = {}) {
+		__blitCanvas(this, canvas, opts);
+	}
+	setImageData(idata) {
+		ensureImageDataSize(idata, this.width, this.height);
+		const src = new Uint32Array(idata.data.buffer);
+		const dest = this.data;
+		const fmt = this.format.fromABGR;
+		for (let i = src.length; i-- > 0;) dest[i] = fmt(src[i]);
+		return this;
+	}
+	toImageData(idata) {
+		idata = ensureImageData(idata, this.width, this.height);
+		const dest = new Uint32Array(idata.data.buffer);
+		const src = this.data;
+		const fmt = this.format.toABGR;
+		for (let i = dest.length; i-- > 0;) dest[i] = fmt(src[i]);
+		return idata;
+	}
+	getRegion(x, y, width, height, fmt) {
+		const [sx, sy, w, h] = __clampRegion(x, y, width, height, this.width, this.height);
+		if (w < 1 || h < 1) return;
+		return this.blit(new IntBuffer(w, h, fmt || this.format), {
+			sx,
+			sy,
+			w,
+			h
+		});
+	}
+	getChannel(id) {
+		const chan = ensureChannel(this.format, id);
+		const buf = new IntBuffer(this.width, this.height, {
+			type: uintTypeForBits(chan.size),
+			size: chan.size,
+			channels: [{
+				size: chan.size,
+				lane: Lane.RED
+			}],
+			fromABGR: __compileGrayFromABGR(chan.size),
+			toABGR: __compileGrayToABGR(chan.size)
+		});
+		const src = this.data;
+		const dest = buf.data;
+		const get = chan.int;
+		for (let i = src.length; i-- > 0;) dest[i] = get(src[i]);
+		return buf;
+	}
+	setChannel(id, src) {
+		const chan = ensureChannel(this.format, id);
+		const dbuf = this.data;
+		const set = chan.setInt;
+		if (isNumber(src)) __setChannelUni(dbuf, src, set);
+		else {
+			const sbuf = src.data;
+			const schan = src.format.channels[0];
+			ensureSize(sbuf, this.width, this.height);
+			if (chan.size === schan.size) __setChannelSame(dbuf, sbuf, schan.int, set);
+			else __setChannelConvert(dbuf, sbuf, this.format.fromABGR, src.format.toABGR, chan.maskA);
+		}
+		return this;
+	}
+	invert() {
+		const { data, format } = this;
+		const mask = Math.pow(2, format.size - format.alpha) - 1;
+		for (let i = data.length; i-- > 0;) data[i] ^= mask;
+		return this;
+	}
+	premultiply() {
+		ensureAlpha(this.format);
+		__transformABGR(this.data, this.format, premultiplyInt);
+		return this;
+	}
+	postmultiply() {
+		__transformABGR(this.data, this.format, postmultiplyInt);
+		return this;
+	}
+	isPremultiplied() {
+		const pix = this.data;
+		const to = this.format.toABGR;
+		for (let i = pix.length; i-- > 0;) if (!isPremultipliedInt(to(pix[i]))) return false;
+		return true;
+	}
+	forEach(f) {
+		const pix = this.data;
+		for (let i = pix.length; i-- > 0;) pix[i] = f(pix[i], i);
+		return this;
+	}
+	fill(x) {
+		this.data.fill(x);
+	}
+	/**
+	* Flips image horizontally.
+	*/
+	flipX() {
+		const { data, width } = this;
+		for (let i = 0; i < data.length; i += width) data.subarray(i, i + width).reverse();
+		return this;
+	}
+	/**
+	* Flips image vertically.
+	*/
+	flipY() {
+		const { data, width } = this;
+		const tmp = typedArray(this.format.type, width);
+		for (let i = 0, j = data.length - width; i < j; i += width, j -= width) {
+			tmp.set(data.subarray(i, i + width));
+			data.copyWithin(i, j, j + width);
+			data.set(tmp, j);
+		}
+		return this;
+	}
+	rotateByID(id) {
+		return id > 0 ? this[ROT_IDS[id - 1]]() : this;
+	}
+	rotateCW() {
+		const { width, height } = this;
+		const h1 = height - 1;
+		this._rotate((x, y) => x * height + h1 - y);
+		this.size[0] = height;
+		this.size[1] = width;
+		return this;
+	}
+	rotateCCW() {
+		const { width, height } = this;
+		const w1 = width - 1;
+		this._rotate((x, y) => (w1 - x) * height + y);
+		this.size[0] = height;
+		this.size[1] = width;
+		return this;
+	}
+	rotate180() {
+		const { width, height } = this;
+		const w1 = width - 1;
+		const h1 = height - 1;
+		this._rotate((x, y) => (h1 - y) * width + w1 - x);
+		return this;
+	}
+	/**
+	* Returns scaled version of this buffer using given sampler or filter
+	* (default: `"linear"`) for interpolation. Syntax sugar for
+	* {@link IntBuffer.resize}.
+	*
+	* @param scale -
+	*/
+	scale(scale, sampler = "linear") {
+		assert(scale > 0, `scale must be > 0`);
+		return this.resize(this.width * scale, this.height * scale, sampler);
+	}
+	resize(w, h, sampler = "linear") {
+		w |= 0;
+		h |= 0;
+		assert(w > 0 && h > 0, `target width & height must be > 0`);
+		const dest = intBuffer(w, h, this.format);
+		const dpix = dest.data;
+		const scaleX = w > 0 ? this.width / w : 0;
+		const scaleY = h > 0 ? this.height / h : 0;
+		sampler = isString(sampler) ? defSampler(this, sampler, "repeat") : sampler;
+		for (let y = 0, i = 0; y < h; y++) {
+			const yy = y * scaleY;
+			for (let x = 0; x < w; x++, i++) dpix[i] = sampler(x * scaleX, yy);
+		}
+		return dest;
+	}
+	upsize() {
+		const { width, height, data } = this;
+		const dest = new IntBuffer(width * 2, height * 2, this.format);
+		const dpix = dest.data;
+		for (let y = 0, si = 0; y < height; y++) for (let x = 0, di = y * width * 4; x < width; x++, si++, di += 2) dpix[di] = data[si];
+		return dest;
+	}
+	_rotate(idxFn) {
+		const { data, format, width, height } = this;
+		const tmp = typedArray(format.type, width * height);
+		for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) tmp[idxFn(x, y)] = data[y * width + x];
+		this.data = tmp;
+	}
+};
+IntBuffer = __decorateClass$1([IGrid2DMixin], IntBuffer);
+//#endregion
+//#region node_modules/@thi.ng/pixel/float.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+function floatBuffer(...args) {
+	return args[0] instanceof IntBuffer ? floatBufferFromInt(...args) : new FloatBuffer(...args);
+}
+var floatBufferFromInt = (src, fmt) => {
+	const dest = new FloatBuffer(src.width, src.height, fmt);
+	const { data: dbuf, format: dfmt, stride: [stride] } = dest;
+	const { data: sbuf, format: sfmt } = src;
+	for (let i = sbuf.length; i-- > 0;) dbuf.set(dfmt.fromABGR(sfmt.toABGR(sbuf[i])), i * stride);
+	return dest;
+};
+var floatBufferFromCanvas = (canvas, fmt = FLOAT_RGBA) => intBufferFromCanvas(canvas).as(fmt);
+var FloatBuffer = class {
+	size;
+	stride;
+	format;
+	data;
+	__empty;
+	constructor(w, h, fmt = FLOAT_RGBA, data) {
+		this.size = [w, h];
+		this.format = fmt.__float ? fmt : defFloatFormat(fmt);
+		const stride = this.format.channels.length;
+		this.stride = [stride, w * stride];
+		this.data = data || new Float32Array(w * h * stride);
+		this.__empty = Object.freeze(new Array(stride).fill(0));
+	}
+	/** @deprecated use `.data` instead */
+	get pixels() {
+		return this.data;
+	}
+	get width() {
+		return this.size[0];
+	}
+	get height() {
+		return this.size[1];
+	}
+	get offset() {
+		return 0;
+	}
+	get dim() {
+		return 2;
+	}
+	*[Symbol.iterator]() {
+		const { data, stride: [stride] } = this;
+		for (let i = 0, n = data.length; i < n; i += stride) yield data.subarray(i, i + stride);
+	}
+	as(fmt) {
+		const { width, height, stride: [stride], data, format: { size, normalized: getNormalized, toABGR } } = this;
+		let i = 0, j = 0, n = data.length;
+		if (fmt.__float) {
+			const $fmt = fmt;
+			const dest = new FloatBuffer(width, height, $fmt);
+			const { data: dpixels, stride: [dstride] } = dest;
+			if (size === 1 && $fmt.channels.length === 1) {
+				const setNormalized = $fmt.fromNormalized;
+				for (; i < n; i += stride, j += dstride) dpixels[j] = setNormalized(getNormalized(data[i]));
+			} else for (; i < n; i += stride, j += dstride) dpixels.set($fmt.fromABGR(toABGR(data.subarray(i, i + stride))), j);
+			return dest;
+		} else {
+			const $fmt = fmt;
+			const dest = new IntBuffer(width, height, $fmt);
+			const dpixels = dest.data;
+			if (size === 1 && $fmt.channels.length === 1) {
+				const setFloat = $fmt.channels[0].setFloat;
+				for (; i < n; i += stride, j++) dpixels[j] = setFloat(0, getNormalized(data[i]));
+			} else for (; i < n; i += stride, j++) dpixels[j] = $fmt.fromABGR(toABGR(data.subarray(i, i + stride)));
+			return dest;
+		}
+	}
+	copy() {
+		const dest = this.empty();
+		dest.data.set(this.data);
+		return dest;
+	}
+	empty() {
+		return new FloatBuffer(this.width, this.height, this.format);
+	}
+	order() {}
+	includes(x, y) {}
+	indexAt(x, y) {}
+	indexAtUnsafe(x, y) {}
+	getAt(x, y) {
+		return this.includes(x, y) ? this.getAtUnsafe(x, y) : this.__empty;
+	}
+	getAtUnsafe(x, y) {
+		const idx = this.indexAtUnsafe(x, y);
+		return this.data.subarray(idx, idx + this.stride[0]);
+	}
+	setAt(x, y, col) {
+		return this.includes(x, y) ? (this.data.set(col, this.indexAtUnsafe(x, y)), true) : false;
+	}
+	setAtUnsafe(x, y, col) {
+		this.data.set(col, this.indexAtUnsafe(x, y));
+		return true;
+	}
+	getChannelAt(x, y, id) {
+		ensureChannel(this.format, id);
+		return this.includes(x, y) ? this.data[this.indexAtUnsafe(x, y) + id] : void 0;
+	}
+	setChannelAt(x, y, id, col) {
+		ensureChannel(this.format, id);
+		this.includes(x, y) && (this.data[this.indexAtUnsafe(x, y) + id] = col);
+		return this;
+	}
+	getChannel(id) {
+		ensureChannel(this.format, id);
+		const { data, stride: [stride] } = this;
+		const [min, max] = this.format.range;
+		const dest = new Float32Array(this.width * this.height);
+		for (let i = id, j = 0, n = data.length; i < n; i += stride, j++) dest[j] = clamp$1(data[i], min, max);
+		return new FloatBuffer(this.width, this.height, FLOAT_GRAY, dest);
+	}
+	setChannel(id, src) {
+		ensureChannel(this.format, id);
+		const { data: dest, stride: [stride] } = this;
+		if (isNumber(src)) for (let i = id, n = dest.length; i < n; i += stride) dest[i] = src;
+		else {
+			const { data: sbuf, stride: [sstride] } = src;
+			ensureSize(sbuf, this.width, this.height, sstride);
+			for (let i = id, j = 0, n = dest.length; i < n; i += stride, j += sstride) dest[i] = sbuf[j];
+		}
+		return this;
+	}
+	blend(op, dest, opts) {
+		this.ensureFormat(dest);
+		const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
+		if (rw < 1 || rh < 1) return dest;
+		const sbuf = this.data;
+		const dbuf = dest.data;
+		const [stride, sw] = this.stride;
+		const dw = dest.stride[1];
+		for (let si = (sx | 0) * stride + (sy | 0) * sw, di = (dx | 0) * stride + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) for (let xx = rw, sii = si, dii = di; xx-- > 0; sii += stride, dii += stride) {
+			const out = dbuf.subarray(dii, dii + stride);
+			op(out, sbuf.subarray(sii, sii + stride), out);
+		}
+		return dest;
+	}
+	blit(dest, opts) {
+		this.ensureFormat(dest);
+		const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
+		if (rw < 1 || rh < 1) return dest;
+		const sbuf = this.data;
+		const dbuf = dest.data;
+		const [stride, sw] = this.stride;
+		const dw = dest.stride[1];
+		const rww = rw * stride;
+		for (let si = (sx | 0) * stride + (sy | 0) * sw, di = (dx | 0) * stride + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) dbuf.set(sbuf.subarray(si, si + rww), di);
+		return dest;
+	}
+	blitCanvas(canvas, opts = {}) {
+		__blitCanvas(this, canvas, opts);
+	}
+	setImageData(idata) {
+		ensureImageDataSize(idata, this.width, this.height);
+		const src = new Uint32Array(idata.data.buffer);
+		const { data: dest, format: { fromABGR }, stride: [stride] } = this;
+		const tmp = [];
+		for (let i = src.length; i-- > 0;) dest.set(fromABGR(src[i], tmp), i * stride);
+		return this;
+	}
+	toImageData(idata) {
+		idata = ensureImageData(idata, this.width, this.height);
+		const dest = new Uint32Array(idata.data.buffer);
+		const { stride: [stride], data, format } = this;
+		for (let i = 0, j = 0, n = data.length; i < n; i += stride, j++) dest[j] = format.toABGR(data.subarray(i, i + stride));
+		return idata;
+	}
+	getRegion(x, y, width, height) {
+		const [sx, sy, w, h] = __clampRegion(x, y, width, height, this.width, this.height);
+		if (w < 1 || h < 1) return;
+		return this.blit(new FloatBuffer(w, h, this.format), {
+			sx,
+			sy,
+			w,
+			h
+		});
+	}
+	forEach(f) {
+		const { data, stride: [stride] } = this;
+		for (let i = 0, j = 0, n = data.length; i < n; i += stride, j++) data.set(f(data.subarray(i, i + stride), j), i);
+		return this;
+	}
+	fill(x) {
+		assert(x.length <= this.format.channels.length, `fill value has too many channels`);
+		const { data, stride: [stride] } = this;
+		for (let i = 0, n = data.length; i < n; i += stride) data.set(x, i);
+	}
+	premultiply() {
+		this.ensureRGBA();
+		const { data, stride: [stride] } = this;
+		for (let i = 0, n = data.length; i < n; i += stride) premultiply(null, data.subarray(i, i + stride));
+		return this;
+	}
+	postmultiply() {
+		this.ensureRGBA();
+		const { data, stride: [stride] } = this;
+		for (let i = 0, n = data.length; i < n; i += stride) postmultiply(null, data.subarray(i, i + stride));
+		return this;
+	}
+	isPremultiplied() {
+		this.ensureRGBA();
+		const { data, stride: [stride] } = this;
+		for (let i = 0, n = data.length; i < n; i += stride) if (!isPremultiplied(data.subarray(i, i + stride))) return false;
+		return true;
+	}
+	clamp() {
+		const data = this.data;
+		const [min, max] = this.format.range;
+		for (let i = data.length; i-- > 0;) data[i] = clamp$1(data[i], min, max);
+		return this;
+	}
+	clampChannel(id) {
+		ensureChannel(this.format, id);
+		const { data, stride: [stride] } = this;
+		const [min, max] = this.format.range;
+		for (let i = id, n = data.length; i < n; i += stride) data[i] = clamp$1(data[i], min, max);
+	}
+	flipX() {
+		const { data, width, height, stride: [sx, sy] } = this;
+		const tmp = new Float32Array(sx);
+		const w1 = width - 1;
+		const w2 = width >>> 1;
+		for (let y = 0; y < height; y++) for (let x = 0, i = y * sy, j = i + w1 * sx; x < w2; x++, i += sx, j -= sx) {
+			tmp.set(data.subarray(i, i + sx));
+			data.copyWithin(i, j, j + sx);
+			data.set(tmp, j);
+		}
+		return this;
+	}
+	/**
+	* Flips image vertically.
+	*/
+	flipY() {
+		const data = this.data;
+		const rowStride = this.stride[1];
+		const tmp = new Float32Array(rowStride);
+		for (let i = 0, j = data.length - rowStride; i < j; i += rowStride, j -= rowStride) {
+			tmp.set(data.subarray(i, i + rowStride));
+			data.copyWithin(i, j, j + rowStride);
+			data.set(tmp, j);
+		}
+		return this;
+	}
+	rotateByID(id) {
+		return id > 0 ? this[ROT_IDS[id - 1]]() : this;
+	}
+	rotateCW() {
+		const { width, height } = this;
+		const h1 = height - 1;
+		this._rotate((x, y) => x * height + h1 - y);
+		this.size[0] = height;
+		this.size[1] = width;
+		return this;
+	}
+	rotateCCW() {
+		const { width, height } = this;
+		const w1 = width - 1;
+		this._rotate((x, y) => (w1 - x) * height + y);
+		this.size[0] = height;
+		this.size[1] = width;
+		return this;
+	}
+	rotate180() {
+		const { width, height } = this;
+		const w1 = width - 1;
+		const h1 = height - 1;
+		this._rotate((x, y) => (h1 - y) * width + w1 - x);
+		return this;
+	}
+	invert() {
+		const { data, format, stride: [stride] } = this;
+		for (let i = 0, n = data.length, m = format.alpha ? stride - 1 : stride; i < n; i += stride) for (let j = 0; j < m; j++) data[i + j] = 1 - data[i + j];
+		return this;
+	}
+	scale(scale, sampler) {
+		assert(scale > 0, `scale must be > 0`);
+		return this.resize(this.width * scale, this.height * scale, sampler);
+	}
+	resize(w, h, sampler = "linear") {
+		w |= 0;
+		h |= 0;
+		assert(w > 0 && h > 0, `target width & height must be > 0`);
+		const dest = floatBuffer(w, h, this.format);
+		const dpix = dest.data;
+		const scaleX = w > 0 ? this.width / w : 0;
+		const scaleY = h > 0 ? this.height / h : 0;
+		const stride = this.stride[0];
+		sampler = isString(sampler) ? defSampler(this, sampler, "repeat") : sampler;
+		for (let y = 0, i = 0; y < h; y++) {
+			const yy = y * scaleY;
+			for (let x = 0; x < w; x++, i += stride) dpix.set(sampler(x * scaleX, yy), i);
+		}
+		return dest;
+	}
+	upsize() {
+		const { width, height, data, stride: [stride, rowStride] } = this;
+		const stride2x = stride * 2;
+		const dest = floatBuffer(width * 2, height * 2, this.format);
+		const dpix = dest.data;
+		for (let y = 0, si = 0; y < height; y++) for (let x = 0, di = y * rowStride * 4; x < width; x++, si += stride, di += stride2x) dpix.set(data.subarray(si, si + stride), di);
+		return dest;
+	}
+	_rotate(idxFn) {
+		const { data, width, height, stride: [stride] } = this;
+		const tmp = new Float32Array(width * height * stride);
+		for (let y = 0, i = 0; y < height; y++) for (let x = 0; x < width; x++, i += stride) tmp.set(data.subarray(i, i + stride), idxFn(x, y) * stride);
+		this.data = tmp;
+	}
+	ensureFormat(dest) {
+		assert(dest.format === this.format, `dest buffer format must be same as src`);
+	}
+	ensureRGBA() {
+		assert(this.format === FLOAT_RGBA, "require FLOAT_RGBA format");
+	}
+};
+__decorateClass([nomixin], FloatBuffer.prototype, "getAt", 1);
+__decorateClass([nomixin], FloatBuffer.prototype, "getAtUnsafe", 1);
+__decorateClass([nomixin], FloatBuffer.prototype, "setAt", 1);
+__decorateClass([nomixin], FloatBuffer.prototype, "setAtUnsafe", 1);
+FloatBuffer = __decorateClass([IGrid2DMixin], FloatBuffer);
+//#endregion
+//#region node_modules/@thi.ng/math/fit.js
+var norm = (x, a, b) => b !== a ? (x - a) / (b - a) : 0;
+var fit = (x, a, b, c, d) => c + (d - c) * norm(x, a, b);
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/float-hsva.js
+var abs$1 = Math.abs;
+var min = Math.min;
+var FLOAT_HSVA = defFloatFormat({
+	alpha: true,
+	channels: [
+		Lane.RED,
+		Lane.GREEN,
+		Lane.BLUE,
+		Lane.ALPHA
+	],
+	convert: {
+		fromABGR: (x, out = []) => {
+			const a = (x >>> 24 & 255) / 255;
+			const b = (x >>> 16 & 255) / 255;
+			const g = (x >>> 8 & 255) / 255;
+			const r = (x & 255) / 255;
+			let p0, p1, p2, p3;
+			let q0, q1, q2, q3;
+			if (g < b) {
+				p0 = b;
+				p1 = g;
+				p2 = -1;
+				p3 = 2 / 3;
+			} else {
+				p0 = g;
+				p1 = b;
+				p2 = 0;
+				p3 = -1 / 3;
+			}
+			if (r < p0) {
+				q0 = p0;
+				q1 = p1;
+				q2 = p3;
+				q3 = r;
+			} else {
+				q0 = r;
+				q1 = p1;
+				q2 = p2;
+				q3 = p0;
+			}
+			const c = q0 - min(q1, q3);
+			q0 = clamp01(q0);
+			out[0] = clamp01(abs$1((q3 - q1) / (6 * c + EPS$1) + q2));
+			out[1] = clamp01(c / (q0 + EPS$1));
+			out[2] = q0;
+			out[3] = a;
+			return out;
+		},
+		toABGR: (x) => {
+			const h = x[0] * 6;
+			const s = x[1];
+			const v = x[2] * 255;
+			const a = x[3] * 255;
+			const r = ((clamp01(abs$1(h - 3) - 1) - 1) * s + 1) * v;
+			const g = ((clamp01(2 - abs$1(h - 2)) - 1) * s + 1) * v;
+			const b = ((clamp01(2 - abs$1(h - 4)) - 1) * s + 1) * v;
+			return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+		}
+	}
+});
+//#endregion
+//#region node_modules/@thi.ng/pixel/format/float-rgba.js
+var FLOAT_RGBA = defFloatFormat({
+	alpha: true,
+	channels: [
+		Lane.RED,
+		Lane.GREEN,
+		Lane.BLUE,
+		Lane.ALPHA
+	]
+});
+//#endregion
+//#region node_modules/@thi.ng/errors/unsupported.js
+var UnsupportedOperationError = defError(() => "unsupported operation");
+var unsupportedOp = (msg) => {
+	throw new UnsupportedOperationError(msg);
+};
+var UnsupportedFeatureError = defError(() => "unsupported feature");
+//#endregion
+//#region node_modules/@thi.ng/vectors/vop.js
+var vop = (dispatch = 1, fallback, ...optimized) => {
+	const impls = [, ,].concat(optimized);
+	const fn = (...args) => {
+		const g = impls[args[dispatch].length] || fallback;
+		return g ? g(...args) : unsupportedOp(`no impl for vec size ${args[dispatch].length}`);
+	};
+	fn.add = (dim, fn2) => impls[dim] = fn2;
+	fn.default = (fn2) => fallback = fn2;
+	fn.impl = (dim) => dim != null ? impls[dim] || fallback : fallback;
+	return fn;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/dot.js
+var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
+var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var dot4 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+var dot = vop(0, (a, b) => {
+	let sum = 0;
+	for (let i = a.length; i-- > 0;) sum += a[i] * b[i];
+	return sum;
+}, dot2, dot3, dot4);
+//#endregion
+//#region node_modules/@thi.ng/memoize/memoizej.js
+function memoizeJ(fn, cache = Object.create(null)) {
+	return (...args) => {
+		const key = JSON.stringify(args);
+		if (key !== void 0) return key in cache ? cache[key] : cache[key] = fn.apply(null, args);
+		return fn.apply(null, args);
+	};
+}
+//#endregion
+//#region node_modules/@thi.ng/memoize/memoizeo.js
+function memoizeO(fn, cache = Object.create(null)) {
+	return (...xs) => {
+		const key = xs.join("-");
+		return key in cache ? cache[key] : cache[key] = fn(...xs);
+	};
+}
+//#endregion
+//#region node_modules/@thi.ng/strings/repeat.js
+var repeat$1 = memoizeO((ch, n) => ch.repeat(n));
+//#endregion
+//#region node_modules/@thi.ng/strings/pad-left.js
+var padLeft = memoizeO((n, ch = " ") => {
+	const buf = repeat$1(String(ch), n);
+	return (x, len) => {
+		if (x == null) return buf;
+		x = x.toString();
+		len = len !== void 0 ? len : x.length;
+		return len < n ? buf.substring(len) + x : x;
+	};
+});
+var Z2 = padLeft(2, "0");
+var Z3$1 = padLeft(3, "0");
+var Z4$1 = padLeft(4, "0");
+//#endregion
+//#region node_modules/@thi.ng/strings/float.js
+var float = memoizeJ((prec, special = false) => special ? (x) => __nanOrInf(x) || x.toFixed(prec) : (x) => x.toFixed(prec));
+var floatFixedWidth = memoizeJ((width, prec = 3) => {
+	const l = width - prec - 1;
+	const pl = Math.pow(10, l);
+	const pln = -Math.pow(10, l - 1);
+	const pr = Math.pow(10, -(prec - 1));
+	const pad = padLeft(width);
+	return (x) => {
+		const ax = Math.abs(x);
+		return pad(__nanOrInf(x) || (x === 0 ? "0" : ax < pr || ax >= pl ? __exp(x, width) : x.toFixed(prec - (x < pln ? 1 : 0))));
+	};
+});
+var __exp = (x, w) => x.toExponential(Math.max(w - 4 - (Math.log(Math.abs(x)) / Math.LN10 >= 10 ? 2 : 1) - (x < 0 ? 1 : 0), 0));
+var __nanOrInf = (x) => isNaN(x) ? "NaN" : x === Infinity ? "+∞" : x === -Infinity ? "-∞" : void 0;
+//#endregion
+//#region node_modules/@thi.ng/strings/percent.js
+var percent = (prec = 0) => (x) => (x * 100).toFixed(prec) + "%";
+//#endregion
+//#region node_modules/@thi.ng/color/api/constants.js
+var BLACK = Object.freeze([
+	0,
+	0,
+	0,
+	1
+]);
+var WHITE = Object.freeze([
+	1,
+	1,
+	1,
+	1
+]);
+var RED = Object.freeze([
+	1,
+	0,
+	0,
+	1
+]);
+var GREEN = Object.freeze([
+	0,
+	1,
+	0,
+	1
+]);
+var BLUE = Object.freeze([
+	0,
+	0,
+	1,
+	1
+]);
+var CYAN = Object.freeze([
+	0,
+	1,
+	1,
+	1
+]);
+var MAGENTA = Object.freeze([
+	1,
+	0,
+	1,
+	1
+]);
+var YELLOW = Object.freeze([
+	1,
+	1,
+	0,
+	1
+]);
+var RGB_LUMINANCE_REC601 = [
+	.299,
+	.587,
+	.114
+];
+var RGB_LUMINANCE_REC709 = [
+	.2126,
+	.7152,
+	.0722
+];
+var XYZ_RGB_D50 = [
+	3.1338561,
+	-.9787684,
+	.0719453,
+	-1.6168667,
+	1.9161415,
+	-.2289914,
+	-.4906146,
+	.033454,
+	1.4052427
+];
+var XYZ_RGB_D65 = [
+	3.2404542,
+	-.969266,
+	.0556434,
+	-1.5371385,
+	1.8760108,
+	-.2040259,
+	-.4985314,
+	.041556,
+	1.0572252
+];
+var BRADFORD_D65_D50 = [
+	1.0478112,
+	.0295424,
+	-.0092345,
+	.0228866,
+	.9904844,
+	.0150436,
+	-.050127,
+	-.0170491,
+	.7521316
+];
+var D50 = [
+	.96422,
+	1,
+	.82521
+];
+var D65 = [
+	.95047,
+	1,
+	1.08883
+];
+var OKLAB_M2 = [
+	.2104542553,
+	1.9779984951,
+	.0259040371,
+	.793617785,
+	-2.428592205,
+	.7827717662,
+	-.0040720468,
+	.4505937099,
+	-.808675766
+];
+var FF = float(3);
+var PC = percent(3);
+var INV8BIT = 1 / 255;
+var EPS = 1 / 256;
+//#endregion
+//#region node_modules/@thi.ng/color/luminance-rgb.js
+var luminanceRgb = (rgb, weights = RGB_LUMINANCE_REC709) => dot3(rgb, weights);
+var luminanceSrgb = (rgb) => dot3(rgb, RGB_LUMINANCE_REC601);
+//#endregion
+//#region node_modules/@thi.ng/vectors/set.js
+var set2 = (o, a) => {
+	!o && (o = []);
+	o[0] = a[0];
+	o[1] = a[1];
+	return o;
+};
+var set3 = (o, a) => {
+	!o && (o = []);
+	o[0] = a[0];
+	o[1] = a[1];
+	o[2] = a[2];
+	return o;
+};
+var set4 = (o, a) => {
+	!o && (o = []);
+	o[0] = a[0];
+	o[1] = a[1];
+	o[2] = a[2];
+	o[3] = a[3];
+	return o;
+};
+var set = vop(1, (o, a) => {
+	!o && (o = []);
+	for (let i = a.length; i-- > 0;) o[i] = a[i];
+	return o;
+}, set2, set3, set4);
+//#endregion
+//#region node_modules/@thi.ng/checks/implements-function.js
+var implementsFunction = (x, fn) => typeof x?.[fn] === "function";
+//#endregion
+//#region node_modules/@thi.ng/checks/is-arraylike.js
+var isArrayLike = (x) => x != null && typeof x !== "function" && x.length !== void 0;
+//#endregion
+//#region node_modules/@thi.ng/errors/illegal-arguments.js
+var IllegalArgumentError = defError(() => "illegal argument(s)");
+var illegalArgs = (msg) => {
+	throw new IllegalArgumentError(msg);
+};
+//#endregion
+//#region node_modules/@thi.ng/strings/vector.js
+var vector = memoizeJ((size, prec = 3, d = ",", pre = "[", post = "]") => {
+	const f = typeof prec === "number" ? float(prec) : prec;
+	switch (size) {
+		case 1: return (v) => `${pre}${f(v[0])}${post}`;
+		case 2: return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${post}`;
+		case 3: return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${post}`;
+		case 4: return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${d}${f(v[3])}${post}`;
+		default: return (v) => {
+			const res = [];
+			for (let i = 0; i < v.length; i++) res.push(f(v[i]));
+			return `${pre}${res.join(d)}${post}`;
+		};
+	}
+});
+//#endregion
+//#region node_modules/@thi.ng/vectors/buffer.js
+var mapStridedBuffer = (ctor, buf, num, start, cstride, estride) => {
+	const res = [];
+	while (num-- > 0) {
+		res.push(new ctor(buf, start, cstride));
+		start += estride;
+	}
+	return res;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/defopvvv.js
+var defOpVVV = (op, dispatch = 1, outA = true) => {
+	const a = outA ? (o, a2, b2, c2) => {
+		!o && (o = a2);
+		for (let i = a2.length; i-- > 0;) o[i] = op(a2[i], b2[i], c2[i]);
+		return o;
+	} : (o, a2, b2, c2) => {
+		!o && (o = c2);
+		for (let i = a2.length; i-- > 0;) o[i] = op(a2[i], b2[i], c2[i]);
+		return o;
+	};
+	const b = outA ? (o, a2, b2, c2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		return o;
+	} : (o, a2, b2, c2) => {
+		!o && (o = c2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		return o;
+	};
+	const c = outA ? (o, a2, b2, c2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		o[2] = op(a2[2], b2[2], c2[2]);
+		return o;
+	} : (o, a2, b2, c2) => {
+		!o && (o = c2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		o[2] = op(a2[2], b2[2], c2[2]);
+		return o;
+	};
+	const d = outA ? (o, a2, b2, c2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		o[2] = op(a2[2], b2[2], c2[2]);
+		o[3] = op(a2[3], b2[3], c2[3]);
+		return o;
+	} : (o, a2, b2, c2) => {
+		!o && (o = c2);
+		o[0] = op(a2[0], b2[0], c2[0]);
+		o[1] = op(a2[1], b2[1], c2[1]);
+		o[2] = op(a2[2], b2[2], c2[2]);
+		o[3] = op(a2[3], b2[3], c2[3]);
+		return o;
+	};
+	return [
+		vop(dispatch, a, b, c, d),
+		b,
+		c,
+		d
+	];
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/clamp.js
+var [a$7, b$7, c$7, d$7] = defOpVVV(clamp$1);
+var clamp4 = d$7;
+//#endregion
+//#region node_modules/@thi.ng/vectors/accessors.js
+var declareIndex = (proto, id, idx, strided = true, defNumeric = true) => {
+	const get = idx > 0 ? strided ? function() {
+		return this.buf[this.offset + idx * this.stride];
+	} : function() {
+		return this.buf[this.offset + idx];
+	} : function() {
+		return this.buf[this.offset];
+	};
+	const set = idx > 0 ? strided ? function(n) {
+		this.buf[this.offset + idx * this.stride] = n;
+	} : function(n) {
+		this.buf[this.offset + idx] = n;
+	} : function(n) {
+		this.buf[this.offset] = n;
+	};
+	defNumeric && Object.defineProperty(proto, idx, {
+		get,
+		set,
+		enumerable: true
+	});
+	Object.defineProperty(proto, id, {
+		get,
+		set,
+		enumerable: true
+	});
+};
+var declareIndices = (proto, props, strided, defNumeric) => props.forEach((id, i) => declareIndex(proto, id, i, strided, defNumeric));
+//#endregion
+//#region node_modules/@thi.ng/math/eqdelta.js
+var abs = Math.abs;
+var eqDelta$1 = (a, b, eps = EPS$1) => abs(a - b) <= eps;
+//#endregion
+//#region node_modules/@thi.ng/vectors/eqdelta.js
+var eqDelta2 = (a, b, eps = EPS$1) => {
+	return a.length === b.length && eqDelta$1(a[0], b[0], eps) && eqDelta$1(a[1], b[1], eps);
+};
+var eqDelta3 = (a, b, eps = EPS$1) => {
+	return a.length === b.length && eqDelta$1(a[0], b[0], eps) && eqDelta$1(a[1], b[1], eps) && eqDelta$1(a[2], b[2], eps);
+};
+var eqDelta4 = (a, b, eps = EPS$1) => {
+	return a.length === b.length && eqDelta$1(a[0], b[0], eps) && eqDelta$1(a[1], b[1], eps) && eqDelta$1(a[2], b[2], eps) && eqDelta$1(a[3], b[3], eps);
+};
+var eqDelta = vop(0, (v1, v2, eps = EPS$1) => {
+	if (implementsFunction(v1, "eqDelta")) return v1.eqDelta(v2, eps);
+	if (implementsFunction(v2, "eqDelta")) return v2.eqDelta(v1, eps);
+	return eqDeltaS(v1, v2, v1.length, eps);
+}, eqDelta2, eqDelta3, eqDelta4);
+var eqDeltaS = (a, b, n, eps = EPS$1, ia = 0, ib = 0, sa = 1, sb = 1) => {
+	for (; n > 0; n--, ia += sa, ib += sb) if (!eqDelta$1(a[ia], b[ib], eps)) return false;
+	return true;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/iterator.js
+function* stridedValues(buf, num, start, stride) {
+	while (num-- > 0) {
+		yield buf[start];
+		start += stride;
+	}
+}
+//#endregion
+//#region node_modules/@thi.ng/random/arandom.js
+var INV_MAX = 1 / 2 ** 32;
+var ARandom = class {
+	float(norm = 1) {
+		return this.int() * INV_MAX * norm;
+	}
+	probability(p) {
+		return this.float() < p;
+	}
+	norm(norm = 1) {
+		return (this.int() * INV_MAX - .5) * 2 * norm;
+	}
+	normMinMax(min, max) {
+		const x = this.minmax(min, max);
+		return this.float() < .5 ? x : -x;
+	}
+	minmax(min, max) {
+		return this.float() * (max - min) + min;
+	}
+	minmaxInt(min, max) {
+		min |= 0;
+		const range = (max | 0) - min;
+		return range ? min + this.int() % range : min;
+	}
+	minmaxUint(min, max) {
+		min >>>= 0;
+		const range = (max >>> 0) - min;
+		return range ? min + this.int() % range : min;
+	}
+};
+//#endregion
+//#region node_modules/@thi.ng/random/wrapped.js
+var WrappedRandom = class extends ARandom {
+	constructor(rnd) {
+		super();
+		this.rnd = rnd;
+	}
+	float(norm = 1) {
+		return this.rnd() * norm;
+	}
+	norm(norm = 1) {
+		return (this.rnd() - .5) * 2 * norm;
+	}
+	int() {
+		return this.rnd() * 4294967296 >>> 0;
+	}
+};
+//#endregion
+//#region node_modules/@thi.ng/random/system.js
+var SYSTEM = new WrappedRandom(Math.random);
+//#endregion
+//#region node_modules/@thi.ng/random/weighted-random.js
+var weightedRandom = (choices, weights, rnd = SYSTEM) => {
+	const n = choices.length;
+	assert(n > 0, "no choices given");
+	const opts = weights ? choices.map((x, i) => [weights[i] || 0, x]).sort((a, b) => b[0] - a[0]) : choices.map((x) => [1, x]);
+	const total = opts.reduce((acc, o) => acc + o[0], 0);
+	total <= 0 && console.warn("total weights <= 0");
+	return () => {
+		const r = rnd.float(total);
+		let sum = total;
+		for (let i = 0; i < n; i++) {
+			sum -= opts[i][0];
+			if (sum <= r) return opts[i][1];
+		}
+	};
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/rand-minmax.js
+var randMinMax = vop(1, (o, a, b, rnd = SYSTEM) => {
+	!o && (o = a);
+	for (let i = a.length; i-- > 0;) o[i] = rnd.minmax(a[i], b[i]);
+	return o;
+});
+//#endregion
+//#region node_modules/@thi.ng/checks/is-array.js
+var isArray = Array.isArray;
+//#endregion
+//#region node_modules/@thi.ng/color/convert.js
+var CONVERSIONS = {};
+var defConversions = (mode, spec) => {
+	for (const id in spec) {
+		const val = spec[id];
+		if (isArray(val)) {
+			const [a, b, c, d] = val;
+			spec[id] = val.length === 2 ? (out, src) => b(out, a(out, src)) : val.length === 3 ? (out, src) => c(out, b(out, a(out, src))) : (out, src) => d(out, c(out, b(out, a(out, src))));
+		}
+	}
+	CONVERSIONS[mode] = {
+		...CONVERSIONS[mode],
+		...spec
+	};
+};
+var convert = (res, src, destMode, srcMode) => {
+	const spec = CONVERSIONS[destMode];
+	assert(!!spec, `no conversions available for ${destMode}`);
+	let $convert = spec[srcMode];
+	return $convert ? $convert(res, src) : CONVERSIONS.rgb[srcMode] ? spec.rgb(res, CONVERSIONS.rgb[srcMode]([], src)) : unsupportedOp(`can't convert: ${srcMode} -> ${destMode}`);
+};
+//#endregion
+//#region node_modules/@thi.ng/binary/rotate.js
+var rotateRight = (x, n) => (x >>> n | x << 32 - n) >>> 0;
+//#endregion
+//#region node_modules/@thi.ng/binary/splat.js
+var interleave4_12_24 = (x) => (x & 3840) * 4352 | (x & 240) * 272 | (x & 15) * 17;
+var interleave4_16_32 = (x) => ((x & 61440) * 69632 | (x & 3840) * 4352 | (x & 240) * 272 | (x & 15) * 17) >>> 0;
+//#endregion
+//#region node_modules/@thi.ng/color/api.js
+var ParsedColor = class {
+	constructor(mode, value) {
+		this.mode = mode;
+		this.value = value;
+	}
+	deref() {
+		return this.value;
+	}
+};
+//#endregion
+//#region node_modules/@thi.ng/color/api/names.js
+var CSS_NAMES = {
+	aliceblue: "f0f8ff",
+	antiquewhite: "faebd7",
+	aqua: "0ff",
+	aquamarine: "7fffd4",
+	azure: "f0ffff",
+	beige: "f5f5dc",
+	bisque: "ffe4c4",
+	black: "000",
+	blanchedalmond: "ffebcd",
+	blue: "00f",
+	blueviolet: "8a2be2",
+	brown: "a52a2a",
+	burlywood: "deb887",
+	cadetblue: "5f9ea0",
+	chartreuse: "7fff00",
+	chocolate: "d2691e",
+	coral: "ff7f50",
+	cornflowerblue: "6495ed",
+	cornsilk: "fff8dc",
+	crimson: "dc143c",
+	cyan: "0ff",
+	darkblue: "00008b",
+	darkcyan: "008b8b",
+	darkgoldenrod: "b8860b",
+	darkgray: "a9a9a9",
+	darkgreen: "006400",
+	darkgrey: "a9a9a9",
+	darkkhaki: "bdb76b",
+	darkmagenta: "8b008b",
+	darkolivegreen: "556b2f",
+	darkorange: "ff8c00",
+	darkorchid: "9932cc",
+	darkred: "8b0000",
+	darksalmon: "e9967a",
+	darkseagreen: "8fbc8f",
+	darkslateblue: "483d8b",
+	darkslategray: "2f4f4f",
+	darkslategrey: "2f4f4f",
+	darkturquoise: "00ced1",
+	darkviolet: "9400d3",
+	deeppink: "ff1493",
+	deepskyblue: "00bfff",
+	dimgray: "696969",
+	dimgrey: "696969",
+	dodgerblue: "1e90ff",
+	firebrick: "b22222",
+	floralwhite: "fffaf0",
+	forestgreen: "228b22",
+	fuchsia: "f0f",
+	gainsboro: "dcdcdc",
+	ghostwhite: "f8f8ff",
+	gold: "ffd700",
+	goldenrod: "daa520",
+	gray: "808080",
+	grey: "808080",
+	green: "008000",
+	greenyellow: "adff2f",
+	honeydew: "f0fff0",
+	hotpink: "ff69b4",
+	indianred: "cd5c5c",
+	indigo: "4b0082",
+	ivory: "fffff0",
+	khaki: "f0e68c",
+	lavender: "e6e6fa",
+	lavenderblush: "fff0f5",
+	lawngreen: "7cfc00",
+	lemonchiffon: "fffacd",
+	lightblue: "add8e6",
+	lightcoral: "f08080",
+	lightcyan: "e0ffff",
+	lightgoldenrodyellow: "fafad2",
+	lightgray: "d3d3d3",
+	lightgreen: "90ee90",
+	lightgrey: "d3d3d3",
+	lightpink: "ffb6c1",
+	lightsalmon: "ffa07a",
+	lightseagreen: "20b2aa",
+	lightskyblue: "87cefa",
+	lightslategray: "789",
+	lightslategrey: "789",
+	lightsteelblue: "b0c4de",
+	lightyellow: "ffffe0",
+	lime: "0f0",
+	limegreen: "32cd32",
+	linen: "faf0e6",
+	magenta: "f0f",
+	maroon: "800000",
+	mediumaquamarine: "66cdaa",
+	mediumblue: "0000cd",
+	mediumorchid: "ba55d3",
+	mediumpurple: "9370db",
+	mediumseagreen: "3cb371",
+	mediumslateblue: "7b68ee",
+	mediumspringgreen: "00fa9a",
+	mediumturquoise: "48d1cc",
+	mediumvioletred: "c71585",
+	midnightblue: "191970",
+	mintcream: "f5fffa",
+	mistyrose: "ffe4e1",
+	moccasin: "ffe4b5",
+	navajowhite: "ffdead",
+	navy: "000080",
+	oldlace: "fdf5e6",
+	olive: "808000",
+	olivedrab: "6b8e23",
+	orange: "ffa500",
+	orangered: "ff4500",
+	orchid: "da70d6",
+	palegoldenrod: "eee8aa",
+	palegreen: "98fb98",
+	paleturquoise: "afeeee",
+	palevioletred: "db7093",
+	papayawhip: "ffefd5",
+	peachpuff: "ffdab9",
+	peru: "cd853f",
+	pink: "ffc0cb",
+	plum: "dda0dd",
+	powderblue: "b0e0e6",
+	purple: "800080",
+	red: "f00",
+	rosybrown: "bc8f8f",
+	royalblue: "4169e1",
+	saddlebrown: "8b4513",
+	salmon: "fa8072",
+	sandybrown: "f4a460",
+	seagreen: "2e8b57",
+	seashell: "fff5ee",
+	sienna: "a0522d",
+	silver: "c0c0c0",
+	skyblue: "87ceeb",
+	slateblue: "6a5acd",
+	slategray: "708090",
+	slategrey: "708090",
+	snow: "fffafa",
+	springgreen: "00ff7f",
+	steelblue: "4682b4",
+	tan: "d2b48c",
+	teal: "008080",
+	thistle: "d8bfd8",
+	tomato: "ff6347",
+	turquoise: "40e0d0",
+	violet: "ee82ee",
+	wheat: "f5deb3",
+	white: "fff",
+	whitesmoke: "f5f5f5",
+	yellow: "ff0",
+	yellowgreen: "9acd32",
+	transparent: "0000",
+	rebeccapurple: "639"
+};
+//#endregion
+//#region node_modules/@thi.ng/color/api/system.js
+var CSS_SYSTEM_COLORS = {
+	canvas: "fff",
+	canvastext: "000",
+	linktext: "001ee4",
+	visitedtext: "4e2386",
+	activetext: "eb3323",
+	buttonface: "ddd",
+	buttontext: "000",
+	buttonborder: "000",
+	field: "fff",
+	fieldtext: "000",
+	highlight: "bbd5fb",
+	highlighttext: "000",
+	mark: "000",
+	marktext: "fff",
+	graytext: "808080"
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/setc.js
+var setC3 = (out, x, y, z) => {
+	!out && (out = []);
+	out[0] = x;
+	out[1] = y;
+	out[2] = z;
+	return out;
+};
+var setC4 = (out, x, y, z, w) => {
+	!out && (out = []);
+	out[0] = x;
+	out[1] = y;
+	out[2] = z;
+	out[3] = w;
+	return out;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/int/int-srgb.js
+var intArgb32Srgb = (out, src) => setC4(out || [], (src >>> 16 & 255) * INV8BIT, (src >>> 8 & 255) * INV8BIT, (src & 255) * INV8BIT, (src >>> 24) * INV8BIT);
+var intAbgr32Srgb = (out, src) => setC4(out || [], (src & 255) * INV8BIT, (src >>> 8 & 255) * INV8BIT, (src >>> 16 & 255) * INV8BIT, (src >>> 24) * INV8BIT);
+//#endregion
+//#region node_modules/@thi.ng/color/css/parse-css.js
+var parseCss = (src) => {
+	src = (isString(src) ? src : src.deref()).toLowerCase();
+	const named = CSS_NAMES[src] || CSS_SYSTEM_COLORS[src];
+	if (named || src[0] === "#") return new ParsedColor("srgb", intArgb32Srgb([], parseHex(named || src)));
+	const parts = src.split(/[(),/ ]+/);
+	const [mode, a, b, c, d] = parts;
+	assert(parts.length === 5 || parts.length === 6, `invalid color: ${src}`);
+	switch (mode) {
+		case "rgb":
+		case "rgba": return new ParsedColor("srgb", [
+			__numOrPercent(a, 1, INV8BIT, true),
+			__numOrPercent(b, 1, INV8BIT, true),
+			__numOrPercent(c, 1, INV8BIT, true),
+			__alpha(d)
+		]);
+		case "hsl":
+		case "hsla": return new ParsedColor("hsl", [
+			__hue(a),
+			__percent(b),
+			__percent(c),
+			__alpha(d)
+		]);
+		case "lab": return new ParsedColor("lab50", [
+			__numOrPercent(a),
+			__numOrPercent(b, 1.25),
+			__numOrPercent(c, 1.25),
+			__alpha(d)
+		]);
+		case "lch": return new ParsedColor(mode, [
+			__numOrPercent(a),
+			__numOrPercent(b, 1.5),
+			__hue(c),
+			__alpha(d)
+		]);
+		case "oklab": return new ParsedColor(mode, [
+			__numOrPercent(a, 1, 1),
+			__numOrPercent(b, .4, 1),
+			__numOrPercent(c, .4, 1),
+			__alpha(d)
+		]);
+		case "oklch": return new ParsedColor(mode, [
+			__numOrPercent(a, 1, 1),
+			__numOrPercent(b, .4, 1),
+			__hue(c),
+			__alpha(d)
+		]);
+		default: unsupportedOp(`color mode: ${mode}`);
+	}
+};
+var HUE_NORMS = {
+	rad: TAU,
+	grad: 400,
+	turn: 1,
+	deg: 360
+};
+var __hue = (x) => {
+	const match = /^(-?[0-9.]+)(deg|rad|grad|turn)?$/.exec(x);
+	assert(!!match, `expected hue, got: ${x}`);
+	return fract(parseFloat(match[1]) / (HUE_NORMS[match[2]] || 360));
+};
+var __alpha = (x) => x ? __numOrPercent(x, 1, 1, true) : 1;
+var __percent = (x, clamp = true) => {
+	assert(/^([0-9.]+)%$/.test(x), `expected percentage, got: ${x}`);
+	const res = parseFloat(x) / 100;
+	return clamp ? clamp01(res) : res;
+};
+var __numOrPercent = (x, scalePerc = 1, scale = .01, clamp = false) => {
+	assert(/^-?[0-9.]+%?$/.test(x), `expected number or percentage, got: ${x}`);
+	const res = parseFloat(x) * (x.endsWith("%") ? .01 * scalePerc : scale);
+	return clamp ? clamp01(res) : res;
+};
+var parseHex = (src) => {
+	const match = /^#?([0-9a-f]{3,8})$/i.exec(src);
+	if (match) {
+		const hex = match[1];
+		const val = parseInt(hex, 16);
+		switch (hex.length) {
+			case 3: return (interleave4_12_24(val) | 4278190080) >>> 0;
+			case 4: return rotateRight(interleave4_16_32(val), 8);
+			case 6: return (val | 4278190080) >>> 0;
+			case 8: return rotateRight(val, 8);
+			default:
+		}
+	}
+	return illegalArgs(`invalid hex color: "${src}"`);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/internal/ensure.js
+var __ensureAlpha = (x, def = 1) => x != void 0 ? clamp01(x) : def;
+var __ensureArgs = (args) => {
+	if (typeof args[0] === "number") switch (args.length) {
+		case 1: return args.push(0, 0, 1), [args];
+		case 2: return args.push(0, 1), [args];
+		case 3: return args.push(1), [args];
+		default: return [args];
+	}
+	return args;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/defcolor.js
+var defColor = (spec) => {
+	const channels = spec.channels || {};
+	const order = spec.order;
+	const numChannels = order.length;
+	order.reduce((acc, id) => {
+		acc[id] = {
+			range: [0, 1],
+			...channels[id]
+		};
+		return acc;
+	}, channels);
+	const min = Object.freeze(order.map((id) => channels[id].range[0]));
+	const max = Object.freeze(order.map((id) => channels[id].range[1]));
+	const minR = set4([], min);
+	const maxR = set4([], max);
+	minR[numChannels - 1] = 1;
+	const hueChanID = order.findIndex((id) => !!channels[id].hue);
+	const $Color = class {
+		constructor(buf, offset = 0, stride = 1) {
+			this.offset = offset;
+			this.stride = stride;
+			this.buf = buf || [
+				0,
+				0,
+				0,
+				0
+			];
+			this.offset = offset;
+			this.stride = stride;
+		}
+		buf;
+		get mode() {
+			return spec.mode;
+		}
+		get length() {
+			return numChannels;
+		}
+		get range() {
+			return [min, max];
+		}
+		get [Symbol.toStringTag]() {
+			return spec.mode;
+		}
+		get xyz() {
+			return [
+				this[0],
+				this[1],
+				this[2]
+			];
+		}
+		[Symbol.iterator]() {
+			return stridedValues(this.buf, this.length, this.offset, this.stride);
+		}
+		copy() {
+			return new $Color(this.deref());
+		}
+		copyView() {
+			return new $Color(this.buf, this.offset, this.stride);
+		}
+		empty() {
+			return new $Color();
+		}
+		deref() {
+			return [
+				this[0],
+				this[1],
+				this[2],
+				this[3]
+			];
+		}
+		set(src) {
+			return set4(this, src);
+		}
+		clamp() {
+			hueChanID >= 0 && (this[hueChanID] = fract(this[hueChanID]));
+			clamp4(null, this, min, max);
+			return this;
+		}
+		eqDelta(o, eps = EPS$1) {
+			return eqDelta4(this, o, eps);
+		}
+		randomize(rnd) {
+			return randMinMax(this, minR, maxR, rnd);
+		}
+		toJSON() {
+			return this.deref();
+		}
+		toString() {
+			return vector(4, 4)(this);
+		}
+	};
+	declareIndices($Color.prototype, order);
+	defConversions(spec.mode, spec.from);
+	defConversions("rgb", { [spec.mode]: spec.toRgb });
+	const fromColor = (src, mode, args) => {
+		const res = new $Color(...args);
+		return mode !== spec.mode ? convert(res, src, spec.mode, mode) : res.set(src);
+	};
+	const factory = (src, ...args) => src == null ? new $Color() : isString(src) ? factory(parseCss(src), ...args) : isArrayLike(src) ? isString(src.mode) ? fromColor(src, src.mode, args) : new $Color(src, ...args) : implementsFunction(src, "deref") ? fromColor(src.deref(), src.mode, args) : isNumber(src) ? args.length && args.every(isNumber) ? new $Color(...__ensureArgs([src, ...args])) : fromColor(intArgb32Srgb([], src), "srgb", args) : illegalArgs(`can't create a ${spec.mode} color from: ${src}`);
+	factory.class = $Color;
+	factory.range = [min, max];
+	factory.random = (rnd, buf, idx, stride) => new $Color(buf, idx, stride).randomize(rnd);
+	factory.mapBuffer = (buf, num = buf.length / numChannels | 0, start = 0, cstride = 1, estride = numChannels) => mapStridedBuffer($Color, buf, num, start, cstride, estride);
+	return factory;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/hue-rgb.js
+var hueRgb = (out, hue, alpha = 1) => {
+	hue = fract(hue) * 6;
+	return setC4(out || [], clamp01(Math.abs(hue - 3) - 1), clamp01(2 - Math.abs(hue - 2)), clamp01(2 - Math.abs(hue - 4)), alpha);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hcy/hcy-rgb.js
+var hcyRgb = (out, src) => {
+	const h = src[0];
+	let c = src[1];
+	const y = src[2];
+	const rgb = hueRgb(out || src, h, __ensureAlpha(src[3]));
+	const lum = luminanceRgb(rgb);
+	if (y < lum) c *= y / lum;
+	else if (lum < 1) c *= (1 - y) / (1 - lum);
+	return setC3(rgb, clamp01((rgb[0] - lum) * c + y), clamp01((rgb[1] - lum) * c + y), clamp01((rgb[2] - lum) * c + y));
+};
+//#endregion
+//#region node_modules/@thi.ng/color/clamp.js
+var clamp = (out, src, alpha = 1) => setC4(out || src, clamp01(src[0]), clamp01(src[1]), clamp01(src[2]), __ensureAlpha(src[3], alpha));
+var clampH = (out, src, alpha = 1) => setC4(out || src, fract(src[0]), clamp01(src[1]), clamp01(src[2]), __ensureAlpha(src[3], alpha));
+//#endregion
+//#region node_modules/@thi.ng/color/hsi/hsi-rgb.js
+var hsiRgb = (out, src) => {
+	out = clampH(out || src, src);
+	const s = out[1];
+	const i = out[2];
+	if (s < 1e-6) return setC3(out, i, i, i);
+	const h = out[0] * 6 % 6;
+	const m = i * (1 - s);
+	const z = 1 - Math.abs(h % 2 - 1);
+	let c = 3 * i * s / (1 + z);
+	const x = c * z + m;
+	c += m;
+	switch (h | 0) {
+		case 0: return setC3(out, c, x, m);
+		case 1: return setC3(out, x, c, m);
+		case 2: return setC3(out, m, c, x);
+		case 3: return setC3(out, m, x, c);
+		case 4: return setC3(out, x, m, c);
+		case 5: return setC3(out, c, m, x);
+		default: return setC3(out, m, m, m);
+	}
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsl/hsl-rgb.js
+var hslRgb = (out, src) => {
+	const s = clamp01(src[1]);
+	const l = clamp01(src[2]);
+	out = hueRgb(out || src, src[0], __ensureAlpha(src[3]));
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	return setC3(out, (out[0] - .5) * c + l, (out[1] - .5) * c + l, (out[2] - .5) * c + l);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsv/hsv-rgb.js
+var hsvRgb = (out, src) => {
+	out = clampH(out || src, src);
+	const s = out[1];
+	const v = out[2];
+	hueRgb(out, src[0], out[3]);
+	return setC3(out, ((out[0] - 1) * s + 1) * v, ((out[1] - 1) * s + 1) * v, ((out[2] - 1) * s + 1) * v);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/linear.js
+var linearSrgb = (x) => x <= .0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - .055;
+var srgbLinear = (x) => x <= .04045 ? x / 12.92 : Math.pow((x + .055) / 1.055, 2.4);
+//#endregion
+//#region node_modules/@thi.ng/color/srgb/srgb-rgb.js
+var srgbRgb = (out, src) => setC4(out || src, srgbLinear(src[0]), srgbLinear(src[1]), srgbLinear(src[2]), __ensureAlpha(src[3]));
+//#endregion
+//#region node_modules/@thi.ng/color/int/int-rgb.js
+var intArgb32Rgb = (out, src) => srgbRgb(null, intArgb32Srgb(out, src));
+var intAbgr32Rgb = (out, src) => srgbRgb(null, intAbgr32Srgb(out, src));
+//#endregion
+//#region node_modules/@thi.ng/math/angle.js
+var cossin = (theta, n = 1) => [Math.cos(theta) * n, Math.sin(theta) * n];
+var absTheta = (theta) => (theta %= TAU, theta < 0 ? TAU + theta : theta);
+var atan2Abs = (y, x) => absTheta(Math.atan2(y, x));
+//#endregion
+//#region node_modules/@thi.ng/color/lab/lab-lch.js
+var lchLab = (out, src) => {
+	let { 1: c, 2: h } = src;
+	h *= TAU;
+	const a = __ensureAlpha(src[3]);
+	return c > 0 ? setC4(out || src, src[0], Math.cos(h) * c, Math.sin(h) * c, a) : setC4(out || src, src[0], 0, 0, a);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/lab/lab-xyz.js
+var __transform$1 = (x) => {
+	const y = x ** 3;
+	return y > .008856 ? y : (x - 16 / 116) / 7.787;
+};
+var labXyz = (out, src, white = D50) => {
+	const y = (src[0] + .16) / 1.16;
+	return setC4(out || src, __transform$1(src[1] / 5 + y) * white[0], __transform$1(y) * white[1], __transform$1(y - src[2] / 2) * white[2], __ensureAlpha(src[3]));
+};
+var labXyzD65 = (out, src) => labXyz(out, src, D65);
+//#endregion
+//#region node_modules/@thi.ng/vectors/dots.js
+var dotS3 = (a, b, ia = 0, ib = 0, sa = 1, sb = 1) => a[ia] * b[ib] + a[ia + sa] * b[ib + sb] + a[ia + 2 * sa] * b[ib + 2 * sb];
+//#endregion
+//#region node_modules/@thi.ng/color/internal/matrix-ops.js
+var __mulV33 = (out, mat, src, clampOut = false) => {
+	const x = dotS3(mat, src, 0, 0, 3);
+	const y = dotS3(mat, src, 1, 0, 3);
+	const z = dotS3(mat, src, 2, 0, 3);
+	const a = __ensureAlpha(src[3]);
+	return clampOut ? setC4(out || src, clamp01(x), clamp01(y), clamp01(z), a) : setC4(out || src, x, y, z, a);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/xyz/xyz-rgb.js
+var xyzRgb = (out, src, mat = XYZ_RGB_D50) => __mulV33(out, mat, src);
+var xyzRgbD65 = (out, src) => xyzRgb(out, src, XYZ_RGB_D65);
+//#endregion
+//#region node_modules/@thi.ng/color/lab/lab-rgb.js
+var labRgb = (out, src) => xyzRgb(null, labXyz(out, src));
+var labRgbD65 = (out, src) => xyzRgbD65(null, labXyzD65(out, src));
+//#endregion
+//#region node_modules/@thi.ng/color/oklab/oklab-rgb.js
+var LMS_CONE = [
+	4.0767416621,
+	-1.2684380046,
+	-.0041960863,
+	-3.307711591,
+	2.6097574011,
+	-.7034186147,
+	.2309699292,
+	-.3413193965,
+	1.707614701
+];
+var oklabRgb = (out, { 0: l, 1: a, 2: b, 3: alpha }) => __mulV33(out, LMS_CONE, [
+	(l + .3963377774 * a + .2158037573 * b) ** 3,
+	(l - .1055613458 * a - .0638541728 * b) ** 3,
+	(l - .0894841775 * a - 1.291485548 * b) ** 3,
+	alpha
+]);
+//#endregion
+//#region node_modules/@thi.ng/math/safe-div.js
+var safeDiv = (a, b) => b !== 0 ? a / b : 0;
+//#endregion
+//#region node_modules/@thi.ng/color/xyy/xyy-xyz.js
+var xyyXyz = (out, src) => {
+	const { 0: x, 1: y, 2: Y } = src;
+	return setC4(out || src, safeDiv(Y * x, y), Y, safeDiv(Y * (1 - x - y), y), __ensureAlpha(src[3]));
+};
+//#endregion
+//#region node_modules/@thi.ng/color/ycc/ycc-rgb.js
+var yccRgb = (out, src, luma = RGB_LUMINANCE_REC709) => {
+	const y = src[0];
+	const bb = (2 - 2 * luma[2]) * src[1];
+	const rr = (2 - 2 * luma[0]) * src[2];
+	return setC4(out || src, y + rr, y - luma[2] / luma[1] * bb - luma[0] / luma[1] * rr, y + bb, __ensureAlpha(src[3]));
+};
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb.js
+var rgb = defColor({
+	mode: "rgb",
+	order: [
+		"r",
+		"g",
+		"b",
+		"alpha"
+	],
+	from: {
+		abgr32: (out, src) => intAbgr32Rgb(out, src[0]),
+		argb32: (out, src) => intArgb32Rgb(out, src[0]),
+		hcy: hcyRgb,
+		hsi: hsiRgb,
+		hsl: hslRgb,
+		hsv: hsvRgb,
+		lab50: labRgb,
+		lab65: labRgbD65,
+		lch: [lchLab, labRgb],
+		oklab: oklabRgb,
+		rgb: set4,
+		srgb: srgbRgb,
+		xyy: [xyyXyz, xyzRgbD65],
+		xyz50: xyzRgb,
+		xyz65: xyzRgbD65,
+		ycc: yccRgb
+	},
+	toRgb: set4
+});
+//#endregion
+//#region node_modules/@thi.ng/color/contrast.js
+var contrast = (a, b) => {
+	const lumA = luminanceRgb(rgb(a)) + .05;
+	const lumB = luminanceRgb(rgb(b)) + .05;
+	return lumA > lumB ? lumA / lumB : lumB / lumA;
+};
+//#endregion
+//#region node_modules/@thi.ng/arrays/ensure-iterable.js
+var ensureIterable = (x) => {
+	(x == null || !x[Symbol.iterator]) && illegalArgs(`value is not iterable: ${x}`);
+	return x;
+};
+//#endregion
+//#region node_modules/@thi.ng/arrays/ensure-array.js
+var ensureArray = (x) => isArray(x) ? x : [...ensureIterable(x)];
+var ensureArrayLike = (x) => isArrayLike(x) ? x : [...ensureIterable(x)];
+//#endregion
+//#region node_modules/@thi.ng/color/hsl/hsl-css.js
+var hslCss = (src) => {
+	const h = FF(fract(src[0]) * 360);
+	const s = PC(clamp01(src[1]));
+	const l = PC(clamp01(src[2]));
+	const a = __ensureAlpha(src[3]);
+	return a < 1 ? `hsla(${h},${s},${l},${FF(a)})` : `hsl(${h},${s},${l})`;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsv/hsv-hsl.js
+var hsvHsl = (out, src) => {
+	out = clampH(out || src, src);
+	const s = out[1];
+	const v = out[2];
+	const l = (2 - s) * v / 2;
+	out[2] = l;
+	out[1] = l && l < 1 ? s * v / (l < .5 ? l * 2 : 2 - l * 2) : s;
+	return out;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsv/hsv-css.js
+var hsvCss = (src) => hslCss(hsvHsl([], src));
+//#endregion
+//#region node_modules/@thi.ng/hex/index.js
+var HEX = "0123456789abcdef";
+var U8 = (x) => HEX[x >>> 4 & 15] + HEX[x & 15];
+var U16 = (x) => U8(x >>> 8) + U8(x & 255);
+var U24$1 = (x) => U8(x >>> 16) + U16(x);
+//#endregion
+//#region node_modules/@thi.ng/strings/radix.js
+var radix = memoizeO((radix2, n, prefix = "") => {
+	const buf = repeat$1("0", n);
+	return (x) => {
+		x = (x >>> 0).toString(radix2);
+		return prefix + (x.length < n ? buf.substring(x.length) + x : x);
+	};
+});
+var B8 = radix(2, 8);
+var B16 = radix(2, 16);
+var B32 = radix(2, 32);
+var U24 = U24$1;
+//#endregion
+//#region node_modules/@thi.ng/color/int/int-css.js
+var intArgb32Css = (src) => {
+	const a = src >>> 24;
+	return a < 255 ? `rgba(${src >> 16 & 255},${src >> 8 & 255},${src & 255},${FF(a * INV8BIT)})` : `#${U24(src & 16777215)}`;
+};
+//#endregion
+//#region node_modules/@thi.ng/binary/swizzle.js
+var swapLane13 = (x) => (x & 255) << 16 | x >> 16 & 255 | x & 4278255360;
+//#endregion
+//#region node_modules/@thi.ng/color/int/int-int.js
+var intAbgr32Argb32 = swapLane13;
+//#endregion
+//#region node_modules/@thi.ng/color/internal/css.js
+var __labCss = (mode, src, scale) => {
+	return __css(mode, PC(clamp0(src[0])), FF(src[1] * scale), FF(src[2] * scale), __ensureAlpha(src[3]));
+};
+var __lchCss = (mode, src, scaleC) => {
+	return __css(mode, PC(clamp0(src[0])), FF(clamp0(src[1]) * scaleC), FF(fract(src[2]) * 360), __ensureAlpha(src[3]));
+};
+var __css = (mode, x, y, z, a) => `${mode}(${x} ${y} ${z}` + (a < 1 ? `/${FF(a)})` : ")");
+//#endregion
+//#region node_modules/@thi.ng/color/lab/lab-css.js
+var labCss = (src) => __labCss("lab", src, 100);
+//#endregion
+//#region node_modules/@thi.ng/color/xyz/xyz-lab.js
+var __transform = (x) => x > .00885645 ? Math.cbrt(x) : 7.787037 * x + 16 / 116;
+var xyzLab = (out, src, white = D50) => {
+	const x = __transform(src[0] / white[0]);
+	const y = __transform(src[1] / white[1]);
+	const z = __transform(src[2] / white[2]);
+	return setC4(out || src, 1.16 * y - .16, 5 * (x - y), 2 * (y - z), __ensureAlpha(src[3]));
+};
+//#endregion
+//#region node_modules/@thi.ng/color/xyz/xyz-xyz.js
+var xyzXyzD65_50 = (out, src) => __mulV33(out, BRADFORD_D65_D50, src);
+//#endregion
+//#region node_modules/@thi.ng/color/lab/lab-lab.js
+var labLabD65_50 = (out, src) => xyzLab(out, xyzXyzD65_50(out, labXyzD65(out, src)));
+//#endregion
+//#region node_modules/@thi.ng/color/lch/lch-css.js
+var lchCss = (src) => __lchCss("lch", src, 100);
+//#endregion
+//#region node_modules/@thi.ng/color/oklab/oklab-css.js
+var oklabCss = (src) => __labCss("oklab", src, 1);
+//#endregion
+//#region node_modules/@thi.ng/color/oklch/oklch-css.js
+var oklchCss = (src) => __lchCss("oklch", src, 1);
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb-srgb.js
+var rgbSrgb = (out, src) => setC4(out || src, linearSrgb(src[0]), linearSrgb(src[1]), linearSrgb(src[2]), __ensureAlpha(src[3]));
+var GAMMA = 1 / 2.2;
+//#endregion
+//#region node_modules/@thi.ng/color/internal/scale.js
+var __scale8bit = (x, shift = 0) => (x < 0 ? 0 : x > 1 ? 1 : x) * 255 + .5 << shift;
+//#endregion
+//#region node_modules/@thi.ng/color/srgb/srgb-css.js
+var srgbCss = (src) => {
+	const r = __scale8bit(src[0]);
+	const g = __scale8bit(src[1]);
+	const b = __scale8bit(src[2]);
+	const a = __ensureAlpha(src[3]);
+	return a < 1 ? `rgba(${r},${g},${b},${FF(a)})` : `#${U24(r << 16 | g << 8 | b)}`;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb-css.js
+var rgbCss = (src) => srgbCss(rgbSrgb([], src));
+//#endregion
+//#region node_modules/@thi.ng/color/css/css.js
+var CSS_LEVEL3 = {
+	abgr32: (x) => intArgb32Css(intAbgr32Argb32(x[0])),
+	argb32: (x) => intArgb32Css(x[0]),
+	hsl: hslCss,
+	hsv: hsvCss,
+	lab50: (src) => srgbCss(rgbSrgb(null, labRgb([], src))),
+	lab65: (src) => srgbCss(rgbSrgb(null, labRgbD65([], src))),
+	lch: (src) => srgbCss(rgbSrgb(null, labRgb(null, lchLab([], src)))),
+	rgb: rgbCss,
+	srgb: srgbCss
+};
+var CSS_LEVEL4 = {
+	...CSS_LEVEL3,
+	lab50: labCss,
+	lab65: (x) => labCss(labLabD65_50([], x)),
+	lch: lchCss,
+	oklab: oklabCss,
+	oklch: oklchCss
+};
+var CSS_DEFAULT = CSS_LEVEL3;
+var css = (src, cssTarget = CSS_DEFAULT) => {
+	let asCss;
+	return isString(src) ? src : isNumber(src) ? intArgb32Css(src) : src.mode ? (asCss = cssTarget[src.mode]) ? asCss(src) : cssTarget.rgb(convert([], src, "rgb", src.mode)) : srgbCss(src);
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsl/hsl-hsv.js
+var hslHsv = (out, src) => {
+	out = clampH(out || src, src);
+	const s = out[1];
+	const l = out[2];
+	const l2 = 2 * l;
+	const v = (l2 + s * (1 - Math.abs(l2 - 1))) * .5;
+	out[1] = 2 * (v - l) / v;
+	out[2] = v;
+	return out;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb-hcv.js
+var rgbHcv = (out, src) => {
+	out = clamp(out || src, src);
+	const p = out[1] < out[2] ? [
+		out[2],
+		out[1],
+		-1,
+		2 / 3
+	] : [
+		out[1],
+		out[2],
+		0,
+		-1 / 3
+	];
+	const q = out[0] < p[0] ? [
+		p[0],
+		p[1],
+		p[3],
+		out[0]
+	] : [
+		out[0],
+		p[1],
+		p[2],
+		p[0]
+	];
+	const c = q[0] - Math.min(q[1], q[3]);
+	return setC3(out, clamp01(Math.abs((q[3] - q[1]) / (6 * c + EPS$1) + q[2])), clamp01(c), clamp01(q[0]));
+};
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb-hsv.js
+var rgbHsv = (out, src) => {
+	out = rgbHcv(out, src);
+	out[1] /= out[2] + EPS$1;
+	return out;
+};
+//#endregion
+//#region node_modules/@thi.ng/color/hsv/hsv.js
+var hsv = defColor({
+	mode: "hsv",
+	channels: { h: { hue: true } },
+	order: [
+		"h",
+		"s",
+		"v",
+		"alpha"
+	],
+	from: {
+		rgb: rgbHsv,
+		srgb: rgbHsv,
+		hsl: hslHsv,
+		lch: [
+			lchLab,
+			labRgb,
+			rgbSrgb,
+			rgbHsv
+		]
+	},
+	toRgb: hsvRgb
+});
+//#endregion
+//#region node_modules/@thi.ng/vectors/defopvn.js
+var defOpVN = (op, dispatch = 1) => {
+	const a = (o, a2, n) => {
+		!o && (o = a2);
+		for (let i = a2.length; i-- > 0;) o[i] = op(a2[i], n);
+		return o;
+	};
+	const b = (o, a2, n) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], n);
+		o[1] = op(a2[1], n);
+		return o;
+	};
+	const c = (o, a2, n) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], n);
+		o[1] = op(a2[1], n);
+		o[2] = op(a2[2], n);
+		return o;
+	};
+	const d = (o, a2, n) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], n);
+		o[1] = op(a2[1], n);
+		o[2] = op(a2[2], n);
+		o[3] = op(a2[3], n);
+		return o;
+	};
+	return [
+		vop(dispatch, a, b, c, d),
+		b,
+		c,
+		d
+	];
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/pown.js
+var [a$6, b$6, c$6, d$6] = defOpVN(Math.pow);
+var powN3 = c$6;
+//#endregion
+//#region node_modules/@thi.ng/color/rgb/rgb-oklab.js
+var CONE_LMS = [
+	.4122214708,
+	.2119034982,
+	.0883024619,
+	.5363325363,
+	.6806995451,
+	.2817188376,
+	.0514459929,
+	.1073969566,
+	.6299787005
+];
+var rgbOklab = (out, src) => __mulV33(null, OKLAB_M2, powN3(null, __mulV33(out, CONE_LMS, src), 1 / 3));
+//#endregion
+//#region node_modules/@thi.ng/color/oklch/oklab-oklch.js
+var oklabOklch = (out, src) => setC4(out || src, src[0], Math.hypot(src[1], src[2]), atan2Abs(src[2], src[1]) * INV_TAU, __ensureAlpha(src[3]));
+//#endregion
+//#region node_modules/@thi.ng/color/oklch/oklch-oklab.js
+var oklchOklab = (out, src) => setC4(out || src, src[0], ...cossin(src[2] * TAU, src[1]), __ensureAlpha(src[3]));
+//#endregion
+//#region node_modules/@thi.ng/color/oklch/oklch.js
+var oklch = defColor({
+	mode: "oklch",
+	channels: { c: { range: [0, .3225] } },
+	order: [
+		"l",
+		"c",
+		"h",
+		"alpha"
+	],
+	from: {
+		oklab: oklabOklch,
+		rgb: (out, src) => oklabOklch(null, rgbOklab(out, src))
+	},
+	toRgb: [oklchOklab, oklabRgb]
+});
+//#endregion
+//#region node_modules/@thi.ng/color/srgb/srgb.js
+var srgb = defColor({
+	mode: "srgb",
+	order: [
+		"r",
+		"g",
+		"b",
+		"alpha"
+	],
+	from: {
+		abgr32: (out, src) => intAbgr32Srgb(out, src[0]),
+		argb32: (out, src) => intArgb32Srgb(out, src[0]),
+		hcy: hcyRgb,
+		hsi: hsiRgb,
+		hsl: hslRgb,
+		hsv: hsvRgb,
+		rgb: rgbSrgb
+	},
+	toRgb: srgbRgb
+});
+//#endregion
+//#region node_modules/@thi.ng/compare/compare.js
+var compare = (a, b) => {
+	if (a === b) return 0;
+	if (a == null) return b == null ? 0 : -1;
+	if (b == null) return a == null ? 0 : 1;
+	if (typeof a.compare === "function") return a.compare(b);
+	if (typeof b.compare === "function") return -b.compare(a);
+	return a < b ? -1 : a > b ? 1 : 0;
+};
+//#endregion
+//#region node_modules/@thi.ng/compare/keys.js
+var __key = (k) => typeof k === "function" ? k : (x) => x[k];
+function compareByKey(key, cmp = compare) {
+	const kfn = __key(key);
+	return (x, y) => cmp(kfn(x), kfn(y));
+}
+//#endregion
+//#region node_modules/@thi.ng/compare/numeric.js
+var compareNumDesc = (a, b) => b - a;
+//#endregion
+//#region node_modules/@thi.ng/vectors/defopvv.js
+var defOpVV = (op, dispatch = 1, outA = true) => {
+	const a = outA ? (o, a2, b2) => {
+		!o && (o = a2);
+		for (let i = a2.length; i-- > 0;) o[i] = op(a2[i], b2[i]);
+		return o;
+	} : (o, a2, b2) => {
+		!o && (o = b2);
+		for (let i = a2.length; i-- > 0;) o[i] = op(a2[i], b2[i]);
+		return o;
+	};
+	const b = outA ? (o, a2, b2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		return o;
+	} : (o, a2, b2) => {
+		!o && (o = b2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		return o;
+	};
+	const c = outA ? (o, a2, b2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		o[2] = op(a2[2], b2[2]);
+		return o;
+	} : (o, a2, b2) => {
+		!o && (o = b2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		o[2] = op(a2[2], b2[2]);
+		return o;
+	};
+	const d = outA ? (o, a2, b2) => {
+		!o && (o = a2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		o[2] = op(a2[2], b2[2]);
+		o[3] = op(a2[3], b2[3]);
+		return o;
+	} : (o, a2, b2) => {
+		!o && (o = b2);
+		o[0] = op(a2[0], b2[0]);
+		o[1] = op(a2[1], b2[1]);
+		o[2] = op(a2[2], b2[2]);
+		o[3] = op(a2[3], b2[3]);
+		return o;
+	};
+	return [
+		vop(dispatch, a, b, c, d),
+		b,
+		c,
+		d
+	];
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/ops.js
+var $add = (a, b) => a + b;
+var $mul = (a, b) => a * b;
+var $sub = (a, b) => a - b;
+//#endregion
+//#region node_modules/@thi.ng/vectors/add.js
+var [a$5, b$5, c$5, d$5] = defOpVV($add);
+var add = a$5;
+var add2 = b$5;
+//#endregion
+//#region node_modules/@thi.ng/vectors/api.js
+var mi = -Infinity;
+var mx = Infinity;
+var MIN2 = Object.freeze([mi, mi]);
+var MAX2 = Object.freeze([mx, mx]);
+var ONE2 = Object.freeze([1, 1]);
+var ZERO2 = Object.freeze([0, 0]);
+var X2 = Object.freeze([1, 0]);
+var Y2 = Object.freeze([0, 1]);
+var MIN3 = Object.freeze([
+	mi,
+	mi,
+	mi
+]);
+var MAX3 = Object.freeze([
+	mx,
+	mx,
+	mx
+]);
+var ONE3 = Object.freeze([
+	1,
+	1,
+	1
+]);
+var ZERO3 = Object.freeze([
+	0,
+	0,
+	0
+]);
+var X3 = Object.freeze([
+	1,
+	0,
+	0
+]);
+var Y3 = Object.freeze([
+	0,
+	1,
+	0
+]);
+var Z3 = Object.freeze([
+	0,
+	0,
+	1
+]);
+var MIN4 = Object.freeze([
+	mi,
+	mi,
+	mi,
+	mi
+]);
+var MAX4 = Object.freeze([
+	mx,
+	mx,
+	mx,
+	mx
+]);
+var ONE4 = Object.freeze([
+	1,
+	1,
+	1,
+	1
+]);
+var ZERO4 = Object.freeze([
+	0,
+	0,
+	0,
+	0
+]);
+var X4 = Object.freeze([
+	1,
+	0,
+	0,
+	0
+]);
+var Y4 = Object.freeze([
+	0,
+	1,
+	0,
+	0
+]);
+var Z4 = Object.freeze([
+	0,
+	0,
+	1,
+	0
+]);
+var W4 = Object.freeze([
+	0,
+	0,
+	0,
+	1
+]);
+//#endregion
+//#region node_modules/@thi.ng/vectors/cartesian.js
+var cos = Math.cos;
+var sin = Math.sin;
+var cartesian = vop(1);
+var cartesian2 = cartesian.add(2, (out, v, offset = ZERO2) => add2(out || v, cossin(v[1], v[0]), offset));
+var cartesian3 = cartesian.add(3, (out, v, offset = ZERO3) => {
+	const r = v[0];
+	const theta = v[1];
+	const phi = v[2];
+	const ct = cos(theta);
+	return setC3(out || v, r * ct * cos(phi) + offset[0], r * ct * sin(phi) + offset[1], r * sin(theta) + offset[2]);
+});
+var cartesian2FromAngles = (angles, n) => {
+	const polar = [];
+	for (const x of angles) polar.push(cossin(x, n));
+	return polar;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/ensure.js
+var __ensureInputs = (src) => assert(src.length > 0, `no inputs given`);
+//#endregion
+//#region node_modules/@thi.ng/vectors/muln.js
+var [a$4, b$4, c$4, d$4] = defOpVN($mul);
+var mulN = a$4;
+//#endregion
+//#region node_modules/@thi.ng/vectors/sum.js
+var sum2 = (a) => a[0] + a[1];
+var sum3 = (a) => a[0] + a[1] + a[2];
+var sum4 = (a) => a[0] + a[1] + a[2] + a[3];
+var sum = vop(0, (v) => {
+	let res = 0;
+	for (let i = v.length; i-- > 0;) res += v[i];
+	return res;
+}, sum2, sum3, sum4);
+//#endregion
+//#region node_modules/@thi.ng/vectors/mean.js
+var mean = (out, src) => {
+	__ensureInputs(src);
+	out = set(out || [], src[0]);
+	for (let i = src.length; i-- > 1;) add(out, out, src[i]);
+	return mulN(out, out, 1 / src.length);
+};
+var vmean = (a) => a.length > 0 ? sum(a) / a.length : 0;
+//#endregion
+//#region node_modules/@thi.ng/vectors/subn.js
+var [a$3, b$3, c$3, d$3] = defOpVN($sub);
+var subN = a$3;
+//#endregion
+//#region node_modules/@thi.ng/vectors/center.js
+var center = (out, a) => subN(out, a, vmean(a));
+//#endregion
+//#region node_modules/@thi.ng/vectors/heading.js
+var headingXY = (a) => atan2Abs(a[1], a[0]);
+//#endregion
+//#region node_modules/@thi.ng/vectors/magsq.js
+var magSq2 = (a) => a[0] * a[0] + a[1] * a[1];
+var magSq3 = (a) => a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+var magSq4 = (a) => a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+var magSq = vop(0, (a) => {
+	let sum = 0;
+	for (let i = a.length; i-- > 0;) sum += a[i] * a[i];
+	return sum;
+}, magSq2, magSq3, magSq4);
+//#endregion
+//#region node_modules/@thi.ng/vectors/variance.js
+var variance = (a, isCentered = false, corrected = false) => {
+	const k = ~~corrected;
+	return a.length > k ? magSq(isCentered ? a : center([], a)) / (a.length - k) : 0;
+};
+var sd = (a, isCentered = false, corrected = false) => Math.sqrt(variance(a, isCentered, corrected));
+//#endregion
+//#region node_modules/@thi.ng/vectors/circular.js
+var circularMean = (angles) => headingXY(mean([], cartesian2FromAngles(angles)));
+var centerCircular = (out, angles) => {
+	const mean2 = circularMean(angles);
+	!out && (out = []);
+	for (let i = 0, n = angles.length; i < n; i++) out[i] = (angles[i] - mean2 + PI) % TAU;
+	return center(null, out);
+};
+var circularSD = (angles, corrected) => sd(centerCircular([], angles), true, corrected);
+//#endregion
+//#region node_modules/@thi.ng/vectors/max.js
+var [a$2, b$2, c$2, d$2] = defOpVV(Math.max);
+var vmax = (v) => {
+	let max5 = -Infinity;
+	for (let i = v.length; i-- > 0;) max5 = Math.max(max5, v[i]);
+	return max5;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/median.js
+var vmedian = (a) => {
+	if (!a.length) return 0;
+	const n = a.length;
+	const m = n >> 1;
+	a = [...a].sort((a2, b) => a2 - b);
+	return n & 1 ? a[m] : (a[m - 1] + a[m]) * .5;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/min.js
+var [a$1, b$1, c$1, d$1] = defOpVV(Math.min);
+var vmin = (v) => {
+	let min5 = Infinity;
+	for (let i = v.length; i-- > 0;) min5 = Math.min(min5, v[i]);
+	return min5;
+};
+//#endregion
+//#region node_modules/@thi.ng/metrics/metrics.js
+var defMetric = (values) => {
+	const [min, max] = valueRange(values);
+	return {
+		min,
+		max,
+		mean: vmean(values),
+		median: vmedian(values),
+		sd: sd(values)
+	};
+};
+var defWeightedMetric = (values, weights) => {
+	const [min, max] = valueRange(values);
+	return {
+		min,
+		max,
+		mean: vmean(values),
+		median: vmedian(values),
+		sd: sd(values),
+		weighted: dot(values, weights)
+	};
+};
+var defCircularMetric = (values) => {
+	const scaledValues = values.map((x) => x * TAU);
+	const mean = fract(circularMean(scaledValues) / TAU);
+	const [min, max] = circularRange(values, mean);
+	return {
+		min,
+		max,
+		mean,
+		median: __circularMedian(values, min, max),
+		sd: circularSD(scaledValues) / TAU
+	};
+};
+var valueRange = (values) => [vmin(values), vmax(values)];
+var circularRange = (values, mean) => {
+	const range = valueRange(values);
+	const [min, max] = range;
+	if (mean < min || mean > max) return [values.reduce((acc, x) => {
+		const d = fract(mean - x);
+		return d < .5 && d > acc[1] ? [x, d] : acc;
+	}, [max, fract(mean - max)])[0], values.reduce((acc, x) => {
+		const d = fract(x - mean);
+		return d < .5 && d > acc[1] ? [x, d] : acc;
+	}, [min, fract(min - mean)])[0]];
+	return range;
+};
+var __circularMedian = (values, min, max) => {
+	if (min <= max) return vmedian(values);
+	const n = values.length;
+	const m = n >> 1;
+	const sorted = [...values].sort((a, b) => a - b);
+	const split = sorted.findIndex((x) => x === min);
+	const reordered = sorted.slice(split).concat(sorted.slice(0, split));
+	return n & 1 ? reordered[m] : (reordered[m - 1] + reordered[m]) * .5;
+};
+//#endregion
+//#region node_modules/@thi.ng/checks/is-function.js
+var isFunction = (x) => typeof x === "function";
+//#endregion
+//#region node_modules/@thi.ng/vectors/distsq.js
+var distSq2 = (a, b) => {
+	const dx = a[0] - b[0];
+	const dy = a[1] - b[1];
+	return dx * dx + dy * dy;
+};
+var distSq3 = (a, b) => {
+	const dx = a[0] - b[0];
+	const dy = a[1] - b[1];
+	const dz = a[2] - b[2];
+	return dx * dx + dy * dy + dz * dz;
+};
+var distSq4 = (a, b) => {
+	const dx = a[0] - b[0];
+	const dy = a[1] - b[1];
+	const dz = a[2] - b[2];
+	const dw = a[3] - b[3];
+	return dx * dx + dy * dy + dz * dz + dw * dw;
+};
+var distSq = vop(0, (a, b) => {
+	let sum = 0;
+	for (let i = a.length; i-- > 0;) {
+		const d = a[i] - b[i];
+		sum += d * d;
+	}
+	return sum;
+}, distSq2, distSq3, distSq4);
+//#endregion
+//#region node_modules/@thi.ng/distance/squared.js
+var Squared = class {
+	constructor(metric) {
+		this.metric = metric;
+	}
+	to(x) {
+		return x * x;
+	}
+	from(x) {
+		return Math.sqrt(x);
+	}
+};
+var DIST_SQ = new Squared(distSq);
+var DIST_SQ1 = new Squared((a, b) => (a - b) ** 2);
+var DIST_SQ2 = new Squared(distSq2);
+var DIST_SQ3 = new Squared(distSq3);
+//#endregion
+//#region node_modules/@thi.ng/distance/argmin.js
+var argmin = (p, samples, dist = DIST_SQ) => {
+	const distFn = isFunction(dist) ? dist : dist.metric;
+	let minD = Infinity;
+	let minArg = -1;
+	for (let i = 0, n = samples.length; i < n; i++) {
+		const d = distFn(p, samples[i]);
+		if (d < minD) {
+			minD = d;
+			minArg = i;
+		}
+	}
+	return minArg;
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/setn.js
+var setN2 = (a, n) => {
+	a[0] = n;
+	a[1] = n;
+	return a;
+};
+var setN3 = (a, n) => {
+	a[0] = n;
+	a[1] = n;
+	a[2] = n;
+	return a;
+};
+var setN4 = (a, n) => {
+	a[0] = n;
+	a[1] = n;
+	a[2] = n;
+	a[3] = n;
+	return a;
+};
+var setN = vop(0, (a, n) => {
+	for (let i = a.length; i-- > 0;) a[i] = n;
+	return a;
+}, setN2, setN3, setN4);
+var zeroes = (n) => Array(n).fill(0);
+var ones = (n) => Array(n).fill(1);
+//#endregion
+//#region node_modules/@thi.ng/k-means/kmeans.js
+var kmeans = (k, samples, opts = {}) => {
+	let { dim = samples[0].length, dist = DIST_SQ, maxIter = 32, strategy = means, exponent, initial, rnd } = opts;
+	const num = samples.length;
+	const centroids = Array.isArray(initial) ? initial : initial ? initial(k, samples, dist, rnd) : kmeansPlusPlus(k, samples, dist, rnd, exponent);
+	assert(centroids.length > 0, `missing initial centroids`);
+	k = centroids.length;
+	const clusters = new Uint32Array(num).fill(k);
+	let update = true;
+	while (update && maxIter-- > 0) {
+		update = __assign(samples, centroids, clusters, dist);
+		if (!update) break;
+		for (let i = 0; i < k; i++) {
+			const impl = strategy(dim);
+			for (let j = 0; j < num; j++) i === clusters[j] && impl.update(samples[j]);
+			const centroid = impl.finish();
+			if (centroid) centroids[i] = centroid;
+		}
+	}
+	return __buildClusters(centroids, clusters);
+};
+var kmeansPlusPlus = (k, samples, dist = DIST_SQ, rnd = SYSTEM, exponent = 2) => {
+	const num = samples.length;
+	assert(num > 0, `missing samples`);
+	k = Math.min(k, num);
+	const centroidIDs = [rnd.int() % num];
+	const centroids = [samples[centroidIDs[0]]];
+	const indices = new Array(num).fill(0).map((_, i) => i);
+	const metric = dist.metric;
+	while (centroidIDs.length < k) {
+		let psum = 0;
+		const probs = samples.map((p) => {
+			const d = dist.from(metric(p, centroids[argmin(p, centroids, dist)])) ** exponent;
+			psum += d;
+			return d;
+		});
+		if (!psum) break;
+		let id;
+		do
+			id = weightedRandom(indices, probs, rnd)();
+		while (centroidIDs.includes(id));
+		centroidIDs.push(id);
+		centroids.push(samples[id]);
+	}
+	return centroids;
+};
+var __assign = (samples, centroids, assignments, dist) => {
+	let update = false;
+	for (let i = samples.length; i-- > 0;) {
+		const id = argmin(samples[i], centroids, dist);
+		if (id !== assignments[i]) {
+			assignments[i] = id;
+			update = true;
+		}
+	}
+	return update;
+};
+var __buildClusters = (centroids, assignments) => {
+	const clusters = [];
+	for (let i = 0, n = assignments.length; i < n; i++) {
+		const id = assignments[i];
+		(clusters[id] || (clusters[id] = {
+			id,
+			centroid: centroids[id],
+			items: []
+		})).items.push(i);
+	}
+	return clusters.filter((x) => !!x);
+};
+var means = (dim) => {
+	const acc = zeroes(dim);
+	let n = 0;
+	return {
+		update: (p) => {
+			add(acc, acc, p);
+			n++;
+		},
+		finish: () => n ? mulN(acc, acc, 1 / n) : void 0
+	};
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel-dominant-colors/utils.js
+var filterSamples = (pred, img) => {
+	const samples = [];
+	let i = 0;
+	for (const p of img) {
+		if (pred(p, i)) samples.push(p);
+		i++;
+	}
+	return samples;
+};
+//#endregion
+//#region node_modules/@thi.ng/pixel-dominant-colors/kmeans.js
+var dominantColorsKmeans = (img, num, opts) => {
+	const samples = opts?.filter ? filterSamples(opts.filter, img) : Array.isArray(img) ? img : [...img];
+	return samples.length ? kmeans(Math.min(num, samples.length), samples, opts).sort((a, b) => b.items.length - a.items.length).map((c) => ({
+		color: [...c.centroid],
+		area: c.items.length / samples.length,
+		ids: c.items
+	})) : [];
+};
+//#endregion
+//#region node_modules/@thi.ng/checks/is-iterable.js
+var isIterable = (x) => typeof x?.[Symbol.iterator] === "function";
+//#endregion
+//#region node_modules/@thi.ng/transducers/compr.js
+var compR = (rfn, fn) => [
+	rfn[0],
+	rfn[1],
+	fn
+];
+//#endregion
+//#region node_modules/@thi.ng/api/api.js
+var SEMAPHORE = Symbol();
+var NO_OP = () => {};
+//#endregion
+//#region node_modules/@thi.ng/transducers/ensure.js
+var ensureTransducer = (x) => implementsFunction(x, "xform") ? x.xform() : x;
+//#endregion
+//#region node_modules/@thi.ng/errors/illegal-arity.js
+var IllegalArityError = defError(() => "illegal arity");
+var illegalArity = (n) => {
+	throw new IllegalArityError(n);
+};
+//#endregion
+//#region node_modules/@thi.ng/transducers/reduced.js
+var Reduced = class {
+	value;
+	constructor(val) {
+		this.value = val;
+	}
+	deref() {
+		return this.value;
+	}
+};
+var isReduced = (x) => x instanceof Reduced;
+var ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
+var unreduced = (x) => x instanceof Reduced ? x.deref() : x;
+//#endregion
+//#region node_modules/@thi.ng/transducers/reduce.js
+var __parseArgs = (args) => args.length === 2 ? [void 0, args[1]] : args.length === 3 ? [args[1], args[2]] : illegalArity(args.length);
+function reduce(...args) {
+	const rfn = args[0];
+	const init = rfn[0];
+	const complete = rfn[1];
+	const reduce2 = rfn[2];
+	args = __parseArgs(args);
+	const acc = args[0] == null ? init() : args[0];
+	const src = args[1];
+	return unreduced(complete(implementsFunction(src, "$reduce") ? src.$reduce(reduce2, acc) : isArrayLike(src) ? __reduceArray(reduce2, acc, src) : __reduceIterable(reduce2, acc, src)));
+}
+var __reduceArray = (rfn, acc, src) => {
+	for (let i = 0, n = src.length; i < n; i++) {
+		acc = rfn(acc, src[i]);
+		if (isReduced(acc)) {
+			acc = acc.deref();
+			break;
+		}
+	}
+	return acc;
+};
+var __reduceIterable = (rfn, acc, src) => {
+	for (const x of src) {
+		acc = rfn(acc, x);
+		if (isReduced(acc)) {
+			acc = acc.deref();
+			break;
+		}
+	}
+	return acc;
+};
+var reducer = (init, rfn) => [
+	init,
+	identity$1,
+	rfn
+];
+var $$reduce = (rfn, args) => {
+	const n = args.length - 1;
+	return isIterable(args[n]) ? args.length > 1 ? reduce(rfn.apply(null, args.slice(0, n)), args[n]) : reduce(rfn(), args[0]) : void 0;
+};
+//#endregion
+//#region node_modules/@thi.ng/transducers/push.js
+function push(src) {
+	return src ? [...src] : reducer(() => [], (acc, x) => (acc.push(x), acc));
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/iterator.js
+function* iterator(xform, src) {
+	const rfn = ensureTransducer(xform)(push());
+	const complete = rfn[1];
+	const reduce = rfn[2];
+	for (const x of src) {
+		const y = reduce([], x);
+		if (isReduced(y)) {
+			yield* unreduced(complete(y.deref()));
+			return;
+		}
+		if (y.length) yield* y;
+	}
+	yield* unreduced(complete([]));
+}
+function* iterator1(xform, src) {
+	const reduce = ensureTransducer(xform)([
+		NO_OP,
+		NO_OP,
+		(_, x) => x
+	])[2];
+	for (const x of src) {
+		let y = reduce(SEMAPHORE, x);
+		if (isReduced(y)) {
+			y = unreduced(y.deref());
+			if (y !== SEMAPHORE) yield y;
+			return;
+		}
+		if (y !== SEMAPHORE) yield y;
+	}
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/map.js
+function map(fn, src) {
+	return isIterable(src) ? iterator1(map(fn), src) : (rfn) => {
+		const r = rfn[2];
+		return compR(rfn, (acc, x) => r(acc, fn(x)));
+	};
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/max.js
+function max(src) {
+	return src ? reduce(max(), src) : reducer(() => -Infinity, (acc, x) => Math.max(acc, x));
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/permutations.js
+function* permutations(...src) {
+	const n = src.length - 1;
+	if (n < 0) return;
+	const step = new Array(n + 1).fill(0);
+	const realized = src.map(ensureArrayLike);
+	const total = realized.reduce((acc, x) => acc * x.length, 1);
+	for (let i = 0; i < total; i++) {
+		const tuple = [];
+		for (let j = n; j >= 0; j--) {
+			const r = realized[j];
+			let s = step[j];
+			if (s === r.length) {
+				step[j] = s = 0;
+				j > 0 && step[j - 1]++;
+			}
+			tuple[j] = r[s];
+		}
+		step[n]++;
+		yield tuple;
+	}
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/transduce.js
+function transduce(...args) {
+	return $transduce(transduce, reduce, args);
+}
+var $transduce = (tfn, rfn, args) => {
+	let acc, src;
+	switch (args.length) {
+		case 4:
+			src = args[3];
+			acc = args[2];
+			break;
+		case 3:
+			src = args[2];
+			break;
+		case 2: return map((x) => tfn(args[0], args[1], x));
+		default: illegalArity(args.length);
+	}
+	return rfn(ensureTransducer(args[0])(args[1]), acc, src);
+};
+//#endregion
+//#region node_modules/@thi.ng/vectors/roundn.js
+var [a, b, c, d] = defOpVN(roundTo);
+var roundN = a;
+//#endregion
+//#region node_modules/@thi.ng/math/step.js
+var smoothStep = (edge, edge2, x) => smoothStep01(clamp01((x - edge) / (edge2 - edge)));
+var smoothStep01 = (x) => x * x * (3 - 2 * x);
+//#endregion
+//#region node_modules/@thi.ng/compose/comp.js
+function comp$1(...fns) {
+	let [a, b, c, d, e, f, g, h, i, j] = fns;
+	switch (fns.length) {
+		case 0: illegalArity(0);
+		case 1: return a;
+		case 2: return (...args) => a(b(...args));
+		case 3: return (...args) => a(b(c(...args)));
+		case 4: return (...args) => a(b(c(d(...args))));
+		case 5: return (...args) => a(b(c(d(e(...args)))));
+		case 6: return (...args) => a(b(c(d(e(f(...args))))));
+		case 7: return (...args) => a(b(c(d(e(f(g(...args)))))));
+		case 8: return (...args) => a(b(c(d(e(f(g(h(...args))))))));
+		case 9: return (...args) => a(b(c(d(e(f(g(h(i(...args)))))))));
+		default:
+			const fn = (...args) => a(b(c(d(e(f(g(h(i(j(...args))))))))));
+			return fns.length === 10 ? fn : comp$1(fn, ...fns.slice(10));
+	}
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/comp.js
+function comp(...fns) {
+	fns = fns.map(ensureTransducer);
+	return comp$1.apply(null, fns);
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/count.js
+function count(...args) {
+	const res = $$reduce(count, args);
+	if (res !== void 0) return res;
+	const [offset = 0, step = 1] = args;
+	return reducer(() => offset, (acc, _) => acc + step);
+}
+//#endregion
+//#region node_modules/@thi.ng/compose/identity.js
+var identity = (x) => x;
+//#endregion
+//#region node_modules/@thi.ng/transducers/internal/group-opts.js
+var __groupByOpts = (opts) => ({
+	key: (x) => x,
+	group: push(),
+	...opts
+});
+//#endregion
+//#region node_modules/@thi.ng/transducers/group-by-map.js
+function groupByMap(...args) {
+	const res = $$reduce(groupByMap, args);
+	if (res !== void 0) return res;
+	const opts = __groupByOpts(args[0]);
+	const [init, complete, reduce] = opts.group;
+	return [
+		() => new Map(),
+		(acc) => {
+			for (const k of acc.keys()) acc.set(k, complete(acc.get(k)));
+			return acc;
+		},
+		(acc, x) => {
+			const k = opts.key(x);
+			return acc.set(k, acc.has(k) ? reduce(acc.get(k), x) : reduce(init(), x));
+		}
+	];
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/frequencies.js
+function frequencies(...args) {
+	return $$reduce(frequencies, args) || groupByMap({
+		key: args[0] || identity,
+		group: count()
+	});
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/norm-frequencies-auto.js
+function normFrequenciesAuto(...args) {
+	const res = $$reduce(normFrequenciesAuto, args);
+	if (res !== void 0) return res;
+	const [init, complete, reduce] = frequencies(...args);
+	let norm = 0;
+	return [
+		init,
+		(acc) => {
+			acc = complete(acc);
+			for (const p of acc) acc.set(p[0], p[1] / norm);
+			return acc;
+		},
+		(acc, x) => (norm++, reduce(acc, x))
+	];
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/cat.js
+var cat = () => (rfn) => {
+	const r = rfn[2];
+	return compR(rfn, (acc, x) => {
+		if (x) for (const y of unreduced(x) || []) {
+			acc = r(acc, y);
+			if (isReduced(acc)) break;
+		}
+		return isReduced(x) ? ensureReduced(acc) : acc;
+	});
+};
+//#endregion
+//#region node_modules/@thi.ng/transducers/mapcat.js
+function mapcat(fn, src) {
+	return isIterable(src) ? iterator(mapcat(fn), src) : comp(map(fn), cat());
+}
+//#endregion
+//#region node_modules/@thi.ng/transducers/repeat.js
+function* repeat(x, n = Infinity) {
+	while (n-- > 0) yield x;
+}
+//#endregion
+//#region node_modules/@thi.ng/pixel-analysis/hues.js
+var temperature = (colors, minSat = .2, coeffs) => {
+	const $colors = ensureArray(colors);
+	const filtered = $colors.filter((x) => x[1] >= minSat);
+	const area = filtered.length / $colors.length;
+	const hues = [...transduce(map((x) => roundTo(x[0], 1 / 12) % 1), normFrequenciesAuto(), filtered)].sort(compareByKey(0));
+	const angles = [...mapcat(([hue, num]) => {
+		num *= 50;
+		return num >= 1 ? repeat(hue * TAU, num) : null;
+	}, hues)];
+	if (!angles.length) return {
+		hues,
+		meanHue: 0,
+		temp: 0,
+		areaTemp: 0,
+		area: 0
+	};
+	const meanHue = circularMean(angles) / TAU;
+	const temp = hueTemperature(meanHue, coeffs);
+	return {
+		hues,
+		meanHue,
+		temp,
+		areaTemp: temp * area,
+		area
+	};
+};
+var DEFAULT_TEMPERATURE_COEFFS = [
+	.1,
+	.6,
+	.72,
+	.92
+];
+var hueTemperature = (hue, [a, b, c, d] = DEFAULT_TEMPERATURE_COEFFS) => 2 * (hue < 2 / 3 ? smoothStep(b, a, hue) : smoothStep(c, d, hue)) - 1;
+//#endregion
+//#region node_modules/@thi.ng/pixel-analysis/analyze-colors.js
+var analyzeColors = (img, opts) => {
+	let $img = img.format !== FLOAT_RGBA ? img.as(FLOAT_RGBA) : img;
+	if (opts?.size) $img = __resize($img, opts.size);
+	const imgGray = $img.as(FLOAT_GRAY);
+	const imgHsv = $img.as(FLOAT_HSVA);
+	const colors = __dominantColors($img, opts);
+	const colorAreas = colors.map((x) => x.area);
+	const derived = deriveColorResults(colors.map((x) => x.color), colorAreas, opts?.minSat, opts?.tempCoeffs);
+	const lumImg = defMetric(imgGray.data);
+	return {
+		...derived,
+		img: $img,
+		imgGray,
+		imgHsv,
+		lumImg,
+		temperature: temperature(imgHsv, opts?.minSat, opts?.tempCoeffs),
+		contrastImg: lumImg.max - lumImg.min
+	};
+};
+var deriveColorResults = (colors, areas = ones(colors.length), minSat, tempCoeffs) => {
+	const dominantLuma = colors.map((x) => luminanceSrgb(x));
+	const dominantSrgb = colors.map((x) => srgb(x));
+	const dominantHsv = dominantSrgb.map((x) => hsv(x));
+	const dominantOklch = dominantSrgb.map((x) => oklch(x));
+	const dominantCss = dominantSrgb.map((x) => css(x));
+	const hues = dominantHsv.map((x) => x[0]);
+	const sats = dominantHsv.map((x) => x[1]);
+	const lum = defWeightedMetric(dominantLuma, areas);
+	return {
+		css: dominantCss,
+		srgb: dominantSrgb,
+		hsv: dominantHsv,
+		oklch: dominantOklch,
+		hue: defCircularMetric(hues),
+		sat: defWeightedMetric(sats, areas),
+		chroma: defWeightedMetric(dominantOklch.map((x) => x[1]), areas),
+		lum,
+		areas,
+		contrast: lum.max - lum.min,
+		colorContrast: fit(transduce(map((pair) => contrast(...pair)), max(), permutations(dominantSrgb, dominantSrgb)), 1, 21, 0, 1),
+		temperature: temperature(dominantHsv, minSat, tempCoeffs)
+	};
+};
+var __dominantColors = (img, { dominantFn = dominantColorsKmeans, numColors = 4, prec = .001 } = {}) => dominantFn(img, numColors).sort(compareByKey("area", compareNumDesc)).map((x) => (roundN(null, x.color, prec), x));
+var __resize = ($img, size) => {
+	size = ~~size;
+	let w = $img.width;
+	let h = $img.height;
+	[w, h] = w > h ? [size, ~~Math.max(1, h / w * size)] : [~~Math.max(1, w / h * size), size];
+	return $img.resize(w, h);
+};
+//#endregion
+//#region lib/utilities/general.js
+/**
+* Options for extracting colors / evaluating lightness from an image.
+* @property {boolean} isDark - Whether the image is considered dark overall.
+* @property {boolean} isTransparent - Whether the image has any transparency.
+* @property {{ any: boolean, left: boolean, right: boolean, top: boolean, bottom: boolean }} transparencyInfo - More detailed transparency info.
+* @property {Array<{ color: string, area: number, isDark: boolean }>} dominantColors - Dominant colors extracted from the image.
+* @property {Array} dominantColors.<index>.color - The color value.
+* @property {Array} dominantColors.<index>.area - The area occupied by this color (0 - 1).
+* @property {Array} dominantColors.<index>.isDark - Whether this color is considered dark.
+*/
+/**
+* Options for extracting colors / evaluating lightness from an image.
+* @property {number} [numColors=2] - Number of dominant colors to return.
+* @property {number} [lightnessThreshold=0.5] - Threshold (0.0 - 1.0) used to decide if a color is considered "light".
+* @property {number} [yFrom=0.0] - Minimum Y (luminance) value (0.0 - 1.0) to include when evaluating lightness.
+* @property {number} [yTo=1.0] - Maximum Y (luminance) value (0.0 - 1.0) to include when evaluating lightness.
+* @property {number} [maxSize=320] - Maximum width/height to scale down the image to before analysis, for performance.
+* @property {number} [alphaThreshold=30] - Threhold (0-255) below which a pixel is considered "transparent" for the purposes of analysis.
+*/
+var defaultAnalysisSettings = {
+	numColors: 3,
+	lightnessThreshold: .5,
+	yFrom: 0,
+	yTo: 1,
+	maxSize: 320,
+	alphaThreshold: 30
+};
+/**
+* Analyze an image element to determine overall luminance, dominant colors and transparency.
+* @param {ImageAnalysisSettings} [settings] - Optional settings to customize the analysis.
+*   Returns an object on success:
+*     - isDark: true if the computed mean image luminance is below 0.5.
+*     - dominantColors: an array of up to the requested number of dominant colors. Each entry contains:
+*         - color: CSS color string (as produced by the analyzer).
+*         - area: the relative area (weight) of that color.
+*         - isDark: boolean indicating whether the color's lightness (oklch.l) is < 0.5.
+*     - isTransparent: true if any inspected pixel has alpha < 255.
+*   Returns false if an error occurred during analysis.
+*/
+var analyzeImage = (image, rawSettings) => {
+	const settings = {
+		...defaultAnalysisSettings,
+		...rawSettings
+	};
+	const { yFrom, yTo, maxSize } = settings;
+	const cacheKey = `es-uic-img-analysis-${cyrb64Hash(image.src)}`;
+	if (localStorage?.getItem(cacheKey)) return JSON.parse(localStorage.getItem(cacheKey));
+	try {
+		const fileExtension = getFileExtension(image.src);
+		let skipTransparencyCheck = false;
+		if (fileExtension) skipTransparencyCheck = ![
+			"png",
+			"webp",
+			"gif",
+			"tiff",
+			"svg",
+			"avif"
+		].includes(fileExtension);
+		let imageWidth = image.naturalWidth || image.width;
+		let imageHeight = image.naturalHeight || image.height;
+		if (!image.complete) throw new Error("Image not fully loaded");
+		if (!imageWidth || !imageHeight) return false;
+		let imageScale = 1;
+		if (imageWidth > maxSize || imageHeight > maxSize) imageScale = Math.min(maxSize / imageWidth, maxSize / imageHeight);
+		const imageWidthScaled = Math.floor(imageWidth * imageScale);
+		const imageHeightScaled = Math.floor(imageHeight * imageScale);
+		const srcX = 0;
+		const srcY = Math.floor(yFrom * imageHeight);
+		const srcW = Math.max(1, imageWidth);
+		const srcH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeight));
+		const destW = Math.max(1, imageWidthScaled);
+		const destH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeightScaled));
+		const colorCanvas = document.createElement("canvas");
+		colorCanvas.width = destW;
+		colorCanvas.height = destH;
+		colorCanvas.getContext("2d").drawImage(image, srcX, srcY, srcW, srcH, 0, 0, destW, destH);
+		const buffer = floatBufferFromCanvas(colorCanvas, FLOAT_RGBA);
+		let imageData = null;
+		if (!skipTransparencyCheck) {
+			const transparencyCanvas = document.createElement("canvas");
+			transparencyCanvas.width = imageWidthScaled;
+			transparencyCanvas.height = imageHeightScaled;
+			const transparencyContext = transparencyCanvas.getContext("2d", { willReadFrequently: true });
+			transparencyContext.drawImage(image, 0, 0, imageWidth, imageHeight, 0, 0, imageWidthScaled, imageHeightScaled);
+			imageData = transparencyContext.getImageData(0, 0, imageWidthScaled, imageHeightScaled).data;
+		}
+		const result = analyzeImageData({
+			buffer,
+			imageData,
+			width: imageWidthScaled,
+			height: imageHeightScaled,
+			settings,
+			skipTransparencyCheck,
+			fileName: image.src
+		});
+		localStorage?.setItem(cacheKey, JSON.stringify(result));
+		return result;
+	} catch (error) {
+		console.error("Error analyzing image:", error);
+		return false;
+	}
+};
+/**
+* Async version of analyzeImage for use in web workers or off-main-thread contexts.
+* Accepts image data as ArrayBuffer, Blob, or ImageBitmap, and uses OffscreenCanvas.
+* @param {ImageAnalysisSettings} [settings] - Optional settings to customize the analysis.
+*   Returns a promise resolving to the analysis result object, or false if an error occurred.
+*/
+var analyzeImageAsync = async (imageSource, rawSettings, fbfc, fr, ac, dck, srgbFn, cssFn) => {
+	const settings = Object.assign({}, {
+		numColors: 3,
+		lightnessThreshold: .5,
+		yFrom: 0,
+		yTo: 1,
+		maxSize: 600,
+		alphaThreshold: 50
+	}, rawSettings);
+	const numColors = settings.numColors;
+	const lightnessThreshold = settings.lightnessThreshold;
+	const yFrom = settings.yFrom;
+	const yTo = settings.yTo;
+	const maxSize = settings.maxSize;
+	const alphaThreshold = settings.alphaThreshold;
+	const getFileExt = (input) => {
+		try {
+			const match = new URL(input).pathname.match(/\.([a-zA-Z0-9]+)(?:\?|#|$)/);
+			return match ? match[1].toLowerCase() : null;
+		} catch {
+			return null;
+		}
+	};
+	const isColorDark = (r, g, b, threshold) => {
+		return (.299 * r + .587 * g + .114 * b) / 255 < threshold;
+	};
+	const checkTransparency = (imageData, w, h) => {
+		const transparency = {
+			any: true,
+			left: true,
+			right: true,
+			top: true,
+			bottom: true
+		};
+		let counts = {
+			any: 0,
+			left: 0,
+			right: 0,
+			top: 0,
+			bottom: 0
+		};
+		const perimeterThresholdW = Math.floor(.15 * w);
+		const perimeterThresholdH = Math.floor((h > 100 ? .075 : .75) * h);
+		const innerThreshold = Math.floor(w * h * .001);
+		if (w > 0 && h > 0) {
+			for (let x = 0; x < w; x++) if (imageData[(0 * w + x) * 4 + 3] > alphaThreshold) {
+				counts.top++;
+				if (counts.top >= perimeterThresholdW) {
+					transparency.top = false;
+					break;
+				}
+			}
+			for (let x = 0; x < w; x++) if (imageData[((h - 1) * w + x) * 4 + 3] > alphaThreshold) {
+				counts.bottom++;
+				if (counts.bottom >= perimeterThresholdW) {
+					transparency.bottom = false;
+					break;
+				}
+			}
+			for (let y = 0; y < h; y++) if (imageData[(y * w + 0) * 4 + 3] > alphaThreshold) {
+				counts.left++;
+				if (counts.left >= perimeterThresholdH) {
+					transparency.left = false;
+					break;
+				}
+			}
+			for (let y = 0; y < h; y++) if (imageData[(y * w + (w - 1)) * 4 + 3] > alphaThreshold) {
+				counts.right++;
+				if (counts.right >= perimeterThresholdH) {
+					transparency.right = false;
+					break;
+				}
+			}
+			if (!transparency.top && !transparency.bottom && !transparency.left && !transparency.right) {
+				for (let i = 3; i < imageData.length; i += 4) if (imageData[i] > alphaThreshold) {
+					counts.any++;
+					if (counts.any >= innerThreshold) {
+						transparency.any = false;
+						break;
+					}
+				}
+			} else transparency.any = true;
+		}
+		return transparency;
+	};
+	try {
+		let imageBitmap;
+		if (typeof imageSource === "string") imageBitmap = await createImageBitmap(await (await fetch(imageSource)).blob());
+		else if (imageSource instanceof Blob) imageBitmap = await createImageBitmap(imageSource);
+		else if (imageSource instanceof ArrayBuffer) imageBitmap = await createImageBitmap(new Blob([imageSource]));
+		else if (imageSource instanceof ImageBitmap) imageBitmap = imageSource;
+		else throw new Error("Unsupported imageSource type");
+		const imageWidth = imageBitmap.width;
+		const imageHeight = imageBitmap.height;
+		if (!imageWidth || !imageHeight) return false;
+		let imageScale = 1;
+		if (imageWidth > maxSize || imageHeight > maxSize) imageScale = Math.min(maxSize / imageWidth, maxSize / imageHeight);
+		const imageWidthScaled = Math.floor(imageWidth * imageScale);
+		const imageHeightScaled = Math.floor(imageHeight * imageScale);
+		const srcX = 0;
+		const srcY = Math.floor(yFrom * imageHeight);
+		const srcW = Math.max(1, imageWidth);
+		const srcH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeight));
+		const destW = Math.max(1, imageWidthScaled);
+		const destH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeightScaled));
+		const colorCanvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(destW, destH) : (() => {
+			const c = document.createElement("canvas");
+			c.width = destW;
+			c.height = destH;
+			return c;
+		})();
+		colorCanvas.getContext("2d").drawImage(imageBitmap, srcX, srcY, srcW, srcH, 0, 0, destW, destH);
+		const data = ac(fbfc(colorCanvas, fr), {
+			numColors,
+			dominantFn: (pixels, num) => dck(pixels, num, { filter: (p) => {
+				const { alpha } = srgbFn(p);
+				return alpha > 0;
+			} }),
+			prec: .01
+		});
+		const { lumImg, srgb: srgbData, areas: colorAreas } = data;
+		if (!Array.isArray(srgbData)) {
+			console.error("srgbData is not an array:", srgbData, "Full data:", data);
+			return false;
+		}
+		let transparencyInfo = false;
+		let skipTransparencyCheck = false;
+		if (typeof imageSource === "string") {
+			const fileExtension = getFileExt(imageSource);
+			if (fileExtension) skipTransparencyCheck = ![
+				"png",
+				"webp",
+				"gif",
+				"tiff",
+				"svg",
+				"avif"
+			].includes(fileExtension);
+		}
+		if (!skipTransparencyCheck) {
+			const transparencyContext = (typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(imageWidthScaled, imageHeightScaled) : (() => {
+				const c = document.createElement("canvas");
+				c.width = imageWidthScaled;
+				c.height = imageHeightScaled;
+				return c;
+			})()).getContext("2d");
+			transparencyContext.drawImage(imageBitmap, 0, 0, imageWidth, imageHeight, 0, 0, imageWidthScaled, imageHeightScaled);
+			const imageData = transparencyContext.getImageData(0, 0, imageWidthScaled, imageHeightScaled).data;
+			transparencyInfo = checkTransparency(imageData, imageWidthScaled, imageHeightScaled);
+		}
+		return {
+			isDark: lumImg.mean < lightnessThreshold,
+			isTransparent: skipTransparencyCheck ? false : transparencyInfo?.any,
+			transparencyInfo: skipTransparencyCheck ? null : transparencyInfo,
+			dominantColors: srgbData.map(({ r, g, b }, index) => ({
+				color: cssFn([
+					r,
+					g,
+					b
+				]),
+				area: colorAreas?.[index],
+				isDark: isColorDark(r * 255, g * 255, b * 255, lightnessThreshold)
+			}))
+		};
+	} catch (error) {
+		console.error("Error analyzing image (async):", error);
+		return false;
+	}
+};
+/**
+* Check image transparency by analyzing pixel alpha values.
+* @param {number} w - The width of the image.
+* @param {number} h - The height of the image.
+* @param {ImageAnalysisSettings} [settings] - Optional settings to customize the transparency check.
+*/
+var checkTransparency = (imageData, w, h, settings = {}) => {
+	const { alphaThreshold } = {
+		...defaultAnalysisSettings,
+		...settings
+	};
+	const transparency = {
+		any: true,
+		left: true,
+		right: true,
+		top: true,
+		bottom: true
+	};
+	let counts = {
+		any: 0,
+		left: 0,
+		right: 0,
+		top: 0,
+		bottom: 0
+	};
+	const perimeterThresholdW = Math.floor(.15 * w);
+	const perimeterThresholdH = Math.floor((h > 100 ? .05 : .5) * h);
+	const innerThreshold = Math.floor(w * h * .001);
+	if (w > 0 && h > 0) {
+		for (let x = 0; x < w; x++) if (imageData[(0 * w + x) * 4 + 3] > alphaThreshold) {
+			counts.top++;
+			if (counts.top >= perimeterThresholdW) {
+				transparency.top = false;
+				break;
+			}
+		}
+		for (let x = 0; x < w; x++) if (imageData[((h - 1) * w + x) * 4 + 3] > alphaThreshold) {
+			counts.bottom++;
+			if (counts.bottom >= perimeterThresholdW) {
+				transparency.bottom = false;
+				break;
+			}
+		}
+		for (let y = 0; y < h; y++) if (imageData[(y * w + 0) * 4 + 3] > alphaThreshold) {
+			counts.left++;
+			if (counts.left >= perimeterThresholdH) {
+				transparency.left = false;
+				break;
+			}
+		}
+		for (let y = 0; y < h; y++) if (imageData[(y * w + (w - 1)) * 4 + 3] > alphaThreshold) {
+			counts.right++;
+			if (counts.right >= perimeterThresholdH) {
+				transparency.right = false;
+				break;
+			}
+		}
+		if (!transparency.top && !transparency.bottom && !transparency.left && !transparency.right) {
+			for (let i = 3; i < imageData.length; i += 4) if (imageData[i] > alphaThreshold) {
+				counts.any++;
+				if (counts.any >= innerThreshold) {
+					transparency.any = false;
+					break;
+				}
+			}
+		} else transparency.any = true;
+	}
+	return transparency;
+};
+/**
+* Get file extension from a URL string.
+* getFileExtension('https://example.com/image.png'); // 'png'
+* getFileExtension('https://example.com/archive.tar.gz'); // 'gz'
+* getFileExtension('https://example.com/no-extension'); // null
+*/
+var getFileExtension = (input) => {
+	const match = new URL(input).pathname.match(/\.([a-zA-Z0-9]+)(?:\?|#|$)/);
+	return match ? match[1].toLowerCase() : null;
+};
+/**
+* Determine if a color is considered "dark" based on its RGB values and a lightness threshold.
+* @param {number} g - Green component (0-255).
+* @param {number} b - Blue component (0-255).
+* @param {number} [threshold=0.5] - Lightness threshold (0.0 - 1.0) below which the color is considered dark.
+* isColorDark(0, 0, 0); // true (black)
+* isColorDark(255, 255, 255); // false (white)
+* isColorDark(100, 100, 100, 0.4); // false (gray with higher threshold)
+*/
+var isColorDark = (r, g, b, threshold = .5) => {
+	return (.299 * r + .587 * g + .114 * b) / 255 < threshold;
+};
+/**
+* Core analysis logic shared by both main thread and worker.
+* @prop {Float32Array} buffer - Float32Array RGBA buffer (from floatBufferFromCanvas)
+* @prop {Uint8ClampedArray} imageData - Uint8ClampedArray (from getImageData)
+* @prop {number} width - Image width
+* @prop {number} height - Image height
+* @prop {ImageAnalysisSettings} settings - Analysis settings
+* @prop {boolean} skipTransparencyCheck - Boolean to skip transparency check
+*/
+var analyzeImageData = ({ buffer, imageData, width, height, settings, skipTransparencyCheck = false }) => {
+	const { numColors, lightnessThreshold } = settings;
+	const { lumImg, srgb: srgbData, areas: colorAreas } = analyzeColors(buffer, {
+		numColors,
+		dominantFn: (pixels, num) => dominantColorsKmeans(pixels, num, { filter: (p) => srgb(p).alpha > 0 }),
+		prec: .01
+	});
+	let transparencyInfo = false;
+	if (!skipTransparencyCheck && imageData) transparencyInfo = checkTransparency(imageData, width, height, settings);
+	return {
+		isDark: lumImg.mean < lightnessThreshold,
+		isTransparent: skipTransparencyCheck ? false : transparencyInfo?.any,
+		transparencyInfo: skipTransparencyCheck ? null : transparencyInfo,
+		dominantColors: srgbData.map(({ r, g, b }, index) => ({
+			color: css([
+				r,
+				g,
+				b
+			]),
+			area: colorAreas?.[index],
+			isDark: isColorDark(r * 255, g * 255, b * 255, lightnessThreshold)
+		}))
+	};
+};
+//#endregion
+export { getFileExtension as a, FLOAT_RGBA as c, checkTransparency as i, floatBufferFromCanvas as l, analyzeImageAsync as n, isColorDark as o, analyzeImageData as r, srgb as s, analyzeImage as t };