shaders 3.0.448 → 3.0.449

package/dist/core/{DataMosh-CWRLpjU3.js → DataMosh-Ysev5-c_.js}

@@ -1,25 +1,26 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu, qt as mixExpr } from "./coords-BkIjixe_.js";
+import { Ct as floor, Et as max, Gt as textureStorage2d, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, et as src_default, in as vec4f, it as textureLoad, nn as vec3f, nt as std_exports, p as call, pt as select, rt as textureDimensions, sn as u32, tn as vec2u, v as mixExpr, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
 var STATE_RES = 768;
 var STATE_FORMAT = "rgba16float";
-var MoshParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	time: d.f32,
-	dt: d.f32,
-	seed: d.f32,
-	intensity: d.f32,
-	blockSize: d.f32,
-	drift: d.f32,
-	churn: d.f32
+var MoshParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	time: f32,
+	dt: f32,
+	seed: f32,
+	intensity: f32,
+	blockSize: f32,
+	drift: f32,
+	churn: f32
 }), "MoshParams");
-var moshLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	src: { texture: d.texture2d(d.f32) },
-	prev: { texture: d.texture2d(d.f32) },
-	next: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	display: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+var moshLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	src: { texture: texture2d(f32) },
+	prev: { texture: texture2d(f32) },
+	next: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	display: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
 	params: { uniform: MoshParams }
 }), "moshLayout");
-const moshHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
+const moshHash = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(x), 43758.5453123));
+	return fract(__tsover_mul(sin(x), 43758.5453123));
 }), {
 	v: 1,
 	name: void 0,
@@ -52,87 +53,84 @@ const moshHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__T
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const moshKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const moshKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const P = moshLayout.$.params;
-	const res = d.f32(STATE_RES);
-	const px = d.f32(cx);
-	const py = d.f32(cy);
+	const res = f32(STATE_RES);
+	const px = f32(cx);
+	const py = f32(cy);
 	const fx = __tsover_div(__tsover_add(px, .5), res);
 	const fy = __tsover_div(__tsover_add(py, .5), res);
 	const churnRate = __tsover_add(.15, __tsover_mul(P.churn, .8));
-	const bsF = std.max(P.blockSize, 8);
+	const bsF = max(P.blockSize, 8);
 	const coarse = __tsover_mul(bsF, 2.6);
-	const cbx = std.floor(__tsover_div(px, coarse));
-	const cby = std.floor(__tsover_div(py, coarse));
+	const cbx = floor(__tsover_div(px, coarse));
+	const cby = floor(__tsover_div(py, coarse));
 	const cPhase = moshHash(__tsover_add(__tsover_add(__tsover_mul(cbx, 91.17), __tsover_mul(cby, 41.23)), __tsover_mul(P.seed, 3.7)));
-	const cEpoch = std.floor(__tsover_add(__tsover_mul(__tsover_mul(P.time, churnRate), .25), cPhase));
-	const scalePick = moshHash(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(cbx, 12.9898), __tsover_mul(cby, 78.233)), __tsover_mul(cEpoch, 37.71)), __tsover_mul(P.seed, 3.7)));
-	const bs = std.select(bsF, coarse, scalePick < .35);
-	const bx = std.floor(__tsover_div(px, bs));
-	const by = std.floor(__tsover_div(py, bs));
+	const cEpoch = floor(__tsover_add(__tsover_mul(__tsover_mul(P.time, churnRate), .25), cPhase));
+	const bs = select(bsF, coarse, moshHash(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(cbx, 12.9898), __tsover_mul(cby, 78.233)), __tsover_mul(cEpoch, 37.71)), __tsover_mul(P.seed, 3.7))) < .35);
+	const bx = floor(__tsover_div(px, bs));
+	const by = floor(__tsover_div(py, bs));
 	const bPhase = moshHash(__tsover_add(__tsover_add(__tsover_mul(bx, 127.1), __tsover_mul(by, 311.7)), __tsover_mul(P.seed, 17.9)));
 	const bRate = __tsover_mul(churnRate, __tsover_add(.7, __tsover_mul(.6, moshHash(__tsover_add(__tsover_add(__tsover_mul(bx, 53.7), __tsover_mul(by, 97.3)), __tsover_mul(P.seed, 5.3))))));
-	const bEpoch = std.floor(__tsover_add(__tsover_mul(P.time, bRate), bPhase));
+	const bEpoch = floor(__tsover_add(__tsover_mul(P.time, bRate), bPhase));
 	const bh = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(bx, 127.1), __tsover_mul(by, 311.7)), __tsover_mul(bEpoch, 74.7)), __tsover_mul(P.seed, 17.9));
 	const h1 = moshHash(__tsover_add(bh, .13));
 	const h2 = moshHash(__tsover_add(bh, 7.77));
 	const h3 = moshHash(__tsover_add(bh, 23.19));
 	const bcx = __tsover_div(__tsover_mul(__tsover_add(bx, .5), bs), res);
 	const bcy = __tsover_div(__tsover_mul(__tsover_add(by, .5), bs), res);
-	const field = __tsover_add(__tsover_add(.5, __tsover_mul(__tsover_mul(.25, std.sin(__tsover_add(__tsover_add(__tsover_mul(bcx, 2.7), __tsover_mul(P.time, .31)), P.seed))), std.sin(__tsover_add(__tsover_sub(__tsover_mul(bcy, 2.1), __tsover_mul(P.time, .23)), __tsover_mul(P.seed, .4))))), __tsover_mul(.25, std.sin(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(bcx, bcy), 1.6), __tsover_mul(P.time, .17)), __tsover_mul(P.seed, .7)))));
+	const field = __tsover_add(__tsover_add(.5, __tsover_mul(__tsover_mul(.25, sin(__tsover_add(__tsover_add(__tsover_mul(bcx, 2.7), __tsover_mul(P.time, .31)), P.seed))), sin(__tsover_add(__tsover_sub(__tsover_mul(bcy, 2.1), __tsover_mul(P.time, .23)), __tsover_mul(P.seed, .4))))), __tsover_mul(.25, sin(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(bcx, bcy), 1.6), __tsover_mul(P.time, .17)), __tsover_mul(P.seed, .7)))));
 	const thresh = __tsover_sub(1, __tsover_mul(P.intensity, .55));
-	const hold = std.smoothstep(__tsover_sub(thresh, .09), __tsover_add(thresh, .09), __tsover_add(field, __tsover_mul(__tsover_sub(h1, .5), .3)));
-	const flowAng = __tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(bcx, 1.9), __tsover_mul(P.seed, 3.1))), 1.7), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(bcy, 2.3), __tsover_mul(P.seed, 2.7))), 1.3)), __tsover_mul(P.time, .15));
+	const hold = smoothstep(__tsover_sub(thresh, .09), __tsover_add(thresh, .09), __tsover_add(field, __tsover_mul(__tsover_sub(h1, .5), .3)));
+	const flowAng = __tsover_add(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(bcx, 1.9), __tsover_mul(P.seed, 3.1))), 1.7), __tsover_mul(cos(__tsover_sub(__tsover_mul(bcy, 2.3), __tsover_mul(P.seed, 2.7))), 1.3)), __tsover_mul(P.time, .15));
 	const ang = __tsover_add(flowAng, __tsover_mul(__tsover_sub(h2, .5), 1.1));
 	const mag = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(.5, __tsover_mul(.5, h3)), P.drift), P.dt), 10), __tsover_div(bs, res));
-	const suRaw = __tsover_sub(fx, __tsover_mul(std.cos(ang), mag));
-	const svRaw = __tsover_sub(fy, __tsover_mul(std.sin(ang), mag));
-	const inBounds = __tsover_mul(__tsover_mul(__tsover_mul(std.select(d.f32(0), d.f32(1), suRaw >= 0), std.select(d.f32(0), d.f32(1), suRaw <= 1)), std.select(d.f32(0), d.f32(1), svRaw >= 0)), std.select(d.f32(0), d.f32(1), svRaw <= 1));
-	const su = __tsover_sub(__tsover_mul(std.clamp(suRaw, 0, 1), res), .5);
-	const sv = __tsover_sub(__tsover_mul(std.clamp(svRaw, 0, 1), res), .5);
-	const sx0 = std.floor(su);
-	const sy0 = std.floor(sv);
+	const suRaw = __tsover_sub(fx, __tsover_mul(cos(ang), mag));
+	const svRaw = __tsover_sub(fy, __tsover_mul(sin(ang), mag));
+	const inBounds = __tsover_mul(__tsover_mul(__tsover_mul(select(f32(0), f32(1), suRaw >= 0), select(f32(0), f32(1), suRaw <= 1)), select(f32(0), f32(1), svRaw >= 0)), select(f32(0), f32(1), svRaw <= 1));
+	const su = __tsover_sub(__tsover_mul(clamp(suRaw, 0, 1), res), .5);
+	const sv = __tsover_sub(__tsover_mul(clamp(svRaw, 0, 1), res), .5);
+	const sx0 = floor(su);
+	const sy0 = floor(sv);
 	const sfx = __tsover_sub(su, sx0);
 	const sfy = __tsover_sub(sv, sy0);
 	const maxT = __tsover_sub(res, 1);
-	const ix0 = d.u32(std.clamp(sx0, d.f32(0), maxT));
-	const ix1 = d.u32(std.clamp(__tsover_add(sx0, 1), d.f32(0), maxT));
-	const iy0 = d.u32(std.clamp(sy0, d.f32(0), maxT));
-	const iy1 = d.u32(std.clamp(__tsover_add(sy0, 1), d.f32(0), maxT));
-	const p00 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix0, iy0), 0);
-	const p10 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix1, iy0), 0);
-	const p01 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix0, iy1), 0);
-	const p11 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix1, iy1), 0);
-	const prevC = std.mix(std.mix(p00, p10, sfx), std.mix(p01, p11, sfx), sfy);
-	const quant = std.floor(prevC.xyz.mul(18)).add(d.vec3f(.5, .5, .5)).div(18);
-	const heldRgb = std.mix(prevC.xyz, quant, .12).mul(.9985);
-	const held = d.vec4f(heldRgb, prevC.w);
-	const rekey = std.clamp(__tsover_mul(P.dt, __tsover_add(1.2, __tsover_mul(__tsover_sub(1, P.intensity), 2))), 0, .2);
-	const srcDims = std.textureDimensions(moshLayout.$.src);
-	const srcW = d.f32(srcDims.x);
-	const srcH = d.f32(srcDims.y);
+	const ix0 = u32(clamp(sx0, f32(0), maxT));
+	const ix1 = u32(clamp(__tsover_add(sx0, 1), f32(0), maxT));
+	const iy0 = u32(clamp(sy0, f32(0), maxT));
+	const iy1 = u32(clamp(__tsover_add(sy0, 1), f32(0), maxT));
+	const p00 = textureLoad(moshLayout.$.prev, vec2u(ix0, iy0), 0);
+	const p10 = textureLoad(moshLayout.$.prev, vec2u(ix1, iy0), 0);
+	const p01 = textureLoad(moshLayout.$.prev, vec2u(ix0, iy1), 0);
+	const p11 = textureLoad(moshLayout.$.prev, vec2u(ix1, iy1), 0);
+	const prevC = mix(mix(p00, p10, sfx), mix(p01, p11, sfx), sfy);
+	const quant = floor(prevC.xyz.mul(18)).add(vec3f(.5, .5, .5)).div(18);
+	const held = vec4f(mix(prevC.xyz, quant, .12).mul(.9985), prevC.w);
+	const rekey = clamp(__tsover_mul(P.dt, __tsover_add(1.2, __tsover_mul(__tsover_sub(1, P.intensity), 2))), 0, .2);
+	const srcDims = textureDimensions(moshLayout.$.src);
+	const srcW = f32(srcDims.x);
+	const srcH = f32(srcDims.y);
 	const cu = __tsover_sub(__tsover_mul(fx, srcW), .5);
 	const cv = __tsover_sub(__tsover_mul(fy, srcH), .5);
-	const cx0 = std.floor(cu);
-	const cy0 = std.floor(cv);
+	const cx0 = floor(cu);
+	const cy0 = floor(cv);
 	const cfx = __tsover_sub(cu, cx0);
 	const cfy = __tsover_sub(cv, cy0);
-	const jx0 = d.u32(std.clamp(cx0, d.f32(0), __tsover_sub(srcW, 1)));
-	const jx1 = d.u32(std.clamp(__tsover_add(cx0, 1), d.f32(0), __tsover_sub(srcW, 1)));
-	const jy0 = d.u32(std.clamp(cy0, d.f32(0), __tsover_sub(srcH, 1)));
-	const jy1 = d.u32(std.clamp(__tsover_add(cy0, 1), d.f32(0), __tsover_sub(srcH, 1)));
-	const c00 = std.textureLoad(moshLayout.$.src, d.vec2u(jx0, jy0), 0);
-	const c10 = std.textureLoad(moshLayout.$.src, d.vec2u(jx1, jy0), 0);
-	const c01 = std.textureLoad(moshLayout.$.src, d.vec2u(jx0, jy1), 0);
-	const c11 = std.textureLoad(moshLayout.$.src, d.vec2u(jx1, jy1), 0);
-	const fresh = std.mix(std.mix(c00, c10, cfx), std.mix(c01, c11, cfx), cfy);
-	const heldAnchored = std.mix(held, fresh, rekey);
-	const outC = std.mix(fresh, heldAnchored, __tsover_mul(hold, inBounds));
-	std.textureStore(moshLayout.$.next, d.vec2u(cx, cy), outC);
-	std.textureStore(moshLayout.$.display, d.vec2u(cx, cy), outC);
+	const jx0 = u32(clamp(cx0, f32(0), __tsover_sub(srcW, 1)));
+	const jx1 = u32(clamp(__tsover_add(cx0, 1), f32(0), __tsover_sub(srcW, 1)));
+	const jy0 = u32(clamp(cy0, f32(0), __tsover_sub(srcH, 1)));
+	const jy1 = u32(clamp(__tsover_add(cy0, 1), f32(0), __tsover_sub(srcH, 1)));
+	const c00 = textureLoad(moshLayout.$.src, vec2u(jx0, jy0), 0);
+	const c10 = textureLoad(moshLayout.$.src, vec2u(jx1, jy0), 0);
+	const c01 = textureLoad(moshLayout.$.src, vec2u(jx0, jy1), 0);
+	const c11 = textureLoad(moshLayout.$.src, vec2u(jx1, jy1), 0);
+	const fresh = mix(mix(c00, c10, cfx), mix(c01, c11, cfx), cfy);
+	const outC = mix(fresh, mix(held, fresh, rekey), __tsover_mul(hold, inBounds));
+	textureStore(moshLayout.$.next, vec2u(cx, cy), outC);
+	textureStore(moshLayout.$.display, vec2u(cx, cy), outC);
 }), {
 	v: 1,
 	name: void 0,
@@ -2440,9 +2438,9 @@ const moshKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis._
 	},
 	externals: () => ({
 		moshLayout,
-		d,
+		d: data_exports,
 		STATE_RES,
-		std,
+		std: std_exports,
 		moshHash
 	})
 }) && $.f)({})).$name("dataMoshStep");

package/dist/core/{DiamondGradient-C_2VoEiQ.js → DiamondGradient-pTOwPuAl.js}

@@ -1,35 +1,33 @@
-import { Et as mixColorStopsRuntime, Ht as call, J as std, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Et as max, H as mixColorsLinear, It as sin, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, mt as abs, nt as std_exports, p as call, pt as select, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .017453292519943295;
-const diamondFinalT = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, size, rotation, repeat, roundness, uv, viewport) => {
+const diamondFinalT = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, size, rotation, repeat, roundness, uv, viewport) => {
 	"use gpu";
-	const safeViewportY = std.max(viewport.y, 1e-6);
+	const safeViewportY = max(viewport.y, 1e-6);
 	const aspect = __tsover_div(viewport.x, safeViewportY);
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const centerPos = d.vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
 	const dx = __tsover_sub(aspectUV.x, centerPos.x);
 	const dy = __tsover_sub(aspectUV.y, centerPos.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 rdx = __tsover_add(__tsover_mul(dx, cosR), __tsover_mul(dy, sinR));
 	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dx, sinR));
-	const absDx = std.abs(rdx);
-	const absDy = std.abs(rdy);
-	const l1 = __tsover_add(absDx, absDy);
-	const linf = std.max(absDx, absDy);
-	const dist = std.mix(l1, linf, roundness);
+	const absDx = abs(rdx);
+	const absDy = abs(rdy);
+	const dist = mix(__tsover_add(absDx, absDy), max(absDx, absDy), roundness);
 	const t = __tsover_mul(__tsover_div(dist, size), repeat);
-	return std.select(std.clamp(t, 0, 1), std.fract(t), repeat > 1.0001);
+	return select(clamp(t, 0, 1), fract(t), repeat > 1.0001);
 }), {
 	v: 1,
 	name: void 0,
@@ -392,8 +390,8 @@ const diamondFinalT = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		DEG_TO_RAD
 	})
 }) && $.f)({}));

package/dist/core/{DiamondWipe-BkdNODD1.js → DiamondWipe-D6u1P2xH.js}

@@ -1,25 +1,25 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
-const diamondWipeMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, size, feather, progress, invert) => {
+import { $t as vec2f, Et as max, Lt as smoothstep, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, mt as abs, nt as std_exports, p as call, pt as select, wt as fract } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
+const diamondWipeMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, size, feather, progress, invert) => {
 	"use gpu";
-	const gridX = __tsover_div(1, std.max(size, .001));
-	const gridY = std.max(__tsover_div(gridX, aspect), 1);
-	const lx = __tsover_sub(std.fract(__tsover_mul(uv.x, gridX)), .5);
-	const ly = __tsover_sub(std.fract(__tsover_mul(uv.y, gridY)), .5);
-	let coord = __tsover_add(std.abs(lx), std.abs(ly));
-	coord = std.select(coord, __tsover_sub(1, coord), invert > 0);
-	const f = std.max(feather, 1e-4);
+	const gridX = __tsover_div(1, max(size, .001));
+	const gridY = max(__tsover_div(gridX, aspect), 1);
+	const lx = __tsover_sub(fract(__tsover_mul(uv.x, gridX)), .5);
+	const ly = __tsover_sub(fract(__tsover_mul(uv.y, gridY)), .5);
+	let coord = __tsover_add(abs(lx), abs(ly));
+	coord = select(coord, __tsover_sub(1, coord), invert > 0);
+	const f = max(feather, 1e-4);
 	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
-	const reveal = std.smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
-	return d.vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
+	const reveal = smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -303,8 +303,8 @@ const diamondWipeMask = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{DiffuseBlur-Dl7S4KBW.js → DiffuseBlur-BX0cfwyh.js}

@@ -1,14 +1,13 @@
-import { At as applyEdgeHandlingExpr, Bt as ZERO, Ht as call, J as std, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
-const diffuseBlurUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, intensity, viewport) => {
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, nt as std_exports, p as call, t as applyEdgeHandlingExpr, wt as fract } from "./edges-BXNBKxSN.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
+const diffuseBlurUV = src_default.fn([
+	vec2f,
+	f32,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, intensity, viewport) => {
 	"use gpu";
-	const seed = uv.mul(1e3);
-	const sinVal = std.sin(std.dot(seed, d.vec2f(25.9796, 156.466)));
-	const offset = std.fract(d.vec2f(__tsover_mul(sinVal, 43758.5453), __tsover_mul(sinVal, 28461.7231))).mul(2).sub(d.vec2f(1, 1)).mul(intensity).div(viewport);
+	const sinVal = sin(dot(uv.mul(1e3), vec2f(25.9796, 156.466)));
+	const offset = fract(vec2f(__tsover_mul(sinVal, 43758.5453), __tsover_mul(sinVal, 28461.7231))).mul(2).sub(vec2f(1, 1)).mul(intensity).div(viewport);
 	return uv.add(offset);
 }), {
 	v: 1,
@@ -160,8 +159,8 @@ const diffuseBlurUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{DisplacementMap-lv-qoLem.js → DisplacementMap-DMNivtcV.js}

@@ -1,17 +1,17 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, bt as dot, c as sampleRemappedExpr, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const dmDisplaceRG = tgpu.fn([
-	d.vec2f,
-	d.vec4f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount) => {
+const dmDisplaceRG = src_default.fn([
+	vec2f,
+	vec4f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount) => {
 	"use gpu";
-	const a = std.max(src.w, 1e-4);
+	const a = max(src.w, 1e-4);
 	const dx = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(__tsover_div(src.x, a), .5), 2), src.w), amount), aspect);
 	const dy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(__tsover_div(src.y, a), .5), 2), src.w), amount);
-	return d.vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
+	return vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
 }), {
 	v: 1,
 	name: void 0,
@@ -164,25 +164,25 @@ const dmDisplaceRG = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const dmDisplaceLuminance = tgpu.fn([
-	d.vec2f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount, angleDeg) => {
+const dmDisplaceLuminance = src_default.fn([
+	vec2f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, src, aspect, amount, angleDeg) => {
 	"use gpu";
-	const a = std.max(src.w, 1e-4);
-	const lum = std.dot(d.vec3f(__tsover_div(src.x, a), __tsover_div(src.y, a), __tsover_div(src.z, a)), d.vec3f(.2126, .7152, .0722));
+	const a = max(src.w, 1e-4);
+	const lum = dot(vec3f(__tsover_div(src.x, a), __tsover_div(src.y, a), __tsover_div(src.z, a)), vec3f(.2126, .7152, .0722));
 	const scalar = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_sub(lum, .5), 2), src.w), amount);
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dx = __tsover_div(__tsover_mul(scalar, std.cos(angleRad)), aspect);
-	const dy = __tsover_mul(scalar, std.sin(angleRad));
-	return d.vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
+	const dx = __tsover_div(__tsover_mul(scalar, cos(angleRad)), aspect);
+	const dy = __tsover_mul(scalar, sin(angleRad));
+	return vec2f(__tsover_add(uv.x, dx), __tsover_add(uv.y, dy));
 }), {
 	v: 1,
 	name: void 0,
@@ -406,8 +406,8 @@ const dmDisplaceLuminance = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		DEG_TO_RAD
 	})
 }) && $.f)({}));