shaders 3.0.447 → 3.0.449

package/dist/core/{Halftone-DszIQsyx.js → Halftone-3a3rz4ln.js}

@@ -1,28 +1,27 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, r as transformAngle } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, 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, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, r as transformAngle } from "./transformations-CsPUHppB.js";
 var SMOOTHNESS = .1;
 var DEG_TO_RAD = Math.PI / 180;
 var transformStyle = (value) => value === "cmyk" ? 1 : 0;
 var styleModeOf = (raw) => typeof raw === "number" ? raw : raw === "cmyk" ? 1 : 0;
-const halftoneClassic = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, angleDeg, frequency) => {
+const halftoneClassic = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, angleDeg, frequency) => {
 	"use gpu";
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const c = std.cos(angleRad);
-	const s = std.sin(angleRad);
-	const rotatedUV = d.vec2f(std.dot(aspectUV, d.vec2f(c, __tsover_mul(s, -1))), std.dot(aspectUV, d.vec2f(s, c)));
-	const gridUV = std.fract(rotatedUV.mul(frequency)).sub(d.vec2f(.5, .5));
-	const brightness = std.dot(d.vec3f(childColor.x, childColor.y, childColor.z), d.vec3f(.299, .587, .114));
+	const c = cos(angleRad);
+	const s = sin(angleRad);
+	const gridUV = fract(vec2f(dot(aspectUV, vec2f(c, __tsover_mul(s, -1))), dot(aspectUV, vec2f(s, c))).mul(frequency)).sub(vec2f(.5, .5));
+	const brightness = dot(vec3f(childColor.x, childColor.y, childColor.z), vec3f(.299, .587, .114));
 	const dotSize = __tsover_add(__tsover_mul(brightness, .7), .15);
-	const dist = std.length(gridUV);
-	const dotPattern = __tsover_sub(1, std.smoothstep(__tsover_sub(dotSize, SMOOTHNESS), __tsover_add(dotSize, SMOOTHNESS), dist));
-	return d.vec4f(__tsover_mul(childColor.x, dotPattern), __tsover_mul(childColor.y, dotPattern), __tsover_mul(childColor.z, dotPattern), __tsover_mul(childColor.w, dotPattern));
+	const dist = length(gridUV);
+	const dotPattern = __tsover_sub(1, smoothstep(__tsover_sub(dotSize, SMOOTHNESS), __tsover_add(dotSize, SMOOTHNESS), dist));
+	return vec4f(__tsover_mul(childColor.x, dotPattern), __tsover_mul(childColor.y, dotPattern), __tsover_mul(childColor.z, dotPattern), __tsover_mul(childColor.w, dotPattern));
 }), {
 	v: 1,
 	name: void 0,
@@ -371,22 +370,22 @@ const halftoneClassic = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SMOOTHNESS
 	})
 }) && $.f)({}));
-const halftonePlateUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, misprintAngleDeg, plateIndexDeg, misprint, aspect) => {
+const halftonePlateUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, misprintAngleDeg, plateIndexDeg, misprint, aspect) => {
 	"use gpu";
 	const angleRad = __tsover_mul(__tsover_add(misprintAngleDeg, plateIndexDeg), DEG_TO_RAD);
-	return d.vec2f(__tsover_add(uv.x, __tsover_mul(std.cos(angleRad), misprint)), __tsover_add(uv.y, __tsover_div(__tsover_mul(std.sin(angleRad), misprint), aspect)));
+	return vec2f(__tsover_add(uv.x, __tsover_mul(cos(angleRad), misprint)), __tsover_add(uv.y, __tsover_div(__tsover_mul(sin(angleRad), misprint), aspect)));
 }), {
 	v: 1,
 	name: void 0,
@@ -493,13 +492,13 @@ const halftonePlateUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelK = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelK = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
-	return __tsover_sub(1, std.max(std.max(s.x, s.y), s.z));
+	return __tsover_sub(1, max(max(s.x, s.y), s.z));
 }), {
 	v: 1,
 	name: void 0,
@@ -544,12 +543,12 @@ const halftoneChannelK = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const halftoneChannelC = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelC = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.x), k), invK);
 }), {
 	v: 1,
@@ -612,13 +611,13 @@ const halftoneChannelC = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelM = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelM = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.y), k), invK);
 }), {
 	v: 1,
@@ -681,13 +680,13 @@ const halftoneChannelM = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelY = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelY = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.z), k), invK);
 }), {
 	v: 1,
@@ -750,26 +749,24 @@ const halftoneChannelY = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftonePlateGrid = 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, angleDeg, intensity, frequency) => {
+const halftonePlateGrid = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg, intensity, frequency) => {
 	"use gpu";
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const c = std.cos(angleRad);
-	const s = std.sin(angleRad);
-	const rotatedUV = d.vec2f(std.dot(aspectUV, d.vec2f(c, __tsover_mul(s, -1))), std.dot(aspectUV, d.vec2f(s, c)));
-	const grid = std.fract(rotatedUV.mul(frequency)).sub(d.vec2f(.5, .5));
-	const dist = std.length(grid);
+	const c = cos(angleRad);
+	const s = sin(angleRad);
+	const dist = length(fract(vec2f(dot(aspectUV, vec2f(c, __tsover_mul(s, -1))), dot(aspectUV, vec2f(s, c))).mul(frequency)).sub(vec2f(.5, .5)));
 	const size = __tsover_sub(__tsover_mul(intensity, .75), SMOOTHNESS);
-	return __tsover_sub(1, std.smoothstep(__tsover_sub(size, SMOOTHNESS), __tsover_add(size, SMOOTHNESS), dist));
+	return __tsover_sub(1, smoothstep(__tsover_sub(size, SMOOTHNESS), __tsover_add(size, SMOOTHNESS), dist));
 }), {
 	v: 1,
 	name: void 0,
@@ -1015,15 +1012,15 @@ const halftonePlateGrid = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SMOOTHNESS
 	})
 }) && $.f)({}));
-const halftoneTransmission = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((inkColor, inkMask) => {
+const halftoneTransmission = src_default.fn([vec4f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((inkColor, inkMask) => {
 	"use gpu";
-	return std.mix(d.vec3f(1, 1, 1), d.vec3f(inkColor.x, inkColor.y, inkColor.z), d.vec3f(__tsover_mul(inkMask, inkColor.w)));
+	return mix(vec3f(1, 1, 1), vec3f(inkColor.x, inkColor.y, inkColor.z), vec3f(__tsover_mul(inkMask, inkColor.w)));
 }), {
 	v: 1,
 	name: void 0,
@@ -1104,8 +1101,8 @@ const halftoneTransmission = 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/{Heart-COpnSJPD.js → Heart-CzO0_GoB.js}

@@ -1,14 +1,15 @@
-import { A as heartSdf, 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 heartShape = tgpu.fn([
-	d.vec2f,
-	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, u as heartSdf, v as strokeMaskFromSdf } 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 heartShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Heatmap-CMm8SD-P.js → Heatmap-DPtUc8YG.js}

@@ -1,8 +1,10 @@
-import { Et as mixColorStopsRuntime, F as sdf_exports, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports, st as hash12, y as sdf3d_exports, yt as value12 } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, 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, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, vt as cos, wt as fract, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { p as noise_exports, s as hash12, y as value12 } 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, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
@@ -37,19 +39,19 @@ var DEFAULT_STOPS = [
 		position: 1
 	}
 ];
-const heatmapShadow = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b, tk, phase) => {
+const heatmapShadow = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b, tk, phase) => {
 	"use gpu";
-	const posS = std.mix(-.6, .6, tk);
-	const wob = __tsover_sub(value12(d.vec2f(__tsover_add(__tsover_mul(b, 4), __tsover_mul(phase, 13.7)), __tsover_add(__tsover_mul(tk, 3), __tsover_mul(phase, 7.1)))), .5);
+	const posS = mix(-.6, .6, tk);
+	const wob = __tsover_sub(value12(vec2f(__tsover_add(__tsover_mul(b, 4), __tsover_mul(phase, 13.7)), __tsover_add(__tsover_mul(tk, 3), __tsover_mul(phase, 7.1)))), .5);
 	const aEff = __tsover_add(__tsover_sub(a, posS), __tsover_mul(wob, .12));
-	const band = std.exp(__tsover_div(__tsover_mul(__tsover_mul(aEff, aEff), -1), __tsover_mul(.16, .16)));
-	const gate = __tsover_mul(std.smoothstep(0, .15, tk), __tsover_sub(1, std.smoothstep(.85, 1, tk)));
-	return std.clamp(__tsover_mul(band, gate), 0, 1);
+	const band = exp(__tsover_div(__tsover_mul(__tsover_mul(aEff, aEff), -1), __tsover_mul(.16, .16)));
+	const gate = __tsover_mul(smoothstep(0, .15, tk), __tsover_sub(1, smoothstep(.85, 1, tk)));
+	return clamp(__tsover_mul(band, gate), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -272,55 +274,55 @@ const heatmapShadow = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		noise: noise_exports,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const heatmapHeatField = tgpu.fn([
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.vec4f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, animTime, p0, scale) => {
+const heatmapHeatField = src_default.fn([
+	f32,
+	vec2f,
+	f32,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, animTime, p0, scale) => {
 	"use gpu";
 	const innerGlow = p0.x;
 	const outerGlow = p0.y;
 	const contour = p0.z;
 	const angleDeg = p0.w;
-	const scl = std.max(scale, .001);
+	const scl = max(scale, .001);
 	const f = __tsover_div(fieldRaw, scl);
-	const inside = __tsover_sub(1, std.smoothstep(-.003, .003, f));
+	const inside = __tsover_sub(1, smoothstep(-.003, .003, f));
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dirX = std.cos(angleRad);
-	const dirY = std.sin(angleRad);
+	const dirX = cos(angleRad);
+	const dirY = sin(angleRad);
 	const a = __tsover_add(__tsover_mul(dirX, __tsover_sub(sdfUV.x, .5)), __tsover_mul(dirY, __tsover_sub(sdfUV.y, .5)));
 	const b = __tsover_sub(__tsover_mul(dirY, __tsover_sub(sdfUV.x, .5)), __tsover_mul(dirX, __tsover_sub(sdfUV.y, .5)));
 	const tBase = __tsover_sub(__tsover_mul(.1, animTime), .3);
-	const t0 = std.fract(tBase);
-	const t1 = std.fract(__tsover_add(tBase, __tsover_div(1, 3)));
-	const t2 = std.fract(__tsover_add(tBase, __tsover_div(2, 3)));
-	const innerBlur = std.exp(__tsover_div(__tsover_mul(std.max(__tsover_mul(f, -1), 0), -1), .12));
+	const t0 = fract(tBase);
+	const t1 = fract(__tsover_add(tBase, __tsover_div(1, 3)));
+	const t2 = fract(__tsover_add(tBase, __tsover_div(2, 3)));
+	const innerBlur = exp(__tsover_div(__tsover_mul(max(__tsover_mul(f, -1), 0), -1), .12));
 	let inner = __tsover_add(.8, __tsover_mul(.8, innerBlur));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t0, 1));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t1, 2));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t2, 3));
+	inner = mix(inner, 0, heatmapShadow(a, b, t0, 1));
+	inner = mix(inner, 0, heatmapShadow(a, b, t1, 2));
+	inner = mix(inner, 0, heatmapShadow(a, b, t2, 3));
 	inner = __tsover_mul(inner, __tsover_mul(2, innerGlow));
-	inner = __tsover_add(inner, __tsover_mul(__tsover_mul(contour, 2), std.exp(__tsover_div(__tsover_mul(std.abs(f), -1), .03))));
-	inner = __tsover_mul(std.min(inner, 1), inside);
-	inner = std.pow(std.max(inner, 0), 1.2);
-	const outerBlur = std.exp(__tsover_div(__tsover_mul(std.max(f, 0), -1), __tsover_add(.05, __tsover_mul(.15, outerGlow))));
-	const t3 = std.fract(__tsover_sub(__tsover_mul(tBase, 3), .1));
-	const yy = std.fract(__tsover_sub(__tsover_mul(a, 1.2), t3));
-	const animatedMask = __tsover_add(.5, __tsover_mul(std.smoothstep(.3, .65, yy), __tsover_sub(1, std.smoothstep(.65, 1, yy))));
-	const outer = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(.9, std.pow(outerBlur, .8)), animatedMask), 5), outerGlow), outerGlow), __tsover_sub(1, inside));
-	let heat = std.clamp(__tsover_add(inner, outer), 0, 1);
-	const frame = __tsover_mul(__tsover_mul(__tsover_mul(std.smoothstep(-.06, .1, sdfUV.x), __tsover_sub(1, std.smoothstep(.9, 1.06, sdfUV.x))), std.smoothstep(-.06, .1, sdfUV.y)), __tsover_sub(1, std.smoothstep(.9, 1.06, sdfUV.y)));
+	inner = __tsover_add(inner, __tsover_mul(__tsover_mul(contour, 2), exp(__tsover_div(__tsover_mul(abs(f), -1), .03))));
+	inner = __tsover_mul(min(inner, 1), inside);
+	inner = pow(max(inner, 0), 1.2);
+	const outerBlur = exp(__tsover_div(__tsover_mul(max(f, 0), -1), __tsover_add(.05, __tsover_mul(.15, outerGlow))));
+	const t3 = fract(__tsover_sub(__tsover_mul(tBase, 3), .1));
+	const yy = fract(__tsover_sub(__tsover_mul(a, 1.2), t3));
+	const animatedMask = __tsover_add(.5, __tsover_mul(smoothstep(.3, .65, yy), __tsover_sub(1, smoothstep(.65, 1, yy))));
+	const outer = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(.9, pow(outerBlur, .8)), animatedMask), 5), outerGlow), outerGlow), __tsover_sub(1, inside));
+	let heat = clamp(__tsover_add(inner, outer), 0, 1);
+	const frame = __tsover_mul(__tsover_mul(__tsover_mul(smoothstep(-.06, .1, sdfUV.x), __tsover_sub(1, smoothstep(.9, 1.06, sdfUV.x))), smoothstep(-.06, .1, sdfUV.y)), __tsover_sub(1, smoothstep(.9, 1.06, sdfUV.y)));
 	heat = __tsover_mul(heat, frame);
-	heat = __tsover_add(heat, __tsover_mul(.005, __tsover_sub(hash12(d.vec2f(__tsover_mul(sdfUV.x, 991.3), __tsover_mul(sdfUV.y, 787.7))), .5)));
-	const coverage = __tsover_mul(std.clamp(__tsover_add(inside, outer), 0, 1), frame);
-	return d.vec2f(std.clamp(heat, 0, 1), coverage);
+	heat = __tsover_add(heat, __tsover_mul(.005, __tsover_sub(hash12(vec2f(__tsover_mul(sdfUV.x, 991.3), __tsover_mul(sdfUV.y, 787.7))), .5)));
+	const coverage = __tsover_mul(clamp(__tsover_add(inside, outer), 0, 1), frame);
+	return vec2f(clamp(heat, 0, 1), coverage);
 }), {
 	v: 1,
 	name: void 0,
@@ -1298,16 +1300,16 @@ const heatmapHeatField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
 		heatmapShadow,
 		noise: noise_exports,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const heatmapCompose = tgpu.fn([d.f32, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coverage, ramp) => {
+const heatmapCompose = src_default.fn([f32, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coverage, ramp) => {
 	"use gpu";
-	return d.vec4f(std.clamp(ramp.xyz, d.vec3f(0), d.vec3f(1)), __tsover_mul(ramp.w, coverage));
+	return vec4f(clamp(ramp.xyz, vec3f(0), vec3f(1)), __tsover_mul(ramp.w, coverage));
 }), {
 	v: 1,
 	name: void 0,
@@ -1372,8 +1374,8 @@ const heatmapCompose = tgpu.fn([d.f32, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) =
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{HexGrid-B6wNW-45.js → HexGrid-CN5A0m5j.js}

@@ -1,12 +1,12 @@
-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 vec2f, Ct as floor, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Pt as round, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, ct as fwidth, et as src_default, mt as abs, nt as std_exports, p as call, pt as select, vt as cos, wt as fract, y as vec4, zt as step } from "./edges-BXNBKxSN.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 INV_SQRT3_2 = 2 / Math.sqrt(3);
 var SQRT3_2 = Math.sqrt(3) / 2;
-var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
+var flooredMod2 = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
 	"use gpu";
-	return d.vec2f(__tsover_sub(p.x, __tsover_mul(m.x, std.floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, std.floor(__tsover_div(p.y, m.y)))));
+	return vec2f(__tsover_sub(p.x, __tsover_mul(m.x, floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, floor(__tsover_div(p.y, m.y)))));
 }), {
 	v: 1,
 	name: void 0,
@@ -108,52 +108,49 @@ var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const hexGridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	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) => {
+const hexGridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
 	"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 s = d.vec2f(SQRT3, 1);
+	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 s = vec2f(SQRT3, 1);
 	const sh = s.mul(.5);
 	const a = flooredMod2(scaledUV, s).sub(sh);
 	const b = flooredMod2(scaledUV.sub(sh), s).sub(sh);
-	const gv = std.select(b, a, std.dot(a, a) < std.dot(b, b));
+	const gv = select(b, a, dot(a, a) < dot(b, b));
 	const cellId = scaledUV.sub(gv);
-	const ix = std.round(__tsover_mul(cellId.x, INV_SQRT3_2));
-	const iy = std.round(__tsover_mul(cellId.y, 2));
-	const q0 = std.fract(d.vec2f(ix, iy).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 pAbs = d.vec2f(std.abs(gv.x), std.abs(gv.y));
-	const hexDist = std.max(std.dot(pAbs, d.vec2f(SQRT3_2, .5)), pAbs.y);
+	const q0 = fract(vec2f(round(__tsover_mul(cellId.x, INV_SQRT3_2)), round(__tsover_mul(cellId.y, 2))).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 pAbs = vec2f(abs(gv.x), abs(gv.y));
+	const hexDist = max(dot(pAbs, vec2f(SQRT3_2, .5)), pAbs.y);
 	const edgeDist = __tsover_sub(.5, hexDist);
 	const lineWidth = __tsover_mul(thickness, .01);
-	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);
-	const lineMask = __tsover_mul(__tsover_sub(1, std.smoothstep(lo, hi, edgeDist)), std.step(1e-4, lineWidth));
-	return d.vec2f(lineMask, variedFactor);
+	return vec2f(__tsover_mul(__tsover_sub(1, smoothstep(lo, hi, edgeDist)), step(1e-4, lineWidth)), variedFactor);
 }), {
 	v: 1,
 	name: void 0,
@@ -881,9 +878,9 @@ const hexGridField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
 		flooredMod2,
 		INV_SQRT3_2,