shaders 3.0.447 → 3.0.449

package/dist/core/{Spherize-DUQxwwCL.js → Spherize-SBfCc9Wk.js}

@@ -1,15 +1,15 @@
-import { Bt as ZERO, Ht as call, J as std, Rt as sampleCatmullRomExpr, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-const spherizeGeom = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, center, radius, depth, lightPos, lightIntensity, lightSoftness) => {
+import { $t as vec2f, At as pow, Et as max, Lt as smoothstep, N as unpremultiplyAlpha, Rt as sqrt, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, kt as normalize, l as sampleCatmullRomExpr, 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 spherizeGeom = src_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, center, radius, depth, lightPos, lightIntensity, lightSoftness) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const centerX = center.x;
@@ -19,25 +19,23 @@ const spherizeGeom = tgpu.fn([
 	const sphereX = __tsover_div(__tsover_mul(cuX, 2), radius);
 	const sphereY = __tsover_div(__tsover_mul(cuY, 2), radius);
 	const radiusSq = __tsover_add(__tsover_mul(sphereX, sphereX), __tsover_mul(sphereY, sphereY));
-	const sphereAlpha = __tsover_sub(1, std.smoothstep(.98, 1, radiusSq));
-	const z = std.sqrt(std.max(d.f32(0), __tsover_sub(1, radiusSq)));
+	const sphereAlpha = __tsover_sub(1, smoothstep(.98, 1, radiusSq));
+	const z = sqrt(max(f32(0), __tsover_sub(1, radiusSq)));
 	const depthFactor = __tsover_add(1, __tsover_mul(z, depth));
 	const finalX = __tsover_div(__tsover_mul(__tsover_div(sphereX, depthFactor), radius), 2);
 	const finalY = __tsover_div(__tsover_mul(__tsover_div(sphereY, depthFactor), radius), 2);
 	const transformedX = __tsover_add(__tsover_div(finalX, aspect), centerX);
 	const transformedY = __tsover_add(finalY, centerY);
-	const normal = std.normalize(d.vec3f(sphereX, sphereY, z));
-	const viewDir = d.vec3f(0, 0, 1);
+	const normal = normalize(vec3f(sphereX, sphereY, z));
+	const viewDir = vec3f(0, 0, 1);
 	const fresnelPower = __tsover_add(1, __tsover_mul(4, __tsover_sub(1, lightSoftness)));
-	const fresnel = std.pow(__tsover_sub(1, std.max(std.dot(normal, viewDir), d.f32(0))), fresnelPower);
+	const fresnel = pow(__tsover_sub(1, max(dot(normal, viewDir), f32(0))), fresnelPower);
 	const lightDir2Dx = __tsover_mul(__tsover_sub(lightPos.x, .5), 2);
 	const lightDir2Dy = __tsover_mul(__tsover_sub(__tsover_sub(1, lightPos.y), .5), 2);
-	const normalDir = std.normalize(d.vec2f(__tsover_add(normal.x, 1e-4), __tsover_add(normal.y, 1e-4)));
-	const lightDirNorm = std.normalize(d.vec2f(__tsover_add(lightDir2Dx, 1e-4), __tsover_add(lightDir2Dy, 1e-4)));
-	const directionality = std.max(d.f32(0), std.dot(normalDir, lightDirNorm));
-	const directionalBias = std.pow(directionality, d.f32(2));
-	const rimLight = __tsover_mul(__tsover_mul(__tsover_mul(fresnel, directionalBias), lightIntensity), 2);
-	return d.vec4f(transformedX, transformedY, sphereAlpha, rimLight);
+	const normalDir = normalize(vec2f(__tsover_add(normal.x, 1e-4), __tsover_add(normal.y, 1e-4)));
+	const lightDirNorm = normalize(vec2f(__tsover_add(lightDir2Dx, 1e-4), __tsover_add(lightDir2Dy, 1e-4)));
+	const directionalBias = pow(max(f32(0), dot(normalDir, lightDirNorm)), f32(2));
+	return vec4f(transformedX, transformedY, sphereAlpha, __tsover_mul(__tsover_mul(__tsover_mul(fresnel, directionalBias), lightIntensity), 2));
 }), {
 	v: 1,
 	name: void 0,
@@ -642,22 +640,18 @@ const spherizeGeom = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const spherizeCompose = tgpu.fn([
-	d.vec4f,
-	d.vec3f,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((straight, lightColor, rimLight, sphereAlpha) => {
+const spherizeCompose = src_default.fn([
+	vec4f,
+	vec3f,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((straight, lightColor, rimLight, sphereAlpha) => {
 	"use gpu";
-	const r = __tsover_add(straight.x, __tsover_mul(lightColor.x, rimLight));
-	const g = __tsover_add(straight.y, __tsover_mul(lightColor.y, rimLight));
-	const b = __tsover_add(straight.z, __tsover_mul(lightColor.z, rimLight));
-	const a = __tsover_mul(straight.w, sphereAlpha);
-	return d.vec4f(r, g, b, a);
+	return vec4f(__tsover_add(straight.x, __tsover_mul(lightColor.x, rimLight)), __tsover_add(straight.y, __tsover_mul(lightColor.y, rimLight)), __tsover_add(straight.z, __tsover_mul(lightColor.z, rimLight)), __tsover_mul(straight.w, sphereAlpha));
 }), {
 	v: 1,
 	name: void 0,
@@ -781,7 +775,7 @@ const spherizeCompose = tgpu.fn([
 		]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "Spherize",

package/dist/core/{Spiral-DY1c-N4F.js → Spiral-iRrT222n.js}

@@ -1,20 +1,20 @@
-import { Ht as call, J as std, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, H as mixColorsLinear, Lt as smoothstep, Ot as mix, Tt as length, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, ct as fwidth, et as src_default, gt as atan2, mt as abs, nt as std_exports, p as call, wt as fract } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var TWO_PI = 6.283185307;
-const spiralOffset = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, animTime, uv, viewport) => {
+const spiralOffset = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, animTime, uv, viewport) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect));
 	const dy = __tsover_sub(uv.y, __tsover_sub(1, center.y));
-	const l = std.length(d.vec2f(dx, dy));
-	const angle = __tsover_sub(std.atan2(dy, dx), animTime);
+	const l = length(vec2f(dx, dy));
+	const angle = __tsover_sub(atan2(dy, dx), animTime);
 	return __tsover_add(__tsover_mul(l, scale), __tsover_div(angle, TWO_PI));
 }), {
 	v: 1,
@@ -175,37 +175,37 @@ const spiralOffset = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		TWO_PI
 	})
 }) && $.f)({}));
-const spiralMask = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, strokeWidth, strokeFalloff, softness, animTime, uv, viewport) => {
+const spiralMask = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, strokeWidth, strokeFalloff, softness, animTime, uv, viewport) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect));
 	const dy = __tsover_sub(uv.y, __tsover_sub(1, center.y));
-	const l = std.length(d.vec2f(dx, dy));
-	const angle = __tsover_sub(std.atan2(dy, dx), animTime);
+	const l = length(vec2f(dx, dy));
+	const angle = __tsover_sub(atan2(dy, dx), animTime);
 	const offset = __tsover_add(__tsover_mul(l, scale), __tsover_div(angle, TWO_PI));
-	const stripe = std.fract(offset);
-	const shape = __tsover_mul(std.abs(__tsover_sub(stripe, .5)), 2);
-	const baseWidth = std.clamp(strokeWidth, __tsover_mul(strokeFalloff, .005), 1);
-	const falloffAmount = __tsover_sub(1, __tsover_mul(std.clamp(strokeFalloff, 0, 1), l));
+	const stripe = fract(offset);
+	const shape = __tsover_mul(abs(__tsover_sub(stripe, .5)), 2);
+	const baseWidth = clamp(strokeWidth, __tsover_mul(strokeFalloff, .005), 1);
+	const falloffAmount = __tsover_sub(1, __tsover_mul(clamp(strokeFalloff, 0, 1), l));
 	const width = __tsover_mul(baseWidth, falloffAmount);
-	const fw = std.fwidth(offset);
-	const fwMult = __tsover_sub(4, __tsover_mul(__tsover_mul(std.smoothstep(.05, .4, __tsover_mul(strokeWidth, 2)), std.smoothstep(.05, .4, __tsover_mul(__tsover_sub(1, strokeWidth), 2))), 3));
-	const pixelSize = std.mix(__tsover_mul(fwMult, fw), std.fwidth(shape), std.clamp(fw, 0, 1));
-	return std.smoothstep(__tsover_sub(__tsover_sub(width, pixelSize), softness), __tsover_add(__tsover_add(width, pixelSize), softness), shape);
+	const fw = fwidth(offset);
+	const fwMult = __tsover_sub(4, __tsover_mul(__tsover_mul(smoothstep(.05, .4, __tsover_mul(strokeWidth, 2)), smoothstep(.05, .4, __tsover_mul(__tsover_sub(1, strokeWidth), 2))), 3));
+	const pixelSize = mix(__tsover_mul(fwMult, fw), fwidth(shape), clamp(fw, 0, 1));
+	return smoothstep(__tsover_sub(__tsover_sub(width, pixelSize), softness), __tsover_add(__tsover_add(width, pixelSize), softness), shape);
 }), {
 	v: 1,
 	name: void 0,
@@ -623,8 +623,8 @@ const spiralMask = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		TWO_PI
 	})
 }) && $.f)({}));

package/dist/core/{Star-DRxNaHHo.js → Star-DL3d_HqY.js}

@@ -1,16 +1,17 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, L as starSdf, 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 starShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	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 { _ as starSdf, g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, 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 starShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, sides, innerRatio, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Stone-CUdcvOWd.js → Stone-OTsCM-rr.js}

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

package/dist/core/{Strands-CFxYJMFu.js → Strands-DjoQgGnd.js}

@@ -1,13 +1,13 @@
-import { Ct as MAX_COLOR_STOPS, Ht as call, J as std, Jt as vec4, Sn as sRGBToP3, Tn as d, Tt as gradientStopsInSpace, bn as oklchToOklab, dn as hslToRgb, fn as hsvToRgb, mn as lchToLab, n as tgpu, pn as labToRgb, wt as colorStops_exports, yn as oklabToRgb } from "./coords-BkIjixe_.js";
-import { c as transformPosition, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, At as pow, B as labToRgb, Et as max, It as sin, J as oklchToOklab, Lt as smoothstep, Pt as round, R as hslToRgb, Tt as length, Ut as arrayOf, V as lchToLab, Vt as data_exports, X as sRGBToP3, _t as clamp, an as f32, bt as dot, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, q as oklabToRgb, wt as fract, y as vec4, z as hsvToRgb } from "./edges-BXNBKxSN.js";
+import { b as colorStops_exports, h as colorStopsPropConfig, t as animatedTime, x as gradientStopsInSpace, y as MAX_COLOR_STOPS } from "./porters-DBK1Aipq.js";
+import { c as transformPosition, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var TAU = Math.PI * 2;
 var PI = Math.PI;
 var MAX = 8;
 var STRAND_MAX = 16;
-var strandsTonePow = tgpu.fn([d.vec3f], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+var strandsTonePow = src_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
 	"use gpu";
-	return std.pow(rgb, d.vec3f(.85, .85, .85));
+	return pow(rgb, vec3f(.85, .85, .85));
 }), {
 	v: 1,
 	name: void 0,
@@ -40,22 +40,22 @@ var strandsTonePow = tgpu.fn([d.vec3f], d.vec3f)(/* @__PURE__ */ (($) => (global
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const strandsField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.arrayOf(d.vec4f, MAX),
-	d.arrayOf(d.vec4f, MAX / 4),
-	d.arrayOf(d.vec3f, MAX)
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, start, end, packed1, packed2, packed3, colors, positions, converted) => {
+const strandsField = src_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f,
+	arrayOf(vec4f, MAX),
+	arrayOf(vec4f, MAX / 4),
+	arrayOf(vec3f, MAX)
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, start, end, packed1, packed2, packed3, colors, positions, converted) => {
 	"use gpu";
 	const amplitude = packed1.x;
 	const frequency = packed1.y;
@@ -69,51 +69,49 @@ const strandsField = tgpu.fn([
 	const waveT = packed3.y;
 	const colorT = packed3.z;
 	const stopCount = packed3.w;
-	const aspectRatio = __tsover_div(viewport.x, std.max(viewport.y, 1e-6));
-	const startPos = d.vec2f(__tsover_mul(start.x, aspectRatio), __tsover_sub(1, start.y));
-	const endPos = d.vec2f(__tsover_mul(end.x, aspectRatio), __tsover_sub(1, end.y));
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspectRatio), uv.y);
-	const direction = d.vec2f(__tsover_sub(endPos.x, startPos.x), __tsover_sub(endPos.y, startPos.y));
-	const len = std.max(std.length(direction), 1e-6);
-	const normalizedDir = d.vec2f(__tsover_div(direction.x, len), __tsover_div(direction.y, len));
-	const perpDir = d.vec2f(-normalizedDir.y, normalizedDir.x);
-	const relativePos = d.vec2f(__tsover_sub(aspectUV.x, startPos.x), __tsover_sub(aspectUV.y, startPos.y));
-	const progress = __tsover_div(std.dot(relativePos, normalizedDir), len);
-	const perpDist = std.dot(relativePos, perpDir);
-	const clampedProg = std.clamp(progress, 0, 1);
-	const pinch = std.select(d.f32(1), std.sin(__tsover_mul(clampedProg, PI)), pinOn);
-	const fade = __tsover_mul(std.smoothstep(0, .06, progress), __tsover_sub(1, std.smoothstep(.94, 1, progress)));
-	const edgeFade = std.select(d.f32(1), fade, pinOn);
+	const aspectRatio = __tsover_div(viewport.x, max(viewport.y, 1e-6));
+	const startPos = vec2f(__tsover_mul(start.x, aspectRatio), __tsover_sub(1, start.y));
+	const endPos = vec2f(__tsover_mul(end.x, aspectRatio), __tsover_sub(1, end.y));
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspectRatio), uv.y);
+	const direction = vec2f(__tsover_sub(endPos.x, startPos.x), __tsover_sub(endPos.y, startPos.y));
+	const len = max(length(direction), 1e-6);
+	const normalizedDir = vec2f(__tsover_div(direction.x, len), __tsover_div(direction.y, len));
+	const perpDir = vec2f(-normalizedDir.y, normalizedDir.x);
+	const relativePos = vec2f(__tsover_sub(aspectUV.x, startPos.x), __tsover_sub(aspectUV.y, startPos.y));
+	const progress = __tsover_div(dot(relativePos, normalizedDir), len);
+	const perpDist = dot(relativePos, perpDir);
+	const clampedProg = clamp(progress, 0, 1);
+	const pinch = select(f32(1), sin(__tsover_mul(clampedProg, PI)), pinOn);
+	const fade = __tsover_mul(smoothstep(0, .06, progress), __tsover_sub(1, smoothstep(.94, 1, progress)));
+	const edgeFade = select(f32(1), fade, pinOn);
 	const thickness = __tsover_mul(lineWidth, .07);
 	const softness = __tsover_add(__tsover_mul(softnessP, .08), 8e-4);
-	const denom = std.max(__tsover_sub(lineCount, 1), 1);
-	let accumColor = d.vec3f(0, 0, 0);
-	let accumWeight = d.f32(0);
+	const denom = max(__tsover_sub(lineCount, 1), 1);
+	let accumColor = vec3f(0, 0, 0);
+	let accumWeight = f32(0);
 	const waveBase = __tsover_mul(__tsover_mul(progress, TAU), frequency);
 	const shimmerBase = __tsover_add(__tsover_mul(progress, 8), __tsover_mul(waveT, 2));
 	const colorBase = __tsover_add(__tsover_mul(progress, colorScale), colorT);
-	const n = d.i32(std.round(lineCount));
+	const n = i32(round(lineCount));
 	for (let idx = 0; idx < n; idx++) {
-		const fi = d.f32(idx);
+		const fi = f32(idx);
 		const norm = __tsover_div(fi, denom);
 		const phase = __tsover_mul(fi, .9);
 		const strandT = __tsover_mul(waveT, __tsover_add(__tsover_mul(norm, .6), .7));
-		const wave = __tsover_add(std.sin(__tsover_add(__tsover_add(waveBase, strandT), phase)), __tsover_mul(std.sin(__tsover_add(__tsover_sub(__tsover_mul(waveBase, 2.1), __tsover_mul(strandT, .7)), phase)), .5));
+		const wave = __tsover_add(sin(__tsover_add(__tsover_add(waveBase, strandT), phase)), __tsover_mul(sin(__tsover_add(__tsover_sub(__tsover_mul(waveBase, 2.1), __tsover_mul(strandT, .7)), phase)), .5));
 		const displacement = __tsover_mul(__tsover_mul(wave, amplitude), .06);
 		const baseline = __tsover_mul(__tsover_sub(norm, .5), spread);
 		const centre = __tsover_mul(__tsover_add(baseline, displacement), pinch);
-		const dd = std.abs(__tsover_sub(perpDist, centre));
-		const line = __tsover_sub(1, std.smoothstep(thickness, __tsover_add(thickness, softness), dd));
-		const shimmer = __tsover_add(__tsover_mul(std.sin(__tsover_add(shimmerBase, fi)), .15), .85);
+		const dd = abs(__tsover_sub(perpDist, centre));
+		const line = __tsover_sub(1, smoothstep(thickness, __tsover_add(thickness, softness), dd));
+		const shimmer = __tsover_add(__tsover_mul(sin(__tsover_add(shimmerBase, fi)), .15), .85);
 		const cc = __tsover_add(colorBase, __tsover_mul(norm, colorVariance));
-		const strandColor = gradientStopsInSpace(__tsover_sub(1, std.abs(__tsover_sub(__tsover_mul(std.fract(__tsover_mul(cc, .5)), 2), 1))), colors, positions, converted, stopCount).conv;
+		const strandColor = gradientStopsInSpace(__tsover_sub(1, abs(__tsover_sub(__tsover_mul(fract(__tsover_mul(cc, .5)), 2), 1))), colors, positions, converted, stopCount).conv;
 		const weight = __tsover_mul(line, shimmer);
 		accumColor = accumColor.add(strandColor.mul(weight));
 		accumWeight = __tsover_add(accumWeight, weight);
 	}
-	const workingColor = accumColor.div(std.max(accumWeight, 1e-4));
-	const alpha = std.clamp(__tsover_mul(accumWeight, edgeFade), 0, 1);
-	return d.vec4f(workingColor, alpha);
+	return vec4f(accumColor.div(max(accumWeight, 1e-4)), clamp(__tsover_mul(accumWeight, edgeFade), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1279,8 +1277,8 @@ const strandsField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		PI,
 		TAU,
 		kitColorStops: colorStops_exports

package/dist/core/{Stretch-DYrVdt8A.js → Stretch-CdzhxnbM.js}

@@ -1,31 +1,31 @@
-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";
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, _t as clamp, an as f32, bt as dot, 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";
 var DEG_TO_RAD = Math.PI / 180;
-const stretchUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, strength, angle, falloff, uv, aspect) => {
+const stretchUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, strength, angle, falloff, uv, aspect) => {
 	"use gpu";
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const centerPos = d.vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const aspectCorrectedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
 	const delta = aspectCorrectedUV.sub(centerPos);
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const directionVector = d.vec2f(std.cos(angleRad), std.sin(angleRad));
-	const projection = std.dot(delta, directionVector);
+	const directionVector = vec2f(cos(angleRad), sin(angleRad));
+	const projection = dot(delta, directionVector);
 	const parallel = directionVector.mul(projection);
 	const perpendicular = delta.sub(parallel);
-	const transitionWidth = std.mix(.001, 75, falloff);
-	const effectMask = std.clamp(__tsover_div(projection, transitionWidth), 0, 1);
+	const transitionWidth = mix(.001, 75, falloff);
+	const effectMask = clamp(__tsover_div(projection, transitionWidth), 0, 1);
 	const scaledStrength = __tsover_mul(strength, 100);
 	const stretchFactor = __tsover_add(1, __tsover_mul(scaledStrength, effectMask));
 	const finalProjection = __tsover_div(projection, stretchFactor);
 	const stretchedDelta = directionVector.mul(finalProjection).add(perpendicular);
 	const stretchedUV = centerPos.add(stretchedDelta);
-	return d.vec2f(__tsover_div(stretchedUV.x, aspect), stretchedUV.y);
+	return vec2f(__tsover_div(stretchedUV.x, aspect), stretchedUV.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -348,9 +348,9 @@ const stretchUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Stripes-BvnoWdwn.js → Stripes-CsBgKYdp.js}

@@ -1,22 +1,22 @@
-import { Ht as call, J as std, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Ct as floor, Et as max, H as mixColorsLinear, It as sin, U as mixColorsVariants, _t as clamp, an as f32, et as src_default, mt as abs, nt as std_exports, ot as dpdx, p as call, st as dpdy, 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, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .0174533;
-const stripeCoordP = 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, angle, density, animTime, offset) => {
+const stripeCoordP = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, density, animTime, offset) => {
 	"use gpu";
-	const aspect = __tsover_div(viewport.x, std.max(viewport.y, 1e-6));
+	const aspect = __tsover_div(viewport.x, max(viewport.y, 1e-6));
 	const acx = __tsover_mul(uv.x, aspect);
 	const acy = uv.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 rotatedCoord = __tsover_add(__tsover_mul(acx, cosA), __tsover_mul(acy, sinA));
 	return __tsover_add(__tsover_add(__tsover_mul(rotatedCoord, density), animTime), offset);
 }), {
@@ -175,22 +175,22 @@ const stripeCoordP = tgpu.fn([
 		"externalNames": ["std", "DEG_TO_RAD"]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD
 	})
 }) && $.f)({}));
-const stripeMaskValue = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, balance) => {
+const stripeMaskValue = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, balance) => {
 	"use gpu";
 	const a = __tsover_add(p, __tsover_mul(w, .5));
 	const b = __tsover_sub(p, __tsover_mul(w, .5));
 	const oneMinusBalance = __tsover_sub(1, balance);
-	const Fa = __tsover_add(__tsover_mul(std.floor(a), oneMinusBalance), std.max(__tsover_sub(std.fract(a), balance), 0));
-	const Fb = __tsover_add(__tsover_mul(std.floor(b), oneMinusBalance), std.max(__tsover_sub(std.fract(b), balance), 0));
-	return std.clamp(__tsover_div(__tsover_sub(Fa, Fb), w), 0, 1);
+	const Fa = __tsover_add(__tsover_mul(floor(a), oneMinusBalance), max(__tsover_sub(fract(a), balance), 0));
+	const Fb = __tsover_add(__tsover_mul(floor(b), oneMinusBalance), max(__tsover_sub(fract(b), balance), 0));
+	return clamp(__tsover_div(__tsover_sub(Fa, Fb), w), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -364,24 +364,24 @@ const stripeMaskValue = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const stripesMask = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	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, angle, density, animTime, offset, balance, softness) => {
+const stripesMask = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, density, animTime, offset, balance, softness) => {
 	"use gpu";
 	const p = stripeCoordP(uv, viewport, angle, density, animTime, offset);
-	const dpx = std.dpdx(p);
-	const dpy = std.dpdy(p);
-	const baseW = std.max(std.abs(dpx), std.abs(dpy));
-	return stripeMaskValue(p, std.max(__tsover_add(baseW, softness), 1e-5), balance);
+	const dpx = dpdx(p);
+	const dpy = dpdy(p);
+	const baseW = max(abs(dpx), abs(dpy));
+	return stripeMaskValue(p, max(__tsover_add(baseW, softness), 1e-5), balance);
 }), {
 	v: 1,
 	name: void 0,
@@ -528,7 +528,7 @@ const stripesMask = tgpu.fn([
 	},
 	externals: () => ({
 		stripeCoordP,
-		std,
+		std: std_exports,
 		stripeMaskValue
 	})
 }) && $.f)({}));