shaders 3.0.448 → 3.0.450

package/dist/core/{Goo-C0_0QYne.js → Goo-28A_pNBg.js}

@@ -1,8 +1,9 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, n as tgpu, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { At as mix, Bt as sqrt, Ct as exp, Gt as arrayOf, Mt as pow, Ot as max, Rt as sin, St as dot, Ut as data_exports, _ as floatE, bt as cos, et as src_default, in as vec3f, jt as normalize, kt as min, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
@@ -21,23 +22,23 @@ var PHASE_INIT = [];
 for (let i = 0; i < N_CHARGES; i++) {
 	const theta = i * 2.399963;
 	const rr = Math.sqrt((i + .5) / N_CHARGES);
-	POS_FREQ_INIT.push(d.vec4f(rr * Math.cos(theta), rr * Math.sin(theta), .5 + jhash(i + 1), .5 + jhash(i + 7)));
-	PHASE_INIT.push(d.vec4f(.5 + jhash(i + 13), jhash(i + 2) * 6.2831853, jhash(i + 5) * 6.2831853, jhash(i + 9) * 6.2831853));
+	POS_FREQ_INIT.push(vec4f(rr * Math.cos(theta), rr * Math.sin(theta), .5 + jhash(i + 1), .5 + jhash(i + 7)));
+	PHASE_INIT.push(vec4f(.5 + jhash(i + 13), jhash(i + 2) * 6.2831853, jhash(i + 5) * 6.2831853, jhash(i + 9) * 6.2831853));
 }
-var POS_FREQ = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.vec4f, N_CHARGES), POS_FREQ_INIT), "POS_FREQ");
-var PHASE = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.vec4f, N_CHARGES), PHASE_INIT), "PHASE");
-const gooComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec4f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, gooColor, specColor, p0, p1, p2, p3) => {
+var POS_FREQ = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(vec4f, N_CHARGES), POS_FREQ_INIT), "POS_FREQ");
+var PHASE = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(vec4f, N_CHARGES), PHASE_INIT), "PHASE");
+const gooComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec4f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, gooColor, specColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const spread = __tsover_mul(p0.x, .45);
 	const driftAmp = __tsover_mul(p0.y, .12);
@@ -57,66 +58,64 @@ const gooComposite = tgpu.fn([
 	const animTime = p3.w;
 	const px = __tsover_sub(sdfUV.x, .5);
 	const py = __tsover_sub(sdfUV.y, .5);
-	const distC = std.sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(py, py)));
+	const distC = sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(py, py)));
 	const radiusMul = __tsover_add(.65, __tsover_mul(merge, .7));
 	const baseR = __tsover_mul(__tsover_mul(blobScale, .38), radiusMul);
-	if (distC > __tsover_add(__tsover_add(__tsover_add(spread, __tsover_mul(baseR, __tsover_add(1, breatheAmp))), driftAmp), .2)) return d.vec4f(0, 0, 0, 0);
-	const EPS = d.f32(.004);
-	let potC = d.f32(0);
-	let potX = d.f32(0);
-	let potY = d.f32(0);
+	if (distC > __tsover_add(__tsover_add(__tsover_add(spread, __tsover_mul(baseR, __tsover_add(1, breatheAmp))), driftAmp), .2)) return vec4f(0, 0, 0, 0);
+	const EPS = f32(.004);
+	let potC = f32(0);
+	let potX = f32(0);
+	let potY = f32(0);
 	for (let i = 0; i < N_CHARGES; i++) {
 		const pf = POS_FREQ.$[i];
 		const ph = PHASE.$[i];
-		const cx = __tsover_add(__tsover_mul(pf.x, spread), __tsover_mul(driftAmp, std.sin(__tsover_add(__tsover_mul(animTime, pf.z), ph.y))));
-		const cy = __tsover_add(__tsover_mul(pf.y, spread), __tsover_mul(driftAmp, std.cos(__tsover_add(__tsover_mul(animTime, pf.w), ph.z))));
-		const rVal = __tsover_mul(baseR, __tsover_add(1, __tsover_mul(breatheAmp, std.sin(__tsover_add(__tsover_mul(animTime, ph.x), ph.w)))));
-		const invR2 = __tsover_div(1, std.max(__tsover_mul(rVal, rVal), d.f32(1e-4)));
+		const cx = __tsover_add(__tsover_mul(pf.x, spread), __tsover_mul(driftAmp, sin(__tsover_add(__tsover_mul(animTime, pf.z), ph.y))));
+		const cy = __tsover_add(__tsover_mul(pf.y, spread), __tsover_mul(driftAmp, cos(__tsover_add(__tsover_mul(animTime, pf.w), ph.z))));
+		const rVal = __tsover_mul(baseR, __tsover_add(1, __tsover_mul(breatheAmp, sin(__tsover_add(__tsover_mul(animTime, ph.x), ph.w)))));
+		const invR2 = __tsover_div(1, max(__tsover_mul(rVal, rVal), f32(1e-4)));
 		const dcx = __tsover_sub(px, cx);
 		const dcy = __tsover_sub(py, cy);
-		potC = __tsover_add(potC, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dcy, dcy)), invR2), -1)));
+		potC = __tsover_add(potC, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dcy, dcy)), invR2), -1)));
 		const dxx = __tsover_sub(__tsover_add(px, EPS), cx);
-		potX = __tsover_add(potX, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dxx, dxx), __tsover_mul(dcy, dcy)), invR2), -1)));
+		potX = __tsover_add(potX, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dxx, dxx), __tsover_mul(dcy, dcy)), invR2), -1)));
 		const dyy = __tsover_sub(__tsover_add(py, EPS), cy);
-		potY = __tsover_add(potY, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dyy, dyy)), invR2), -1)));
+		potY = __tsover_add(potY, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dyy, dyy)), invR2), -1)));
 	}
-	const containerSoft = d.f32(.06);
-	const inside0 = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surf0.x));
-	const insideX = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfX.x));
-	const insideY = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfY.x));
-	const H0 = __tsover_add(__tsover_mul(potC, std.mix(d.f32(1), inside0, contain)), __tsover_mul(inside0, contain));
-	const Hx = __tsover_add(__tsover_mul(potX, std.mix(d.f32(1), insideX, contain)), __tsover_mul(insideX, contain));
-	const Hy = __tsover_add(__tsover_mul(potY, std.mix(d.f32(1), insideY, contain)), __tsover_mul(insideY, contain));
-	const soft = std.max(edgeSoftness, d.f32(.001));
-	const coverage = std.smoothstep(__tsover_sub(T, soft), __tsover_add(T, soft), H0);
+	const containerSoft = f32(.06);
+	const inside0 = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surf0.x));
+	const insideX = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfX.x));
+	const insideY = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfY.x));
+	const H0 = __tsover_add(__tsover_mul(potC, mix(f32(1), inside0, contain)), __tsover_mul(inside0, contain));
+	const Hx = __tsover_add(__tsover_mul(potX, mix(f32(1), insideX, contain)), __tsover_mul(insideX, contain));
+	const Hy = __tsover_add(__tsover_mul(potY, mix(f32(1), insideY, contain)), __tsover_mul(insideY, contain));
+	const soft = max(edgeSoftness, f32(.001));
+	const coverage = smoothstep(__tsover_sub(T, soft), __tsover_add(T, soft), H0);
 	const gradHx = __tsover_div(__tsover_sub(Hx, H0), EPS);
 	const gradHy = __tsover_div(__tsover_sub(Hy, H0), EPS);
 	const metaSlope = __tsover_add(__tsover_mul(bulge, .12), .03);
-	const reliefGate = std.min(std.min(inside0, insideX), insideY);
+	const reliefGate = min(min(inside0, insideX), insideY);
 	const shapeRelief = __tsover_mul(__tsover_mul(contain, 1.6), reliefGate);
-	const gradAx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -6, 6);
-	const gradAy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -6, 6);
-	const n = std.normalize(d.vec3f(__tsover_add(__tsover_mul(__tsover_mul(gradHx, -1), metaSlope), __tsover_mul(gradAx, shapeRelief)), __tsover_add(__tsover_mul(__tsover_mul(gradHy, -1), metaSlope), __tsover_mul(gradAy, shapeRelief)), -1));
-	const domeZ = __tsover_mul(std.sqrt(std.max(__tsover_sub(H0, T), d.f32(0))), bulge);
-	const shapeDepth = std.max(__tsover_mul(surf0.x, -1), d.f32(0));
-	const thick = std.clamp(__tsover_add(domeZ, __tsover_mul(__tsover_mul(shapeDepth, contain), 1.2)), 0, 1);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const L = std.normalize(d.vec3f(lx, ly, -.8));
-	const Hh = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndl = std.clamp(std.dot(n, L), 0, 1);
-	const ndh = std.clamp(std.dot(n, Hh), 0, 1);
-	const ndv = std.clamp(__tsover_mul(n.z, -1), 0, 1);
-	const specCore = __tsover_mul(std.pow(ndh, d.f32(232)), 1.7);
-	const specHalo = __tsover_mul(std.pow(ndh, d.f32(32)), .25);
-	const glint = __tsover_mul(std.smoothstep(.992, .999, ndh), 1.9);
-	const fres = __tsover_mul(std.pow(__tsover_sub(1, ndv), d.f32(5)), fresnelAmt);
+	const gradAx = clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -6, 6);
+	const gradAy = clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -6, 6);
+	const n = normalize(vec3f(__tsover_add(__tsover_mul(__tsover_mul(gradHx, -1), metaSlope), __tsover_mul(gradAx, shapeRelief)), __tsover_add(__tsover_mul(__tsover_mul(gradHy, -1), metaSlope), __tsover_mul(gradAy, shapeRelief)), -1));
+	const domeZ = __tsover_mul(sqrt(max(__tsover_sub(H0, T), f32(0))), bulge);
+	const shapeDepth = max(__tsover_mul(surf0.x, -1), f32(0));
+	const thick = clamp(__tsover_add(domeZ, __tsover_mul(__tsover_mul(shapeDepth, contain), 1.2)), 0, 1);
+	const L = normalize(vec3f(cos(__tsover_mul(lightAngle, DEG_TO_RAD)), sin(__tsover_mul(lightAngle, DEG_TO_RAD)), -.8));
+	const Hh = normalize(L.add(vec3f(0, 0, -1)));
+	const ndl = clamp(dot(n, L), 0, 1);
+	const ndh = clamp(dot(n, Hh), 0, 1);
+	const ndv = clamp(__tsover_mul(n.z, -1), 0, 1);
+	const specCore = __tsover_mul(pow(ndh, f32(232)), 1.7);
+	const specHalo = __tsover_mul(pow(ndh, f32(32)), .25);
+	const glint = __tsover_mul(smoothstep(.992, .999, ndh), 1.9);
+	const fres = __tsover_mul(pow(__tsover_sub(1, ndv), f32(5)), fresnelAmt);
 	const specRgb = specColor.mul(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(specCore, specHalo), glint), fres), wetness));
-	const transmit = std.exp(__tsover_mul(__tsover_mul(absorbAmt, -1), __tsover_sub(1, thick)));
+	const transmit = exp(__tsover_mul(__tsover_mul(absorbAmt, -1), __tsover_sub(1, thick)));
 	const gooRgb = gooColor.xyz;
 	const sss = gooRgb.mul(__tsover_mul(translucency, transmit)).mul(__tsover_add(__tsover_mul(ndl, .5), .5));
 	const rgb = gooRgb.mul(__tsover_add(ambientAmt, __tsover_mul(ndl, .7))).add(sss).add(specRgb);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, __tsover_mul(coverage, gooColor.w));
+	return vec4f(rgb.x, rgb.y, rgb.z, __tsover_mul(coverage, gooColor.w));
 }), {
 	v: 1,
 	name: void 0,
@@ -2041,8 +2040,8 @@ const gooComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		N_CHARGES,
 		POS_FREQ,
 		PHASE,

package/dist/core/{GradientMap-DOVK05_a.js → GradientMap-D8dv-1AX.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Tn as d, Xt as formatFloat, 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";
+import { At as mix, Et as fract, H as mixColorsLinear, Ot as max, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, bt as cos, d as ZERO, et as src_default, g as expr, in as vec3f, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, x as formatFloat, yt as clamp } from "./edges-BZUKQxSE.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var PALETTES = {
 	0: {
 		a: [
@@ -147,17 +147,17 @@ var transformPalette = (value) => {
 };
 var TWO_PI = 6.283185307179586;
 var vec3E = (v) => expr(`vec3f(${formatFloat(v[0])}, ${formatFloat(v[1])}, ${formatFloat(v[2])})`);
-const gradientMapT = tgpu.fn([
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, black, white, contrast) => {
+const gradientMapT = src_default.fn([
+	vec4f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, black, white, contrast) => {
 	"use gpu";
-	const luma = std.dot(color.xyz, d.vec3f(.2126, .7152, .0722));
-	const range = std.max(__tsover_sub(white, black), 1e-4);
-	let t = std.clamp(__tsover_div(__tsover_sub(luma, black), range), 0, 1);
-	t = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(t, .5), contrast), .5), 0, 1);
+	const luma = dot(color.xyz, vec3f(.2126, .7152, .0722));
+	const range = max(__tsover_sub(white, black), 1e-4);
+	let t = clamp(__tsover_div(__tsover_sub(luma, black), range), 0, 1);
+	t = clamp(__tsover_add(__tsover_mul(__tsover_sub(t, .5), contrast), .5), 0, 1);
 	return t;
 }), {
 	v: 1,
@@ -294,22 +294,21 @@ const gradientMapT = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gradientMapCosine = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase, pa, pb, pc, pd) => {
+const gradientMapCosine = src_default.fn([
+	f32,
+	f32,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase, pa, pb, pc, pd) => {
 	"use gpu";
-	const arg = pc.mul(t).add(pd).add(d.vec3f(phase, phase, phase)).mul(TWO_PI);
-	const mapped = pa.add(pb.mul(std.cos(arg)));
-	return std.clamp(mapped, d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
+	const arg = pc.mul(t).add(pd).add(vec3f(phase, phase, phase)).mul(TWO_PI);
+	return clamp(pa.add(pb.mul(cos(arg))), vec3f(0, 0, 0), vec3f(1, 1, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -464,16 +463,16 @@ const gradientMapCosine = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		TWO_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const gradientMapCustomPhase = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase) => {
+const gradientMapCustomPhase = src_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase) => {
 	"use gpu";
-	const t01 = std.fract(__tsover_add(t, phase));
+	const t01 = fract(__tsover_add(t, phase));
 	const t3 = __tsover_mul(t01, 3);
-	return d.vec2f(std.fract(t3), std.floor(t3));
+	return vec2f(fract(t3), floor(t3));
 }), {
 	v: 1,
 	name: void 0,
@@ -543,19 +542,18 @@ const gradientMapCustomPhase = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gradientMapSelect = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((seg0, seg1, seg2, i) => {
+const gradientMapSelect = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((seg0, seg1, seg2, i) => {
 	"use gpu";
-	const upper = std.select(seg2, seg1, i < 2);
-	return std.select(upper, seg0, i < 1);
+	return select(select(seg2, seg1, i < 2), seg0, i < 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -619,16 +617,15 @@ const gradientMapSelect = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gradientMapCompose = tgpu.fn([
-	d.vec4f,
-	d.vec3f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, mapped, strength) => {
+const gradientMapCompose = src_default.fn([
+	vec4f,
+	vec3f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, mapped, strength) => {
 	"use gpu";
-	const outRgb = std.mix(color.xyz, mapped, d.vec3f(strength, strength, strength));
-	return d.vec4f(outRgb, color.w);
+	return vec4f(mix(color.xyz, mapped, vec3f(strength, strength, strength)), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -695,8 +692,8 @@ const gradientMapCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Grayscale-Uv_6LYA9.js → Grayscale-BlVXBVwW.js}

@@ -1,8 +1,8 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const grayscaleColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+import { St as dot, Ut as data_exports, d as ZERO, et as src_default, in as vec3f, nt as std_exports, on as vec4f, p as call } from "./edges-BZUKQxSE.js";
+const grayscaleColor = src_default.fn([vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	const luminance = std.dot(color.xyz, d.vec3f(.2126, .7152, .0722));
-	return d.vec4f(luminance, luminance, luminance, color.w);
+	const luminance = dot(color.xyz, vec3f(.2126, .7152, .0722));
+	return vec4f(luminance, luminance, luminance, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -60,8 +60,8 @@ const grayscaleColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (glob
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Grid-Dbp4DoXZ.js → Grid-D9vlHvs1.js}

@@ -1,32 +1,32 @@
-import { 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";
+import { Et as fract, H as mixColorsLinear, Ot as max, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, Vt as step, bt as cos, ct as dpdy, et as src_default, ht as abs, kt as min, nt as std_exports, p as call, sn as f32, st as dpdx, tn as vec2f, y as vec4 } from "./edges-BZUKQxSE.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const gridCellCenterUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, rotation) => {
+const gridCellCenterUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, rotation) => {
 	"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 rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedX, centerX);
 	const cy = __tsover_sub(correctedY, centerY);
 	const rotX = __tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX);
 	const rotY = __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY);
-	const cellRX = __tsover_div(__tsover_add(std.floor(__tsover_mul(rotX, cells)), .5), cells);
-	const cellRY = __tsover_div(__tsover_add(std.floor(__tsover_mul(rotY, cells)), .5), cells);
+	const cellRX = __tsover_div(__tsover_add(floor(__tsover_mul(rotX, cells)), .5), cells);
+	const cellRY = __tsover_div(__tsover_add(floor(__tsover_mul(rotY, cells)), .5), cells);
 	const ccx = __tsover_sub(cellRX, centerX);
 	const ccy = __tsover_sub(cellRY, centerY);
 	const unrotX = __tsover_add(__tsover_add(__tsover_mul(ccx, cosR), __tsover_mul(ccy, sinR)), centerX);
 	const unrotY = __tsover_add(__tsover_add(__tsover_mul(ccx, -sinR), __tsover_mul(ccy, cosR)), centerY);
-	return d.vec2f(__tsover_div(unrotX, aspect), __tsover_sub(1, unrotY));
+	return vec2f(__tsover_div(unrotX, aspect), __tsover_sub(1, unrotY));
 }), {
 	v: 1,
 	name: void 0,
@@ -375,19 +375,19 @@ const gridCellCenterUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gridFilterAxis = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, wx, N) => {
+const gridFilterAxis = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, wx, N) => {
 	"use gpu";
 	const a = __tsover_add(px, __tsover_mul(wx, .5));
 	const b = __tsover_sub(px, __tsover_mul(wx, .5));
-	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(std.floor(a), std.min(__tsover_mul(std.fract(a), N), 1)), std.floor(b)), std.min(__tsover_mul(std.fract(b), N), 1)), __tsover_mul(N, wx));
+	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(floor(a), min(__tsover_mul(fract(a), N), 1)), floor(b)), min(__tsover_mul(fract(b), N), 1)), __tsover_mul(N, wx));
 }), {
 	v: 1,
 	name: void 0,
@@ -524,50 +524,48 @@ const gridFilterAxis = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
+const gridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
 	"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 rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedX, centerX);
 	const cy = __tsover_sub(correctedY, centerY);
 	const rotX = __tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX);
 	const rotY = __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY);
-	const gridUV = d.vec2f(__tsover_mul(rotX, cells), __tsover_mul(rotY, cells));
+	const gridUV = vec2f(__tsover_mul(rotX, cells), __tsover_mul(rotY, cells));
 	const lineWidth = __tsover_mul(thickness, .01);
-	const safeLine = std.max(lineWidth, 1e-4);
+	const safeLine = max(lineWidth, 1e-4);
 	const lineFraction = __tsover_mul(safeLine, 2);
 	const N = __tsover_div(1, lineFraction);
 	const p = gridUV.add(safeLine);
-	const dpx = std.dpdx(p);
-	const dpy = std.dpdy(p);
-	const wx = __tsover_add(std.max(std.max(std.abs(dpx.x), std.abs(dpy.x)), 1e-5), softness);
-	const wy = __tsover_add(std.max(std.max(std.abs(dpx.y), std.abs(dpy.y)), 1e-5), softness);
+	const dpx = dpdx(p);
+	const dpy = dpdy(p);
+	const wx = __tsover_add(max(max(abs(dpx.x), abs(dpy.x)), 1e-5), softness);
+	const wy = __tsover_add(max(max(abs(dpx.y), abs(dpy.y)), 1e-5), softness);
 	const iX = gridFilterAxis(p.x, wx, N);
 	const iY = gridFilterAxis(p.y, wy, N);
 	const gapBoth = __tsover_mul(__tsover_sub(1, iX), __tsover_sub(1, iY));
-	const gridMask = __tsover_mul(__tsover_sub(1, gapBoth), std.step(1e-4, lineWidth));
-	const cellId = std.floor(gridUV);
-	const q0 = std.fract(cellId.mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	return d.vec2f(gridMask, variedFactor);
+	const gridMask = __tsover_mul(__tsover_sub(1, gapBoth), step(1e-4, lineWidth));
+	const q0 = fract(floor(gridUV).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	return vec2f(gridMask, max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -1201,8 +1199,8 @@ const gridField = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		gridFilterAxis
 	})
 }) && $.f)({}));