shaders 3.0.447 → 3.0.449

package/dist/core/{Text-BGdsqRl5.js → Text-vyzeMvhl.js}

@@ -1,6 +1,6 @@
-import { Ht as call, J as std, Jt as vec4, Rt as sampleCatmullRomExpr, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { n as loadGoogleFont, t as isFontAvailable } from "./fonts-DwhbVe2B.js";
+import { $t as vec2f, It as sin, Vt as data_exports, an as f32, et as src_default, l as sampleCatmullRomExpr, nn as vec3f, nt as std_exports, p as call, vt as cos, y as vec4, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
+import { n as loadGoogleFont, t as isFontAvailable } from "./fonts-v_F1SFl9.js";
 function applyTextTransform(text, mode) {
 	switch (mode) {
 		case "uppercase": return text.toUpperCase();
@@ -139,28 +139,27 @@ var fontSizePxOf = (v, canvasHeight) => {
 	if (v && typeof v === "object" && typeof v.value === "number") return v.unit === "px" ? v.value : v.value * canvasHeight;
 	return (typeof v === "number" ? v : .1) * canvasHeight;
 };
-const textField = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, rotationDeg, halfW, halfH) => {
+const textField = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, rotationDeg, halfW, halfH) => {
 	"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));
 	const dx = __tsover_sub(aspectUV.x, centerPos.x);
 	const dy = __tsover_sub(aspectUV.y, centerPos.y);
 	const rotRad = __tsover_mul(rotationDeg, 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 localU = __tsover_add(__tsover_div(rdx, __tsover_mul(halfW, 2)), .5);
 	const localV = __tsover_add(__tsover_div(rdy, __tsover_mul(halfH, 2)), .5);
-	const insideMask = __tsover_mul(__tsover_mul(__tsover_mul(std.step(0, localU), std.step(localU, 1)), std.step(0, localV)), std.step(localV, 1));
-	return d.vec3f(localU, localV, insideMask);
+	return vec3f(localU, localV, __tsover_mul(__tsover_mul(__tsover_mul(step(0, localU), step(localU, 1)), step(0, localV)), step(localV, 1)));
 }), {
 	v: 1,
 	name: void 0,
@@ -474,9 +473,9 @@ const textField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -486,11 +485,11 @@ const componentDefinition = {
 	acceptsUVContext: true,
 	extraFields: {
 		halfW: {
-			schema: d.f32,
+			schema: f32,
 			initial: .001
 		},
 		halfH: {
-			schema: d.f32,
+			schema: f32,
 			initial: .001
 		}
 	},

package/dist/core/{ThinFilm-DhMKI5e2.js → ThinFilm-CbkMTbD2.js}

@@ -1,7 +1,8 @@
-import { Dn as __export, F as sdf_exports, Ht as call, J as std, Kt as floatE, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, qt as mixExpr, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { i as sdfSpaceUV, r as offsetUV, t as glassGradient } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Ct as floor, Et as max, H as mixColorsLinear, It as sin, Ot as mix, Rt as sqrt, U as mixColorsVariants, Vt as data_exports, _ as floatE, _t as clamp, an as f32, cn as __export, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, v as mixExpr, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { i as sdfSpaceUV, r as offsetUV, t as glassGradient } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var thinFilm_exports = /* @__PURE__ */ __export({
 	applyThinFilmEffect: () => applyThinFilmEffect$1,
 	thinFilmCompose: () => thinFilmCompose,
@@ -11,45 +12,42 @@ var thinFilm_exports = /* @__PURE__ */ __export({
 });
 var DEG_TO_RAD = .017453292519943295;
 var TWO_PI = 6.283185307179586;
-const thinFilmShade = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfRaw, scale, gradX, gradY, edgeSoftness, rimWidthUniform, thickness, dispersion, hueShift, lightAngle, animTime, volumetric) => {
+const thinFilmShade = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfRaw, scale, gradX, gradY, edgeSoftness, rimWidthUniform, thickness, dispersion, hueShift, lightAngle, animTime, volumetric) => {
 	"use gpu";
 	const sdf = __tsover_div(sdfRaw, scale);
-	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
-	const gLen = std.max(std.sqrt(__tsover_add(__tsover_mul(gradX, gradX), __tsover_mul(gradY, gradY))), 1e-4);
+	const sharp = max(__tsover_mul(edgeSoftness, .5), .001);
+	const gLen = max(sqrt(__tsover_add(__tsover_mul(gradX, gradX), __tsover_mul(gradY, gradY))), 1e-4);
 	const nx = __tsover_div(gradX, gLen);
 	const ny = __tsover_div(gradY, gLen);
-	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
-	const rimWidth = std.max(__tsover_mul(rimWidthUniform, .1), .001);
-	const depth = std.clamp(__tsover_div(__tsover_mul(sdf, -1), rimWidth), 0, 1);
-	const cosView = __tsover_div(1, std.sqrt(__tsover_add(__tsover_mul(gLen, gLen), 1)));
-	const exponent = std.mix(7, 1.5, std.clamp(rimWidthUniform, 0, 1));
-	const volRim = __tsover_mul(std.pow(__tsover_sub(1, cosView), exponent), rb1);
-	const flatRim = __tsover_mul(__tsover_mul(__tsover_sub(1, depth), __tsover_sub(1, depth)), rb1);
-	const rim = std.select(flatRim, volRim, volumetric > .5);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const rb1 = clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const rimWidth = max(__tsover_mul(rimWidthUniform, .1), .001);
+	const depth = clamp(__tsover_div(__tsover_mul(sdf, -1), rimWidth), 0, 1);
+	const cosView = __tsover_div(1, sqrt(__tsover_add(__tsover_mul(gLen, gLen), 1)));
+	const exponent = mix(7, 1.5, clamp(rimWidthUniform, 0, 1));
+	const volRim = __tsover_mul(pow(__tsover_sub(1, cosView), exponent), rb1);
+	const rim = select(__tsover_mul(__tsover_mul(__tsover_sub(1, depth), __tsover_sub(1, depth)), rb1), volRim, volumetric > .5);
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
 	const baseCos = __tsover_add(__tsover_mul(nx, lx), __tsover_mul(ny, ly));
 	const baseSin = __tsover_sub(__tsover_mul(ny, lx), __tsover_mul(nx, ly));
 	const theta = __tsover_mul(animTime, TWO_PI);
-	const rotatedDot = __tsover_add(__tsover_mul(baseCos, std.cos(theta)), __tsover_mul(baseSin, std.sin(theta)));
-	const thickVol = __tsover_mul(__tsover_mul(thickness, std.max(__tsover_mul(sdf, -1), 0)), 10);
-	const thickFlat = __tsover_mul(__tsover_mul(thickness, depth), 2);
-	const thicknessTerm = std.select(thickFlat, thickVol, volumetric > .5);
-	const phase = __tsover_add(__tsover_add(hueShift, __tsover_mul(dispersion, rotatedDot)), thicknessTerm);
-	return d.vec2f(phase, rim);
+	const rotatedDot = __tsover_add(__tsover_mul(baseCos, cos(theta)), __tsover_mul(baseSin, sin(theta)));
+	const thickVol = __tsover_mul(__tsover_mul(thickness, max(__tsover_mul(sdf, -1), 0)), 10);
+	const thicknessTerm = select(__tsover_mul(__tsover_mul(thickness, depth), 2), thickVol, volumetric > .5);
+	return vec2f(__tsover_add(__tsover_add(hueShift, __tsover_mul(dispersion, rotatedDot)), thicknessTerm), rim);
 }), {
 	v: 1,
 	name: void 0,
@@ -630,19 +628,16 @@ const thinFilmShade = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
 		TWO_PI,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const thinFilmRainbow = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((phase) => {
+const thinFilmRainbow = src_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((phase) => {
 	"use gpu";
-	const r = std.cos(__tsover_mul(__tsover_add(phase, 0), TWO_PI));
-	const g = std.cos(__tsover_mul(__tsover_add(phase, .3333), TWO_PI));
-	const b = std.cos(__tsover_mul(__tsover_add(phase, .6667), TWO_PI));
-	const half = d.vec3f(r, g, b).mul(.5);
-	return d.vec3f(__tsover_add(half.x, .5), __tsover_add(half.y, .5), __tsover_add(half.z, .5));
+	const half = vec3f(cos(__tsover_mul(__tsover_add(phase, 0), TWO_PI)), cos(__tsover_mul(__tsover_add(phase, .3333), TWO_PI)), cos(__tsover_mul(__tsover_add(phase, .6667), TWO_PI))).mul(.5);
+	return vec3f(__tsover_add(half.x, .5), __tsover_add(half.y, .5), __tsover_add(half.z, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -794,20 +789,18 @@ const thinFilmRainbow = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globa
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		TWO_PI,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const thinFilmCustomParams = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((phase) => {
+const thinFilmCustomParams = src_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((phase) => {
 	"use gpu";
-	const t = std.fract(phase);
+	const t = fract(phase);
 	const t3 = __tsover_mul(t, 3);
-	const si = std.fract(t3);
-	const floorT3 = std.floor(t3);
-	const gate12 = std.select(d.f32(0), d.f32(1), floorT3 <= 1.5);
-	const gate01 = std.select(d.f32(0), d.f32(1), floorT3 <= .5);
-	return d.vec3f(si, gate12, gate01);
+	const si = fract(t3);
+	const floorT3 = floor(t3);
+	return vec3f(si, select(f32(0), f32(1), floorT3 <= 1.5), select(f32(0), f32(1), floorT3 <= .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -959,21 +952,20 @@ const thinFilmCustomParams = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const thinFilmCompose = tgpu.fn([
-	d.vec3f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseColor, rim, intensity, saturation) => {
+const thinFilmCompose = src_default.fn([
+	vec3f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseColor, rim, intensity, saturation) => {
 	"use gpu";
-	const white = d.vec3f(1, 1, 1);
-	const rgb = std.mix(white, baseColor, saturation).mul(rim).mul(intensity);
-	const alpha = std.clamp(rim, 0, 1);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, alpha);
+	const rgb = mix(vec3f(1, 1, 1), baseColor, saturation).mul(rim).mul(intensity);
+	const alpha = clamp(rim, 0, 1);
+	return vec4f(rgb.x, rgb.y, rgb.z, alpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -1099,8 +1091,8 @@ const thinFilmCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 function applyThinFilmEffect$1(params, sdfSampler, options) {

package/dist/core/{TiltShift-BwuYyXB6.js → TiltShift-BVMyB8lF.js}

@@ -1,25 +1,26 @@
-import { 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, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { c as transformPosition, r as transformAngle } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, At as pow, Et as max, Gt as textureStorage2d, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Pt as round, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, et as src_default, in as vec4f, it as textureLoad, mt as abs, nn as vec3f, nt as std_exports, on as i32, p as call, sn as u32, tn as vec2u, v as mixExpr, vt as cos } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as createVariableGaussianBlurCompute, t as BLUR_MAP_FORMAT } from "./blur-tvWOoxKt.js";
+import { c as transformPosition, r as transformAngle } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 const INTENSITY_TO_RADIUS = .36;
 const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
-const tiltShiftBlurAmount = tgpu.fn([
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angleDeg, center, width, falloff, uv, aspect) => {
+const tiltShiftBlurAmount = src_default.fn([
+	f32,
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angleDeg, center, width, falloff, uv, aspect) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const perpVector = d.vec2f(__tsover_mul(std.sin(angleRad), -1), std.cos(angleRad));
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const perpVector = vec2f(__tsover_mul(sin(angleRad), -1), cos(angleRad));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const centeredUV = uv.sub(centerPos);
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y);
-	const distFromLine = std.abs(std.dot(aspectCorrectedUV, perpVector));
+	const distFromLine = abs(dot(vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y), perpVector));
 	const focusWidth = __tsover_mul(width, .5);
-	return std.smoothstep(focusWidth, __tsover_add(focusWidth, falloff), distFromLine);
+	return smoothstep(focusWidth, __tsover_add(focusWidth, falloff), distFromLine);
 }), {
 	v: 1,
 	name: void 0,
@@ -222,54 +223,54 @@ const tiltShiftBlurAmount = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({})).$name("tiltShiftBlurAmount");
 function tiltShiftFillParams() {
-	return d.struct({
-		angle: d.f32,
-		centerX: d.f32,
-		centerY: d.f32,
-		width: d.f32,
-		falloff: d.f32,
-		aspect: d.f32,
-		maxRadius: d.f32
+	return struct({
+		angle: f32,
+		centerX: f32,
+		centerY: f32,
+		width: f32,
+		falloff: f32,
+		aspect: f32,
+		maxRadius: f32
 	});
 }
 function tiltShiftFillMapParams() {
-	return d.struct({
-		angle: d.f32,
-		centerX: d.f32,
-		centerY: d.f32,
-		width: d.f32,
-		falloff: d.f32,
-		aspect: d.f32,
-		inputWidth: d.f32,
-		inputHeight: d.f32,
-		inputMin: d.f32,
-		inputMax: d.f32,
-		outputMin: d.f32,
-		outputMax: d.f32,
-		curve: d.f32
+	return struct({
+		angle: f32,
+		centerX: f32,
+		centerY: f32,
+		width: f32,
+		falloff: f32,
+		aspect: f32,
+		inputWidth: f32,
+		inputHeight: f32,
+		inputMin: f32,
+		inputMax: f32,
+		outputMin: f32,
+		outputMax: f32,
+		curve: f32
 	});
 }
 function buildTiltShiftFillGraph(computeWidth, computeHeight) {
 	const Params = tiltShiftFillParams();
-	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 u = __tsover_div(__tsover_add(d.f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(d.f32(cy), .5), computeHeight);
-			const blurAmount = tiltShiftBlurAmount(p.angle, d.vec2f(p.centerX, p.centerY), p.width, p.falloff, d.vec2f(u, v), p.aspect);
+			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const blurAmount = tiltShiftBlurAmount(p.angle, vec2f(p.centerX, p.centerY), p.width, p.falloff, vec2f(u, v), p.aspect);
 			const radius = __tsover_mul(blurAmount, p.maxRadius);
-			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,
@@ -465,11 +466,11 @@ function buildTiltShiftFillGraph(computeWidth, computeHeight) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
 				tiltShiftBlurAmount,
-				std
+				std: std_exports
 			})
 		}) && $.f)({})).$name("tiltShiftFillBlurMap"),
 		Params
@@ -477,30 +478,28 @@ function buildTiltShiftFillGraph(computeWidth, computeHeight) {
 }
 function buildTiltShiftFillMapGraph(computeWidth, computeHeight, channel) {
 	const Params = tiltShiftFillMapParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		source: { texture: d.texture2d(d.f32) },
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		source: { texture: texture2d(f32) },
+		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 u = __tsover_div(__tsover_add(d.f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(d.f32(cy), .5), computeHeight);
-			const blurAmount = tiltShiftBlurAmount(p.angle, d.vec2f(p.centerX, p.centerY), p.width, p.falloff, d.vec2f(u, v), p.aspect);
-			const srcX = std.clamp(d.i32(std.round(__tsover_mul(u, p.inputWidth))), 0, d.i32(__tsover_sub(p.inputWidth, 1)));
-			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 0, d.i32(__tsover_sub(p.inputHeight, 1)));
-			const sample = std.textureLoad(layout.$.source, d.vec2u(d.u32(srcX), d.u32(srcY)), 0);
-			const raw = channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722))) : std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
-			const inputRange = std.max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
-			const normalised = std.clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1);
-			const exponent = std.pow(2, __tsover_mul(-p.curve, 2));
-			const eased = std.pow(normalised, exponent);
-			const maxRadius = __tsover_mul(std.mix(p.outputMin, p.outputMax, eased), .36);
+			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const blurAmount = tiltShiftBlurAmount(p.angle, vec2f(p.centerX, p.centerY), p.width, p.falloff, vec2f(u, v), p.aspect);
+			const srcX = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
+			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
+			const sample = textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0);
+			const raw = channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(sample.xyz, vec3f(.2126, .7152, .0722))) : dot(sample.xyz, vec3f(.2126, .7152, .0722));
+			const inputRange = max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
+			const eased = pow(clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1), pow(2, __tsover_mul(-p.curve, 2)));
+			const maxRadius = __tsover_mul(mix(p.outputMin, p.outputMax, eased), .36);
 			const radius = __tsover_mul(blurAmount, maxRadius);
-			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,
@@ -1088,11 +1087,11 @@ function buildTiltShiftFillMapGraph(computeWidth, computeHeight, channel) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
 				tiltShiftBlurAmount,
-				std,
+				std: std_exports,
 				channel,
 				INTENSITY_TO_RADIUS: .36
 			})