shaders 3.0.447 → 3.0.449

package/dist/core/{Pixelate-XJI9f1oT.js → Pixelate-D7Dto_8I.js}

@@ -1,24 +1,24 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-const pixelateSample = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, gap, roundness) => {
+import { $t as vec2f, Ct as floor, Et as max, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, d as ZERO, et as src_default, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+const pixelateSample = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, gap, roundness) => {
 	"use gpu";
 	const isWide = aspect > 1;
-	const pixelCountX = std.max(std.select(__tsover_mul(scale, aspect), scale, isWide), 1);
-	const pixelCountY = std.max(std.select(scale, __tsover_div(scale, aspect), isWide), 1);
-	const sampleUV = d.vec2f(__tsover_div(std.floor(__tsover_mul(uv.x, pixelCountX)), pixelCountX), __tsover_div(std.floor(__tsover_mul(uv.y, pixelCountY)), pixelCountY));
-	const localUV = d.vec2f(__tsover_sub(std.fract(__tsover_mul(uv.x, pixelCountX)), .5), __tsover_sub(std.fract(__tsover_mul(uv.y, pixelCountY)), .5));
+	const pixelCountX = max(select(__tsover_mul(scale, aspect), scale, isWide), 1);
+	const pixelCountY = max(select(scale, __tsover_div(scale, aspect), isWide), 1);
+	const sampleUV = vec2f(__tsover_div(floor(__tsover_mul(uv.x, pixelCountX)), pixelCountX), __tsover_div(floor(__tsover_mul(uv.y, pixelCountY)), pixelCountY));
+	const localUV = vec2f(__tsover_sub(fract(__tsover_mul(uv.x, pixelCountX)), .5), __tsover_sub(fract(__tsover_mul(uv.y, pixelCountY)), .5));
 	const halfSize = __tsover_sub(.5, __tsover_mul(gap, .5));
 	const cornerRadius = __tsover_mul(roundness, halfSize);
-	const qx = std.max(__tsover_add(__tsover_sub(std.abs(localUV.x), halfSize), cornerRadius), 0);
-	const qy = std.max(__tsover_add(__tsover_sub(std.abs(localUV.y), halfSize), cornerRadius), 0);
-	const sdf = __tsover_sub(std.length(d.vec2f(qx, qy)), cornerRadius);
-	const mask = std.select(d.f32(0), d.f32(1), sdf <= 0);
-	return d.vec3f(sampleUV.x, sampleUV.y, mask);
+	const qx = max(__tsover_add(__tsover_sub(abs(localUV.x), halfSize), cornerRadius), 0);
+	const qy = max(__tsover_add(__tsover_sub(abs(localUV.y), halfSize), cornerRadius), 0);
+	const sdf = __tsover_sub(length(vec2f(qx, qy)), cornerRadius);
+	const mask = select(f32(0), f32(1), sdf <= 0);
+	return vec3f(sampleUV.x, sampleUV.y, mask);
 }), {
 	v: 1,
 	name: void 0,
@@ -414,8 +414,8 @@ const pixelateSample = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Plasma-C0dnSaw1.js → Plasma-DWIDcCnn.js}

@@ -1,17 +1,18 @@
-import { Et as mixColorStopsRuntime, Ht as call, J as std, Tn as d, dt as mxNoiseFloat3, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-const plasmaTone = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fluid, intensity, contrast, balance) => {
+import { $t as vec2f, At as pow, H as mixColorsLinear, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, nn as vec3f, nt as std_exports, p as call, xt as exp } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const plasmaTone = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fluid, intensity, contrast, balance) => {
 	"use gpu";
-	const plasma = std.pow(fluid, __tsover_div(5, intensity));
-	const contrasted = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(plasma, .5), contrast), .5), 0, 1);
+	const plasma = pow(fluid, __tsover_div(5, intensity));
+	const contrasted = clamp(__tsover_add(__tsover_mul(__tsover_sub(plasma, .5), contrast), .5), 0, 1);
 	const balanceShift = __tsover_sub(__tsover_div(balance, 100), .5);
-	const balanced = std.clamp(__tsover_add(contrasted, balanceShift), 0, 1);
+	const balanced = clamp(__tsover_add(contrasted, balanceShift), 0, 1);
 	return __tsover_sub(1, balanced);
 }), {
 	v: 1,
@@ -132,29 +133,29 @@ const plasmaTone = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const plasmaT = 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, density, warp, intensity, contrast, balance, animTime) => {
+const plasmaT = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, density, warp, intensity, contrast, balance, animTime) => {
 	"use gpu";
 	const t = __tsover_mul(animTime, .125);
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const pos = d.vec3f(__tsover_mul(uv.x, aspect), uv.y, 0).mul(std.exp(__tsover_sub(density, 1)));
+	const pos = vec3f(__tsover_mul(uv.x, aspect), uv.y, 0).mul(exp(__tsover_sub(density, 1)));
 	const warpAmount = __tsover_mul(warp, 4);
-	const qx = mxNoiseFloat3(pos.add(d.vec3f(__tsover_mul(t, .3), __tsover_mul(t, -.2), 0)));
-	const qy = mxNoiseFloat3(pos.add(d.vec3f(5.2, 1.3, __tsover_mul(t, .25))));
-	const warped1 = pos.add(d.vec3f(qx, qy, 0).mul(warpAmount));
-	const rx = mxNoiseFloat3(warped1.add(d.vec3f(1.7, 9.2, __tsover_mul(t, .15))));
-	const ry = mxNoiseFloat3(warped1.add(d.vec3f(8.3, 2.8, __tsover_mul(t, .13))));
-	const warped2 = pos.add(d.vec3f(rx, ry, 0).mul(warpAmount));
+	const qx = mxNoiseFloat3(pos.add(vec3f(__tsover_mul(t, .3), __tsover_mul(t, -.2), 0)));
+	const qy = mxNoiseFloat3(pos.add(vec3f(5.2, 1.3, __tsover_mul(t, .25))));
+	const warped1 = pos.add(vec3f(qx, qy, 0).mul(warpAmount));
+	const rx = mxNoiseFloat3(warped1.add(vec3f(1.7, 9.2, __tsover_mul(t, .15))));
+	const ry = mxNoiseFloat3(warped1.add(vec3f(8.3, 2.8, __tsover_mul(t, .13))));
+	const warped2 = pos.add(vec3f(rx, ry, 0).mul(warpAmount));
 	return plasmaTone(__tsover_add(__tsover_mul(mxNoiseFloat3(warped2), .5), .5), intensity, contrast, balance);
 }), {
 	v: 1,
@@ -558,8 +559,8 @@ const plasmaT = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports,
 		plasmaTone
 	})

package/dist/core/{Plastic-DBv_6A7q.js → Plastic-CWAOd2i9.js}

@@ -1,8 +1,10 @@
-import { Et as mixColorStopsRuntime, F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2, y as sdf3d_exports } 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, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Mt as reflect, Ot as mix, Rt as sqrt, St as exp2, U as mixColorsVariants, Vt as data_exports, _ as floatE, _t as clamp, an as f32, bt as dot, et as src_default, 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, 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, u as mxNoiseFloat2 } 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, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
@@ -11,15 +13,15 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "circleSDF",
 	radius: .35
 });
-const plasticEnvBox = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, lo, hi, soft) => {
+const plasticEnvBox = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, lo, hi, soft) => {
 	"use gpu";
-	const a = std.smoothstep(__tsover_sub(lo, soft), __tsover_add(lo, soft), x);
-	const b = __tsover_sub(1, std.smoothstep(__tsover_sub(hi, soft), __tsover_add(hi, soft), x));
+	const a = smoothstep(__tsover_sub(lo, soft), __tsover_add(lo, soft), x);
+	const b = __tsover_sub(1, smoothstep(__tsover_sub(hi, soft), __tsover_add(hi, soft), x));
 	return __tsover_mul(a, b);
 }), {
 	v: 1,
@@ -112,18 +114,18 @@ const plasticEnvBox = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const plasticCrumple = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, py, cScale, seedOff) => {
+const plasticCrumple = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, py, cScale, seedOff) => {
 	"use gpu";
-	const p1 = d.vec2f(__tsover_add(__tsover_mul(px, cScale), seedOff), __tsover_add(__tsover_mul(py, cScale), __tsover_mul(seedOff, .617)));
-	const p2 = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(px, cScale), 2.3), 13.1), seedOff), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(py, cScale), 2.3), 7.7), __tsover_mul(seedOff, .617)));
-	return __tsover_add(std.abs(mxNoiseFloat2(p1)), __tsover_mul(std.abs(mxNoiseFloat2(p2)), .45));
+	const p1 = vec2f(__tsover_add(__tsover_mul(px, cScale), seedOff), __tsover_add(__tsover_mul(py, cScale), __tsover_mul(seedOff, .617)));
+	const p2 = vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(px, cScale), 2.3), 13.1), seedOff), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(py, cScale), 2.3), 7.7), __tsover_mul(seedOff, .617)));
+	return __tsover_add(abs(mxNoiseFloat2(p1)), __tsover_mul(abs(mxNoiseFloat2(p2)), .45));
 }), {
 	v: 1,
 	name: void 0,
@@ -294,19 +296,19 @@ const plasticCrumple = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));
-const plasticGradientT = tgpu.fn([d.vec2f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, gradientAngle) => {
+const plasticGradientT = src_default.fn([vec2f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, gradientAngle) => {
 	"use gpu";
 	const gr = __tsover_mul(gradientAngle, DEG_TO_RAD);
-	const gx = std.cos(gr);
-	const gy = std.sin(gr);
+	const gx = cos(gr);
+	const gy = sin(gr);
 	const gdx = __tsover_sub(sdfUV.x, .5);
 	const gdy = __tsover_sub(sdfUV.y, .5);
-	return std.smoothstep(0, 1, std.clamp(__tsover_add(__tsover_div(__tsover_add(__tsover_mul(gdx, gx), __tsover_mul(gdy, gy)), .7), .5), 0, 1));
+	return smoothstep(0, 1, clamp(__tsover_add(__tsover_div(__tsover_add(__tsover_mul(gdx, gx), __tsover_mul(gdy, gy)), .7), .5), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -438,22 +440,22 @@ const plasticGradientT = tgpu.fn([d.vec2f, d.f32], d.f32)(/* @__PURE__ */ (($) =
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const plasticComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec3f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, baseRgb, rimColor, p0, p1, p2, p3) => {
+const plasticComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, baseRgb, rimColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const scale = p0.x;
 	const edgeSoftness = p0.y;
@@ -469,28 +471,25 @@ const plasticComposite = tgpu.fn([
 	const rimP = p2.w;
 	const animTime = p3.x;
 	const volumetric = p3.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 sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scale);
-	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
 	const lr = __tsover_mul(__tsover_add(lightAngle, __tsover_mul(animTime, 6)), DEG_TO_RAD);
-	const lx = std.cos(lr);
-	const ly = std.sin(lr);
+	const lx = cos(lr);
+	const ly = sin(lr);
 	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 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 thicknessRange = std.max(__tsover_mul(thickness, .3), .01);
-	const depthNorm = std.clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
-	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 nVol = std.normalize(d.vec3f(ddx, ddy, -1));
-	const bevelSlope = __tsover_mul(std.sqrt(std.max(__tsover_sub(1, __tsover_mul(depthNorm, depthNorm)), d.f32(0))), 2.4);
-	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1));
-	const nBase = std.select(nFlat, nVol, volumetric > .5);
+	const rb1 = clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	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 thicknessRange = max(__tsover_mul(thickness, .3), .01);
+	const depthNorm = clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
+	const nVol = 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(sqrt(max(__tsover_sub(1, __tsover_mul(depthNorm, depthNorm)), f32(0))), 2.4);
+	const nBase = select(normalize(vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1)), nVol, volumetric > .5);
 	const cScale = __tsover_mul(crumpleScale, 4);
 	const cAmp = __tsover_mul(crumple, .9);
 	const seedOff = __tsover_mul(seed, 7.31);
@@ -498,44 +497,43 @@ const plasticComposite = tgpu.fn([
 	const cr0 = plasticCrumple(pdx, pdy, cScale, seedOff);
 	const crx = __tsover_div(__tsover_sub(plasticCrumple(__tsover_add(pdx, neps), pdy, cScale, seedOff), cr0), neps);
 	const cry = __tsover_div(__tsover_sub(plasticCrumple(pdx, __tsover_add(pdy, neps), cScale, seedOff), cr0), neps);
-	const coverage = std.clamp(crumpleCoverage, 0, 1);
-	const covNoise = __tsover_add(__tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(pdx, 2.6), seedOff), 31.7), __tsover_add(__tsover_add(__tsover_mul(pdy, 2.6), __tsover_mul(seedOff, .617)), 17.3))), .5), .5);
+	const coverage = clamp(crumpleCoverage, 0, 1);
+	const covNoise = __tsover_add(__tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_add(__tsover_mul(pdx, 2.6), seedOff), 31.7), __tsover_add(__tsover_add(__tsover_mul(pdy, 2.6), __tsover_mul(seedOff, .617)), 17.3))), .5), .5);
 	const covThreshold = __tsover_sub(1.25, __tsover_mul(coverage, 1.75));
-	const covMask = std.smoothstep(__tsover_sub(covThreshold, .25), __tsover_add(covThreshold, .25), covNoise);
-	const crumpleW = __tsover_mul(__tsover_mul(cAmp, covMask), __tsover_add(__tsover_mul(std.smoothstep(0, .35, depthNorm), .85), .15));
-	const n = std.normalize(nBase.add(d.vec3f(__tsover_mul(__tsover_mul(crx, crumpleW), .25), __tsover_mul(__tsover_mul(cry, crumpleW), .25), 0)));
-	const cosView = std.clamp(__tsover_mul(n.z, -1), 0, 1);
+	const covMask = smoothstep(__tsover_sub(covThreshold, .25), __tsover_add(covThreshold, .25), covNoise);
+	const crumpleW = __tsover_mul(__tsover_mul(cAmp, covMask), __tsover_add(__tsover_mul(smoothstep(0, .35, depthNorm), .85), .15));
+	const n = normalize(nBase.add(vec3f(__tsover_mul(__tsover_mul(crx, crumpleW), .25), __tsover_mul(__tsover_mul(cry, crumpleW), .25), 0)));
+	const cosView = clamp(__tsover_mul(n.z, -1), 0, 1);
 	const grazing = __tsover_sub(1, cosView);
-	const R = std.reflect(d.vec3f(0, 0, 1), n);
-	const rough = std.clamp(roughness, 0, 1);
-	const grain = mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, 140), __tsover_mul(pdy, 140)));
+	const R = reflect(vec3f(0, 0, 1), n);
+	const rough = clamp(roughness, 0, 1);
+	const grain = mxNoiseFloat2(vec2f(__tsover_mul(pdx, 140), __tsover_mul(pdy, 140)));
 	const rJit = __tsover_mul(__tsover_mul(rough, grain), .18);
 	const eu = __tsover_add(__tsover_add(__tsover_mul(R.x, lx), __tsover_mul(R.y, ly)), rJit);
 	const ev = __tsover_add(__tsover_add(__tsover_mul(R.x, __tsover_mul(ly, -1)), __tsover_mul(R.y, lx)), __tsover_mul(rJit, .6));
-	const soft = std.mix(.02, .45, rough);
+	const soft = mix(.02, .45, rough);
 	const windowBox = __tsover_mul(plasticEnvBox(eu, .18, .95, soft), plasticEnvBox(ev, -.42, .42, soft));
 	const mullion = __tsover_mul(__tsover_mul(plasticEnvBox(ev, -.045, .045, __tsover_mul(soft, .6)), .8), __tsover_sub(1, rough));
 	const keyLight = __tsover_mul(windowBox, __tsover_sub(1, mullion));
 	const strip = __tsover_mul(__tsover_mul(plasticEnvBox(eu, -.16, -.05, __tsover_mul(soft, .7)), plasticEnvBox(ev, -.85, .85, soft)), .85);
 	const fill = __tsover_mul(__tsover_mul(plasticEnvBox(eu, -.95, -.45, __tsover_mul(soft, 1.6)), plasticEnvBox(ev, -.6, .6, __tsover_mul(soft, 1.6))), .3);
-	const dome = __tsover_mul(std.clamp(__tsover_add(__tsover_mul(eu, .5), .5), 0, 1), .12);
+	const dome = __tsover_mul(clamp(__tsover_add(__tsover_mul(eu, .5), .5), 0, 1), .12);
 	const env = __tsover_mul(__tsover_add(__tsover_add(__tsover_add(keyLight, strip), fill), dome), __tsover_sub(1, __tsover_mul(rough, .55)));
-	const fresnel = __tsover_add(.3, __tsover_mul(std.pow(grazing, d.f32(3)), .7));
+	const fresnel = __tsover_add(.3, __tsover_mul(pow(grazing, f32(3)), .7));
 	const specW = __tsover_mul(reflectivity, fresnel);
-	const L = std.normalize(d.vec3f(lx, ly, -.8));
-	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndh = std.clamp(std.dot(n, H), 0, 1);
-	const shininess = std.exp2(std.mix(d.f32(9), d.f32(4), rough));
-	const glint = __tsover_mul(__tsover_mul(std.pow(ndh, shininess), 1.6), __tsover_sub(1, __tsover_mul(rough, .7)));
+	const L = normalize(vec3f(lx, ly, -.8));
+	const ndh = clamp(dot(n, normalize(L.add(vec3f(0, 0, -1)))), 0, 1);
+	const shininess = exp2(mix(f32(9), f32(4), rough));
+	const glint = __tsover_mul(__tsover_mul(pow(ndh, shininess), 1.6), __tsover_sub(1, __tsover_mul(rough, .7)));
 	const specular = __tsover_mul(__tsover_add(env, glint), specW);
-	const ndl = std.clamp(std.dot(n, L), -1, 1);
+	const ndl = clamp(dot(n, L), -1, 1);
 	const lit = __tsover_add(__tsover_mul(ndl, .5), .5);
-	const diffuse = std.mix(__tsover_sub(1, __tsover_mul(shading, .75)), __tsover_add(1, __tsover_mul(shading, .45)), lit);
-	const ao = std.mix(.6, 1, std.smoothstep(0, 1, std.clamp(__tsover_div(__tsover_mul(sdf, -1), .025), 0, 1)));
-	const rimGlow = __tsover_mul(__tsover_mul(__tsover_mul(std.pow(grazing, d.f32(3.5)), rimP), __tsover_add(__tsover_mul(lit, .6), .4)), 1.6);
-	const plasticRgb = baseRgb.mul(diffuse).mul(ao).add(d.vec3f(specular, specular, specular)).add(rimColor.mul(rimGlow));
-	const transition = std.smoothstep(0, 1, rb1);
-	return d.vec4f(plasticRgb.x, plasticRgb.y, plasticRgb.z, transition);
+	const diffuse = mix(__tsover_sub(1, __tsover_mul(shading, .75)), __tsover_add(1, __tsover_mul(shading, .45)), lit);
+	const ao = mix(.6, 1, smoothstep(0, 1, clamp(__tsover_div(__tsover_mul(sdf, -1), .025), 0, 1)));
+	const rimGlow = __tsover_mul(__tsover_mul(__tsover_mul(pow(grazing, f32(3.5)), rimP), __tsover_add(__tsover_mul(lit, .6), .4)), 1.6);
+	const plasticRgb = baseRgb.mul(diffuse).mul(ao).add(vec3f(specular, specular, specular)).add(rimColor.mul(rimGlow));
+	const transition = smoothstep(0, 1, rb1);
+	return vec4f(plasticRgb.x, plasticRgb.y, plasticRgb.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -2566,8 +2564,8 @@ const plasticComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		DEG_TO_RAD,
 		plasticCrumple,
 		noise: noise_exports,

package/dist/core/{PolarCoordinates-B8Cq2bzT.js → PolarCoordinates-DQM3dLK3.js}

@@ -1,24 +1,22 @@
-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, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, gt as atan2, n as composeEdgeRemapExpr, nt as std_exports, p as call, v as mixExpr } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
 var PI = Math.PI;
 var TAU = Math.PI * 2;
-const polarCoordsUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, wrap, radius, uv, aspect) => {
+const polarCoordsUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, wrap, radius, 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 theta = std.atan2(delta.y, delta.x);
+	const theta = atan2(delta.y, delta.x);
 	const normalizedAngle = __tsover_div(__tsover_add(theta, PI), TAU);
-	const r = std.length(delta);
-	const u = __tsover_mul(normalizedAngle, wrap);
-	const v = __tsover_mul(r, radius);
-	return d.vec2f(u, v);
+	const r = length(delta);
+	return vec2f(__tsover_mul(normalizedAngle, wrap), __tsover_mul(r, radius));
 }), {
 	v: 1,
 	name: void 0,
@@ -203,8 +201,8 @@ const polarCoordsUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		PI,
 		TAU
 	})

package/dist/core/{Polygon-ORM35JKg.js → Polygon-CFmLohBu.js}

@@ -1,22 +1,21 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, J as std, Jt as vec4, M as polygonSdf, R as strokeMaskFromSdf, T as circleSdf, 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 polygonShape = 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, Ot as mix, U as mixColorsVariants, an as f32, et as src_default, nt as std_exports, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { f as polygonSdf, g as shapeLocalCoords, h as sdf_exports, i as circleSdf, 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 polygonShape = 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, rounding, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);
-	const polyDist = polygonSdf(local.x, local.y, radius, sides);
-	const circDist = circleSdf(local.x, local.y, radius);
-	return strokeMaskFromSdf(std.mix(polyDist, circDist, rounding), softness, strokeThickness, strokePosition);
+	return strokeMaskFromSdf(mix(polygonSdf(local.x, local.y, radius, sides), circleSdf(local.x, local.y, radius), rounding), softness, strokeThickness, strokePosition);
 }), {
 	v: 1,
 	name: void 0,
@@ -169,7 +168,7 @@ const polygonShape = tgpu.fn([
 	},
 	externals: () => ({
 		sdf: sdf_exports,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Posterize-Dn-Vv2S1.js → Posterize-B8PHXwhy.js}

@@ -1,10 +1,7 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const posterizeColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, steps) => {
+import { Ct as floor, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+const posterizeColor = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, steps) => {
 	"use gpu";
-	const r = __tsover_div(std.floor(__tsover_mul(color.x, steps)), steps);
-	const g = __tsover_div(std.floor(__tsover_mul(color.y, steps)), steps);
-	const b = __tsover_div(std.floor(__tsover_mul(color.z, steps)), steps);
-	return d.vec4f(r, g, b, color.w);
+	return vec4f(__tsover_div(floor(__tsover_mul(color.x, steps)), steps), __tsover_div(floor(__tsover_mul(color.y, steps)), steps), __tsover_div(floor(__tsover_mul(color.z, steps)), steps), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -120,8 +117,8 @@ const posterizeColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {