shaders 3.0.448 → 3.0.449

package/dist/core/{Chalkboard-C7srb54u.js → Chalkboard-wRYj23wL.js}

@@ -1,12 +1,12 @@
-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 } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Et as max, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Rt as sqrt, Vt as data_exports, _ as floatE, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, wt as fract, y as vec4, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var SIN_045 = Math.sin(.785);
 var COS_045 = Math.cos(.785);
 var SIN_N45 = Math.sin(-.785);
 var COS_N45 = Math.cos(-.785);
-var chalkHash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var chalkHash21 = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(std.dot(p, d.vec2f(12.9898, 78.233))), 43758.5453));
+	return fract(__tsover_mul(sin(dot(p, vec2f(12.9898, 78.233))), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -56,20 +56,20 @@ var chalkHash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-var chalkVnoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var chalkVnoise = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const i = std.floor(p);
-	const f = std.fract(p);
+	const i = floor(p);
+	const f = fract(p);
 	const u = f.mul(f).mul(f.mul(-2).add(3));
 	const a = chalkHash21(i);
-	const b = chalkHash21(d.vec2f(__tsover_add(i.x, 1), i.y));
-	const c = chalkHash21(d.vec2f(i.x, __tsover_add(i.y, 1)));
-	const dd = chalkHash21(d.vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
-	return std.mix(std.mix(a, b, u.x), std.mix(c, dd, u.x), u.y);
+	const b = chalkHash21(vec2f(__tsover_add(i.x, 1), i.y));
+	const c = chalkHash21(vec2f(i.x, __tsover_add(i.y, 1)));
+	const dd = chalkHash21(vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
+	return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -307,14 +307,14 @@ var chalkVnoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		chalkHash21,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-var chalkLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+var chalkLuma = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	return std.dot(d.vec3f(color.x, color.y, color.z), d.vec3f(.299, .587, .114));
+	return dot(vec3f(color.x, color.y, color.z), vec3f(.299, .587, .114));
 }), {
 	v: 1,
 	name: void 0,
@@ -371,21 +371,21 @@ var chalkLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const chalkOffsetUV = 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, edgeThickness, ox, oy) => {
+const chalkOffsetUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, edgeThickness, ox, oy) => {
 	"use gpu";
 	const texelX = __tsover_div(1, viewport.x);
 	const texelY = __tsover_div(1, viewport.y);
-	return d.vec2f(__tsover_add(uv.x, __tsover_mul(__tsover_mul(texelX, edgeThickness), ox)), __tsover_add(uv.y, __tsover_mul(__tsover_mul(texelY, edgeThickness), oy)));
+	return vec2f(__tsover_add(uv.x, __tsover_mul(__tsover_mul(texelX, edgeThickness), ox)), __tsover_add(uv.y, __tsover_mul(__tsover_mul(texelY, edgeThickness), oy)));
 }), {
 	v: 1,
 	name: void 0,
@@ -491,21 +491,21 @@ const chalkOffsetUV = tgpu.fn([
 		]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-var chalkHatchLine = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((P, hatchScale, shade, sa, ca, thr) => {
+var chalkHatchLine = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((P, hatchScale, shade, sa, ca, thr) => {
 	"use gpu";
 	const ry = __tsover_add(__tsover_mul(P.x, sa), __tsover_mul(P.y, ca));
-	const hl = __tsover_mul(std.abs(__tsover_sub(std.fract(__tsover_div(ry, hatchScale)), .5)), 2);
-	const line = __tsover_sub(1, std.smoothstep(0, .35, hl));
-	return __tsover_mul(line, std.step(thr, shade));
+	const hl = __tsover_mul(abs(__tsover_sub(fract(__tsover_div(ry, hatchScale)), .5)), 2);
+	const line = __tsover_sub(1, smoothstep(0, .35, hl));
+	return __tsover_mul(line, step(thr, shade));
 }), {
 	v: 1,
 	name: void 0,
@@ -640,18 +640,18 @@ var chalkHatchLine = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const chalkboardCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sobelA, sobelB, uv, viewport, misc, params, boardColor, chalkColor) => {
+const chalkboardCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sobelA, sobelB, uv, viewport, misc, params, boardColor, chalkColor) => {
 	"use gpu";
 	const tl = sobelA.x;
 	const t = sobelA.y;
@@ -669,18 +669,16 @@ const chalkboardCompose = tgpu.fn([
 	const grain = params.w;
 	const gx = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(l, 2)), bl), tr), __tsover_mul(r, 2)), br);
 	const gy = __tsover_add(__tsover_add(__tsover_add(__tsover_sub(__tsover_sub(-tl, __tsover_mul(t, 2)), tr), bl), __tsover_mul(bo, 2)), br);
-	const edgeMag = std.sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy)));
-	const edgeHigh = std.mix(d.f32(1), .08, edgeSensitivity);
-	const edge = std.smoothstep(__tsover_mul(edgeHigh, .4), edgeHigh, edgeMag);
+	const edgeMag = sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy)));
+	const edgeHigh = mix(f32(1), .08, edgeSensitivity);
+	const edge = smoothstep(__tsover_mul(edgeHigh, .4), edgeHigh, edgeMag);
 	const shade = __tsover_sub(1, centerLum);
 	const P = uv.mul(viewport);
-	const hatch = __tsover_mul(std.max(std.max(chalkHatchLine(P, hatchScale, shade, SIN_045, COS_045, .22), chalkHatchLine(P, hatchScale, shade, SIN_N45, COS_N45, .5)), chalkHatchLine(P, hatchScale, shade, 0, 1, .78)), shading);
-	const dust = std.mix(__tsover_sub(1, grain), d.f32(1), chalkVnoise(P.mul(.5)));
-	const chalkMask = std.clamp(__tsover_mul(std.max(edge, hatch), dust), 0, 1);
+	const hatch = __tsover_mul(max(max(chalkHatchLine(P, hatchScale, shade, SIN_045, COS_045, .22), chalkHatchLine(P, hatchScale, shade, SIN_N45, COS_N45, .5)), chalkHatchLine(P, hatchScale, shade, 0, 1, .78)), shading);
+	const dust = mix(__tsover_sub(1, grain), f32(1), chalkVnoise(P.mul(.5)));
+	const chalkMask = clamp(__tsover_mul(max(edge, hatch), dust), 0, 1);
 	const boardGrain = __tsover_mul(__tsover_sub(chalkVnoise(P.mul(.9)), .5), .04);
-	const boardRGB = boardColor.xyz.add(boardGrain);
-	const col = std.mix(boardRGB, chalkColor.xyz, d.vec3f(chalkMask));
-	return d.vec4f(col, centerAlpha);
+	return vec4f(mix(boardColor.xyz.add(boardGrain), chalkColor.xyz, vec3f(chalkMask)), centerAlpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -1258,8 +1256,8 @@ const chalkboardCompose = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		chalkHatchLine,
 		SIN_045,
 		COS_045,

package/dist/core/{ChannelBlur-DE3T4-pj.js → ChannelBlur-DKD9GUpc.js}

@@ -1,25 +1,23 @@
-import { Bt as ZERO, Ht as call, J as std, K as createGaussianBlurCompute, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
+import { Et as max, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { i as createGaussianBlurCompute } from "./blur-tvWOoxKt.js";
 const INTENSITY_TO_RADIUS = .1;
 const channelIntensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
-const channelBlurCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sharp, blurred, redIntensity, greenIntensity, blueIntensity) => {
+const channelBlurCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sharp, blurred, redIntensity, greenIntensity, blueIntensity) => {
 	"use gpu";
 	const redRadius = __tsover_mul(redIntensity, .1);
 	const greenRadius = __tsover_mul(greenIntensity, .1);
 	const blueRadius = __tsover_mul(blueIntensity, .1);
-	const maxRadius = std.max(std.max(std.max(redRadius, greenRadius), blueRadius), .01);
+	const maxRadius = max(max(max(redRadius, greenRadius), blueRadius), .01);
 	const rMix = __tsover_div(redRadius, maxRadius);
 	const gMix = __tsover_div(greenRadius, maxRadius);
 	const bMix = __tsover_div(blueRadius, maxRadius);
-	const finalR = std.mix(sharp.x, blurred.x, rMix);
-	const finalG = std.mix(sharp.y, blurred.y, gMix);
-	const finalB = std.mix(sharp.z, blurred.z, bMix);
-	return d.vec4f(finalR, finalG, finalB, sharp.w);
+	return vec4f(mix(sharp.x, blurred.x, rMix), mix(sharp.y, blurred.y, gMix), mix(sharp.z, blurred.z, bMix), sharp.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -233,8 +231,8 @@ const channelBlurCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("channelBlurCompose");
 const componentDefinition = {

package/dist/core/{CheckerWipe-Dp49-iaT.js → CheckerWipe-D0WmsSKg.js}

@@ -1,27 +1,27 @@
-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 checkerWipeMask = 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, blockSize, softness, progress, invert) => {
+import { $t as vec2f, Ct as floor, Et as max, Lt as smoothstep, Vt as data_exports, _t as clamp, an as f32, d as ZERO, et as src_default, in as vec4f, 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 checkerWipeMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, blockSize, softness, progress, invert) => {
 	"use gpu";
-	const gridX = __tsover_div(1, std.max(blockSize, .001));
-	const gridY = std.max(__tsover_div(gridX, aspect), 1);
-	const cx = std.floor(__tsover_mul(uv.x, gridX));
-	const cy = std.floor(__tsover_mul(uv.y, gridY));
-	const parity = __tsover_mul(std.fract(__tsover_mul(__tsover_add(cx, cy), .5)), 2);
+	const gridX = __tsover_div(1, max(blockSize, .001));
+	const gridY = max(__tsover_div(gridX, aspect), 1);
+	const cx = floor(__tsover_mul(uv.x, gridX));
+	const cy = floor(__tsover_mul(uv.y, gridY));
+	const parity = __tsover_mul(fract(__tsover_mul(__tsover_add(cx, cy), .5)), 2);
 	const diag = __tsover_mul(__tsover_add(__tsover_div(cx, gridX), __tsover_div(cy, gridY)), .5);
-	let r = std.clamp(__tsover_add(__tsover_mul(.5, parity), __tsover_mul(.5, diag)), 0, 1);
-	r = std.select(r, __tsover_sub(1, r), invert > 0);
-	const f = std.max(softness, 1e-4);
+	let r = clamp(__tsover_add(__tsover_mul(.5, parity), __tsover_mul(.5, diag)), 0, 1);
+	r = select(r, __tsover_sub(1, r), invert > 0);
+	const f = max(softness, 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), r);
-	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), r);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -354,8 +354,8 @@ const checkerWipeMask = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Checkerboard-oVWtS0rz.js → Checkerboard-2sQYJks9.js}

@@ -1,12 +1,12 @@
-import { 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, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const checkerCoord = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, cells) => {
+import { $t as vec2f, Et as max, H as mixColorsLinear, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, mt as abs, nt as std_exports, ot as dpdx, p as call, st as dpdy, wt as fract } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const checkerCoord = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, cells) => {
 	"use gpu";
-	return d.vec2f(__tsover_mul(__tsover_mul(uv.x, aspect), cells), __tsover_mul(__tsover_sub(1, uv.y), cells));
+	return vec2f(__tsover_mul(__tsover_mul(uv.x, aspect), cells), __tsover_mul(__tsover_sub(1, uv.y), cells));
 }), {
 	v: 1,
 	name: void 0,
@@ -64,18 +64,18 @@ const checkerCoord = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const checkerFilterValue = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w) => {
+const checkerFilterValue = src_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w) => {
 	"use gpu";
-	const aHalf = d.vec2f(__tsover_mul(w.x, .5), __tsover_mul(w.y, .5));
-	const minusSideX = std.abs(__tsover_sub(std.fract(__tsover_mul(__tsover_sub(p.x, aHalf.x), .5)), .5));
-	const minusSideY = std.abs(__tsover_sub(std.fract(__tsover_mul(__tsover_sub(p.y, aHalf.y), .5)), .5));
-	const plusSideX = std.abs(__tsover_sub(std.fract(__tsover_mul(__tsover_add(p.x, aHalf.x), .5)), .5));
-	const plusSideY = std.abs(__tsover_sub(std.fract(__tsover_mul(__tsover_add(p.y, aHalf.y), .5)), .5));
+	const aHalf = vec2f(__tsover_mul(w.x, .5), __tsover_mul(w.y, .5));
+	const minusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.x, aHalf.x), .5)), .5));
+	const minusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.y, aHalf.y), .5)), .5));
+	const plusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.x, aHalf.x), .5)), .5));
+	const plusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.y, aHalf.y), .5)), .5));
 	const iX = __tsover_div(__tsover_mul(__tsover_sub(minusSideX, plusSideX), 2), w.x);
 	const iY = __tsover_div(__tsover_mul(__tsover_sub(minusSideY, plusSideY), 2), w.y);
-	return std.clamp(__tsover_sub(.5, __tsover_mul(__tsover_mul(iX, iY), .5)), 0, 1);
+	return clamp(__tsover_sub(.5, __tsover_mul(__tsover_mul(iX, iY), .5)), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -375,22 +375,22 @@ const checkerFilterValue = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ ((
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const checkerBlend = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, softness) => {
+const checkerBlend = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, softness) => {
 	"use gpu";
-	const p = checkerCoord(uv, __tsover_div(viewport.x, std.max(viewport.y, 1e-6)), cells);
-	const dpx = std.dpdx(p);
-	const dpy = std.dpdy(p);
-	const baseW = d.vec2f(std.max(std.abs(dpx.x), std.abs(dpy.x)), std.max(std.abs(dpx.y), std.abs(dpy.y)));
-	return checkerFilterValue(p, d.vec2f(std.max(__tsover_add(baseW.x, softness), 1e-5), std.max(__tsover_add(baseW.y, softness), 1e-5)));
+	const p = checkerCoord(uv, __tsover_div(viewport.x, max(viewport.y, 1e-6)), cells);
+	const dpx = dpdx(p);
+	const dpy = dpdy(p);
+	const baseW = vec2f(max(abs(dpx.x), abs(dpy.x)), max(abs(dpx.y), abs(dpy.y)));
+	return checkerFilterValue(p, vec2f(max(__tsover_add(baseW.x, softness), 1e-5), max(__tsover_add(baseW.y, softness), 1e-5)));
 }), {
 	v: 1,
 	name: void 0,
@@ -617,9 +617,9 @@ const checkerBlend = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		checkerCoord,
-		d,
+		d: data_exports,
 		checkerFilterValue
 	})
 }) && $.f)({}));

package/dist/core/{Chevron-CCD5JTRA.js → Chevron-D3oPw2-i.js}

@@ -1,33 +1,33 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, H as mixColorsLinear, It as sin, Lt as smoothstep, U as mixColorsVariants, an as f32, ct as fwidth, et as src_default, mt as abs, nt as std_exports, p as call, v as mixExpr, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .0174533;
-const chevronMask = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	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, count, angle, balance, softness, offset, animTime) => {
+const chevronMask = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, count, angle, balance, softness, offset, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const au = __tsover_mul(uv.x, aspect);
 	const av = uv.y;
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
 	const cu = __tsover_sub(au, __tsover_mul(aspect, .5));
 	const cv = __tsover_sub(av, .5);
 	const rotU = __tsover_add(__tsover_mul(cu, cosA), __tsover_mul(cv, sinA));
 	const rotV = __tsover_add(-__tsover_mul(cu, sinA), __tsover_mul(cv, cosA));
-	const zigzag = __tsover_mul(std.abs(__tsover_sub(std.fract(__tsover_mul(rotV, count)), .5)), 2);
+	const zigzag = __tsover_mul(abs(__tsover_sub(fract(__tsover_mul(rotV, count)), .5)), 2);
 	const stripeCoord = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(rotU, count), __tsover_mul(zigzag, .5)), animTime), offset);
-	const pattern = std.fract(stripeCoord);
-	const fw = std.fwidth(stripeCoord);
-	return std.smoothstep(__tsover_sub(__tsover_sub(balance, softness), fw), __tsover_add(__tsover_add(balance, softness), fw), pattern);
+	const pattern = fract(stripeCoord);
+	const fw = fwidth(stripeCoord);
+	return smoothstep(__tsover_sub(__tsover_sub(balance, softness), fw), __tsover_add(__tsover_add(balance, softness), fw), pattern);
 }), {
 	v: 1,
 	name: void 0,
@@ -343,7 +343,7 @@ const chevronMask = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{ChromaFlow-BiE9Mes0.js → ChromaFlow-px9KG_h6.js}

@@ -1,14 +1,15 @@
-import { H as toHalfFloat, Ht as call, J as std, Kt as floatE, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, an as f32, et as src_default, in as vec4f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { t as toHalfFloat } from "./dataEncoding-CEmpiitu.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var GRID_SIZE = 128;
 var num = (v, f) => typeof v === "number" ? v : f;
-const chromaFlowTapUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, dx, dy) => {
+const chromaFlowTapUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, dx, dy) => {
 	"use gpu";
-	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,
@@ -56,39 +57,37 @@ const chromaFlowTapUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({})).$name("chromaFlowTapUV");
-const chromaFlowColor = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s0, s1, s2, s3, s4, base, up, down, left, right) => {
+const chromaFlowColor = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s0, s1, s2, s3, s4, base, up, down, left, right) => {
 	"use gpu";
-	const smoothedLiquid = __tsover_mul(__tsover_add(__tsover_add(__tsover_add(__tsover_add(s0.z, s1.z), s2.z), s3.z), s4.z), .2);
-	const liquidIntensity = std.smoothstep(0, .1, smoothedLiquid);
+	const liquidIntensity = smoothstep(0, .1, __tsover_mul(__tsover_add(__tsover_add(__tsover_add(__tsover_add(s0.z, s1.z), s2.z), s3.z), s4.z), .2));
 	const flow = s0.xy.add(s1.xy).add(s2.xy).add(s3.xy).add(s4.xy).mul(.2);
-	const flowMagnitude = std.length(flow);
-	const hasFlow = std.smoothstep(.01, .1, flowMagnitude);
+	const flowMagnitude = length(flow);
+	const hasFlow = smoothstep(.01, .1, flowMagnitude);
 	const normalizedX = __tsover_div(flow.x, __tsover_add(flowMagnitude, .001));
 	const normalizedY = __tsover_div(flow.y, __tsover_add(flowMagnitude, .001));
-	const rightAmount = std.smoothstep(0, .7, std.max(normalizedX, 0));
-	const leftAmount = std.smoothstep(0, .7, std.max(__tsover_mul(normalizedX, -1), 0));
-	const upAmount = std.smoothstep(0, .7, std.max(normalizedY, 0));
-	const downAmount = std.smoothstep(0, .7, std.max(__tsover_mul(normalizedY, -1), 0));
+	const rightAmount = smoothstep(0, .7, max(normalizedX, 0));
+	const leftAmount = smoothstep(0, .7, max(__tsover_mul(normalizedX, -1), 0));
+	const upAmount = smoothstep(0, .7, max(normalizedY, 0));
+	const downAmount = smoothstep(0, .7, max(__tsover_mul(normalizedY, -1), 0));
 	const horizontalColor = left.mul(leftAmount).add(right.mul(rightAmount));
 	const verticalColor = down.mul(downAmount).add(up.mul(upAmount));
 	const horizontalWeight = __tsover_add(leftAmount, rightAmount);
 	const verticalWeight = __tsover_add(upAmount, downAmount);
 	const totalWeight = __tsover_add(__tsover_add(horizontalWeight, verticalWeight), .001);
-	const directionalColor = horizontalColor.mul(__tsover_div(horizontalWeight, totalWeight)).add(verticalColor.mul(__tsover_div(verticalWeight, totalWeight)));
-	return std.mix(base, directionalColor, d.vec4f(hasFlow)).mul(liquidIntensity);
+	return mix(base, horizontalColor.mul(__tsover_div(horizontalWeight, totalWeight)).add(verticalColor.mul(__tsover_div(verticalWeight, totalWeight))), vec4f(hasFlow)).mul(liquidIntensity);
 }), {
 	v: 1,
 	name: void 0,
@@ -624,8 +623,8 @@ const chromaFlowColor = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("chromaFlowColor");
 const componentDefinition = {

package/dist/core/{ChromaticAberration-XEasUrD3.js → ChromaticAberration-DLFROPJV.js}

@@ -1,15 +1,15 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { r as transformAngle } from "./transformations-t0d2-uSX.js";
-const chromaticOffsetUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, angle, strength, aspect, channelOffset) => {
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, d as ZERO, et as src_default, jt as radians, nt as std_exports, p as call, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { r as transformAngle } from "./transformations-CsPUHppB.js";
+const chromaticOffsetUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, angle, strength, aspect, channelOffset) => {
 	"use gpu";
-	const angleRad = std.radians(angle);
-	const direction = d.vec2f(__tsover_div(std.cos(angleRad), aspect), std.sin(angleRad));
+	const angleRad = radians(angle);
+	const direction = vec2f(__tsover_div(cos(angleRad), aspect), sin(angleRad));
 	const scaledStrength = __tsover_mul(strength, .1);
 	const offsetBase = direction.mul(scaledStrength);
 	return uv.add(offsetBase.mul(channelOffset));
@@ -131,8 +131,8 @@ const chromaticOffsetUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Circle-CvQ9duDU.js → Circle-0CqIPN3a.js}

@@ -1,17 +1,18 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, Jt as vec4, R as strokeMaskFromSdf, T as circleSdf, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const circleShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, Vt as data_exports, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { h as sdf_exports, i as circleSdf, n as ShapeMask, v as strokeMaskFromSdf } from "./sdf-R0EN3EvS.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const circleShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
-	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));
 	return strokeMaskFromSdf(circleSdf(__tsover_sub(aspectUV.x, centerPos.x), __tsover_sub(aspectUV.y, centerPos.y), __tsover_mul(radius, .5)), softness, strokeThickness, strokePosition);
 }), {
 	v: 1,
@@ -186,7 +187,7 @@ const circleShape = tgpu.fn([
 		"externalNames": ["d", "sdf"]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		sdf: sdf_exports
 	})
 }) && $.f)({}));