shaders 3.0.447 → 3.0.449

package/dist/core/{WaveDistortion-BLrvGOzF.js → WaveDistortion-DHz1FxLT.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 { s as transformEdges } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, mt as abs, n as composeEdgeRemapExpr, nt as std_exports, p as call, vt as cos, wt as fract, zt as step } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var TAU = Math.PI * 2;
-const wavePhase = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, t) => {
+const wavePhase = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, t) => {
 	"use gpu";
-	const centeredUV = uv.sub(d.vec2f(.5, .5));
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y);
+	const centeredUV = uv.sub(vec2f(.5, .5));
+	const aspectCorrectedUV = vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y);
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
 	const rotatedY = __tsover_add(__tsover_mul(aspectCorrectedUV.x, sinA), __tsover_mul(aspectCorrectedUV.y, cosA));
 	return __tsover_add(__tsover_mul(__tsover_mul(__tsover_add(rotatedY, .5), frequency), TAU), t);
 }), {
@@ -186,27 +186,27 @@ const wavePhase = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		TAU
 	})
 }) && $.f)({}));
-const waveApply = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, strength, wave) => {
+const waveApply = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, strength, wave) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
 	const displacement = __tsover_mul(__tsover_mul(wave, strength), .5);
 	const displacementX = __tsover_div(__tsover_mul(displacement, cosA), aspect);
 	const displacementY = __tsover_mul(displacement, sinA);
-	return d.vec2f(__tsover_add(uv.x, displacementX), __tsover_add(uv.y, displacementY));
+	return vec2f(__tsover_add(uv.x, displacementX), __tsover_add(uv.y, displacementY));
 }), {
 	v: 1,
 	name: void 0,
@@ -346,21 +346,20 @@ const waveApply = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const waveDistortSine = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
+const waveDistortSine = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
 	"use gpu";
-	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	return waveApply(uv, aspect, angle, strength, std.sin(phase));
+	return waveApply(uv, aspect, angle, strength, sin(wavePhase(uv, aspect, angle, frequency, t)));
 }), {
 	v: 1,
 	name: void 0,
@@ -440,22 +439,22 @@ const waveDistortSine = tgpu.fn([
 	},
 	externals: () => ({
 		wavePhase,
-		std,
+		std: std_exports,
 		waveApply
 	})
 }) && $.f)({}));
-const waveDistortTriangle = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
+const waveDistortTriangle = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
 	"use gpu";
 	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = std.fract(__tsover_div(phase, TAU));
-	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(std.abs(__tsover_sub(__tsover_mul(normalizedPhase, 2), 1)), 2), 1));
+	const normalizedPhase = fract(__tsover_div(phase, TAU));
+	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(abs(__tsover_sub(__tsover_mul(normalizedPhase, 2), 1)), 2), 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -574,23 +573,23 @@ const waveDistortTriangle = tgpu.fn([
 	},
 	externals: () => ({
 		wavePhase,
-		std,
+		std: std_exports,
 		TAU,
 		waveApply
 	})
 }) && $.f)({}));
-const waveDistortSquare = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
+const waveDistortSquare = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
 	"use gpu";
 	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = std.fract(__tsover_div(phase, TAU));
-	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(std.step(.5, normalizedPhase), 2), 1));
+	const normalizedPhase = fract(__tsover_div(phase, TAU));
+	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(step(.5, normalizedPhase), 2), 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -699,22 +698,22 @@ const waveDistortSquare = tgpu.fn([
 	},
 	externals: () => ({
 		wavePhase,
-		std,
+		std: std_exports,
 		TAU,
 		waveApply
 	})
 }) && $.f)({}));
-const waveDistortSawtooth = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
+const waveDistortSawtooth = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
 	"use gpu";
 	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = std.fract(__tsover_div(phase, TAU));
+	const normalizedPhase = fract(__tsover_div(phase, TAU));
 	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(normalizedPhase, 2), 1));
 }), {
 	v: 1,
@@ -816,22 +815,21 @@ const waveDistortSawtooth = tgpu.fn([
 	},
 	externals: () => ({
 		wavePhase,
-		std,
+		std: std_exports,
 		TAU,
 		waveApply
 	})
 }) && $.f)({}));
-const waveDistortBounce = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
+const waveDistortBounce = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
 	"use gpu";
-	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	return waveApply(uv, aspect, angle, strength, std.abs(std.sin(phase)));
+	return waveApply(uv, aspect, angle, strength, abs(sin(wavePhase(uv, aspect, angle, frequency, t))));
 }), {
 	v: 1,
 	name: void 0,
@@ -919,7 +917,7 @@ const waveDistortBounce = tgpu.fn([
 	},
 	externals: () => ({
 		wavePhase,
-		std,
+		std: std_exports,
 		waveApply
 	})
 }) && $.f)({}));

package/dist/core/{WaveletNoise-a5OpO8-D.js → WaveletNoise-CsLE9gbM.js}

@@ -1,17 +1,19 @@
-import { Ht as call, J as std, Tn as d, et as toneAndColorExpr, n as tgpu, pt as noise_exports, xt as wavelet12 } from "./coords-BkIjixe_.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-CRpf22bk.js";
-const waveletNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime, detail) => {
+import { $t as vec2f, Vt as data_exports, an as f32, et as src_default, nt as std_exports, p as call, xt as exp } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { p as noise_exports, x as wavelet12 } from "./noise-wTSHXgFz.js";
+import { n as toneAndColorExpr } from "./noiseColor-CPakiKNF.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-DscZM9CO.js";
+const waveletNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime, detail) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const pos = d.vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(std.exp(scale)).add(seed);
+	const pos = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
 	return __tsover_add(__tsover_mul(wavelet12(pos, animTime, detail), .5), .5);
 }), {
 	v: 1,
@@ -148,8 +150,8 @@ const waveletNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{Weave-D1D3kuUg.js → Weave-CQEF71nr.js}

@@ -1,44 +1,41 @@
-import { 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";
+import { $t as vec2f, Ct as floor, Et as max, It as sin, Lt as smoothstep, Vt as data_exports, _t as clamp, an as f32, ct as fwidth, et as src_default, in as vec4f, nt as std_exports, p as call, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const weaveColor = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, gap, rotation, colorA, colorB) => {
+const weaveColor = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, gap, rotation, colorA, colorB) => {
 	"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 rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	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 pixel = __tsover_mul(std.fwidth(scaledUV.x), .5);
-	const hBand = __tsover_mul(std.smoothstep(gap, __tsover_add(gap, pixel), localUV.y), std.smoothstep(gap, __tsover_add(gap, pixel), __tsover_sub(1, localUV.y)));
-	const vBand = __tsover_mul(std.smoothstep(gap, __tsover_add(gap, pixel), localUV.x), std.smoothstep(gap, __tsover_add(gap, pixel), __tsover_sub(1, localUV.x)));
+	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 pixel = __tsover_mul(fwidth(scaledUV.x), .5);
+	const hBand = __tsover_mul(smoothstep(gap, __tsover_add(gap, pixel), localUV.y), smoothstep(gap, __tsover_add(gap, pixel), __tsover_sub(1, localUV.y)));
+	const vBand = __tsover_mul(smoothstep(gap, __tsover_add(gap, pixel), localUV.x), smoothstep(gap, __tsover_add(gap, pixel), __tsover_sub(1, localUV.x)));
 	const s = __tsover_add(cell.x, cell.y);
-	const isHTopFloat = __tsover_sub(s, __tsover_mul(2, std.floor(__tsover_div(s, 2))));
+	const isHTopFloat = __tsover_sub(s, __tsover_mul(2, floor(__tsover_div(s, 2))));
 	const intersection = __tsover_mul(hBand, vBand);
-	const hVis = std.clamp(__tsover_sub(hBand, __tsover_mul(intersection, isHTopFloat)), 0, 1);
-	const vVis = std.clamp(__tsover_sub(vBand, __tsover_mul(intersection, __tsover_sub(1, isHTopFloat))), 0, 1);
+	const hVis = clamp(__tsover_sub(hBand, __tsover_mul(intersection, isHTopFloat)), 0, 1);
+	const vVis = clamp(__tsover_sub(vBand, __tsover_mul(intersection, __tsover_sub(1, isHTopFloat))), 0, 1);
 	const weightA = __tsover_mul(colorA.w, hVis);
 	const weightB = __tsover_mul(colorB.w, vVis);
-	const totalAlpha = std.clamp(__tsover_add(weightA, weightB), 0, 1);
-	const safeWeight = std.max(__tsover_add(weightA, weightB), .001);
-	const r = __tsover_div(__tsover_add(__tsover_mul(colorA.x, weightA), __tsover_mul(colorB.x, weightB)), safeWeight);
-	const g = __tsover_div(__tsover_add(__tsover_mul(colorA.y, weightA), __tsover_mul(colorB.y, weightB)), safeWeight);
-	const b = __tsover_div(__tsover_add(__tsover_mul(colorA.z, weightA), __tsover_mul(colorB.z, weightB)), safeWeight);
-	return d.vec4f(r, g, b, totalAlpha);
+	const totalAlpha = clamp(__tsover_add(weightA, weightB), 0, 1);
+	const safeWeight = max(__tsover_add(weightA, weightB), .001);
+	return vec4f(__tsover_div(__tsover_add(__tsover_mul(colorA.x, weightA), __tsover_mul(colorB.x, weightB)), safeWeight), __tsover_div(__tsover_add(__tsover_mul(colorA.y, weightA), __tsover_mul(colorB.y, weightB)), safeWeight), __tsover_div(__tsover_add(__tsover_mul(colorA.z, weightA), __tsover_mul(colorB.z, weightB)), safeWeight), totalAlpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -729,9 +726,9 @@ const weaveColor = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{WebcamTexture-pBETyQYG.js → WebcamTexture-BcsYFM_g.js}

@@ -1,6 +1,7 @@
-import { Ht as call, J as std, Tn as d, _ as scaleScaleDown, d as alphaCutLinear, f as sampleUV, g as scaleNone, h as scaleFill, m as scaleCover, n as tgpu, p as scaleContain } from "./coords-BkIjixe_.js";
+import { $t as vec2f, Vt as data_exports, an as f32, et as src_default, nt as std_exports, p as call, pt as select } from "./edges-BXNBKxSN.js";
 import { r as debugWarn } from "./support-6QRFK3xB.js";
-import { r as registerNaturalSize } from "./naturalSize-Caz3-kRv.js";
+import { a as scaleFill, i as scaleCover, n as sampleUV, o as scaleNone, r as scaleContain, s as scaleScaleDown, t as alphaCutLinear } from "./media-B9BNeMPu.js";
+import { r as registerNaturalSize } from "./naturalSize-B679wTgN.js";
 var OBJECT_FIT_MODES = {
 	cover: 0,
 	contain: 1,
@@ -8,10 +9,9 @@ var OBJECT_FIT_MODES = {
 	"scale-down": 3,
 	none: 4
 };
-const applyMirror = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, mirror) => {
+const applyMirror = src_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, mirror) => {
 	"use gpu";
-	const mirroredX = std.select(uv.x, __tsover_sub(1, uv.x), mirror > 0);
-	return d.vec2f(mirroredX, uv.y);
+	return vec2f(select(uv.x, __tsover_sub(1, uv.x), mirror > 0), uv.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -73,8 +73,8 @@ const applyMirror = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Wool-CMnWPdy9.js → Wool-BFSicimy.js}

@@ -1,5 +1,5 @@
-import { Q as applyNoiseReliefExpr, St as wool12 } from "./coords-BkIjixe_.js";
-import { t as reliefStylizeProps } from "./noiseStylize-J6sFKoTh.js";
+import { S as wool12 } from "./noise-wTSHXgFz.js";
+import { n as applyNoiseReliefExpr, t as reliefStylizeProps } from "./noiseStylize-BXpflWPW.js";
 const componentDefinition = {
 	name: "Wool",
 	boundingBoxDeclaration: { aspectRatio: null },

package/dist/core/{WorleyNoise-BAEo0duh.js → WorleyNoise-BKq3es5v.js}

@@ -1,11 +1,10 @@
-import { Ht as call, J as std, Kt as floatE, 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";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Ot as mix, Rt as sqrt, U as mixColorsVariants, Vt as data_exports, _ as floatE, _t as clamp, an as f32, bt as dot, et as src_default, mt as abs, nt as std_exports, p as call, pt as select, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var TAU = Math.PI * 2;
-const worleyHash = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+const worleyHash = src_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const h = d.vec2f(std.dot(p, d.vec2f(127.1, 311.7)), std.dot(p, d.vec2f(269.5, 183.3)));
-	return std.fract(std.sin(h).mul(43758.5453));
+	return fract(sin(vec2f(dot(p, vec2f(127.1, 311.7)), dot(p, vec2f(269.5, 183.3)))).mul(43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -86,8 +85,8 @@ const worleyHash = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalTh
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 var transformMode = (value) => {
@@ -112,46 +111,46 @@ function worleyModeNum(raw) {
 function worleyDistNum(raw) {
 	return typeof raw === "number" ? raw : transformDistance(raw);
 }
-const worleyEvalOctave = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((oUV, animT, seedOff, jitter, distNum, modeNum) => {
+const worleyEvalOctave = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((oUV, animT, seedOff, jitter, distNum, modeNum) => {
 	"use gpu";
 	const animTSlow = __tsover_mul(animT, .7);
-	const cell = std.floor(oUV);
-	const localUV = std.fract(oUV);
-	let d1 = d.f32(10);
-	let d2 = d.f32(10);
+	const cell = floor(oUV);
+	const localUV = fract(oUV);
+	let d1 = f32(10);
+	let d2 = f32(10);
 	for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
-		const offset = d.vec2f(d.f32(nx), d.f32(ny));
-		const h = worleyHash(d.vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seedOff), __tsover_add(__tsover_add(cell.y, offset.y), seedOff)));
-		const px = __tsover_add(h.x, __tsover_mul(std.sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15));
-		const py = __tsover_add(h.y, __tsover_mul(std.cos(__tsover_add(animTSlow, __tsover_mul(h.y, TAU))), .15));
-		const jx = std.mix(.5, std.clamp(px, .05, .95), jitter);
-		const jy = std.mix(.5, std.clamp(py, .05, .95), jitter);
+		const offset = vec2f(f32(nx), f32(ny));
+		const h = worleyHash(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seedOff), __tsover_add(__tsover_add(cell.y, offset.y), seedOff)));
+		const px = __tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, TAU))), .15));
+		const py = __tsover_add(h.y, __tsover_mul(cos(__tsover_add(animTSlow, __tsover_mul(h.y, TAU))), .15));
+		const jx = mix(.5, clamp(px, .05, .95), jitter);
+		const jy = mix(.5, clamp(py, .05, .95), jitter);
 		const deltaX = __tsover_sub(localUV.x, __tsover_add(offset.x, jx));
 		const deltaY = __tsover_sub(localUV.y, __tsover_add(offset.y, jy));
 		const dEuclid = __tsover_add(__tsover_mul(deltaX, deltaX), __tsover_mul(deltaY, deltaY));
-		const dManhattan = __tsover_add(std.abs(deltaX), std.abs(deltaY));
-		const dChebyshev = std.max(std.abs(deltaX), std.abs(deltaY));
+		const dManhattan = __tsover_add(abs(deltaX), abs(deltaY));
+		const dChebyshev = max(abs(deltaX), abs(deltaY));
 		let dd = dEuclid;
-		dd = std.select(dd, dManhattan, distNum === 1);
-		dd = std.select(dd, dChebyshev, distNum === 2);
-		d2 = std.min(d2, std.max(dd, d1));
-		d1 = std.min(d1, dd);
+		dd = select(dd, dManhattan, distNum === 1);
+		dd = select(dd, dChebyshev, distNum === 2);
+		d2 = min(d2, max(dd, d1));
+		d1 = min(d1, dd);
 	}
 	const isEuclid = distNum === 0;
-	const sd1 = std.select(d1, std.sqrt(d1), isEuclid);
-	const sd2 = std.select(d2, std.sqrt(d2), isEuclid);
+	const sd1 = select(d1, sqrt(d1), isEuclid);
+	const sd2 = select(d2, sqrt(d2), isEuclid);
 	let raw = sd1;
-	raw = std.select(raw, sd2, modeNum === 1);
-	raw = std.select(raw, __tsover_sub(sd2, sd1), modeNum === 2);
-	raw = std.select(raw, __tsover_add(sd1, sd2), modeNum === 3);
-	raw = std.select(raw, __tsover_mul(sd1, sd2), modeNum === 4);
+	raw = select(raw, sd2, modeNum === 1);
+	raw = select(raw, __tsover_sub(sd2, sd1), modeNum === 2);
+	raw = select(raw, __tsover_add(sd1, sd2), modeNum === 3);
+	raw = select(raw, __tsover_mul(sd1, sd2), modeNum === 4);
 	return raw;
 }), {
 	v: 1,
@@ -906,44 +905,44 @@ const worleyEvalOctave = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		worleyHash,
 		TAU
 	})
 }) && $.f)({}));
-const worleyNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	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 = ((uv, viewport, scale, seed, jitter, lacunarity, persistence, animTime, octaves, distNum, modeNum, modeScale) => {
+const worleyNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, jitter, lacunarity, persistence, animTime, octaves, distNum, modeNum, modeScale) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const baseUVx = __tsover_mul(uv.x, aspect);
 	const baseUVy = uv.y;
-	let acc = d.f32(0);
-	let totalAmp = d.f32(0);
-	let amp = d.f32(1);
+	let acc = f32(0);
+	let totalAmp = f32(0);
+	let amp = f32(1);
 	let freq = scale;
 	for (let o = 0; o < 4; o++) {
-		const fo = d.f32(o);
-		const gate = std.select(d.f32(0), d.f32(1), fo < octaves);
-		const raw = worleyEvalOctave(d.vec2f(__tsover_mul(baseUVx, freq), __tsover_mul(baseUVy, freq)), __tsover_add(animTime, __tsover_mul(fo, 17)), __tsover_add(seed, __tsover_mul(fo, 31)), jitter, distNum, modeNum);
+		const fo = f32(o);
+		const gate = select(f32(0), f32(1), fo < octaves);
+		const raw = worleyEvalOctave(vec2f(__tsover_mul(baseUVx, freq), __tsover_mul(baseUVy, freq)), __tsover_add(animTime, __tsover_mul(fo, 17)), __tsover_add(seed, __tsover_mul(fo, 31)), jitter, distNum, modeNum);
 		acc = __tsover_add(acc, __tsover_mul(__tsover_mul(raw, amp), gate));
 		totalAmp = __tsover_add(totalAmp, __tsover_mul(amp, gate));
 		amp = __tsover_mul(amp, persistence);
 		freq = __tsover_mul(freq, lacunarity);
 	}
-	return __tsover_mul(__tsover_div(acc, std.max(totalAmp, 1e-4)), modeScale);
+	return __tsover_mul(__tsover_div(acc, max(totalAmp, 1e-4)), modeScale);
 }), {
 	v: 1,
 	name: void 0,
@@ -1311,20 +1310,20 @@ const worleyNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		worleyEvalOctave
 	})
 }) && $.f)({}));
-const worleyTone = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normalized, contrast, balance) => {
+const worleyTone = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normalized, contrast, balance) => {
 	"use gpu";
 	const signed = __tsover_sub(__tsover_mul(normalized, 2), 1);
 	const adjusted = __tsover_add(__tsover_mul(signed, contrast), balance);
-	return std.clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
+	return clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -1400,7 +1399,7 @@ const worleyTone = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "WorleyNoise",