shaders 3.0.447 → 3.0.449

package/dist/core/{Twirl-Cw4jm59Q.js → Twirl-CuzhWXfj.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 { $t as vec2f, It as sin, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.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-DYbzndAZ.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 { $t as vec2f, Ct as floor, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, 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, nn as vec3f, nt as std_exports, p as call, qt as mod, vt as cos, wt as fract } from "./edges-BXNBKxSN.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 = {

package/dist/core/{VenetianBlinds-BZ0sS97G.js → VenetianBlinds-DVopy3xp.js}

@@ -1,29 +1,28 @@
-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";
+import { $t as vec2f, Et as max, It as sin, Lt as smoothstep, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, mt as abs, nt as std_exports, p as call, pt as select, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const venetianBlindsMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, stripCount, progress, feather, invert) => {
+const venetianBlindsMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, stripCount, progress, feather, invert) => {
 	"use gpu";
 	const a = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dir = d.vec2f(std.cos(a), std.sin(a));
-	const p = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
-	const grad = std.dot(p, dir);
-	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, std.abs(dir.x)), std.abs(dir.y)));
+	const dir = vec2f(cos(a), sin(a));
+	const grad = dot(vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5)), dir);
+	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, abs(dir.x)), abs(dir.y)));
 	const t = __tsover_add(__tsover_div(grad, __tsover_mul(2, ext)), .5);
-	const phase = std.fract(__tsover_mul(t, stripCount));
-	const coord = std.select(phase, __tsover_sub(1, phase), invert > 0);
-	const f = std.max(feather, 1e-4);
+	const phase = fract(__tsover_mul(t, stripCount));
+	const coord = select(phase, __tsover_sub(1, phase), 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,
@@ -369,8 +368,8 @@ const venetianBlindsMask = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Vesica-Cf1KiSzK.js → Vesica-Cd-XyG3F.js}

@@ -1,15 +1,16 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, R as strokeMaskFromSdf, Tn as d, V as vesicaSdf, 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 vesicaShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, v as strokeMaskFromSdf, x as vesicaSdf } 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 vesicaShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, spread, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Vibrance-qWGvLkrW.js → Vibrance-CvXatkfO.js}

@@ -1,15 +1,14 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const vibranceColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, adjustment) => {
+import { Et as max, Ot as mix, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+const vibranceColor = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, adjustment) => {
 	"use gpu";
 	const r = color.x;
 	const g = color.y;
 	const b = color.z;
 	const average = __tsover_div(__tsover_add(__tsover_add(r, g), b), 3);
-	const mx = std.max(r, std.max(g, b));
+	const mx = max(r, max(g, b));
 	const amt = __tsover_mul(__tsover_mul(__tsover_sub(mx, average), adjustment), -3);
-	const rgb = d.vec3f(r, g, b);
-	const vibrant = std.mix(rgb, d.vec3f(mx, mx, mx), d.vec3f(amt));
-	return d.vec4f(vibrant.x, vibrant.y, vibrant.z, color.w);
+	const vibrant = mix(vec3f(r, g, b), vec3f(mx, mx, mx), vec3f(amt));
+	return vec4f(vibrant.x, vibrant.y, vibrant.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -202,8 +201,8 @@ const vibranceColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =>
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{VideoTexture-48ylVDvN.js → VideoTexture-C5PS6Vly.js}

@@ -1,11 +1,11 @@
-import { Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { r as registerNaturalSize } from "./naturalSize-Caz3-kRv.js";
-const videoScaleCover = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
+import { $t as vec2f, At as pow, Dt as min, Et as max, Vt as data_exports, et as src_default, ft as le, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select } from "./edges-BXNBKxSN.js";
+import { r as registerNaturalSize } from "./naturalSize-B679wTgN.js";
+const videoScaleCover = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
 	"use gpu";
 	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
 	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const coverScale = std.max(__tsover_div(viewportAspect, videoAspect), 1);
-	return d.vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), coverScale), coverScale);
+	const coverScale = max(__tsover_div(viewportAspect, videoAspect), 1);
+	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), coverScale), coverScale);
 }), {
 	v: 1,
 	name: void 0,
@@ -95,16 +95,16 @@ const videoScaleCover = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const videoScaleContain = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
+const videoScaleContain = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
 	"use gpu";
 	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
 	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const containScale = std.min(__tsover_div(viewportAspect, videoAspect), 1);
-	return d.vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), containScale), containScale);
+	const containScale = min(__tsover_div(viewportAspect, videoAspect), 1);
+	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), containScale), containScale);
 }), {
 	v: 1,
 	name: void 0,
@@ -194,13 +194,13 @@ const videoScaleContain = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const videoScaleFill = tgpu.fn([], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
+const videoScaleFill = src_default.fn([], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
 	"use gpu";
-	return d.vec2f(1, 1);
+	return vec2f(1, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -217,16 +217,14 @@ const videoScaleFill = tgpu.fn([], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const videoScaleScaleDown = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
+const videoScaleScaleDown = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
 	"use gpu";
 	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
 	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const containScale = std.min(__tsover_div(viewportAspect, videoAspect), 1);
-	const naturalScale = std.min(__tsover_div(vp.x, videoDims.x), __tsover_div(vp.y, videoDims.y));
-	const scaleDownScale = std.min(containScale, naturalScale);
-	return d.vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), scaleDownScale), scaleDownScale);
+	const scaleDownScale = min(min(__tsover_div(viewportAspect, videoAspect), 1), min(__tsover_div(vp.x, videoDims.x), __tsover_div(vp.y, videoDims.y)));
+	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), scaleDownScale), scaleDownScale);
 }), {
 	v: 1,
 	name: void 0,
@@ -368,14 +366,14 @@ const videoScaleScaleDown = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const videoSampleUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, uvScale) => {
+const videoSampleUV = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, uvScale) => {
 	"use gpu";
-	const centeredUV = uv.sub(d.vec2f(.5, .5));
-	return d.vec2f(__tsover_div(centeredUV.x, uvScale.x), __tsover_div(centeredUV.y, uvScale.y)).add(d.vec2f(.5, .5));
+	const centeredUV = uv.sub(vec2f(.5, .5));
+	return vec2f(__tsover_div(centeredUV.x, uvScale.x), __tsover_div(centeredUV.y, uvScale.y)).add(vec2f(.5, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -468,14 +466,11 @@ const videoSampleUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($)
 		]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const srgbToLinear = tgpu.fn([d.vec3f], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+const srgbToLinear = src_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	const hi = std.pow(color.add(d.vec3f(.055)).div(d.vec3f(1.055)), d.vec3f(2.4));
-	const lo = color.div(d.vec3f(12.92));
-	const isLow = std.le(color, d.vec3f(.04045));
-	return std.select(hi, lo, isLow);
+	return select(pow(color.add(vec3f(.055)).div(vec3f(1.055)), vec3f(2.4)), color.div(vec3f(12.92)), le(color, vec3f(.04045)));
 }), {
 	v: 1,
 	name: void 0,
@@ -597,16 +592,16 @@ const srgbToLinear = tgpu.fn([d.vec3f], d.vec3f)(/* @__PURE__ */ (($) => (global
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const videoAlphaCut = tgpu.fn([d.vec4f, d.vec2f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv) => {
+const videoAlphaCut = src_default.fn([vec4f, vec2f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv) => {
 	"use gpu";
-	const linear = srgbToLinear(d.vec3f(color.x, color.y, color.z));
+	const linear = srgbToLinear(vec3f(color.x, color.y, color.z));
 	const outOfBounds = uv.x < 0 || uv.x > 1 || uv.y < 0 || uv.y > 1;
-	const alpha = std.select(color.w, 0, outOfBounds);
-	return d.vec4f(linear.x, linear.y, linear.z, alpha);
+	const alpha = select(color.w, 0, outOfBounds);
+	return vec4f(linear.x, linear.y, linear.z, alpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -764,8 +759,8 @@ const videoAlphaCut = tgpu.fn([d.vec4f, d.vec2f], d.vec4f)(/* @__PURE__ */ (($)
 	},
 	externals: () => ({
 		srgbToLinear,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 var OBJECT_FIT_MODES = {

package/dist/core/{Vignette-CK_Li7v2.js → Vignette-DtBpWWxW.js}

@@ -1,24 +1,22 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-const vignetteColor = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, vigColor, radius, falloff, intensity) => {
+import { $t as vec2f, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
+const vignetteColor = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	vec2f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, vigColor, radius, falloff, intensity) => {
 	"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 dist = std.length(aspectUV.sub(centerPos));
-	const vignetteMask = std.smoothstep(radius, __tsover_add(radius, falloff), dist);
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const vigRgb = d.vec3f(vigColor.x, vigColor.y, vigColor.z);
-	const result = std.mix(rgb, vigRgb, d.vec3f(__tsover_mul(vignetteMask, intensity)));
-	return d.vec4f(result.x, result.y, result.z, color.w);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const dist = length(aspectUV.sub(centerPos));
+	const vignetteMask = smoothstep(radius, __tsover_add(radius, falloff), dist);
+	const result = mix(vec3f(color.x, color.y, color.z), vec3f(vigColor.x, vigColor.y, vigColor.z), vec3f(__tsover_mul(vignetteMask, intensity)));
+	return vec4f(result.x, result.y, result.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -280,8 +278,8 @@ const vignetteColor = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {