shaders 3.0.448 → 3.0.450

package/dist/core/{Tint-BTmcGjEl.js → Tint-Cak_PyOJ.js}

@@ -1,14 +1,13 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
-const tintColorPlain = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
+import { At as mix, Ot as max, 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";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
+const tintColorPlain = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
 	"use gpu";
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const tinted = std.mix(rgb, d.vec3f(tintColor.x, tintColor.y, tintColor.z), d.vec3f(amount));
-	return d.vec4f(tinted.x, tinted.y, tinted.z, color.w);
+	const tinted = mix(vec3f(color.x, color.y, color.z), vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
+	return vec4f(tinted.x, tinted.y, tinted.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -140,23 +139,23 @@ const tintColorPlain = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const tintColorPreserve = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
+const tintColorPreserve = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
 	"use gpu";
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const tinted = std.mix(rgb, d.vec3f(tintColor.x, tintColor.y, tintColor.z), d.vec3f(amount));
-	const luminanceWeights = d.vec3f(.299, .587, .114);
-	const originalLum = std.dot(rgb, luminanceWeights);
-	const tintedLum = std.dot(tinted, luminanceWeights);
-	const result = tinted.mul(__tsover_div(originalLum, std.max(tintedLum, 1e-4)));
-	return d.vec4f(result.x, result.y, result.z, color.w);
+	const rgb = vec3f(color.x, color.y, color.z);
+	const tinted = mix(rgb, vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
+	const luminanceWeights = vec3f(.299, .587, .114);
+	const originalLum = dot(rgb, luminanceWeights);
+	const tintedLum = dot(tinted, luminanceWeights);
+	const result = tinted.mul(__tsover_div(originalLum, max(tintedLum, 1e-4)));
+	return vec4f(result.x, result.y, result.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -357,8 +356,8 @@ const tintColorPreserve = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Trapezoid-CiZCh8QS.js → Trapezoid-DnFhlKCD.js}

@@ -1,16 +1,17 @@
-import { B as trapezoidSdf, C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, 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 trapezoidShape = 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 { b as trapezoidSdf, g as shapeLocalCoords, h as sdf_exports, 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 trapezoidShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, topWidth, bottomWidth, height, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{TriangularGrid-BnQOEljy.js → TriangularGrid-BE9CgVlb.js}

@@ -1,50 +1,48 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { Et as fract, H as mixColorsLinear, Ot as max, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, Vt as step, bt as cos, et as src_default, ht as abs, kt as min, lt as fwidth, nt as std_exports, p as call, sn as f32, tn as vec2f, y as vec4, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var SQRT3 = Math.sqrt(3);
 var TWO_OVER_SQRT3 = 2 / Math.sqrt(3);
-const triangularGridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	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 = ((uv, viewport, cells, thickness, rotation, softness, variation, speedVariance, animTime) => {
+const triangularGridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation, speedVariance, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
 	const ang = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const p = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const ps = d.vec2f(__tsover_sub(p.x, __tsover_div(p.y, SQRT3)), __tsover_mul(p.y, TWO_OVER_SQRT3));
-	const rowIndex = std.floor(ps.y);
-	const rowHash = std.fract(__tsover_mul(std.sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
+	const p = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const ps = vec2f(__tsover_sub(p.x, __tsover_div(p.y, SQRT3)), __tsover_mul(p.y, TWO_OVER_SQRT3));
+	const rowIndex = floor(ps.y);
+	const rowHash = fract(__tsover_mul(sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
 	const speedMod = __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rowHash, .5), 4), speedVariance));
 	const drift = __tsover_mul(animTime, speedMod);
-	const psShifted = d.vec2f(__tsover_sub(ps.x, drift), ps.y);
-	const cell = std.floor(psShifted);
-	const f = std.fract(psShifted);
-	const upper = std.step(1, __tsover_add(f.x, f.y));
-	const triId = d.vec2f(__tsover_add(__tsover_mul(cell.x, 2), upper), cell.y);
-	const q0 = std.fract(triId.mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	const dEdge = std.min(std.min(std.min(f.x, __tsover_sub(1, f.x)), std.min(f.y, __tsover_sub(1, f.y))), std.abs(__tsover_sub(__tsover_add(f.x, f.y), 1)));
+	const psShifted = vec2f(__tsover_sub(ps.x, drift), ps.y);
+	const cell = floor(psShifted);
+	const f = fract(psShifted);
+	const upper = step(1, __tsover_add(f.x, f.y));
+	const q0 = fract(vec2f(__tsover_add(__tsover_mul(cell.x, 2), upper), cell.y).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	const variedFactor = max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
+	const dEdge = min(min(min(f.x, __tsover_sub(1, f.x)), min(f.y, __tsover_sub(1, f.y))), abs(__tsover_sub(__tsover_add(f.x, f.y), 1)));
 	const lineWidth = __tsover_mul(thickness, .02);
-	const aa = __tsover_add(std.max(std.fwidth(ps.x), std.fwidth(ps.y)), __tsover_mul(softness, .5));
-	const lineMask = __tsover_mul(__tsover_sub(1, std.smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), dEdge)), std.step(1e-4, lineWidth));
-	return d.vec2f(lineMask, variedFactor);
+	const aa = __tsover_add(max(fwidth(ps.x), fwidth(ps.y)), __tsover_mul(softness, .5));
+	return vec2f(__tsover_mul(__tsover_sub(1, smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), dEdge)), step(1e-4, lineWidth)), variedFactor);
 }), {
 	v: 1,
 	name: void 0,
@@ -841,9 +839,9 @@ const triangularGridField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
 		TWO_OVER_SQRT3
 	})

package/dist/core/{Tritone-Ta084wlF.js → Tritone-mqU9b4YZ.js}

@@ -1,12 +1,9 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const tritoneFactors = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blendMid) => {
+import { H as mixColorsLinear, St as dot, U as mixColorsVariants, 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, y as vec4, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const tritoneFactors = src_default.fn([vec4f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blendMid) => {
 	"use gpu";
-	const luminance = std.dot(color.xyz, d.vec3f(.299, .587, .114));
-	const shadowToMid = std.smoothstep(__tsover_sub(blendMid, .25), blendMid, luminance);
-	const midToHighlight = std.smoothstep(blendMid, __tsover_add(blendMid, .25), luminance);
-	const finalT = std.smoothstep(__tsover_sub(blendMid, .1), __tsover_add(blendMid, .1), luminance);
-	return d.vec3f(shadowToMid, midToHighlight, finalT);
+	const luminance = dot(color.xyz, vec3f(.299, .587, .114));
+	return vec3f(smoothstep(__tsover_sub(blendMid, .25), blendMid, luminance), smoothstep(blendMid, __tsover_add(blendMid, .25), luminance), smoothstep(__tsover_sub(blendMid, .1), __tsover_add(blendMid, .1), luminance));
 }), {
 	v: 1,
 	name: void 0,
@@ -136,8 +133,8 @@ const tritoneFactors = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) =
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Truchet-BxCh_IIp.js → Truchet-yLdaw6z4.js}

@@ -1,10 +1,10 @@
-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, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { Dt as length, Et as fract, H as mixColorsLinear, Ot as max, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, Vt as step, bt as cos, et as src_default, ht as abs, kt as min, lt as fwidth, mt as select, nt as std_exports, p as call, sn as f32, tn as vec2f, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-var truchetHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var truchetHash = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const h = std.dot(p, d.vec2f(127.1, 311.7));
-	return std.fract(__tsover_mul(std.sin(h), 43758.5453));
+	const h = dot(p, vec2f(127.1, 311.7));
+	return fract(__tsover_mul(sin(h), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -58,44 +58,42 @@ var truchetHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const truchetField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, seed) => {
+const truchetField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, seed) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const ang = -__tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const scaledUV = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const cell = std.floor(scaledUV);
-	const localUV = std.fract(scaledUV);
-	const flip = truchetHash(d.vec2f(__tsover_add(cell.x, seed), __tsover_add(cell.y, seed))) > .5;
-	const c1x = std.select(d.f32(0), d.f32(1), flip);
-	const c2x = std.select(d.f32(1), d.f32(0), flip);
-	const d1 = std.abs(__tsover_sub(std.length(d.vec2f(__tsover_sub(localUV.x, c1x), localUV.y)), .5));
-	const d2 = std.abs(__tsover_sub(std.length(d.vec2f(__tsover_sub(localUV.x, c2x), __tsover_sub(localUV.y, 1))), .5));
-	const arcDist = std.min(d1, d2);
+	const scaledUV = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const cell = floor(scaledUV);
+	const localUV = fract(scaledUV);
+	const flip = truchetHash(vec2f(__tsover_add(cell.x, seed), __tsover_add(cell.y, seed))) > .5;
+	const c1x = select(f32(0), f32(1), flip);
+	const c2x = select(f32(1), f32(0), flip);
+	const arcDist = min(abs(__tsover_sub(length(vec2f(__tsover_sub(localUV.x, c1x), localUV.y)), .5)), abs(__tsover_sub(length(vec2f(__tsover_sub(localUV.x, c2x), __tsover_sub(localUV.y, 1))), .5)));
 	const lineWidth = __tsover_mul(thickness, .005);
-	const pixel = __tsover_mul(std.fwidth(scaledUV.x), .5);
+	const pixel = __tsover_mul(fwidth(scaledUV.x), .5);
 	const soft = __tsover_mul(softness, .5);
-	const lo = std.max(__tsover_sub(lineWidth, soft), 0);
+	const lo = max(__tsover_sub(lineWidth, soft), 0);
 	const hi = __tsover_add(__tsover_add(lineWidth, pixel), soft);
-	return __tsover_mul(__tsover_sub(1, std.smoothstep(lo, hi, arcDist)), std.step(1e-4, lineWidth));
+	return __tsover_mul(__tsover_sub(1, smoothstep(lo, hi, arcDist)), step(1e-4, lineWidth));
 }), {
 	v: 1,
 	name: void 0,
@@ -688,9 +686,9 @@ const truchetField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		truchetHash
 	})
 }) && $.f)({}));

package/dist/core/{Twirl-Cw4jm59Q.js → Twirl-SA6uh8pI.js}

@@ -1,21 +1,21 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
-const twirlUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, uv, aspect) => {
+import { Dt as length, N as unpremultiplyAlpha, Rt as sin, Ut as data_exports, bt as cos, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
+const twirlUV = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, uv, aspect) => {
 	"use gpu";
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const delta = uv.sub(centerPos);
-	const acd = d.vec2f(__tsover_mul(delta.x, aspect), delta.y);
-	const angle = __tsover_mul(intensity, std.length(acd));
-	const cosA = std.cos(angle);
-	const sinA = std.sin(angle);
+	const acd = vec2f(__tsover_mul(delta.x, aspect), delta.y);
+	const angle = __tsover_mul(intensity, length(acd));
+	const cosA = cos(angle);
+	const sinA = sin(angle);
 	const rotatedX = __tsover_sub(__tsover_mul(cosA, acd.x), __tsover_mul(sinA, acd.y));
 	const rotatedY = __tsover_add(__tsover_mul(sinA, acd.x), __tsover_mul(cosA, acd.y));
-	return d.vec2f(__tsover_add(__tsover_div(rotatedX, aspect), centerPos.x), __tsover_add(rotatedY, centerPos.y));
+	return vec2f(__tsover_add(__tsover_div(rotatedX, aspect), centerPos.x), __tsover_add(rotatedY, centerPos.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -240,8 +240,8 @@ const twirlUV = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{VHS-Nwk0E-tf.js → VHS-Ch-bVeit.js}

@@ -1,8 +1,8 @@
-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";
+import { At as mix, Et as fract, N as unpremultiplyAlpha, Rt as sin, St as dot, Tt as floor, Ut as data_exports, Yt as mod, _ as floatE, bt as cos, 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, zt as smoothstep } from "./edges-BZUKQxSE.js";
 var FIELD_LINES = 487;
-var hash2D = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var hash2D = 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,
@@ -52,20 +52,20 @@ var hash2D = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYP
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-var smoothNoise2D = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var smoothNoise2D = 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 u = f.mul(f).mul(d.vec2f(3, 3).sub(f.mul(2)));
+	const i = floor(p);
+	const f = fract(p);
+	const u = f.mul(f).mul(vec2f(3, 3).sub(f.mul(2)));
 	const a = hash2D(i);
-	const b = hash2D(i.add(d.vec2f(1, 0)));
-	const c = hash2D(i.add(d.vec2f(0, 1)));
-	const dd = hash2D(i.add(d.vec2f(1, 1)));
-	return std.mix(std.mix(a, b, u.x), std.mix(c, dd, u.x), u.y);
+	const b = hash2D(i.add(vec2f(1, 0)));
+	const c = hash2D(i.add(vec2f(0, 1)));
+	const dd = hash2D(i.add(vec2f(1, 1)));
+	return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -287,40 +287,40 @@ var smoothNoise2D = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		hash2D
 	})
 }) && $.f)({}));
-const vhsSampleUVs = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, time, speed, wobble, scanlineNoise) => {
+const vhsSampleUVs = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, time, speed, wobble, scanlineNoise) => {
 	"use gpu";
 	const t = __tsover_mul(time, speed);
-	const burst = std.smoothstep(.45, .8, smoothNoise2D(d.vec2f(__tsover_mul(t, .4), 0)));
-	const rowInt = std.floor(__tsover_mul(uv.y, FIELD_LINES));
-	const h0 = __tsover_mul(__tsover_sub(std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(rowInt, 12.9898), __tsover_mul(t, 78.233))), 43758.5453)), .5), 2);
-	const h1 = __tsover_mul(__tsover_sub(std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(rowInt, 12.9898), __tsover_mul(__tsover_add(t, 69.42), 78.233))), 43758.5453)), .5), 2);
+	const burst = smoothstep(.45, .8, smoothNoise2D(vec2f(__tsover_mul(t, .4), 0)));
+	const rowInt = floor(__tsover_mul(uv.y, FIELD_LINES));
+	const h0 = __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_add(__tsover_mul(rowInt, 12.9898), __tsover_mul(t, 78.233))), 43758.5453)), .5), 2);
+	const h1 = __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_add(__tsover_mul(rowInt, 12.9898), __tsover_mul(__tsover_add(t, 69.42), 78.233))), 43758.5453)), .5), 2);
 	const fineGate = __tsover_add(.25, __tsover_mul(burst, .75));
 	const chromaRowOffset = __tsover_mul(__tsover_mul(__tsover_mul(h0, scanlineNoise), .008), fineGate);
 	const lumaRowOffset = __tsover_mul(__tsover_mul(__tsover_mul(h1, scanlineNoise), .004), fineGate);
-	const wave1 = __tsover_sub(smoothNoise2D(d.vec2f(__tsover_mul(uv.y, 3), __tsover_mul(t, .8))), .5);
-	const wave2 = __tsover_sub(smoothNoise2D(d.vec2f(__tsover_mul(uv.y, 30), __tsover_mul(t, 6))), .5);
+	const wave1 = __tsover_sub(smoothNoise2D(vec2f(__tsover_mul(uv.y, 3), __tsover_mul(t, .8))), .5);
+	const wave2 = __tsover_sub(smoothNoise2D(vec2f(__tsover_mul(uv.y, 30), __tsover_mul(t, 6))), .5);
 	const tapeWave = __tsover_mul(__tsover_add(__tsover_mul(wave1, .008), __tsover_mul(wave2, .002)), wobble);
-	const creasePhase = std.smoothstep(.92, .99, std.sin(__tsover_sub(__tsover_mul(uv.y, 8), __tsover_mul(t, 3.77))));
-	const creaseNoise = std.smoothstep(.3, 1, smoothNoise2D(d.vec2f(__tsover_mul(uv.y, 4.77), t)));
+	const creasePhase = smoothstep(.92, .99, sin(__tsover_sub(__tsover_mul(uv.y, 8), __tsover_mul(t, 3.77))));
+	const creaseNoise = smoothstep(.3, 1, smoothNoise2D(vec2f(__tsover_mul(uv.y, 4.77), t)));
 	const creaseShift = __tsover_mul(__tsover_mul(__tsover_mul(creasePhase, creaseNoise), wobble), -.018);
-	const switchPhase = __tsover_sub(1, std.smoothstep(0, .06, uv.y));
-	const switchNoise = __tsover_sub(smoothNoise2D(d.vec2f(__tsover_mul(uv.y, 60), __tsover_mul(t, 14))), .5);
+	const switchPhase = __tsover_sub(1, smoothstep(0, .06, uv.y));
+	const switchNoise = __tsover_sub(smoothNoise2D(vec2f(__tsover_mul(uv.y, 60), __tsover_mul(t, 14))), .5);
 	const switchX = __tsover_mul(__tsover_mul(__tsover_mul(switchPhase, switchNoise), wobble), .09);
 	const switchY = __tsover_mul(__tsover_mul(__tsover_mul(switchPhase, wobble), burst), .02);
 	const globalX = __tsover_add(__tsover_add(tapeWave, creaseShift), switchX);
 	const sy = __tsover_add(uv.y, switchY);
-	return d.vec4f(__tsover_add(__tsover_add(uv.x, globalX), lumaRowOffset), sy, __tsover_add(__tsover_add(uv.x, globalX), chromaRowOffset), sy);
+	return vec4f(__tsover_add(__tsover_add(uv.x, globalX), lumaRowOffset), sy, __tsover_add(__tsover_add(uv.x, globalX), chromaRowOffset), sy);
 }), {
 	v: 1,
 	name: void 0,
@@ -961,21 +961,21 @@ const vhsSampleUVs = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		smoothNoise2D,
-		d,
+		d: data_exports,
 		FIELD_LINES
 	})
 }) && $.f)({}));
-const vhsAcBeat = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, time, speed, wobble) => {
+const vhsAcBeat = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, time, speed, wobble) => {
 	"use gpu";
 	const t = __tsover_mul(time, speed);
-	return __tsover_add(1, __tsover_mul(__tsover_mul(std.cos(__tsover_add(__tsover_mul(std.mod(t, 6.2831853), 2), __tsover_mul(uv.y, .5))), .015), wobble));
+	return __tsover_add(1, __tsover_mul(__tsover_mul(cos(__tsover_add(__tsover_mul(mod(t, 6.2831853), 2), __tsover_mul(uv.y, .5))), .015), wobble));
 }), {
 	v: 1,
 	name: void 0,
@@ -1060,15 +1060,15 @@ const vhsAcBeat = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const vhsChromaTapUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((chromaUV, smearScale, i) => {
+const vhsChromaTapUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((chromaUV, smearScale, i) => {
 	"use gpu";
-	return d.vec2f(__tsover_add(chromaUV.x, __tsover_mul(__tsover_mul(i, -1), smearScale)), chromaUV.y);
+	return vec2f(__tsover_add(chromaUV.x, __tsover_mul(__tsover_mul(i, -1), smearScale)), chromaUV.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -1125,26 +1125,25 @@ const vhsChromaTapUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const vhsCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((luma, c1, c2, c3, c4, c5, acBeat) => {
+const vhsCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((luma, c1, c2, c3, c4, c5, acBeat) => {
 	"use gpu";
-	const sharpY = std.dot(luma.xyz, d.vec3f(.299, .587, .114));
-	const iAxis = d.vec3f(.596, -.274, -.322);
-	const qAxis = d.vec3f(.211, -.523, .312);
-	const accI = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(std.dot(c1.xyz, iAxis), .06666666666666667), __tsover_mul(std.dot(c2.xyz, iAxis), .13333333333333333)), __tsover_mul(std.dot(c3.xyz, iAxis), .2)), __tsover_mul(std.dot(c4.xyz, iAxis), .26666666666666666)), __tsover_mul(std.dot(c5.xyz, iAxis), .3333333333333333));
-	const accQ = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(std.dot(c1.xyz, qAxis), .06666666666666667), __tsover_mul(std.dot(c2.xyz, qAxis), .13333333333333333)), __tsover_mul(std.dot(c3.xyz, qAxis), .2)), __tsover_mul(std.dot(c4.xyz, qAxis), .26666666666666666)), __tsover_mul(std.dot(c5.xyz, qAxis), .3333333333333333));
-	const finalRgb = d.vec3f(__tsover_add(__tsover_add(sharpY, __tsover_mul(accI, .956)), __tsover_mul(accQ, .621)), __tsover_sub(__tsover_sub(sharpY, __tsover_mul(accI, .272)), __tsover_mul(accQ, .647)), __tsover_add(__tsover_sub(sharpY, __tsover_mul(accI, 1.106)), __tsover_mul(accQ, 1.703)));
-	const clamped = std.clamp(finalRgb.mul(acBeat), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	return d.vec4f(clamped.x, clamped.y, clamped.z, luma.w);
+	const sharpY = dot(luma.xyz, vec3f(.299, .587, .114));
+	const iAxis = vec3f(.596, -.274, -.322);
+	const qAxis = vec3f(.211, -.523, .312);
+	const accI = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(dot(c1.xyz, iAxis), .06666666666666667), __tsover_mul(dot(c2.xyz, iAxis), .13333333333333333)), __tsover_mul(dot(c3.xyz, iAxis), .2)), __tsover_mul(dot(c4.xyz, iAxis), .26666666666666666)), __tsover_mul(dot(c5.xyz, iAxis), .3333333333333333));
+	const accQ = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(dot(c1.xyz, qAxis), .06666666666666667), __tsover_mul(dot(c2.xyz, qAxis), .13333333333333333)), __tsover_mul(dot(c3.xyz, qAxis), .2)), __tsover_mul(dot(c4.xyz, qAxis), .26666666666666666)), __tsover_mul(dot(c5.xyz, qAxis), .3333333333333333));
+	const clamped = clamp(vec3f(__tsover_add(__tsover_add(sharpY, __tsover_mul(accI, .956)), __tsover_mul(accQ, .621)), __tsover_sub(__tsover_sub(sharpY, __tsover_mul(accI, .272)), __tsover_mul(accQ, .647)), __tsover_add(__tsover_sub(sharpY, __tsover_mul(accI, 1.106)), __tsover_mul(accQ, 1.703))).mul(acBeat), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	return vec4f(clamped.x, clamped.y, clamped.z, luma.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -1635,8 +1634,8 @@ const vhsCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {