shaders 3.0.448 → 3.0.450

package/dist/core/{ReflectivePlane-BOl9AEoO.js → ReflectivePlane-u3Tje37M.js}

@@ -1,10 +1,12 @@
-import { At as applyEdgeHandlingExpr, Bt as ZERO, Ht as call, J as std, Tn as d, U as BLUR_MAP_FORMAT, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu, q as createVariableGaussianBlurCompute } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { At as mix, N as unpremultiplyAlpha, Ot as max, Qt as struct, Ut as data_exports, Vt as step, d as ZERO, et as src_default, ln as u32, nt as std_exports, on as vec4f, ot as textureStore, p as call, qt as textureStorage2d, rn as vec2u, sn as f32, t as applyEdgeHandlingExpr, tn as vec2f, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { n as createGuardedCompute } from "./compute-BoeIXi0l.js";
+import { a as createVariableGaussianBlurCompute, t as BLUR_MAP_FORMAT } from "./blur-DKmdsW6d.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var HALF_KERNEL = 30;
 var BLUR_TO_RADIUS_PX = 12;
-const reflectedPlaneUV = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, floorY) => {
+const reflectedPlaneUV = src_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, floorY) => {
 	"use gpu";
-	return d.vec2f(uv.x, __tsover_sub(__tsover_mul(floorY, 2), uv.y));
+	return vec2f(uv.x, __tsover_sub(__tsover_mul(floorY, 2), uv.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -45,29 +47,25 @@ const reflectedPlaneUV = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($)
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const reflectivePlaneCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, refl, uvY, floorY, distance, falloff) => {
+const reflectivePlaneCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, refl, uvY, floorY, distance, falloff) => {
 	"use gpu";
-	const distBelow = std.max(__tsover_sub(uvY, floorY), 0);
-	const distanceMax = std.max(distance, .001);
-	const fadeWidth = std.max(__tsover_mul(distanceMax, falloff), 1e-4);
+	const distBelow = max(__tsover_sub(uvY, floorY), 0);
+	const distanceMax = max(distance, .001);
+	const fadeWidth = max(__tsover_mul(distanceMax, falloff), 1e-4);
 	const fadeStart = __tsover_sub(distanceMax, fadeWidth);
-	const visibility = __tsover_sub(1, std.smoothstep(fadeStart, distanceMax, distBelow));
+	const visibility = __tsover_sub(1, smoothstep(fadeStart, distanceMax, distBelow));
 	const effReflA = __tsover_mul(refl.w, visibility);
 	const oneMinusReflA = __tsover_sub(1, effReflA);
-	const belowRgb = refl.xyz.mul(visibility).add(original.xyz.mul(oneMinusReflA));
-	const belowA = __tsover_add(effReflA, __tsover_mul(original.w, oneMinusReflA));
-	const belowFloor = d.vec4f(belowRgb, belowA);
-	const isBelowFloor = std.step(floorY, uvY);
-	return std.mix(original, belowFloor, d.vec4f(isBelowFloor));
+	return mix(original, vec4f(refl.xyz.mul(visibility).add(original.xyz.mul(oneMinusReflA)), __tsover_add(effReflA, __tsover_mul(original.w, oneMinusReflA))), vec4f(step(floorY, uvY)));
 }), {
 	v: 1,
 	name: void 0,
@@ -311,33 +309,33 @@ const reflectivePlaneCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 function reflectiveFillParams() {
-	return d.struct({
-		height: d.f32,
-		blurAmount: d.f32,
-		blurDistance: d.f32
+	return struct({
+		height: f32,
+		blurAmount: f32,
+		blurDistance: f32
 	});
 }
 function buildReflectivePlaneFillGraph(computeWidth, computeHeight) {
 	const Params = reflectiveFillParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
 		params: { uniform: Params }
 	}), "layout");
 	return {
 		layout,
-		kernel: tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 			"use gpu";
 			const p = layout.$.params;
-			const v = __tsover_div(__tsover_add(d.f32(cy), .5), computeHeight);
-			const distBelowAtOutput = std.max(__tsover_sub(p.height, v), 0);
-			const ramp = std.smoothstep(0, p.blurDistance, distBelowAtOutput);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const distBelowAtOutput = max(__tsover_sub(p.height, v), 0);
+			const ramp = smoothstep(0, p.blurDistance, distBelowAtOutput);
 			const radius = __tsover_mul(__tsover_mul(p.blurAmount, ramp), BLUR_TO_RADIUS_PX);
-			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.vec4f(radius, 0, 0, 1));
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -501,9 +499,9 @@ function buildReflectivePlaneFillGraph(computeWidth, computeHeight) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeHeight,
-				std,
+				std: std_exports,
 				BLUR_TO_RADIUS_PX
 			})
 		}) && $.f)({})).$name("reflectivePlaneFillBlurMap"),

package/dist/core/{Repeater-BMXmN95R.js → Repeater-C-agsqBS.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Gt as expr, Ht as call, Xt as formatFloat, Yt as Expr, cn as unpremultiplyAlpha } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { N as unpremultiplyAlpha, b as Expr, d as ZERO, g as expr, p as call, x as formatFloat } from "./edges-BZUKQxSE.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 const componentDefinition = {
 	name: "Repeater",
 	category: "Distortions",

package/dist/core/{Ring-DKcROHDs.js → Ring-Cj7bR89h.js}

@@ -1,18 +1,19 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, Jt as vec4, N as ringSdf, R as strokeMaskFromSdf, 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 ringShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { H as mixColorsLinear, U as mixColorsVariants, Ut as data_exports, et as src_default, p as call, sn as f32, tn as vec2f, y as vec4 } from "./edges-BZUKQxSE.js";
+import { h as sdf_exports, n as ShapeMask, p as ringSdf, v as strokeMaskFromSdf } from "./sdf-o99ONcMJ.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const ringShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, thickness, 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(ringSdf(__tsover_sub(aspectUV.x, centerPos.x), __tsover_sub(aspectUV.y, centerPos.y), radius, thickness), softness, strokeThickness, strokePosition);
 }), {
 	v: 1,
@@ -182,7 +183,7 @@ const ringShape = tgpu.fn([
 		"externalNames": ["d", "sdf"]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		sdf: sdf_exports
 	})
 }) && $.f)({}));

package/dist/core/{RippleWipe-QH8D0Y-2.js → RippleWipe-VL1MMd5o.js}

@@ -1,32 +1,29 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { c as transformPosition, i as transformBoolean } from "./transformations-t0d2-uSX.js";
-const rippleWipeMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, rings, progress, feather, invert) => {
+import { Dt as length, Ot as max, Tt as floor, Ut as data_exports, d as ZERO, et as src_default, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { c as transformPosition, i as transformBoolean } from "./transformations-CsPUHppB.js";
+const rippleWipeMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, rings, progress, feather, invert) => {
 	"use gpu";
 	const cx = __tsover_mul(center.x, aspect);
 	const cy = __tsover_sub(1, center.y);
-	const rel = d.vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), cx), __tsover_sub(uv.y, cy));
-	const dist = std.length(rel);
-	const dx = std.max(cx, __tsover_sub(aspect, cx));
-	const dy = std.max(cy, __tsover_sub(1, cy));
-	const maxDist = std.length(d.vec2f(dx, dy));
-	const rNorm = __tsover_div(dist, std.max(maxDist, 1e-4));
-	const n = std.max(rings, 1);
-	const ringIdx = std.floor(__tsover_mul(rNorm, n));
-	let coord = std.clamp(__tsover_div(__tsover_add(ringIdx, .5), n), 0, 1);
-	coord = std.select(coord, __tsover_sub(1, coord), invert > 0);
-	const f = std.max(feather, 1e-4);
+	const dist = length(vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), cx), __tsover_sub(uv.y, cy)));
+	const maxDist = length(vec2f(max(cx, __tsover_sub(aspect, cx)), max(cy, __tsover_sub(1, cy))));
+	const rNorm = __tsover_div(dist, max(maxDist, 1e-4));
+	const n = max(rings, 1);
+	const ringIdx = floor(__tsover_mul(rNorm, n));
+	let coord = clamp(__tsover_div(__tsover_add(ringIdx, .5), n), 0, 1);
+	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,
@@ -408,8 +405,8 @@ const rippleWipeMask = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Ripples-8fFdo6aq.js → Ripples-B88TeopS.js}

@@ -1,25 +1,22 @@
-import { Ht as call, J as std, Tn as d, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-const ripplesMask = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, frequency, softness, thickness, phase, animTime, uv, viewport) => {
+import { Dt as length, H as mixColorsLinear, Rt as sin, Ut as data_exports, et as src_default, nt as std_exports, p as call, sn as f32, tn as vec2f, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
+const ripplesMask = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, frequency, softness, thickness, phase, animTime, uv, viewport) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect));
-	const dy = __tsover_sub(uv.y, __tsover_sub(1, center.y));
-	const dist = std.length(d.vec2f(dx, dy));
-	const waveInput = __tsover_add(__tsover_sub(__tsover_mul(dist, frequency), animTime), phase);
-	const baseWave = std.sin(waveInput);
+	const dist = length(vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(uv.y, __tsover_sub(1, center.y))));
+	const baseWave = sin(__tsover_add(__tsover_sub(__tsover_mul(dist, frequency), animTime), phase));
 	const thicknessThreshold = __tsover_sub(__tsover_mul(thickness, 2), 1);
-	const banded = std.smoothstep(__tsover_sub(thicknessThreshold, softness), __tsover_add(thicknessThreshold, softness), baseWave);
+	const banded = smoothstep(__tsover_sub(thicknessThreshold, softness), __tsover_add(thicknessThreshold, softness), baseWave);
 	return __tsover_sub(1, banded);
 }), {
 	v: 1,
@@ -235,8 +232,8 @@ const ripplesMask = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{RoundedRect-Cr76tP9o.js → RoundedRect-jn8_QLrT.js}

@@ -1,16 +1,17 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, P as roundedRectSdf, R as strokeMaskFromSdf, 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 roundedRectShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { H as mixColorsLinear, U as mixColorsVariants, et as src_default, p as call, sn as f32, tn as vec2f, y as vec4 } from "./edges-BZUKQxSE.js";
+import { g as shapeLocalCoords, h as sdf_exports, m as roundedRectSdf, n as ShapeMask, v as strokeMaskFromSdf } from "./sdf-o99ONcMJ.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const roundedRectShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, width, height, rounding, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Saturation-Dqifs1x7.js → Saturation-dCNIhHq2.js}

@@ -1,11 +1,10 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const saturationColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, intensity) => {
+import { At as mix, 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, sn as f32 } from "./edges-BZUKQxSE.js";
+const saturationColor = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, intensity) => {
 	"use gpu";
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const luminance = std.dot(rgb, d.vec3f(.2126, .7152, .0722));
-	const gray = d.vec3f(luminance, luminance, luminance);
-	const saturated = std.mix(gray, rgb, d.vec3f(intensity));
-	return d.vec4f(saturated.x, saturated.y, saturated.z, color.w);
+	const rgb = vec3f(color.x, color.y, color.z);
+	const luminance = dot(rgb, vec3f(.2126, .7152, .0722));
+	const saturated = mix(vec3f(luminance, luminance, luminance), rgb, vec3f(intensity));
+	return vec4f(saturated.x, saturated.y, saturated.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -148,8 +147,8 @@ const saturationColor = 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/{Scratches-sa8JU4Eb.js → Scratches-Dz_1Ptk0.js}

@@ -1,17 +1,19 @@
-import { Ht as call, J as std, Tn as d, _t as scratches12, et as toneAndColorExpr, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as noiseColorPropsAB, r as noiseSpeedProp } from "./noiseColor-CRpf22bk.js";
-const scratchesField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime, thickness) => {
+import { Ct as exp, Ut as data_exports, et as src_default, nt as std_exports, p as call, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { _ as scratches12, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { n as toneAndColorExpr } from "./noiseColor-CQyzqpVZ.js";
+import { n as noiseColorPropsAB, r as noiseSpeedProp } from "./noiseColor-DjCUZ_8u.js";
+const scratchesField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime, thickness) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	return scratches12(d.vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(std.exp(scale)).add(seed), animTime, thickness);
+	return scratches12(vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed), animTime, thickness);
 }), {
 	v: 1,
 	name: void 0,
@@ -137,8 +139,8 @@ const scratchesField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{Sharpness-IRuPd9nn.js → Sharpness-Bxq4YiRL.js}

@@ -1,12 +1,12 @@
-import { Bt as ZERO, Ht as call, J as std, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-const sharpnessTapUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, dirX, dirY) => {
+import { N as unpremultiplyAlpha, Ut as data_exports, _ as floatE, d as ZERO, et as src_default, in as vec3f, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp } from "./edges-BZUKQxSE.js";
+const sharpnessTapUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, dirX, dirY) => {
 	"use gpu";
-	return d.vec2f(__tsover_add(uv.x, __tsover_div(dirX, viewport.x)), __tsover_add(uv.y, __tsover_div(dirY, viewport.y)));
+	return vec2f(__tsover_add(uv.x, __tsover_div(dirX, viewport.x)), __tsover_add(uv.y, __tsover_div(dirY, viewport.y)));
 }), {
 	v: 1,
 	name: void 0,
@@ -76,22 +76,21 @@ const sharpnessTapUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const sharpnessCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, top, bottom, left, right, amount) => {
+const sharpnessCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, top, bottom, left, right, amount) => {
 	"use gpu";
 	const centerWeight = __tsover_add(1, __tsover_mul(amount, 4));
 	const neighborWeight = __tsover_mul(amount, -1);
-	const rgb = center.xyz.mul(centerWeight).add(top.xyz.mul(neighborWeight)).add(bottom.xyz.mul(neighborWeight)).add(left.xyz.mul(neighborWeight)).add(right.xyz.mul(neighborWeight));
-	const clamped = std.clamp(rgb, d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	return d.vec4f(clamped.x, clamped.y, clamped.z, center.w);
+	const clamped = clamp(center.xyz.mul(centerWeight).add(top.xyz.mul(neighborWeight)).add(bottom.xyz.mul(neighborWeight)).add(left.xyz.mul(neighborWeight)).add(right.xyz.mul(neighborWeight)), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	return vec4f(clamped.x, clamped.y, clamped.z, center.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -324,8 +323,8 @@ const sharpnessCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {