shaders 3.0.447 → 3.0.449

package/dist/core/{Crystal-U7VqhbHy.js → Crystal-CEeqF1Xa.js}

@@ -1,7 +1,9 @@
-import { Bt as ZERO, F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, ft as mxWorleyNoiseFloat2Pub, n as tgpu, pt as noise_exports, sn as blend_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, i as transformBoolean } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, It as sin, Lt as smoothstep, M as blend_exports, Mt as reflect, Nt as refract, Ot as mix, Rt as sqrt, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, gt as atan2, in as vec4f, kt as normalize, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { f as mxWorleyNoiseFloat2Pub, 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, i as transformBoolean } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { unpremultiplyAlpha } = blend_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
@@ -14,19 +16,19 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	radius: .35,
 	sides: 10
 });
-const crystalKaleidoFold = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvX, uvY, sectorAngle) => {
+const crystalKaleidoFold = src_default.fn([
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvX, uvY, sectorAngle) => {
 	"use gpu";
 	const dx = __tsover_sub(uvX, .5);
 	const dy = __tsover_sub(uvY, .5);
-	const r = std.sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
-	const theta = __tsover_add(std.atan2(dy, dx), PI);
-	const inSector = __tsover_mul(std.fract(__tsover_div(theta, sectorAngle)), sectorAngle);
-	const folded = std.min(inSector, __tsover_sub(sectorAngle, inSector));
-	return d.vec2f(__tsover_mul(r, std.cos(folded)), __tsover_mul(r, std.sin(folded)));
+	const r = sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)));
+	const theta = __tsover_add(atan2(dy, dx), PI);
+	const inSector = __tsover_mul(fract(__tsover_div(theta, sectorAngle)), sectorAngle);
+	const folded = min(inSector, __tsover_sub(sectorAngle, inSector));
+	return vec2f(__tsover_mul(r, cos(folded)), __tsover_mul(r, sin(folded)));
 }), {
 	v: 1,
 	name: void 0,
@@ -196,34 +198,34 @@ const crystalKaleidoFold = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		PI,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const CrystalTrace = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	rUV: d.vec2f,
-	lensUV: d.vec2f,
-	bUV: d.vec2f,
-	innerUV: d.vec2f,
-	outerUV: d.vec2f,
-	factors: d.vec4f,
-	transition: d.f32,
-	fresnelContrib: d.vec3f
+const CrystalTrace = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	rUV: vec2f,
+	lensUV: vec2f,
+	bUV: vec2f,
+	innerUV: vec2f,
+	outerUV: vec2f,
+	factors: vec4f,
+	transition: f32,
+	fresnelContrib: vec3f
 }), "CrystalTrace");
-const crystalTrace = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
+const crystalTrace = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
 ], CrystalTrace)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, center, fresnelColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const scale = p0.x;
@@ -240,7 +242,7 @@ const crystalTrace = tgpu.fn([
 	const fresnelSoftness = p2.w;
 	const volumetric = p3.x;
 	const aspect = __tsover_div(viewportSize.x, viewportSize.y);
-	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sharp = max(__tsover_mul(edgeSoftness, .5), .001);
 	const pxH = __tsover_div(1, viewportSize.y);
 	const centerPosX = center.x;
 	const centerPosY = __tsover_sub(1, center.y);
@@ -249,136 +251,129 @@ const crystalTrace = tgpu.fn([
 	const EPS = .01;
 	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const rb1 = clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
 	const lightRad = __tsover_mul(lightAngle, DEG_TO_RAD);
-	const lx = __tsover_add(std.cos(lightRad), __tsover_mul(__tsover_sub(centerPosX, .5), 3));
-	const ly = __tsover_add(std.sin(lightRad), __tsover_mul(__tsover_sub(centerPosY, .5), 3));
-	const L = std.normalize(d.vec3f(lx, ly, -.75));
-	const Vv = d.vec3f(0, 0, -1);
-	const H = std.normalize(L.add(Vv));
-	const L2 = std.normalize(d.vec3f(__tsover_mul(ly, -1), lx, -.4));
-	const H2 = std.normalize(L2.add(Vv));
-	const depthNorm = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .15), 0, 1);
-	const outerWarp = __tsover_mul(__tsover_sub(1, std.smoothstep(0, .03, sdf)), .4);
+	const lx = __tsover_add(cos(lightRad), __tsover_mul(__tsover_sub(centerPosX, .5), 3));
+	const ly = __tsover_add(sin(lightRad), __tsover_mul(__tsover_sub(centerPosY, .5), 3));
+	const L = normalize(vec3f(lx, ly, -.75));
+	const Vv = vec3f(0, 0, -1);
+	const H = normalize(L.add(Vv));
+	const L2 = normalize(vec3f(__tsover_mul(ly, -1), lx, -.4));
+	const H2 = normalize(L2.add(Vv));
+	const depthNorm = clamp(__tsover_div(__tsover_mul(sdf, -1), .15), 0, 1);
+	const outerWarp = __tsover_mul(__tsover_sub(1, smoothstep(0, .03, sdf)), .4);
 	const refrScale = __tsover_mul(refraction, .15);
 	const haloOffX = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(gradX, -1), refrScale), outerWarp), aspect);
 	const haloOffY = __tsover_mul(__tsover_mul(__tsover_mul(gradY, -1), refrScale), outerWarp);
-	const pdx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const pdy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const pdx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const pdy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
 	const sAngle = __tsover_div(TWO_PI, facets);
 	const fUv = crystalKaleidoFold(__tsover_add(pdx, .5), __tsover_add(pdy, .5), sAngle);
-	const crystalRNorm = __tsover_div(std.sqrt(__tsover_add(__tsover_mul(pdx, pdx), __tsover_mul(pdy, pdy))), .35);
-	const tableMask = __tsover_sub(1, std.smoothstep(.22, .32, crystalRNorm));
-	const radialDensity = __tsover_add(1, __tsover_mul(std.clamp(crystalRNorm, 0, 1), .6));
+	const crystalRNorm = __tsover_div(sqrt(__tsover_add(__tsover_mul(pdx, pdx), __tsover_mul(pdy, pdy))), .35);
+	const tableMask = __tsover_sub(1, smoothstep(.22, .32, crystalRNorm));
+	const radialDensity = __tsover_add(1, __tsover_mul(clamp(crystalRNorm, 0, 1), .6));
 	const tableSuppress = __tsover_sub(1, __tsover_mul(tableMask, .9));
-	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4);
-	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4);
-	const nSurfVol = std.normalize(d.vec3f(ddx, ddy, -1));
-	const bevelSlope = __tsover_mul(__tsover_mul(__tsover_sub(1, std.smoothstep(0, 1, depthNorm)), 1.7), __tsover_sub(1, tableMask));
-	const nSurfFlat = std.normalize(d.vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1));
-	const nSurf = std.select(nSurfFlat, nSurfVol, volumetric > .5);
-	const cosView = std.clamp(__tsover_mul(nSurf.z, -1), 0, 1);
+	const nSurfVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4), -1));
+	const bevelSlope = __tsover_mul(__tsover_mul(__tsover_sub(1, smoothstep(0, 1, depthNorm)), 1.7), __tsover_sub(1, tableMask));
+	const nSurf = select(normalize(vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1)), nSurfVol, volumetric > .5);
+	const cosView = clamp(__tsover_mul(nSurf.z, -1), 0, 1);
 	const grazing = __tsover_sub(1, cosView);
 	const vScale1 = __tsover_mul(__tsover_mul(facets, 1.2), radialDensity);
 	const fUvS1 = fUv.mul(vScale1);
 	const feps = .02;
 	const f1center = mxWorleyNoiseFloat2Pub(fUvS1, 1);
-	const gx1 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS1.add(d.vec2f(feps, 0)), 1), f1center), feps);
-	const gy1 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS1.add(d.vec2f(0, feps)), 1), f1center), feps);
-	const gLen1 = std.max(std.sqrt(__tsover_add(__tsover_mul(gx1, gx1), __tsover_mul(gy1, gy1))), .001);
+	const gx1 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS1.add(vec2f(feps, 0)), 1), f1center), feps);
+	const gy1 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS1.add(vec2f(0, feps)), 1), f1center), feps);
+	const gLen1 = max(sqrt(__tsover_add(__tsover_mul(gx1, gx1), __tsover_mul(gy1, gy1))), .001);
 	const nx1 = __tsover_div(gx1, gLen1);
 	const ny1 = __tsover_div(gy1, gLen1);
-	const cellId1 = std.floor(fUvS1);
-	const cellRand = std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(cellId1.x, 12.9898), __tsover_mul(cellId1.y, 78.233))), 43758.5453));
-	const nF1 = std.normalize(nSurf.add(d.vec3f(__tsover_mul(nx1, .55), __tsover_mul(ny1, .55), 0)));
-	const ndlS = std.dot(nSurf, L);
-	const ndl1 = __tsover_mul(__tsover_sub(std.dot(nF1, L), ndlS), 2.2);
-	const fUvS2 = fUv.mul(__tsover_mul(vScale1, 1.7)).add(d.vec2f(3.7, 1.2));
+	const cellId1 = floor(fUvS1);
+	const cellRand = fract(__tsover_mul(sin(__tsover_add(__tsover_mul(cellId1.x, 12.9898), __tsover_mul(cellId1.y, 78.233))), 43758.5453));
+	const nF1 = normalize(nSurf.add(vec3f(__tsover_mul(nx1, .55), __tsover_mul(ny1, .55), 0)));
+	const ndlS = dot(nSurf, L);
+	const ndl1 = __tsover_mul(__tsover_sub(dot(nF1, L), ndlS), 2.2);
+	const fUvS2 = fUv.mul(__tsover_mul(vScale1, 1.7)).add(vec2f(3.7, 1.2));
 	const c2 = mxWorleyNoiseFloat2Pub(fUvS2, 1);
-	const gx2 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS2.add(d.vec2f(feps, 0)), 1), c2), feps);
-	const gy2 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS2.add(d.vec2f(0, feps)), 1), c2), feps);
-	const gLen2 = std.max(std.sqrt(__tsover_add(__tsover_mul(gx2, gx2), __tsover_mul(gy2, gy2))), .001);
+	const gx2 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS2.add(vec2f(feps, 0)), 1), c2), feps);
+	const gy2 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS2.add(vec2f(0, feps)), 1), c2), feps);
+	const gLen2 = max(sqrt(__tsover_add(__tsover_mul(gx2, gx2), __tsover_mul(gy2, gy2))), .001);
 	const nx2 = __tsover_div(gx2, gLen2);
 	const ny2 = __tsover_div(gy2, gLen2);
-	const nF2 = std.normalize(nSurf.add(d.vec3f(__tsover_mul(nx2, .4), __tsover_mul(ny2, .4), 0)));
-	const ndl2 = __tsover_mul(__tsover_sub(std.dot(nF2, L2), std.dot(nSurf, L2)), 2.2);
-	const I = d.vec3f(0, 0, 1);
-	const facetRefrAmp = std.clamp(__tsover_mul(refraction, .8), 0, 1.6);
-	const nRefr = std.normalize(nSurf.add(d.vec3f(__tsover_mul(__tsover_mul(__tsover_mul(nx1, .75), facetRefrAmp), tableSuppress), __tsover_mul(__tsover_mul(__tsover_mul(ny1, .75), facetRefrAmp), tableSuppress), 0)).add(d.vec3f(__tsover_mul(__tsover_mul(nx2, .55), facetRefrAmp), __tsover_mul(__tsover_mul(ny2, .55), facetRefrAmp), 0)));
-	const eta = __tsover_div(1, __tsover_add(1, __tsover_mul(refraction, .55)));
-	const refr = std.refract(I, nRefr, eta);
-	const thickVol = std.clamp(__tsover_mul(sdfRaw, -1), 0, .6);
-	const thickFlat = __tsover_mul(std.clamp(__tsover_mul(sdfRaw, -1), 0, .12), 1.6);
-	const thickEff = std.select(thickFlat, thickVol, volumetric > .5);
+	const nF2 = normalize(nSurf.add(vec3f(__tsover_mul(nx2, .4), __tsover_mul(ny2, .4), 0)));
+	const ndl2 = __tsover_mul(__tsover_sub(dot(nF2, L2), dot(nSurf, L2)), 2.2);
+	const I = vec3f(0, 0, 1);
+	const facetRefrAmp = clamp(__tsover_mul(refraction, .8), 0, 1.6);
+	const refr = refract(I, normalize(nSurf.add(vec3f(__tsover_mul(__tsover_mul(__tsover_mul(nx1, .75), facetRefrAmp), tableSuppress), __tsover_mul(__tsover_mul(__tsover_mul(ny1, .75), facetRefrAmp), tableSuppress), 0)).add(vec3f(__tsover_mul(__tsover_mul(nx2, .55), facetRefrAmp), __tsover_mul(__tsover_mul(ny2, .55), facetRefrAmp), 0))), __tsover_div(1, __tsover_add(1, __tsover_mul(refraction, .55))));
+	const thickVol = clamp(__tsover_mul(sdfRaw, -1), 0, .6);
+	const thickEff = select(__tsover_mul(clamp(__tsover_mul(sdfRaw, -1), 0, .12), 1.6), thickVol, volumetric > .5);
 	const thickFacet = __tsover_mul(thickEff, __tsover_add(.55, __tsover_mul(cellRand, .9)));
 	const offMag = __tsover_mul(__tsover_mul(thickFacet, scale), rb1);
-	const totalOffX = __tsover_add(__tsover_div(__tsover_mul(__tsover_div(refr.x, std.max(refr.z, .25)), offMag), aspect), haloOffX);
-	const totalOffY = __tsover_add(__tsover_mul(__tsover_div(refr.y, std.max(refr.z, .25)), offMag), haloOffY);
-	const nBack = std.normalize(d.vec3f(__tsover_mul(nx2, .7), __tsover_mul(ny2, .7), -1));
-	const bounce = std.reflect(refr, nBack);
+	const totalOffX = __tsover_add(__tsover_div(__tsover_mul(__tsover_div(refr.x, max(refr.z, .25)), offMag), aspect), haloOffX);
+	const totalOffY = __tsover_add(__tsover_mul(__tsover_div(refr.y, max(refr.z, .25)), offMag), haloOffY);
+	const bounce = reflect(refr, normalize(vec3f(__tsover_mul(nx2, .7), __tsover_mul(ny2, .7), -1)));
 	const bounceMag = __tsover_mul(__tsover_mul(__tsover_mul(thickEff, scale), rb1), .8);
-	const bounceOffX = __tsover_div(__tsover_mul(__tsover_div(bounce.x, std.max(std.abs(bounce.z), .3)), bounceMag), aspect);
-	const bounceOffY = __tsover_mul(__tsover_div(bounce.y, std.max(std.abs(bounce.z), .3)), bounceMag);
+	const bounceOffX = __tsover_div(__tsover_mul(__tsover_div(bounce.x, max(abs(bounce.z), .3)), bounceMag), aspect);
+	const bounceOffY = __tsover_mul(__tsover_div(bounce.y, max(abs(bounce.z), .3)), bounceMag);
 	const innerW = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(grazing, .5), .18), __tsover_add(__tsover_mul(cellRand, .7), .3)), rb1);
-	const pbx = __tsover_add(pdx, __tsover_mul(__tsover_mul(__tsover_div(refr.x, std.max(refr.z, .25)), thickEff), 1.2));
-	const pby = __tsover_add(pdy, __tsover_mul(__tsover_mul(__tsover_div(refr.y, std.max(refr.z, .25)), thickEff), 1.2));
-	const fUvS3 = crystalKaleidoFold(__tsover_add(pbx, .5), __tsover_add(pby, .5), sAngle).mul(__tsover_mul(vScale1, 1.4)).add(d.vec2f(9.1, 4.7));
+	const pbx = __tsover_add(pdx, __tsover_mul(__tsover_mul(__tsover_div(refr.x, max(refr.z, .25)), thickEff), 1.2));
+	const pby = __tsover_add(pdy, __tsover_mul(__tsover_mul(__tsover_div(refr.y, max(refr.z, .25)), thickEff), 1.2));
+	const fUvS3 = crystalKaleidoFold(__tsover_add(pbx, .5), __tsover_add(pby, .5), sAngle).mul(__tsover_mul(vScale1, 1.4)).add(vec2f(9.1, 4.7));
 	const c3 = mxWorleyNoiseFloat2Pub(fUvS3, 1);
-	const gx3 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS3.add(d.vec2f(feps, 0)), 1), c3), feps);
-	const gy3 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS3.add(d.vec2f(0, feps)), 1), c3), feps);
-	const gLen3 = std.max(std.sqrt(__tsover_add(__tsover_mul(gx3, gx3), __tsover_mul(gy3, gy3))), .001);
+	const gx3 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS3.add(vec2f(feps, 0)), 1), c3), feps);
+	const gy3 = __tsover_div(__tsover_sub(mxWorleyNoiseFloat2Pub(fUvS3.add(vec2f(0, feps)), 1), c3), feps);
+	const gLen3 = max(sqrt(__tsover_add(__tsover_mul(gx3, gx3), __tsover_mul(gy3, gy3))), .001);
 	const nx3 = __tsover_div(gx3, gLen3);
 	const ny3 = __tsover_div(gy3, gLen3);
-	const cellId3 = std.floor(fUvS3);
-	const cellRand3 = std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(cellId3.x, 31.727), __tsover_mul(cellId3.y, 57.131))), 43758.5453));
-	const w3 = __tsover_mul(__tsover_mul(std.clamp(__tsover_mul(thickEff, 2.5), 0, 1), std.clamp(__tsover_mul(refraction, 1.2), 0, 1)), rb1);
+	const cellId3 = floor(fUvS3);
+	const cellRand3 = fract(__tsover_mul(sin(__tsover_add(__tsover_mul(cellId3.x, 31.727), __tsover_mul(cellId3.y, 57.131))), 43758.5453));
+	const w3 = __tsover_mul(__tsover_mul(clamp(__tsover_mul(thickEff, 2.5), 0, 1), clamp(__tsover_mul(refraction, 1.2), 0, 1)), rb1);
 	const wedgeLit = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(nx3, lx), __tsover_mul(ny3, ly)), .5), .5);
 	const mosaicLevel = __tsover_mul(__tsover_add(__tsover_mul(cellRand3, .9), .55), __tsover_add(__tsover_mul(wedgeLit, .7), .65));
-	const edge3 = __tsover_add(__tsover_mul(std.smoothstep(.15, .7, gLen3), .45), .55);
+	const edge3 = __tsover_add(__tsover_mul(smoothstep(.15, .7, gLen3), .45), .55);
 	const mosaicMul = __tsover_mul(mosaicLevel, edge3);
-	const mosaicFire = __tsover_mul(__tsover_mul(std.smoothstep(.75, 1, __tsover_mul(wedgeLit, __tsover_add(cellRand3, .4))), w3), .8);
+	const mosaicFire = __tsover_mul(__tsover_mul(smoothstep(.75, 1, __tsover_mul(wedgeLit, __tsover_add(cellRand3, .4))), w3), .8);
 	const zoomedX = __tsover_add(centerPosX, __tsover_div(__tsover_sub(uv.x, centerPosX), innerZoom));
 	const zoomedY = __tsover_add(centerPosY, __tsover_div(__tsover_sub(uv.y, centerPosY), innerZoom));
 	const lensX = __tsover_add(zoomedX, totalOffX);
 	const lensY = __tsover_add(zoomedY, totalOffY);
-	const lit1 = std.clamp(ndl1, 0, 1);
-	const shadow1 = std.clamp(__tsover_mul(ndl1, -1), 0, 1);
-	const bright1 = std.max(__tsover_sub(__tsover_add(1, __tsover_mul(lit1, highlights)), __tsover_mul(shadow1, shadows)), .02);
-	const lit2 = std.clamp(ndl2, 0, 1);
-	const shadow2 = std.clamp(__tsover_mul(ndl2, -1), 0, 1);
+	const lit1 = clamp(ndl1, 0, 1);
+	const shadow1 = clamp(__tsover_mul(ndl1, -1), 0, 1);
+	const bright1 = max(__tsover_sub(__tsover_add(1, __tsover_mul(lit1, highlights)), __tsover_mul(shadow1, shadows)), .02);
+	const lit2 = clamp(ndl2, 0, 1);
+	const shadow2 = clamp(__tsover_mul(ndl2, -1), 0, 1);
 	const bright2 = __tsover_sub(__tsover_add(1, __tsover_mul(lit2, __tsover_mul(highlights, .5))), __tsover_mul(shadow2, __tsover_mul(shadows, .5)));
-	const surfBright = __tsover_sub(__tsover_add(1, __tsover_mul(__tsover_mul(std.clamp(ndlS, 0, 1), highlights), .4)), __tsover_mul(__tsover_mul(std.clamp(__tsover_mul(ndlS, -1), 0, 1), shadows), .6));
+	const surfBright = __tsover_sub(__tsover_add(1, __tsover_mul(__tsover_mul(clamp(ndlS, 0, 1), highlights), .4)), __tsover_mul(__tsover_mul(clamp(__tsover_mul(ndlS, -1), 0, 1), shadows), .6));
 	const combinedBright = __tsover_mul(__tsover_mul(bright1, bright2), surfBright);
 	const chrScale = __tsover_mul(dispersion, .12);
 	const chrOffX = __tsover_mul(totalOffX, chrScale);
 	const chrOffY = __tsover_mul(totalOffY, chrScale);
-	const baseEdge = std.smoothstep(.2, .8, gLen1);
-	const edgeDarken = __tsover_add(__tsover_mul(std.mix(baseEdge, 1, tableMask), .4), .6);
+	const baseEdge = smoothstep(.2, .8, gLen1);
+	const edgeDarken = __tsover_add(__tsover_mul(mix(baseEdge, 1, tableMask), .4), .6);
 	const tableBoost = __tsover_mul(tableMask, .25);
-	const facetMul = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(combinedBright, tableBoost), edgeDarken), std.mix(d.f32(1), mosaicMul, w3)), brightness);
-	const ndh1 = std.clamp(std.dot(nF1, H), 0, 1);
-	const ndh2 = std.clamp(std.dot(nF2, H2), 0, 1);
-	const spec1 = __tsover_mul(std.pow(ndh1, d.f32(110)), 2.2);
-	const spec2 = __tsover_mul(std.pow(ndh2, d.f32(56)), .9);
-	const glint = __tsover_mul(std.smoothstep(.965, .995, ndh1), 3);
+	const facetMul = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(combinedBright, tableBoost), edgeDarken), mix(f32(1), mosaicMul, w3)), brightness);
+	const ndh1 = clamp(dot(nF1, H), 0, 1);
+	const ndh2 = clamp(dot(nF2, H2), 0, 1);
+	const spec1 = __tsover_mul(pow(ndh1, f32(110)), 2.2);
+	const spec2 = __tsover_mul(pow(ndh2, f32(56)), .9);
+	const glint = __tsover_mul(smoothstep(.965, .995, ndh1), 3);
 	const flashContrib = __tsover_mul(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(spec1, spec2), glint), mosaicFire), highlights), brightness);
-	const fresnelExp = std.mix(6, 1.5, std.clamp(__tsover_mul(fresnelSoftness, .5), 0, 1));
-	const fresnelRim = __tsover_mul(__tsover_mul(__tsover_mul(std.pow(grazing, fresnelExp), fresnel), 2), rb1);
+	const fresnelExp = mix(6, 1.5, clamp(__tsover_mul(fresnelSoftness, .5), 0, 1));
+	const fresnelRim = __tsover_mul(__tsover_mul(__tsover_mul(pow(grazing, fresnelExp), fresnel), 2), rb1);
 	const fresnelContrib = fresnelColor.mul(fresnelRim);
 	const normalDotLight = __tsover_add(__tsover_mul(gradX, lx), __tsover_mul(gradY, ly));
 	const lightFacing = __tsover_add(__tsover_mul(normalDotLight, .5), .5);
 	const sdfOuter = __tsover_sub(sdf, pxH);
-	const rb2base = __tsover_sub(std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdfOuter, -1), sharp), 16), 0, 1), std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 16), 0, 1));
+	const rb2base = __tsover_sub(clamp(__tsover_mul(__tsover_div(__tsover_mul(sdfOuter, -1), sharp), 16), 0, 1), clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 16), 0, 1));
 	const rb2 = __tsover_mul(__tsover_mul(rb2base, lightFacing), .35);
-	const transition = std.smoothstep(0, 1, rb1);
-	const outerUV = d.vec2f(__tsover_add(uv.x, haloOffX), __tsover_add(uv.y, haloOffY));
+	const transition = smoothstep(0, 1, rb1);
+	const outerUV = vec2f(__tsover_add(uv.x, haloOffX), __tsover_add(uv.y, haloOffY));
 	return CrystalTrace({
-		rUV: d.vec2f(__tsover_add(lensX, chrOffX), __tsover_add(lensY, chrOffY)),
-		lensUV: d.vec2f(lensX, lensY),
-		bUV: d.vec2f(__tsover_sub(lensX, chrOffX), __tsover_sub(lensY, chrOffY)),
-		innerUV: d.vec2f(__tsover_add(lensX, bounceOffX), __tsover_add(lensY, bounceOffY)),
+		rUV: vec2f(__tsover_add(lensX, chrOffX), __tsover_add(lensY, chrOffY)),
+		lensUV: vec2f(lensX, lensY),
+		bUV: vec2f(__tsover_sub(lensX, chrOffX), __tsover_sub(lensY, chrOffY)),
+		innerUV: vec2f(__tsover_add(lensX, bounceOffX), __tsover_add(lensY, bounceOffY)),
 		outerUV,
-		factors: d.vec4f(facetMul, flashContrib, innerW, rb2),
+		factors: vec4f(facetMul, flashContrib, innerW, rb2),
 		transition,
 		fresnelContrib
 	});
@@ -4103,26 +4098,26 @@ const crystalTrace = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
-		d,
+		d: data_exports,
 		TWO_PI,
 		crystalKaleidoFold,
 		noise: noise_exports,
 		CrystalTrace
 	})
 }) && $.f)({}));
-const crystalCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec3f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sampledR, sampledG, sampledB, innerSample, baseColor, fresnelContrib, tintColor, factors, misc) => {
+const crystalCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sampledR, sampledG, sampledB, innerSample, baseColor, fresnelContrib, tintColor, factors, misc) => {
 	"use gpu";
 	const facetMul = factors.x;
 	const flashContrib = factors.y;
@@ -4132,21 +4127,17 @@ const crystalCompose = tgpu.fn([
 	const tintIntensity = misc.y;
 	const preserveLum = misc.z;
 	const cutout = misc.w;
-	const primary = d.vec3f(sampledR.x, sampledG.y, sampledB.z);
-	const innerRgb = d.vec3f(innerSample.x, innerSample.y, innerSample.z);
-	const refractedRgb = std.mix(primary, innerRgb, d.vec3f(innerW));
+	const refractedRgb = mix(vec3f(sampledR.x, sampledG.y, sampledB.z), vec3f(innerSample.x, innerSample.y, innerSample.z), vec3f(innerW));
 	const refractedA = sampledG.w;
 	const litRgb = refractedRgb.mul(facetMul);
-	const lumWeights = d.vec3f(.299, .587, .114);
-	const origLum = std.dot(litRgb, lumWeights);
-	const tinted = std.mix(litRgb, tintColor, d.vec3f(tintIntensity));
-	const tintedLum = std.dot(tinted, lumWeights);
-	const lumPreserved = tinted.mul(__tsover_div(origLum, std.max(tintedLum, 1e-4)));
-	const finalRgb = std.select(tinted, lumPreserved, preserveLum > .5).add(d.vec3f(flashContrib, flashContrib, flashContrib)).add(fresnelContrib).add(d.vec3f(rb2, rb2, rb2));
-	const lighting = d.vec4f(finalRgb.x, finalRgb.y, finalRgb.z, refractedA);
-	const composited = std.mix(baseColor, lighting, d.vec4f(transition));
-	const cutoutAlpha = std.select(d.f32(1), transition, cutout > .5);
-	return d.vec4f(composited.x, composited.y, composited.z, __tsover_mul(composited.w, cutoutAlpha));
+	const lumWeights = vec3f(.299, .587, .114);
+	const origLum = dot(litRgb, lumWeights);
+	const tinted = mix(litRgb, tintColor, vec3f(tintIntensity));
+	const tintedLum = dot(tinted, lumWeights);
+	const finalRgb = select(tinted, tinted.mul(__tsover_div(origLum, max(tintedLum, 1e-4))), preserveLum > .5).add(vec3f(flashContrib, flashContrib, flashContrib)).add(fresnelContrib).add(vec3f(rb2, rb2, rb2));
+	const composited = mix(baseColor, vec4f(finalRgb.x, finalRgb.y, finalRgb.z, refractedA), vec4f(transition));
+	const cutoutAlpha = select(f32(1), transition, cutout > .5);
+	return vec4f(composited.x, composited.y, composited.z, __tsover_mul(composited.w, cutoutAlpha));
 }), {
 	v: 1,
 	name: void 0,
@@ -4660,8 +4651,8 @@ const crystalCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{CurlNoise-BXWYh1Qi.js → CurlNoise-uvTKk4Wa.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, rt as curl22z } 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 curlNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime) => {
+import { $t as vec2f, Tt as length, 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, r as curl22z } 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 curlNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime) => {
 	"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);
-	return __tsover_div(std.length(curl22z(pos, __tsover_mul(animTime, .2))), 1.414);
+	const pos = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
+	return __tsover_div(length(curl22z(pos, __tsover_mul(animTime, .2))), 1.414);
 }), {
 	v: 1,
 	name: void 0,
@@ -147,8 +149,8 @@ const curlNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));