shaders 3.0.447 → 3.0.449

package/dist/core/{Ellipse-CrQ1XYjx.js → Ellipse-DxRnSw__.js}

@@ -1,15 +1,16 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, O as ellipseSdf, 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 ellipseShape = tgpu.fn([
-	d.vec2f,
-	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 { c as ellipseSdf, 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 ellipseShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radiusX, radiusY, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Emboss-DNwO5JcE.js → Emboss-BJxzjZmZ.js}

@@ -1,7 +1,8 @@
-import { Bt as ZERO, Dn as __export, F as sdf_exports, Ht as call, J as std, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { i as sdfSpaceUV, r as offsetUV } from "./glass-sOqjtPJD.js";
-import { c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, Et as max, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Rt as sqrt, Vt as data_exports, _ as floatE, _t as clamp, an as f32, cn as __export, d as ZERO, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.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 { i as sdfSpaceUV, r as offsetUV } from "./glass-IfoQ8Prf.js";
+import { c as transformPosition } from "./transformations-CsPUHppB.js";
 var emboss_exports = /* @__PURE__ */ __export({
 	applyEmbossEffect: () => applyEmbossEffect$1,
 	embossComposite: () => embossComposite,
@@ -13,16 +14,15 @@ var emboss_exports = /* @__PURE__ */ __export({
 var DEG_TO_RAD = .017453292519943295;
 var _INV_LIGHT_LEN = 1 / Math.sqrt(1.49);
 var _LZN = .7 * _INV_LIGHT_LEN;
-const embossHeight = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s, depth, transitionW, volumetric) => {
+const embossHeight = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s, depth, transitionW, volumetric) => {
 	"use gpu";
-	const vol = __tsover_mul(depth, std.clamp(__tsover_div(__tsover_mul(s, -1), .18), 0, 1));
-	const flat = __tsover_mul(depth, std.smoothstep(transitionW, __tsover_mul(transitionW, -1), s));
-	return std.select(flat, vol, volumetric > .5);
+	const vol = __tsover_mul(depth, clamp(__tsover_div(__tsover_mul(s, -1), .18), 0, 1));
+	return select(__tsover_mul(depth, smoothstep(transitionW, __tsover_mul(transitionW, -1), s)), vol, volumetric > .5);
 }), {
 	v: 1,
 	name: void 0,
@@ -134,20 +134,20 @@ const embossHeight = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const embossTraceUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, lightAngle, depth, frac) => {
+const embossTraceUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, lightAngle, depth, frac) => {
 	"use gpu";
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const absDepth = std.max(std.abs(depth), 1e-4);
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const absDepth = max(abs(depth), 1e-4);
 	const spread = __tsover_mul(absDepth, .06);
-	return d.vec2f(__tsover_add(sdfUV.x, __tsover_mul(__tsover_mul(lx, spread), frac)), __tsover_add(sdfUV.y, __tsover_mul(__tsover_mul(ly, spread), frac)));
+	return vec2f(__tsover_add(sdfUV.x, __tsover_mul(__tsover_mul(lx, spread), frac)), __tsover_add(sdfUV.y, __tsover_mul(__tsover_mul(ly, spread), frac)));
 }), {
 	v: 1,
 	name: void 0,
@@ -293,24 +293,24 @@ const embossTraceUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const embossWarpUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, center, sdfC, depth) => {
+const embossWarpUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, center, sdfC, depth) => {
 	"use gpu";
 	const tw = .003;
-	const inside = std.smoothstep(tw, __tsover_mul(tw, -1), sdfC);
+	const inside = smoothstep(tw, __tsover_mul(tw, -1), sdfC);
 	const dispScale = __tsover_sub(1, __tsover_mul(__tsover_mul(depth, .05), inside));
 	const centerX = center.x;
 	const centerY = __tsover_sub(1, center.y);
-	return d.vec2f(__tsover_add(centerX, __tsover_mul(__tsover_sub(uv.x, centerX), dispScale)), __tsover_add(centerY, __tsover_mul(__tsover_sub(uv.y, centerY), dispScale)));
+	return vec2f(__tsover_add(centerX, __tsover_mul(__tsover_sub(uv.x, centerX), dispScale)), __tsover_add(centerY, __tsover_mul(__tsover_sub(uv.y, centerY), dispScale)));
 }), {
 	v: 1,
 	name: void 0,
@@ -459,20 +459,20 @@ const embossWarpUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const embossEdgeLighting = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfR, sdfL, sdfU, sdfD, depth, lightAngle, lightIntensity, volumetric) => {
+const embossEdgeLighting = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfR, sdfL, sdfU, sdfD, depth, lightAngle, lightIntensity, volumetric) => {
 	"use gpu";
 	const eps = .003;
 	const tw = .003;
@@ -482,20 +482,18 @@ const embossEdgeLighting = tgpu.fn([
 	const hD = embossHeight(sdfD, depth, tw, volumetric);
 	const dhx = __tsover_div(__tsover_sub(hR, hL), __tsover_mul(eps, 2));
 	const dhy = __tsover_div(__tsover_sub(hU, hD), __tsover_mul(eps, 2));
-	const nLen = std.sqrt(__tsover_add(__tsover_add(__tsover_mul(dhx, dhx), __tsover_mul(dhy, dhy)), 1));
+	const nLen = sqrt(__tsover_add(__tsover_add(__tsover_mul(dhx, dhx), __tsover_mul(dhy, dhy)), 1));
 	const nx = __tsover_div(__tsover_mul(dhx, -1), nLen);
 	const ny = __tsover_div(__tsover_mul(dhy, -1), nLen);
 	const nz = __tsover_div(1, nLen);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
 	const lxn = __tsover_mul(lx, _INV_LIGHT_LEN);
 	const lyn = __tsover_mul(ly, _INV_LIGHT_LEN);
 	const lzn = _LZN;
 	const NdotL = __tsover_add(__tsover_add(__tsover_mul(nx, lxn), __tsover_mul(ny, lyn)), __tsover_mul(nz, lzn));
 	const edgeLighting = __tsover_mul(__tsover_sub(NdotL, lzn), lightIntensity);
-	const highlight = std.max(edgeLighting, 0);
-	const edgeShadow = std.max(__tsover_mul(edgeLighting, -1), 0);
-	return d.vec2f(highlight, edgeShadow);
+	return vec2f(max(edgeLighting, 0), max(__tsover_mul(edgeLighting, -1), 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -884,46 +882,46 @@ const embossEdgeLighting = tgpu.fn([
 	},
 	externals: () => ({
 		embossHeight,
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
 		_INV_LIGHT_LEN,
 		_LZN,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const embossComposite = tgpu.fn([
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, sdfC, sdfR, sdfL, sdfU, sdfD, h1raw, h2raw, depth, lightAngle, lightIntensity, shadowIntensity, volumetric) => {
+const embossComposite = src_default.fn([
+	vec4f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, sdfC, sdfR, sdfL, sdfU, sdfD, h1raw, h2raw, depth, lightAngle, lightIntensity, shadowIntensity, volumetric) => {
 	"use gpu";
 	const tw = .003;
 	const light = embossEdgeLighting(sdfR, sdfL, sdfU, sdfD, depth, lightAngle, lightIntensity, volumetric);
 	const highlight = light.x;
 	const edgeShadow = light.y;
 	const hC = embossHeight(sdfC, depth, tw, volumetric);
-	const absDepth = std.max(std.abs(depth), 1e-4);
+	const absDepth = max(abs(depth), 1e-4);
 	const shadowTw = __tsover_mul(absDepth, .06);
 	const h1 = embossHeight(h1raw, depth, shadowTw, volumetric);
 	const h2 = embossHeight(h2raw, depth, shadowTw, volumetric);
 	const diff1 = __tsover_div(__tsover_sub(h1, hC), absDepth);
 	const diff2 = __tsover_div(__tsover_sub(h2, hC), absDepth);
-	const castShadow = __tsover_add(__tsover_mul(std.smoothstep(0, .5, diff1), .55), __tsover_mul(std.smoothstep(0, .5, diff2), .45));
-	const totalShadow = __tsover_mul(std.clamp(__tsover_add(edgeShadow, castShadow), 0, 1), shadowIntensity);
-	const childRgb = d.vec3f(childColor.x, childColor.y, childColor.z);
-	const highlightRgb = d.vec3f(highlight, highlight, highlight);
-	const finalRgb = std.clamp(childRgb.mul(__tsover_sub(1, totalShadow)).add(highlightRgb), d.vec3f(0), d.vec3f(1));
-	return d.vec4f(finalRgb.x, finalRgb.y, finalRgb.z, childColor.w);
+	const castShadow = __tsover_add(__tsover_mul(smoothstep(0, .5, diff1), .55), __tsover_mul(smoothstep(0, .5, diff2), .45));
+	const totalShadow = __tsover_mul(clamp(__tsover_add(edgeShadow, castShadow), 0, 1), shadowIntensity);
+	const childRgb = vec3f(childColor.x, childColor.y, childColor.z);
+	const highlightRgb = vec3f(highlight, highlight, highlight);
+	const finalRgb = clamp(childRgb.mul(__tsover_sub(1, totalShadow)).add(highlightRgb), vec3f(0), vec3f(1));
+	return vec4f(finalRgb.x, finalRgb.y, finalRgb.z, childColor.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -1339,8 +1337,8 @@ const embossComposite = tgpu.fn([
 	externals: () => ({
 		embossEdgeLighting,
 		embossHeight,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 function applyEmbossEffect$1(params, sdfSampler, childTexture, options) {

package/dist/core/{Engraving-FsaRQiyI.js → Engraving-DmQCj8vU.js}

@@ -1,26 +1,26 @@
-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, pt as noise_exports, ut as mxNoiseFloat2 } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, 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, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, gt as atan2, in as vec4f, nn as vec3f, nt as std_exports, p as call, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.js";
+import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-CsPUHppB.js";
 var TAU = 6.283185307179586;
 var DEG_TO_RAD = .017453292519943295;
 var transformStyle = (value) => value === "spiral" ? 2 : value === "line" ? 0 : 1;
 var styleModeOf = (raw) => typeof raw === "number" ? raw : transformStyle(String(raw));
-const engravingPlate = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, angleDeg, frequency, reliefPhase, level, aa) => {
+const engravingPlate = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, angleDeg, frequency, reliefPhase, level, aa) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const c = std.cos(angleRad);
-	const s = std.sin(angleRad);
+	const c = cos(angleRad);
+	const s = sin(angleRad);
 	const w = __tsover_add(__tsover_mul(p.x, __tsover_mul(s, -1)), __tsover_mul(p.y, c));
-	const phase = __tsover_add(__tsover_mul(__tsover_mul(w, frequency), TAU), reliefPhase);
-	const v = std.cos(phase);
-	const thr = std.mix(-1.15, 1.15, std.clamp(level, 0, 1));
-	return std.smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
+	const v = cos(__tsover_add(__tsover_mul(__tsover_mul(w, frequency), TAU), reliefPhase));
+	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
+	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
 }), {
 	v: 1,
 	name: void 0,
@@ -223,26 +223,25 @@ const engravingPlate = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		TAU
 	})
 }) && $.f)({}));
-const engravingSpiralPlate = 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 = ((p, c, frequency, reliefPhase, level, aa) => {
+const engravingSpiralPlate = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c, frequency, reliefPhase, level, aa) => {
 	"use gpu";
 	const dv = p.sub(c);
-	const r = std.length(dv);
-	const theta = std.atan2(dv.y, dv.x);
-	const phase = __tsover_add(__tsover_mul(__tsover_sub(__tsover_mul(r, frequency), __tsover_mul(theta, __tsover_div(1, TAU))), TAU), reliefPhase);
-	const v = std.cos(phase);
-	const thr = std.mix(-1.15, 1.15, std.clamp(level, 0, 1));
-	return std.smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
+	const r = length(dv);
+	const theta = atan2(dv.y, dv.x);
+	const v = cos(__tsover_add(__tsover_mul(__tsover_sub(__tsover_mul(r, frequency), __tsover_mul(theta, __tsover_div(1, TAU))), TAU), reliefPhase));
+	const thr = mix(-1.15, 1.15, clamp(level, 0, 1));
+	return smoothstep(__tsover_sub(thr, aa), __tsover_add(thr, aa), v);
 }), {
 	v: 1,
 	name: void 0,
@@ -429,21 +428,21 @@ const engravingSpiralPlate = tgpu.fn([
 		"externalNames": ["std", "TAU"]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		TAU
 	})
 }) && $.f)({}));
 function makeEngravingComposite(style) {
-	return tgpu.fn([
-		d.vec4f,
-		d.vec2f,
-		d.f32,
-		d.vec4f,
-		d.vec4f,
-		d.vec2f,
-		d.vec4f,
-		d.vec4f
-	], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, paper, ink, center, p0, p1) => {
+	return src_default.fn([
+		vec4f,
+		vec2f,
+		f32,
+		vec4f,
+		vec4f,
+		vec2f,
+		vec4f,
+		vec4f
+	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, paper, ink, center, p0, p1) => {
 		"use gpu";
 		const angleDeg = p0.x;
 		const frequency = p0.y;
@@ -451,27 +450,26 @@ function makeEngravingComposite(style) {
 		const waviness = p0.w;
 		const contrast = p1.x;
 		const viewportY = p1.y;
-		const lum = std.dot(d.vec3f(childColor.x, childColor.y, childColor.z), d.vec3f(.299, .587, .114));
-		const level = std.clamp(__tsover_add(.5, __tsover_mul(__tsover_sub(lum, .5), contrast)), 0, 1);
-		const pa = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+		const lum = dot(vec3f(childColor.x, childColor.y, childColor.z), vec3f(.299, .587, .114));
+		const level = clamp(__tsover_add(.5, __tsover_mul(__tsover_sub(lum, .5), contrast)), 0, 1);
+		const pa = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 		const nx = mxNoiseFloat2(pa.mul(3.1));
-		const ny = mxNoiseFloat2(pa.mul(3.1).add(d.vec2f(7.31, 3.77)));
-		const p = pa.add(d.vec2f(nx, ny).mul(__tsover_mul(waviness, .06)));
-		const aa = std.clamp(__tsover_div(__tsover_mul(frequency, TAU), std.max(viewportY, 1)), .02, 1);
+		const ny = mxNoiseFloat2(pa.mul(3.1).add(vec2f(7.31, 3.77)));
+		const p = pa.add(vec2f(nx, ny).mul(__tsover_mul(waviness, .06)));
+		const aa = clamp(__tsover_div(__tsover_mul(frequency, TAU), max(viewportY, 1)), .02, 1);
 		const reliefPhase = __tsover_mul(__tsover_mul(relief, level), 9.42);
-		let cover = d.f32(0);
-		if (style === 2) cover = engravingSpiralPlate(p, d.vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y)), frequency, reliefPhase, level, aa);
+		let cover = f32(0);
+		if (style === 2) cover = engravingSpiralPlate(p, vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y)), frequency, reliefPhase, level, aa);
 		else if (style === 1) {
 			const ink1 = engravingPlate(p, angleDeg, frequency, reliefPhase, level, aa);
-			const level2 = std.clamp(__tsover_div(level, .55), 0, 1);
+			const level2 = clamp(__tsover_div(level, .55), 0, 1);
 			const ink2 = engravingPlate(p, __tsover_add(angleDeg, 72), __tsover_mul(frequency, .92), __tsover_mul(reliefPhase, .7), level2, aa);
-			const level3 = std.clamp(__tsover_div(level, .28), 0, 1);
-			const ink3 = engravingPlate(p, __tsover_sub(angleDeg, 38), __tsover_mul(frequency, 1.13), __tsover_mul(reliefPhase, .5), level3, aa);
-			cover = std.max(ink1, std.max(ink2, ink3));
+			const level3 = clamp(__tsover_div(level, .28), 0, 1);
+			cover = max(ink1, max(ink2, engravingPlate(p, __tsover_sub(angleDeg, 38), __tsover_mul(frequency, 1.13), __tsover_mul(reliefPhase, .5), level3, aa)));
 		} else cover = engravingPlate(p, angleDeg, frequency, reliefPhase, level, aa);
-		const rgb = std.mix(d.vec3f(paper.x, paper.y, paper.z), d.vec3f(ink.x, ink.y, ink.z), d.vec3f(cover));
-		const alpha = __tsover_mul(childColor.w, std.mix(paper.w, ink.w, cover));
-		return d.vec4f(rgb.x, rgb.y, rgb.z, alpha);
+		const rgb = mix(vec3f(paper.x, paper.y, paper.z), vec3f(ink.x, ink.y, ink.z), vec3f(cover));
+		const alpha = __tsover_mul(childColor.w, mix(paper.w, ink.w, cover));
+		return vec4f(rgb.x, rgb.y, rgb.z, alpha);
 	}), {
 		v: 1,
 		name: void 0,
@@ -1200,8 +1198,8 @@ function makeEngravingComposite(style) {
 			]
 		},
 		externals: () => ({
-			std,
-			d,
+			std: std_exports,
+			d: data_exports,
 			noise: noise_exports,
 			TAU,
 			style,

package/dist/core/{ErosionNoise-CloHpdFT.js → ErosionNoise-7ekcAfBb.js}

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

package/dist/core/{Exposure-mO6KjYvc.js → Exposure-avEereLn.js}

@@ -1,8 +1,7 @@
-import { Bt as ZERO, Ht as call, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const exposureColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, gain) => {
+import { Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, p as call } from "./edges-BXNBKxSN.js";
+const exposureColor = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, gain) => {
 	"use gpu";
-	const rgb = color.xyz.mul(gain);
-	return d.vec4f(rgb, color.w);
+	return vec4f(color.xyz.mul(gain), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -45,7 +44,7 @@ const exposureColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =>
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "Exposure",

package/dist/core/{FallingLines-D_1wHUkx.js → FallingLines-BINyHi3N.js}

@@ -1,10 +1,10 @@
-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, 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, Lt as smoothstep, Rt as sqrt, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, ct as fwidth, et as src_default, mt as abs, nt as std_exports, p as call, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-var colHash = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx) => {
+var colHash = src_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx) => {
 	"use gpu";
-	return d.vec2f(std.fract(__tsover_mul(std.sin(__tsover_mul(idx, 127.1)), 43758.5453123)), std.fract(__tsover_mul(std.sin(__tsover_mul(idx, 311.7)), 38291.3421)));
+	return vec2f(fract(__tsover_mul(sin(__tsover_mul(idx, 127.1)), 43758.5453123)), fract(__tsover_mul(sin(__tsover_mul(idx, 311.7)), 38291.3421)));
 }), {
 	v: 1,
 	name: void 0,
@@ -77,57 +77,55 @@ var colHash = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TY
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const fallingLinesField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, vp, angle, density, speedVariance, trailLength, strokeWidth, rounding, balance, animTime) => {
+const fallingLinesField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, vp, angle, density, speedVariance, trailLength, strokeWidth, rounding, balance, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(vp.x, vp.y);
-	const centeredUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y).sub(d.vec2f(__tsover_mul(aspect, .5), .5));
+	const centeredUV = vec2f(__tsover_mul(uv.x, aspect), uv.y).sub(vec2f(__tsover_mul(aspect, .5), .5));
 	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 u = __tsover_sub(__tsover_mul(centeredUV.y, cosA), __tsover_mul(centeredUV.x, sinA));
 	const v = __tsover_add(__tsover_mul(centeredUV.x, cosA), __tsover_mul(centeredUV.y, sinA));
 	const colF = __tsover_mul(u, density);
-	const colIdx = std.floor(colF);
-	const colLocalU = std.fract(colF);
+	const colIdx = floor(colF);
+	const colLocalU = fract(colF);
 	const h = colHash(colIdx);
 	const speedMod = __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(h.x, .5), speedVariance), 2));
 	const phase = h.y;
-	const animOffset = std.fract(__tsover_mul(animTime, speedMod));
-	const vPeriodic = std.fract(__tsover_sub(__tsover_sub(v, animOffset), phase));
+	const animOffset = fract(__tsover_mul(animTime, speedMod));
+	const vPeriodic = fract(__tsover_sub(__tsover_sub(v, animOffset), phase));
 	const trailLen = trailLength;
-	const withinStreak = std.clamp(__tsover_div(vPeriodic, trailLen), 0, 1);
-	const fwV = std.clamp(std.fwidth(v), .001, .1);
-	const fwU = std.clamp(__tsover_mul(std.fwidth(u), density), .001, .1);
-	const streakMask = __tsover_sub(1, std.smoothstep(__tsover_sub(trailLen, fwV), __tsover_add(trailLen, fwV), vPeriodic));
+	const withinStreak = clamp(__tsover_div(vPeriodic, trailLen), 0, 1);
+	const fwV = clamp(fwidth(v), .001, .1);
+	const fwU = clamp(__tsover_mul(fwidth(u), density), .001, .1);
+	const streakMask = __tsover_sub(1, smoothstep(__tsover_sub(trailLen, fwV), __tsover_add(trailLen, fwV), vPeriodic));
 	const hw = __tsover_mul(strokeWidth, .5);
-	const distFromCenter = std.abs(__tsover_sub(colLocalU, .5));
-	const widthMask = __tsover_sub(1, std.smoothstep(__tsover_sub(hw, fwU), __tsover_add(hw, fwU), distFromCenter));
+	const distFromCenter = abs(__tsover_sub(colLocalU, .5));
+	const widthMask = __tsover_sub(1, smoothstep(__tsover_sub(hw, fwU), __tsover_add(hw, fwU), distFromCenter));
 	const rectMask = __tsover_mul(streakMask, widthMask);
 	const maxDepth = __tsover_mul(hw, rounding);
-	const gapDist = __tsover_mul(std.max(__tsover_sub(vPeriodic, trailLen), 0), density);
-	const tcap = std.clamp(__tsover_div(gapDist, std.max(maxDepth, 1e-4)), 0, 1);
-	const capHW = __tsover_mul(hw, std.sqrt(std.max(__tsover_sub(1, __tsover_mul(tcap, tcap)), 0)));
-	const capAlpha = __tsover_mul(__tsover_sub(1, std.smoothstep(std.max(__tsover_sub(capHW, fwU), 0), std.max(__tsover_add(capHW, fwU), .001), distFromCenter)), std.smoothstep(0, fwU, capHW));
-	const finalMask = std.max(rectMask, capAlpha);
+	const gapDist = __tsover_mul(max(__tsover_sub(vPeriodic, trailLen), 0), density);
+	const tcap = clamp(__tsover_div(gapDist, max(maxDepth, 1e-4)), 0, 1);
+	const capHW = __tsover_mul(hw, sqrt(max(__tsover_sub(1, __tsover_mul(tcap, tcap)), 0)));
+	const finalMask = max(rectMask, __tsover_mul(__tsover_sub(1, smoothstep(max(__tsover_sub(capHW, fwU), 0), max(__tsover_add(capHW, fwU), .001), distFromCenter)), smoothstep(0, fwU, capHW)));
 	const balanceNum = __tsover_sub(__tsover_mul(2, balance), 1);
-	const balanceDen = std.max(__tsover_mul(2, __tsover_sub(1, balance)), .001);
-	const balancedT = std.clamp(__tsover_div(__tsover_add(withinStreak, balanceNum), balanceDen), 0, 1);
-	return d.vec2f(finalMask, balancedT);
+	const balanceDen = max(__tsover_mul(2, __tsover_sub(1, balance)), .001);
+	return vec2f(finalMask, clamp(__tsover_div(__tsover_add(withinStreak, balanceNum), balanceDen), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -905,9 +903,9 @@ const fallingLinesField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		colHash
 	})
 }) && $.f)({}));