shaders 3.0.447 → 3.0.449

package/dist/core/{Dither-B33J_gJU.js → Dither-Cxu-hSc_.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Ht as call, J as std, Kt as floatE, Tn as d, Vt as arrayExpr, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Dt as min, It as sin, N as unpremultiplyAlpha, Ot as mix, Ut as arrayOf, Vt as data_exports, _ as floatE, an as f32, bt as dot, d as ZERO, et as src_default, f as arrayExpr, in as vec4f, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, wt as fract, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var transformPattern = (value) => {
 	return {
 		bayer2: 0,
@@ -14,13 +14,13 @@ var transformPattern = (value) => {
 var transformColorMode = (value) => value === "source" ? 1 : 0;
 var patternModeOf = (raw) => typeof raw === "number" ? raw : transformPattern(raw);
 var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "source" ? 1 : 0;
-const ditherCoord = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridRes, pixelSize) => {
+const ditherCoord = src_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridRes, pixelSize) => {
 	"use gpu";
-	return std.floor(d.vec2f(__tsover_div(__tsover_mul(uv.x, gridRes.x), pixelSize), __tsover_div(__tsover_mul(uv.y, gridRes.y), pixelSize)));
+	return floor(vec2f(__tsover_div(__tsover_mul(uv.x, gridRes.x), pixelSize), __tsover_div(__tsover_mul(uv.y, gridRes.y), pixelSize)));
 }), {
 	v: 1,
 	name: void 0,
@@ -95,17 +95,17 @@ const ditherCoord = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherPixUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, pixelSize, gridRes) => {
+const ditherPixUV = src_default.fn([
+	vec2f,
+	f32,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, pixelSize, gridRes) => {
 	"use gpu";
-	return d.vec2f(__tsover_div(__tsover_mul(__tsover_add(coord.x, .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(coord.y, .5), pixelSize), gridRes.y));
+	return vec2f(__tsover_div(__tsover_mul(__tsover_add(coord.x, .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(coord.y, .5), pixelSize), gridRes.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -181,11 +181,11 @@ const ditherPixUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const ditherLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
+const ditherLuma = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
 	"use gpu";
-	return __tsover_mul(std.dot(d.vec3f(c.x, c.y, c.z), d.vec3f(.299, .587, .114)), c.w);
+	return __tsover_mul(dot(vec3f(c.x, c.y, c.z), vec3f(.299, .587, .114)), c.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -251,11 +251,11 @@ const ditherLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherBayerQuad = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b) => {
+const ditherBayerQuad = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b) => {
 	"use gpu";
 	return __tsover_sub(__tsover_add(__tsover_mul(b, 3), __tsover_mul(a, 2)), __tsover_mul(__tsover_mul(a, b), 4));
 }), {
@@ -304,42 +304,42 @@ const ditherBayerQuad = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (
 	},
 	externals: () => ({})
 }) && $.f)({}));
-const ditherPeriodic = tgpu.fn([d.vec2f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+const ditherPeriodic = src_default.fn([vec2f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
 	"use gpu";
-	const tx = __tsover_sub(coord.x, __tsover_mul(8, std.floor(__tsover_div(coord.x, 8))));
-	const ty = __tsover_sub(coord.y, __tsover_mul(8, std.floor(__tsover_div(coord.y, 8))));
-	const x2 = __tsover_sub(tx, __tsover_mul(2, std.floor(__tsover_div(tx, 2))));
-	const y2 = __tsover_sub(ty, __tsover_mul(2, std.floor(__tsover_div(ty, 2))));
-	const x4 = __tsover_sub(tx, __tsover_mul(4, std.floor(__tsover_div(tx, 4))));
-	const y4 = __tsover_sub(ty, __tsover_mul(4, std.floor(__tsover_div(ty, 4))));
-	const x4h = std.floor(__tsover_div(x4, 2));
-	const y4h = std.floor(__tsover_div(y4, 2));
-	const x8h = std.floor(__tsover_div(tx, 4));
-	const y8h = std.floor(__tsover_div(ty, 4));
+	const tx = __tsover_sub(coord.x, __tsover_mul(8, floor(__tsover_div(coord.x, 8))));
+	const ty = __tsover_sub(coord.y, __tsover_mul(8, floor(__tsover_div(coord.y, 8))));
+	const x2 = __tsover_sub(tx, __tsover_mul(2, floor(__tsover_div(tx, 2))));
+	const y2 = __tsover_sub(ty, __tsover_mul(2, floor(__tsover_div(ty, 2))));
+	const x4 = __tsover_sub(tx, __tsover_mul(4, floor(__tsover_div(tx, 4))));
+	const y4 = __tsover_sub(ty, __tsover_mul(4, floor(__tsover_div(ty, 4))));
+	const x4h = floor(__tsover_div(x4, 2));
+	const y4h = floor(__tsover_div(y4, 2));
+	const x8h = floor(__tsover_div(tx, 4));
+	const y8h = floor(__tsover_div(ty, 4));
 	const b00 = ditherBayerQuad(x2, y2);
 	const b11 = ditherBayerQuad(x4h, y4h);
 	const b22 = ditherBayerQuad(x8h, y8h);
 	const bayer2 = __tsover_div(b00, 4);
 	const bayer4 = __tsover_div(__tsover_add(__tsover_mul(b00, 4), b11), 16);
 	const bayer8 = __tsover_div(__tsover_add(__tsover_add(__tsover_mul(b00, 16), __tsover_mul(b11, 4)), b22), 64);
-	const idx = __tsover_add(__tsover_mul(d.i32(y4), 4), d.i32(x4));
+	const idx = __tsover_add(__tsover_mul(i32(y4), 4), i32(x4));
 	let cd = .75;
-	cd = std.select(cd, .3125, idx === 1);
-	cd = std.select(cd, .375, idx === 2);
-	cd = std.select(cd, .8125, idx === 3);
-	cd = std.select(cd, .25, idx === 4);
-	cd = std.select(cd, d.f32(0), idx === 5);
-	cd = std.select(cd, .0625, idx === 6);
-	cd = std.select(cd, .4375, idx === 7);
-	cd = std.select(cd, .6875, idx === 8);
-	cd = std.select(cd, .1875, idx === 9);
-	cd = std.select(cd, .125, idx === 10);
-	cd = std.select(cd, .5, idx === 11);
-	cd = std.select(cd, .9375, idx === 12);
-	cd = std.select(cd, .625, idx === 13);
-	cd = std.select(cd, .5625, idx === 14);
-	cd = std.select(cd, .875, idx === 15);
-	return d.vec4f(bayer2, bayer4, bayer8, cd);
+	cd = select(cd, .3125, idx === 1);
+	cd = select(cd, .375, idx === 2);
+	cd = select(cd, .8125, idx === 3);
+	cd = select(cd, .25, idx === 4);
+	cd = select(cd, f32(0), idx === 5);
+	cd = select(cd, .0625, idx === 6);
+	cd = select(cd, .4375, idx === 7);
+	cd = select(cd, .6875, idx === 8);
+	cd = select(cd, .1875, idx === 9);
+	cd = select(cd, .125, idx === 10);
+	cd = select(cd, .5, idx === 11);
+	cd = select(cd, .9375, idx === 12);
+	cd = select(cd, .625, idx === 13);
+	cd = select(cd, .5625, idx === 14);
+	cd = select(cd, .875, idx === 15);
+	return vec4f(bayer2, bayer4, bayer8, cd);
 }), {
 	v: 1,
 	name: void 0,
@@ -1103,15 +1103,15 @@ const ditherPeriodic = tgpu.fn([d.vec2f], d.vec4f)(/* @__PURE__ */ (($) => (glob
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		ditherBayerQuad,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherBlueNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+const ditherBlueNoise = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
 	"use gpu";
-	const c = coord.add(d.vec2f(.5, .5));
-	return std.fract(__tsover_mul(52.9829189, std.fract(__tsover_add(__tsover_mul(c.x, .06711056), __tsover_mul(c.y, .00583715)))));
+	const c = coord.add(vec2f(.5, .5));
+	return fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(c.x, .06711056), __tsover_mul(c.y, .00583715)))));
 }), {
 	v: 1,
 	name: void 0,
@@ -1188,13 +1188,13 @@ const ditherBlueNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globa
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const ditherWhiteNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+const ditherWhiteNoise = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(std.dot(coord, d.vec2f(12.9898, 78.233))), 43758.5453));
+	return fract(__tsover_mul(sin(dot(coord, vec2f(12.9898, 78.233))), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -1244,19 +1244,18 @@ const ditherWhiteNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (glob
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherOrderedResult = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ditherValue, luminance, threshold, spread) => {
+const ditherOrderedResult = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ditherValue, luminance, threshold, spread) => {
 	"use gpu";
-	const adjustedDither = __tsover_add(.5, __tsover_mul(__tsover_sub(ditherValue, .5), spread));
-	return std.step(adjustedDither, __tsover_add(luminance, __tsover_sub(threshold, .5)));
+	return step(__tsover_add(.5, __tsover_mul(__tsover_sub(ditherValue, .5), spread)), __tsover_add(luminance, __tsover_sub(threshold, .5)));
 }), {
 	v: 1,
 	name: void 0,
@@ -1319,11 +1318,11 @@ const ditherOrderedResult = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const ditherBlockOrigin = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
+const ditherBlockOrigin = src_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
 	"use gpu";
-	return std.floor(coord.div(d.vec2f(8, 8))).mul(d.vec2f(8, 8));
+	return floor(coord.div(vec2f(8, 8))).mul(vec2f(8, 8));
 }), {
 	v: 1,
 	name: void 0,
@@ -1376,11 +1375,11 @@ const ditherBlockOrigin = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (g
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherLocalCellIndex = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, blockOrigin) => {
+const ditherLocalCellIndex = src_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, blockOrigin) => {
 	"use gpu";
 	return __tsover_add(__tsover_mul(__tsover_sub(coord.y, blockOrigin.y), 8), __tsover_sub(coord.x, blockOrigin.x));
 }), {
@@ -1435,15 +1434,15 @@ const ditherLocalCellIndex = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */
 	},
 	externals: () => ({})
 }) && $.f)({}));
-const ditherCellUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((blockOrigin, lx, ly, pixelSize, gridRes) => {
+const ditherCellUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((blockOrigin, lx, ly, pixelSize, gridRes) => {
 	"use gpu";
-	return d.vec2f(__tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.x, lx), .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.y, ly), .5), pixelSize), gridRes.y));
+	return vec2f(__tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.x, lx), .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.y, ly), .5), pixelSize), gridRes.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -1537,30 +1536,30 @@ const ditherCellUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const ditherFloydSteinberg = tgpu.fn([
-	d.arrayOf(d.f32, 64),
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lum, lic, threshold, spread) => {
+const ditherFloydSteinberg = src_default.fn([
+	arrayOf(f32, 64),
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lum, lic, threshold, spread) => {
 	"use gpu";
 	const thr = __tsover_sub(.5, __tsover_sub(threshold, .5));
-	const ecur = d.arrayOf(d.f32, 8)();
-	const enext = d.arrayOf(d.f32, 8)();
-	const licInt = d.i32(lic);
-	let result = d.f32(0);
+	const ecur = arrayOf(f32, 8)();
+	const enext = arrayOf(f32, 8)();
+	const licInt = i32(lic);
+	let result = f32(0);
 	for (let y = 0; y < 8; y++) {
 		const ltr = (y & 1) === 0;
 		for (let xi = 0; xi < 8; xi++) {
-			const x = std.select(__tsover_sub(7, xi), xi, ltr);
+			const x = select(__tsover_sub(7, xi), xi, ltr);
 			const idx = __tsover_add(__tsover_mul(y, 8), x);
 			const val = __tsover_add(lum[idx], ecur[x]);
-			const qv = std.step(thr, val);
-			result = std.select(result, qv, idx === licInt);
+			const qv = step(thr, val);
+			result = select(result, qv, idx === licInt);
 			const e = __tsover_mul(__tsover_sub(val, qv), spread);
-			const dir = std.select(-1, 1, ltr);
+			const dir = select(-1, 1, ltr);
 			const xr = __tsover_add(x, dir);
 			if (xr >= 0) {
 				if (xr < 8) ecur[xr] = __tsover_add(ecur[xr], __tsover_mul(e, .4375));
@@ -1579,7 +1578,7 @@ const ditherFloydSteinberg = tgpu.fn([
 		}
 		for (let k = 0; k < 8; k++) {
 			ecur[k] = enext[k];
-			enext[k] = d.f32(0);
+			enext[k] = f32(0);
 		}
 	}
 	return result;
@@ -2119,19 +2118,19 @@ const ditherFloydSteinberg = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const ditherComposeCustom = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorA, colorB, ditherResult) => {
+const ditherComposeCustom = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorA, colorB, ditherResult) => {
 	"use gpu";
-	const rgb = std.mix(d.vec3f(colorA.x, colorA.y, colorA.z), d.vec3f(colorB.x, colorB.y, colorB.z), d.vec3f(ditherResult));
-	const a = std.mix(colorA.w, colorB.w, ditherResult);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, a);
+	const rgb = mix(vec3f(colorA.x, colorA.y, colorA.z), vec3f(colorB.x, colorB.y, colorB.z), vec3f(ditherResult));
+	const a = mix(colorA.w, colorB.w, ditherResult);
+	return vec4f(rgb.x, rgb.y, rgb.z, a);
 }), {
 	v: 1,
 	name: void 0,
@@ -2279,17 +2278,15 @@ const ditherComposeCustom = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const ditherComposeSource = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceColor, ditherResult) => {
+const ditherComposeSource = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceColor, ditherResult) => {
 	"use gpu";
-	const rgb = d.vec3f(sourceColor.x, sourceColor.y, sourceColor.z);
-	const dark = rgb.mul(.3);
-	const bright = std.min(rgb.mul(1.3), d.vec3f(1, 1, 1));
-	const out = std.mix(dark, bright, d.vec3f(ditherResult));
-	return d.vec4f(out.x, out.y, out.z, sourceColor.w);
+	const rgb = vec3f(sourceColor.x, sourceColor.y, sourceColor.z);
+	const out = mix(rgb.mul(.3), min(rgb.mul(1.3), vec3f(1, 1, 1)), vec3f(ditherResult));
+	return vec4f(out.x, out.y, out.z, sourceColor.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -2436,8 +2433,8 @@ const ditherComposeSource = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{DotGrid-DaOhiRaL.js → DotGrid-CbNHebie.js}

@@ -1,18 +1,18 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-const dotGridCellCenterUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, density) => {
+import { $t as vec2f, Ct as floor, It as sin, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, an as f32, ct as fwidth, et as src_default, nt as std_exports, p as call, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
+const dotGridCellCenterUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, density) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const correctedX = __tsover_mul(uv.x, aspect);
 	const correctedY = __tsover_sub(1, uv.y);
-	const cellCenterCorrectedX = __tsover_div(__tsover_add(std.floor(__tsover_mul(correctedX, density)), .5), density);
-	const cellCenterCorrectedY = __tsover_div(__tsover_add(std.floor(__tsover_mul(correctedY, density)), .5), density);
-	return d.vec2f(__tsover_div(cellCenterCorrectedX, aspect), __tsover_sub(1, cellCenterCorrectedY));
+	const cellCenterCorrectedX = __tsover_div(__tsover_add(floor(__tsover_mul(correctedX, density)), .5), density);
+	const cellCenterCorrectedY = __tsover_div(__tsover_add(floor(__tsover_mul(correctedY, density)), .5), density);
+	return vec2f(__tsover_div(cellCenterCorrectedX, aspect), __tsover_sub(1, cellCenterCorrectedY));
 }), {
 	v: 1,
 	name: void 0,
@@ -157,40 +157,38 @@ const dotGridCellCenterUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const dotGridAlpha = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, density, dotSize, offset, speedVariance, twinkle, animTime, time) => {
+const dotGridAlpha = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, density, dotSize, offset, speedVariance, twinkle, animTime, time) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
 	const gridUV = correctedUV.mul(density);
-	const rowIndex = std.floor(gridUV.y);
-	const rowHash = std.fract(__tsover_mul(std.sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
+	const rowIndex = floor(gridUV.y);
+	const rowHash = fract(__tsover_mul(sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
 	const speedMod = __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rowHash, .5), 4), speedVariance));
 	const drift = __tsover_mul(animTime, speedMod);
-	const staticStagger = __tsover_mul(offset, __tsover_sub(rowIndex, __tsover_mul(2, std.floor(__tsover_div(rowIndex, 2)))));
-	const shiftedGrid = d.vec2f(__tsover_sub(__tsover_sub(gridUV.x, staticStagger), drift), gridUV.y);
-	const cellUV = shiftedGrid.sub(std.floor(shiftedGrid));
-	const centerDistance = std.length(cellUV.sub(.5));
-	const pixelSize = std.length(std.fwidth(correctedUV.mul(density)));
-	const coverage = __tsover_sub(1, std.smoothstep(__tsover_sub(__tsover_mul(dotSize, .5), __tsover_mul(pixelSize, .5)), __tsover_mul(dotSize, .5), centerDistance));
-	const gridPosition = std.floor(shiftedGrid);
-	const dotPhase = std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(gridPosition.x, 12.9898), __tsover_mul(gridPosition.y, 78.233))), 43758.5453));
+	const staticStagger = __tsover_mul(offset, __tsover_sub(rowIndex, __tsover_mul(2, floor(__tsover_div(rowIndex, 2)))));
+	const shiftedGrid = vec2f(__tsover_sub(__tsover_sub(gridUV.x, staticStagger), drift), gridUV.y);
+	const centerDistance = length(shiftedGrid.sub(floor(shiftedGrid)).sub(.5));
+	const pixelSize = length(fwidth(correctedUV.mul(density)));
+	const coverage = __tsover_sub(1, smoothstep(__tsover_sub(__tsover_mul(dotSize, .5), __tsover_mul(pixelSize, .5)), __tsover_mul(dotSize, .5), centerDistance));
+	const gridPosition = floor(shiftedGrid);
+	const dotPhase = fract(__tsover_mul(sin(__tsover_add(__tsover_mul(gridPosition.x, 12.9898), __tsover_mul(gridPosition.y, 78.233))), 43758.5453));
 	const twinkleTime = __tsover_add(__tsover_mul(time, 2), __tsover_mul(dotPhase, 6.28318));
-	const twinkleValue = __tsover_add(__tsover_mul(std.sin(twinkleTime), .5), .5);
-	const twinkleModifier = std.mix(1, twinkleValue, twinkle);
+	const twinkleModifier = mix(1, __tsover_add(__tsover_mul(sin(twinkleTime), .5), .5), twinkle);
 	return __tsover_mul(coverage, twinkleModifier);
 }), {
 	v: 1,
@@ -689,8 +687,8 @@ const dotGridAlpha = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{DropShadow-C5Z2Rs2C.js → DropShadow-DFyuEA17.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, It as sin, N as unpremultiplyAlpha, Vt as data_exports, _ as floatE, _t as clamp, an as f32, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, i as transformBoolean } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .017453292519943295;
 var WEIGHTS = [
 	.056,
@@ -17,19 +17,19 @@ var WEIGHTS = [
 	.056
 ];
 var WEIGHT_SUM = 6.214;
-const dropShadowUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, distance) => {
+const dropShadowUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, distance) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
 	const dist = __tsover_mul(distance, .2);
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const ox = __tsover_div(__tsover_mul(std.sin(angleRad), dist), aspect);
-	const oy = __tsover_mul(__tsover_mul(std.cos(angleRad), -1), dist);
-	return d.vec2f(__tsover_sub(uv.x, ox), __tsover_sub(uv.y, oy));
+	const ox = __tsover_div(__tsover_mul(sin(angleRad), dist), aspect);
+	const oy = __tsover_mul(__tsover_mul(cos(angleRad), -1), dist);
+	return vec2f(__tsover_sub(uv.x, ox), __tsover_sub(uv.y, oy));
 }), {
 	v: 1,
 	name: void 0,
@@ -177,19 +177,19 @@ const dropShadowUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const dropShadowTapUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, blurRadius, ox, oy) => {
+const dropShadowTapUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, blurRadius, ox, oy) => {
 	"use gpu";
-	return d.vec2f(__tsover_add(uv.x, __tsover_div(__tsover_mul(ox, blurRadius), viewport.x)), __tsover_add(uv.y, __tsover_div(__tsover_mul(oy, blurRadius), viewport.y)));
+	return vec2f(__tsover_add(uv.x, __tsover_div(__tsover_mul(ox, blurRadius), viewport.x)), __tsover_add(uv.y, __tsover_div(__tsover_mul(oy, blurRadius), viewport.y)));
 }), {
 	v: 1,
 	name: void 0,
@@ -273,27 +273,27 @@ const dropShadowTapUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const dropShadowComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((originalColor, shadowColor, shadowAlpha, cutout) => {
+const dropShadowComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((originalColor, shadowColor, shadowAlpha, cutout) => {
 	"use gpu";
-	const shadowRgb = d.vec3f(shadowColor.x, shadowColor.y, shadowColor.z);
+	const shadowRgb = vec3f(shadowColor.x, shadowColor.y, shadowColor.z);
 	const shadowA = __tsover_mul(shadowColor.w, shadowAlpha);
-	const cutoutA = std.clamp(__tsover_sub(shadowA, originalColor.w), 0, 1);
+	const cutoutA = clamp(__tsover_sub(shadowA, originalColor.w), 0, 1);
 	const cutoutRgb = shadowRgb.mul(shadowColor.w).mul(cutoutA);
 	const shadowPremulRgb = shadowRgb.mul(shadowColor.w).mul(shadowAlpha);
 	const oneMinusOrigA = __tsover_sub(1, originalColor.w);
-	const normalRgb = d.vec3f(originalColor.x, originalColor.y, originalColor.z).add(shadowPremulRgb.mul(oneMinusOrigA));
-	const normalA = std.max(__tsover_add(originalColor.w, __tsover_mul(shadowA, oneMinusOrigA)), originalColor.w);
+	const normalRgb = vec3f(originalColor.x, originalColor.y, originalColor.z).add(shadowPremulRgb.mul(oneMinusOrigA));
+	const normalA = max(__tsover_add(originalColor.w, __tsover_mul(shadowA, oneMinusOrigA)), originalColor.w);
 	const useCut = cutout > .5;
-	const rgb = std.select(normalRgb, cutoutRgb, useCut);
-	const a = std.select(normalA, cutoutA, useCut);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, a);
+	const rgb = select(normalRgb, cutoutRgb, useCut);
+	const a = select(normalA, cutoutA, useCut);
+	return vec4f(rgb.x, rgb.y, rgb.z, a);
 }), {
 	v: 1,
 	name: void 0,
@@ -600,8 +600,8 @@ const dropShadowComposite = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Duotone-x4cywJbU.js → Duotone-CgueO-jZ.js}

@@ -1,9 +1,9 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const duotoneFactor = tgpu.fn([d.vec4f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blend) => {
+import { H as mixColorsLinear, Lt as smoothstep, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const duotoneFactor = src_default.fn([vec4f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blend) => {
 	"use gpu";
-	const luminance = std.dot(color.xyz, d.vec3f(.299, .587, .114));
-	return std.smoothstep(__tsover_sub(blend, .5), __tsover_add(blend, .5), luminance);
+	const luminance = dot(color.xyz, vec3f(.299, .587, .114));
+	return smoothstep(__tsover_sub(blend, .5), __tsover_add(blend, .5), luminance);
 }), {
 	v: 1,
 	name: void 0,
@@ -69,8 +69,8 @@ const duotoneFactor = tgpu.fn([d.vec4f, d.f32], d.f32)(/* @__PURE__ */ (($) => (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {