shaders 3.0.447 → 3.0.449

package/dist/core/{LightLeak-CYjuMURe.js → LightLeak-D1CxVo9A.js}

@@ -1,16 +1,17 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu, pt as noise_exports, st as hash12, yt as value12 } 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 lightLeakRamp = tgpu.fn([
-	d.f32,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
+import { $t as vec2f, Et as max, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _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, pt as select, xt as exp } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { p as noise_exports, s as hash12, y as value12 } from "./noise-wTSHXgFz.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
+const lightLeakRamp = src_default.fn([
+	f32,
+	vec3f,
+	vec3f,
+	vec3f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
 	"use gpu";
-	const toMid = std.smoothstep(0, .5, heat);
-	const toHot = std.smoothstep(.55, 1.15, heat);
-	return std.mix(std.mix(fringe, mid, d.vec3f(toMid)), hot, d.vec3f(toHot)).mul(std.clamp(heat, 0, 1.6));
+	const toMid = smoothstep(0, .5, heat);
+	const toHot = smoothstep(.55, 1.15, heat);
+	return mix(mix(fringe, mid, vec3f(toMid)), hot, vec3f(toHot)).mul(clamp(heat, 0, 1.6));
 }), {
 	v: 1,
 	name: void 0,
@@ -138,71 +139,69 @@ const lightLeakRamp = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const lightLeakComposite = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, animTime, position, spread, intensity, streaks, flicker, seed, hot, mid, fringe) => {
+const lightLeakComposite = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec3f,
+	vec3f,
+	vec3f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, animTime, position, spread, intensity, streaks, flicker, seed, hot, mid, fringe) => {
 	"use gpu";
 	const t = __tsover_add(__tsover_mul(animTime, .6), __tsover_mul(seed, 7.9));
-	const pA = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const anchor = d.vec2f(__tsover_mul(position.x, aspect), __tsover_sub(1, position.y));
-	const toCenter = d.vec2f(__tsover_mul(aspect, .5), .5).sub(anchor);
-	const cLen = std.length(toCenter);
-	const dirX = std.select(__tsover_div(toCenter.x, std.max(cLen, .001)), d.f32(1), cLen < .02);
-	const dirY = std.select(__tsover_div(toCenter.y, std.max(cLen, .001)), d.f32(0), cLen < .02);
+	const pA = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const anchor = vec2f(__tsover_mul(position.x, aspect), __tsover_sub(1, position.y));
+	const toCenter = vec2f(__tsover_mul(aspect, .5), .5).sub(anchor);
+	const cLen = length(toCenter);
+	const dirX = select(__tsover_div(toCenter.x, max(cLen, .001)), f32(1), cLen < .02);
+	const dirY = select(__tsover_div(toCenter.y, max(cLen, .001)), f32(0), cLen < .02);
 	const relX = __tsover_sub(pA.x, anchor.x);
 	const relY = __tsover_sub(pA.y, anchor.y);
 	const u = __tsover_add(__tsover_mul(relX, dirX), __tsover_mul(relY, dirY));
 	const v = __tsover_sub(__tsover_mul(relY, dirX), __tsover_mul(relX, dirY));
-	const nA = value12(d.vec2f(__tsover_mul(t, .9), __tsover_add(__tsover_mul(seed, .53), 11.7)));
-	const nB = value12(d.vec2f(__tsover_add(__tsover_mul(t, 2.7), 41.3), __tsover_add(__tsover_mul(seed, .29), 5.1)));
+	const nA = value12(vec2f(__tsover_mul(t, .9), __tsover_add(__tsover_mul(seed, .53), 11.7)));
+	const nB = value12(vec2f(__tsover_add(__tsover_mul(t, 2.7), 41.3), __tsover_add(__tsover_mul(seed, .29), 5.1)));
 	const breathe = __tsover_add(__tsover_mul(nA, .65), __tsover_mul(nB, .35));
-	const flickerMod = std.mix(1, __tsover_add(.25, __tsover_mul(1.5, breathe)), flicker);
-	const evo1 = value12(d.vec2f(__tsover_add(__tsover_mul(t, .13), 3.1), __tsover_add(__tsover_mul(seed, .41), 27)));
-	const evo2 = value12(d.vec2f(__tsover_add(__tsover_mul(t, .09), 17.7), __tsover_add(__tsover_mul(seed, .61), 8.4)));
-	const evo3 = value12(d.vec2f(__tsover_add(__tsover_mul(t, .17), 51.2), __tsover_add(__tsover_mul(seed, .23), 2.9)));
-	const sp = std.max(spread, .05);
+	const flickerMod = mix(1, __tsover_add(.25, __tsover_mul(1.5, breathe)), flicker);
+	const evo1 = value12(vec2f(__tsover_add(__tsover_mul(t, .13), 3.1), __tsover_add(__tsover_mul(seed, .41), 27)));
+	const evo2 = value12(vec2f(__tsover_add(__tsover_mul(t, .09), 17.7), __tsover_add(__tsover_mul(seed, .61), 8.4)));
+	const evo3 = value12(vec2f(__tsover_add(__tsover_mul(t, .17), 51.2), __tsover_add(__tsover_mul(seed, .23), 2.9)));
+	const sp = max(spread, .05);
 	const elong = __tsover_mul(sp, __tsover_add(1.5, __tsover_mul(.7, evo2)));
 	const du = __tsover_div(u, sp);
 	const dv = __tsover_div(v, elong);
-	const main = std.exp(__tsover_mul(__tsover_add(__tsover_mul(du, du), __tsover_mul(dv, dv)), -1.9));
-	const alongFade = std.exp(__tsover_mul(__tsover_mul(dv, dv), -.55));
+	const main = exp(__tsover_mul(__tsover_add(__tsover_mul(du, du), __tsover_mul(dv, dv)), -1.9));
+	const alongFade = exp(__tsover_mul(__tsover_mul(dv, dv), -.55));
 	const s1c = __tsover_mul(sp, __tsover_add(.42, __tsover_mul(.22, evo1)));
-	const s1w = std.max(__tsover_mul(sp, __tsover_add(.07, __tsover_mul(.07, evo3))), .008);
-	const streak1 = __tsover_mul(std.exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, s1c), __tsover_sub(u, s1c)), -1), __tsover_mul(s1w, s1w))), alongFade);
+	const s1w = max(__tsover_mul(sp, __tsover_add(.07, __tsover_mul(.07, evo3))), .008);
+	const streak1 = __tsover_mul(exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, s1c), __tsover_sub(u, s1c)), -1), __tsover_mul(s1w, s1w))), alongFade);
 	const s2c = __tsover_mul(sp, __tsover_add(.8, __tsover_mul(.3, evo1)));
-	const s2w = std.max(__tsover_mul(sp, __tsover_add(.16, __tsover_mul(.12, evo3))), .015);
-	const streak2 = __tsover_mul(__tsover_mul(std.exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, s2c), __tsover_sub(u, s2c)), -1), __tsover_mul(s2w, s2w))), alongFade), .45);
+	const s2w = max(__tsover_mul(sp, __tsover_add(.16, __tsover_mul(.12, evo3))), .015);
+	const streak2 = __tsover_mul(__tsover_mul(exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, s2c), __tsover_sub(u, s2c)), -1), __tsover_mul(s2w, s2w))), alongFade), .45);
 	const streakSum = __tsover_mul(__tsover_add(streak1, streak2), streaks);
-	const shoulder = __tsover_mul(std.exp(__tsover_mul(__tsover_add(__tsover_mul(du, du), __tsover_mul(dv, dv)), -.45)), .22);
+	const shoulder = __tsover_mul(exp(__tsover_mul(__tsover_add(__tsover_mul(du, du), __tsover_mul(dv, dv)), -.45)), .22);
 	let heat = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(__tsover_add(__tsover_mul(main, 1.25), shoulder), __tsover_mul(streakSum, .85)), intensity), 2.2), flickerMod);
-	heat = __tsover_add(heat, __tsover_mul(__tsover_sub(hash12(uv.mul(1024).add(d.vec2f(t, __tsover_mul(t, 1.7)))), .5), .012));
-	heat = std.max(heat, 0);
+	heat = __tsover_add(heat, __tsover_mul(__tsover_sub(hash12(uv.mul(1024).add(vec2f(t, __tsover_mul(t, 1.7)))), .5), .012));
+	heat = max(heat, 0);
 	const rampR = lightLeakRamp(__tsover_mul(heat, 1.08), hot, mid, fringe);
 	const rampG = lightLeakRamp(heat, hot, mid, fringe);
 	const rampB = lightLeakRamp(__tsover_mul(heat, .88), hot, mid, fringe);
-	const leakRgb = d.vec3f(rampR.x, rampG.y, rampB.z);
+	const leakRgb = vec3f(rampR.x, rampG.y, rampB.z);
 	const base = color.xyz;
-	const lifted = d.vec3f(1, 1, 1).sub(d.vec3f(1, 1, 1).sub(std.clamp(base, d.vec3f(0), d.vec3f(1))).mul(d.vec3f(1, 1, 1).sub(std.clamp(leakRgb, d.vec3f(0), d.vec3f(1))))).add(leakRgb.mul(.16));
-	const outRgb = std.clamp(lifted, d.vec3f(0), d.vec3f(1));
-	const leakLuma = std.clamp(std.dot(leakRgb, d.vec3f(.299, .587, .114)), 0, 1);
-	const outA = std.clamp(__tsover_add(color.w, __tsover_mul(leakLuma, .85)), 0, 1);
-	return d.vec4f(outRgb, outA);
+	const outRgb = clamp(vec3f(1, 1, 1).sub(vec3f(1, 1, 1).sub(clamp(base, vec3f(0), vec3f(1))).mul(vec3f(1, 1, 1).sub(clamp(leakRgb, vec3f(0), vec3f(1))))).add(leakRgb.mul(.16)), vec3f(0), vec3f(1));
+	const leakLuma = clamp(dot(leakRgb, vec3f(.299, .587, .114)), 0, 1);
+	return vec4f(outRgb, clamp(__tsover_add(color.w, __tsover_mul(leakLuma, .85)), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1645,8 +1644,8 @@ const lightLeakComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports,
 		lightLeakRamp
 	})

package/dist/core/{LinearBlur-CV7gKYHV.js → LinearBlur-DJBkHfs8.js}

@@ -1,5 +1,5 @@
-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 { r as transformAngle } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, _ as floatE, an as f32, d as ZERO, et as src_default, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { r as transformAngle } from "./transformations-CsPUHppB.js";
 var rawWeights = Array.from({ length: 32 }, (_, i) => {
 	const t = (i / 31 - .5) * 2;
 	return Math.exp(-.5 * t * t / .64);
@@ -8,21 +8,21 @@ var wSum = rawWeights.reduce((a, b) => a + b);
 const BLUR_WEIGHTS = rawWeights.map((w) => w / wSum);
 const TAP_COUNT = 32;
 var DEG_TO_RAD = Math.PI / 180;
-const linearBlurTapCoord = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, angleDeg, intensity, viewport, tapT) => {
+const linearBlurTapCoord = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, angleDeg, intensity, viewport, tapT) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const dirX = __tsover_div(std.cos(angleRad), aspect);
-	const dirY = std.sin(angleRad);
+	const dirX = __tsover_div(cos(angleRad), aspect);
+	const dirY = sin(angleRad);
 	const bvX = __tsover_mul(__tsover_div(__tsover_mul(dirX, intensity), viewport.x), 2);
 	const bvY = __tsover_mul(__tsover_div(__tsover_mul(dirY, intensity), viewport.y), 2);
-	return d.vec2f(__tsover_add(uv.x, __tsover_mul(bvX, tapT)), __tsover_add(uv.y, __tsover_mul(bvY, tapT)));
+	return vec2f(__tsover_add(uv.x, __tsover_mul(bvX, tapT)), __tsover_add(uv.y, __tsover_mul(bvY, tapT)));
 }), {
 	v: 1,
 	name: void 0,
@@ -203,8 +203,8 @@ const linearBlurTapCoord = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{LinearGradient-DAzw65UB.js → LinearGradient-DCRYBS4Q.js}

@@ -1,38 +1,37 @@
-import { Et as mixColorStopsRuntime, Ht as call, J as std, Jt as vec4, Tn as d, Tt as gradientStopsInSpace$1, ln as colorMixing_exports, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, r as transformAngle, s as transformEdges, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Et as max, F as colorMixing_exports, It as sin, Tt as length, Vt as data_exports, _t as clamp, an as f32, bt as dot, et as src_default, kt as normalize, mt as abs, nt as std_exports, p as call, pt as select, qt as mod, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, x as gradientStopsInSpace$1 } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, r as transformAngle, s as transformEdges, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 const gradientStopsInSpace = gradientStopsInSpace$1;
 var DEG_TO_RAD = .017453292519943295;
 var TRANSPARENT = 1;
 var MIRROR = 2;
 var WRAP = 3;
-const gradientRawT = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((start, end, angle, uv, viewport) => {
+const gradientRawT = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((start, end, angle, uv, viewport) => {
 	"use gpu";
-	const startPos = d.vec2f(start.x, __tsover_sub(1, start.y));
-	const endPos = d.vec2f(end.x, __tsover_sub(1, end.y));
+	const startPos = vec2f(start.x, __tsover_sub(1, start.y));
+	const endPos = vec2f(end.x, __tsover_sub(1, end.y));
 	const gradientVector = endPos.sub(startPos);
-	const gradientLength = std.length(gradientVector);
-	const gradientDir = std.normalize(gradientVector);
-	const safeViewportY = std.max(viewport.y, 1e-6);
+	const gradientLength = length(gradientVector);
+	const gradientDir = normalize(gradientVector);
+	const safeViewportY = max(viewport.y, 1e-6);
 	const aspect = __tsover_div(viewport.x, safeViewportY);
 	const angleRad = __tsover_mul(__tsover_mul(angle, DEG_TO_RAD), -1);
-	const cosAngle = std.cos(angleRad);
-	const sinAngle = std.sin(angleRad);
+	const cosAngle = cos(angleRad);
+	const sinAngle = sin(angleRad);
 	const midpoint = startPos.add(endPos).mul(.5);
 	const centeredUV = uv.sub(midpoint);
 	const acX = __tsover_mul(centeredUV.x, aspect);
 	const acY = centeredUV.y;
 	const rotX = __tsover_sub(__tsover_mul(acX, cosAngle), __tsover_mul(acY, sinAngle));
 	const rotY = __tsover_add(__tsover_mul(acX, sinAngle), __tsover_mul(acY, cosAngle));
-	const relativePos = d.vec2f(__tsover_div(rotX, aspect), rotY).add(midpoint).sub(startPos);
-	const projection = std.dot(relativePos, gradientDir);
-	return __tsover_div(projection, std.max(gradientLength, 1e-6));
+	const projection = dot(vec2f(__tsover_div(rotX, aspect), rotY).add(midpoint).sub(startPos), gradientDir);
+	return __tsover_div(projection, max(gradientLength, 1e-6));
 }), {
 	v: 1,
 	name: void 0,
@@ -398,15 +397,15 @@ const gradientRawT = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		DEG_TO_RAD
 	})
 }) && $.f)({}));
-const gradientEdgeMirror = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const gradientEdgeMirror = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	const m = std.mod(std.abs(t), 2);
-	return std.select(m, __tsover_sub(2, m), m > 1);
+	const m = mod(abs(t), 2);
+	return select(m, __tsover_sub(2, m), m > 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -460,11 +459,11 @@ const gradientEdgeMirror = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (glob
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gradientEdgeWrap = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const gradientEdgeWrap = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	return std.fract(t);
+	return fract(t);
 }), {
 	v: 1,
 	name: void 0,
@@ -484,11 +483,11 @@ const gradientEdgeWrap = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (global
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gradientClamp01 = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const gradientClamp01 = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	return std.clamp(t, 0, 1);
+	return clamp(t, 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -512,12 +511,12 @@ const gradientClamp01 = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalT
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gradientTransparentAlpha = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const gradientTransparentAlpha = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	const inLow = std.select(d.f32(0), d.f32(1), t >= 0);
-	const inHigh = std.select(d.f32(0), d.f32(1), t <= 1);
+	const inLow = select(f32(0), f32(1), t >= 0);
+	const inHigh = select(f32(0), f32(1), t <= 1);
 	return __tsover_mul(inLow, inHigh);
 }), {
 	v: 1,
@@ -614,8 +613,8 @@ const gradientTransparentAlpha = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) =>
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 var cm = colorMixing_exports;

package/dist/core/{LinearWipe-DoDZF7y0.js → LinearWipe-Cxfs1tIO.js}

@@ -1,27 +1,26 @@
-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 } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const linearWipeMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, progress, feather, invert) => {
+const linearWipeMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, 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)));
 	let t = __tsover_add(__tsover_div(grad, __tsover_mul(2, ext)), .5);
-	t = std.select(t, __tsover_sub(1, t), invert > 0);
-	const f = std.max(feather, 1e-4);
+	t = select(t, __tsover_sub(1, t), 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), t);
-	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), t);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -346,8 +345,8 @@ const linearWipeMask = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{LiquidMetal-C9OxRyE4.js → LiquidMetal-oscNnbsr.js}

@@ -1,8 +1,10 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, ht as perlin12d, n as tgpu, pt as noise_exports, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Mt as reflect, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, _t as clamp, an as f32, et as src_default, in as vec4f, kt as normalize, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { h as perlin12d, p as noise_exports } from "./noise-wTSHXgFz.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 { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType, isMobileGpuViewport } = sdf3d_exports;
@@ -11,29 +13,29 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "circleSDF",
 	radius: .35
 });
-const liquidStudio = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr) => {
+const liquidStudio = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr) => {
 	"use gpu";
 	const ex = __tsover_sub(__tsover_mul(rx, envC), __tsover_mul(ry, envS));
 	const ey = __tsover_add(__tsover_mul(rx, envS), __tsover_mul(ry, envC));
-	const p = d.vec2f(ex, ey);
-	const sky = std.smoothstep(-.7, .85, ey);
+	const p = vec2f(ex, ey);
+	const sky = smoothstep(-.7, .85, ey);
 	let lum = __tsover_mul(__tsover_mul(sky, sky), .4);
 	const r0 = __tsover_mul(keyRad, 1.05);
-	const box0 = std.smoothstep(r0, __tsover_mul(r0, .2), std.length(p.sub(d.vec2f(__tsover_add(0, drift), .55))));
+	const box0 = smoothstep(r0, __tsover_mul(r0, .2), length(p.sub(vec2f(__tsover_add(0, drift), .55))));
 	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box0, 1.75), envStr));
 	const r1 = __tsover_mul(keyRad, 1.25);
-	const box1 = std.smoothstep(r1, __tsover_mul(r1, .2), std.length(p.sub(d.vec2f(__tsover_add(-.45, drift), -.4))));
+	const box1 = smoothstep(r1, __tsover_mul(r1, .2), length(p.sub(vec2f(__tsover_add(-.45, drift), -.4))));
 	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box1, 1.15), envStr));
 	const r2 = __tsover_mul(keyRad, 1.15);
-	const box2 = std.smoothstep(r2, __tsover_mul(r2, .2), std.length(p.sub(d.vec2f(__tsover_add(.55, drift), .1))));
+	const box2 = smoothstep(r2, __tsover_mul(r2, .2), length(p.sub(vec2f(__tsover_add(.55, drift), .1))));
 	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box2, 1.1), envStr));
 	return lum;
 }), {
@@ -419,23 +421,23 @@ const liquidStudio = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const liquidMetalComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec3f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, lightColor, darkColor, p0, p1, p2, p3) => {
+const liquidMetalComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, lightColor, darkColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const scl = p0.x;
 	const edgeSoftness = p0.y;
@@ -450,61 +452,56 @@ const liquidMetalComposite = tgpu.fn([
 	const animTime = p2.z;
 	const volumetric = p2.w;
 	const mobile = p3.x;
-	const sharpEdge = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sharpEdge = max(__tsover_mul(edgeSoftness, .5), .001);
 	const pxH = __tsover_div(1, viewportSize.y);
 	const sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scl);
-	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
 	const EPS = .01;
-	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5);
-	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5);
-	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
+	const nVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5), -1));
 	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const rimT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
+	const rimT = clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
 	const rimBevel = __tsover_mul(__tsover_sub(1, rimT), 1.6);
-	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1));
-	const nGeo = std.select(nFlat, nVol, volumetric > .5);
-	const fx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const fy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const nGeo = select(normalize(vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1)), nVol, volumetric > .5);
+	const fx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const fy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
 	const freq = __tsover_mul(ripple, 2.6);
 	const flowT = __tsover_mul(animTime, .12);
-	const q = d.vec2f(__tsover_mul(fx, freq), __tsover_mul(fy, freq));
+	const q = vec2f(__tsover_mul(fx, freq), __tsover_mul(fy, freq));
 	const wAmt = __tsover_mul(warp, .9);
 	const warpInput = q.mul(.6);
-	const wx = __tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3)));
-	const wy = __tsover_mul(std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1)));
-	const qw = q.add(d.vec2f(wx, wy).mul(wAmt));
-	const gMax = d.f32(4);
+	const wx = __tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3)));
+	const wy = __tsover_mul(cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1)));
+	const qw = q.add(vec2f(wx, wy).mul(wAmt));
+	const gMax = f32(4);
 	const nd = perlin12d(qw);
 	const reliefGrad = .62;
-	const hx = std.clamp(__tsover_mul(nd.y, reliefGrad), __tsover_mul(gMax, -1), gMax);
-	const hy = std.clamp(__tsover_mul(nd.z, reliefGrad), __tsover_mul(gMax, -1), gMax);
+	const hx = clamp(__tsover_mul(nd.y, reliefGrad), __tsover_mul(gMax, -1), gMax);
+	const hy = clamp(__tsover_mul(nd.z, reliefGrad), __tsover_mul(gMax, -1), gMax);
 	const relief = __tsover_mul(turbulence, .5);
-	const n = std.normalize(d.vec3f(__tsover_sub(nGeo.x, __tsover_mul(hx, relief)), __tsover_sub(nGeo.y, __tsover_mul(hy, relief)), nGeo.z));
-	const R = std.reflect(d.vec3f(0, 0, 1), n);
+	const n = normalize(vec3f(__tsover_sub(nGeo.x, __tsover_mul(hx, relief)), __tsover_sub(nGeo.y, __tsover_mul(hy, relief)), nGeo.z));
+	const R = reflect(vec3f(0, 0, 1), n);
 	const envStr = environment;
-	const sharp = std.clamp(sharpness, 0, 1);
-	const keyRad = std.mix(.5, .18, sharp);
-	const drift = __tsover_mul(std.sin(__tsover_mul(animTime, .07)), .05);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
-	const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
-	const L = std.normalize(d.vec3f(lx, ly, -.7));
-	const Hh = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndh = std.clamp(__tsover_add(__tsover_add(__tsover_mul(n.x, Hh.x), __tsover_mul(n.y, Hh.y)), __tsover_mul(n.z, Hh.z)), 0, 1);
-	const spec = __tsover_mul(std.pow(ndh, std.mix(d.f32(60), d.f32(900), sharp)), std.mix(.4, 1.4, sharp));
+	const sharp = clamp(sharpness, 0, 1);
+	const keyRad = mix(.5, .18, sharp);
+	const drift = __tsover_mul(sin(__tsover_mul(animTime, .07)), .05);
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const envC = cos(__tsover_mul(envRotation, DEG_TO_RAD));
+	const envS = sin(__tsover_mul(envRotation, DEG_TO_RAD));
+	const Hh = normalize(normalize(vec3f(lx, ly, -.7)).add(vec3f(0, 0, -1)));
+	const ndh = clamp(__tsover_add(__tsover_add(__tsover_mul(n.x, Hh.x), __tsover_mul(n.y, Hh.y)), __tsover_mul(n.z, Hh.z)), 0, 1);
+	const spec = __tsover_mul(pow(ndh, mix(f32(60), f32(900), sharp)), mix(.4, 1.4, sharp));
 	const lumG = __tsover_add(liquidStudio(R.x, R.y, envC, envS, keyRad, drift, envStr), spec);
-	const grazeD = __tsover_sub(1, std.clamp(__tsover_mul(n.z, -1), 0, 1));
+	const grazeD = __tsover_sub(1, clamp(__tsover_mul(n.z, -1), 0, 1));
 	const dth = __tsover_mul(__tsover_mul(dispersion, .09), __tsover_add(.4, __tsover_mul(grazeD, 1.3)));
 	const lumBoffset = __tsover_add(liquidStudio(__tsover_add(R.x, __tsover_mul(R.y, dth)), __tsover_sub(R.y, __tsover_mul(R.x, dth)), envC, envS, keyRad, drift, envStr), spec);
-	const lumB = std.select(lumBoffset, lumG, mobile > .5);
-	const lumRdesktop = __tsover_sub(__tsover_mul(lumG, 2), lumBoffset);
-	const lumR = std.select(lumRdesktop, lumG, mobile > .5);
-	const rgb = d.vec3f(std.mix(darkColor.x, lightColor.x, std.clamp(lumR, 0, 1.8)), std.mix(darkColor.y, lightColor.y, std.clamp(lumG, 0, 1.8)), std.mix(darkColor.z, lightColor.z, std.clamp(lumB, 0, 1.8)));
-	const transition = std.smoothstep(0, 1, std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
-	return d.vec4f(rgb.x, rgb.y, rgb.z, transition);
+	const lumB = select(lumBoffset, lumG, mobile > .5);
+	const lumR = select(__tsover_sub(__tsover_mul(lumG, 2), lumBoffset), lumG, mobile > .5);
+	const rgb = vec3f(mix(darkColor.x, lightColor.x, clamp(lumR, 0, 1.8)), mix(darkColor.y, lightColor.y, clamp(lumG, 0, 1.8)), mix(darkColor.z, lightColor.z, clamp(lumB, 0, 1.8)));
+	const transition = smoothstep(0, 1, clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
+	return vec4f(rgb.x, rgb.y, rgb.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -2243,8 +2240,8 @@ const liquidMetalComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		noise: noise_exports,
 		DEG_TO_RAD,
 		liquidStudio