shaders 3.0.447 → 3.0.449

package/dist/core/{ColorWheel-CXvfWAjN.js → ColorWheel-CMtn8slz.js}

@@ -1,21 +1,21 @@
-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, H as mixColorsLinear, It as sin, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, in as vec4f, mt as abs, nt as std_exports, p as call, vt as cos, wt as fract, zt as step } 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 colorWheelT = 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, angle, scale, animTime) => {
+const colorWheelT = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, scale, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.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 projectedCoord = __tsover_add(__tsover_mul(__tsover_mul(uv.x, aspect), cosA), __tsover_mul(uv.y, sinA));
-	return std.fract(__tsover_add(__tsover_mul(__tsover_mul(projectedCoord, scale), .2), animTime));
+	return fract(__tsover_add(__tsover_mul(__tsover_mul(projectedCoord, scale), .2), animTime));
 }), {
 	v: 1,
 	name: void 0,
@@ -159,16 +159,13 @@ const colorWheelT = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const colorWheelRainbow = tgpu.fn([d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const colorWheelRainbow = src_default.fn([f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
 	const h6 = __tsover_mul(t, 6);
-	const r = std.clamp(__tsover_sub(std.abs(__tsover_sub(h6, 3)), 1), 0, 1);
-	const g = std.clamp(__tsover_sub(2, std.abs(__tsover_sub(h6, 2))), 0, 1);
-	const b = std.clamp(__tsover_sub(2, std.abs(__tsover_sub(h6, 4))), 0, 1);
-	return d.vec4f(r, g, b, 1);
+	return vec4f(clamp(__tsover_sub(abs(__tsover_sub(h6, 3)), 1), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(h6, 2))), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(h6, 4))), 0, 1), 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -311,14 +308,14 @@ const colorWheelRainbow = tgpu.fn([d.f32], d.vec4f)(/* @__PURE__ */ (($) => (glo
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const colorWheelPhase = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const colorWheelPhase = src_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
 	const t3 = __tsover_mul(t, 3);
-	return d.vec2f(std.fract(t3), std.floor(t3));
+	return vec2f(fract(t3), floor(t3));
 }), {
 	v: 1,
 	name: void 0,
@@ -364,19 +361,18 @@ const colorWheelPhase = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globa
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const colorWheelSelect = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c01, c12, c20, floorT3) => {
+const colorWheelSelect = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c01, c12, c20, floorT3) => {
 	"use gpu";
-	const seg1 = std.mix(c20, c12, std.step(floorT3, 1.5));
-	return std.mix(seg1, c01, std.step(floorT3, .5));
+	return mix(mix(c20, c12, step(floorT3, 1.5)), c01, step(floorT3, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -446,7 +442,7 @@ const colorWheelSelect = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "ColorWheel",

package/dist/core/{CompressionArtifacts-BDaP7XI6.js → CompressionArtifacts-D7dpVg47.js}

@@ -1,4 +1,5 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu, sn as blend_exports } from "./coords-BkIjixe_.js";
+import { $t as vec2f, Ct as floor, Gt as textureStorage2d, M as blend_exports, N as unpremultiplyAlpha, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, et as src_default, in as vec4f, it as textureLoad, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, sn as u32, tn as vec2u, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
 var LUMA_QUANT = [
 	16,
 	11,
@@ -135,70 +136,67 @@ var COS_LUT_FLAT = [];
 for (let k = 0; k < 8; k++) for (let u = 0; u < 8; u++) COS_LUT_FLAT[k * 8 + u] = Math.cos((2 * k + 1) * u * Math.PI / 16);
 var SQRT1_2 = Math.SQRT1_2;
 var PI_OVER_16 = Math.PI / 16;
-var COS_LUT = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), COS_LUT_FLAT), "COS_LUT");
-var LUMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), LUMA_QUANT), "LUMA_QUANT_C");
-var CHROMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 64), CHROMA_QUANT), "CHROMA_QUANT_C");
+var COS_LUT = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(f32, 64), COS_LUT_FLAT), "COS_LUT");
+var LUMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(f32, 64), LUMA_QUANT), "LUMA_QUANT_C");
+var CHROMA_QUANT_C = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(f32, 64), CHROMA_QUANT), "CHROMA_QUANT_C");
 var N_LUMA = 6;
 var SCALE_N = 4;
 var BLOCK_PX = 8 * SCALE_N;
 var STRIDE = SCALE_N;
 var MAX_CELLS = 1024;
 var CELL_FORMAT = "rgba16float";
-const jpegBlockRgb = tgpu.fn([
-	d.arrayOf(d.vec3f, 64),
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((block, localX, localY, quality) => {
+const jpegBlockRgb = src_default.fn([
+	arrayOf(vec3f, 64),
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((block, localX, localY, quality) => {
 	"use gpu";
-	const qualityC = std.clamp(quality, 1, 100);
-	const qScale = std.select(__tsover_sub(200, __tsover_mul(qualityC, 2)), __tsover_div(5e3, qualityC), qualityC < 50);
-	const Yv = d.arrayOf(d.f32, 64)();
-	const Cbv = d.arrayOf(d.f32, 64)();
-	const Crv = d.arrayOf(d.f32, 64)();
+	const qualityC = clamp(quality, 1, 100);
+	const qScale = select(__tsover_sub(200, __tsover_mul(qualityC, 2)), __tsover_div(5e3, qualityC), qualityC < 50);
+	const Yv = arrayOf(f32, 64)();
+	const Cbv = arrayOf(f32, 64)();
+	const Crv = arrayOf(f32, 64)();
 	for (let i = 0; i < 64; i++) {
 		const c = block[i];
 		Yv[i] = __tsover_sub(__tsover_add(__tsover_add(__tsover_mul(c.x, .299), __tsover_mul(c.y, .587)), __tsover_mul(c.z, .114)), .5);
 		Cbv[i] = __tsover_add(__tsover_add(__tsover_mul(c.x, -.168736), __tsover_mul(c.y, -.331264)), __tsover_mul(c.z, .5));
 		Crv[i] = __tsover_add(__tsover_add(__tsover_mul(c.x, .5), __tsover_mul(c.y, -.418688)), __tsover_mul(c.z, -.081312));
 	}
-	const rowCoef = d.arrayOf(d.f32, __tsover_mul(8, N_LUMA))();
+	const rowCoef = arrayOf(f32, __tsover_mul(8, N_LUMA))();
 	for (let y = 0; y < 8; y++) for (let u = 0; u < N_LUMA; u++) {
-		let sum = d.f32(0);
+		let sum = f32(0);
 		for (let x = 0; x < 8; x++) sum = __tsover_add(sum, __tsover_mul(Yv[__tsover_add(__tsover_mul(y, 8), x)], COS_LUT.$[__tsover_add(__tsover_mul(x, 8), u)]));
 		rowCoef[__tsover_add(__tsover_mul(y, N_LUMA), u)] = sum;
 	}
-	let acc = d.f32(0);
+	let acc = f32(0);
 	for (let v = 0; v < N_LUMA; v++) {
-		const av = std.select(1, SQRT1_2, v === 0);
-		const cy = std.cos(__tsover_mul(__tsover_add(__tsover_mul(localY, 2), 1), __tsover_mul(d.f32(v), PI_OVER_16)));
+		const av = select(1, SQRT1_2, v === 0);
+		const cy = cos(__tsover_mul(__tsover_add(__tsover_mul(localY, 2), 1), __tsover_mul(f32(v), PI_OVER_16)));
 		for (let u = 0; u < N_LUMA; u++) {
-			const au = std.select(1, SQRT1_2, u === 0);
-			let colSum = d.f32(0);
+			const au = select(1, SQRT1_2, u === 0);
+			let colSum = f32(0);
 			for (let y = 0; y < 8; y++) colSum = __tsover_add(colSum, __tsover_mul(rowCoef[__tsover_add(__tsover_mul(y, N_LUMA), u)], COS_LUT.$[__tsover_add(__tsover_mul(y, 8), v)]));
 			const G = __tsover_mul(colSum, __tsover_mul(__tsover_mul(.25, au), av));
-			const q = __tsover_div(std.clamp(std.floor(__tsover_div(__tsover_add(__tsover_mul(qScale, LUMA_QUANT_C.$[__tsover_add(__tsover_mul(v, 8), u)]), 50), 100)), 1, 255), 255);
-			const Gq = __tsover_mul(std.floor(__tsover_add(__tsover_div(G, q), .5)), q);
-			const cx = std.cos(__tsover_mul(__tsover_add(__tsover_mul(localX, 2), 1), __tsover_mul(d.f32(u), PI_OVER_16)));
+			const q = __tsover_div(clamp(floor(__tsover_div(__tsover_add(__tsover_mul(qScale, LUMA_QUANT_C.$[__tsover_add(__tsover_mul(v, 8), u)]), 50), 100)), 1, 255), 255);
+			const Gq = __tsover_mul(floor(__tsover_add(__tsover_div(G, q), .5)), q);
+			const cx = cos(__tsover_mul(__tsover_add(__tsover_mul(localX, 2), 1), __tsover_mul(f32(u), PI_OVER_16)));
 			acc = __tsover_add(acc, __tsover_mul(__tsover_mul(__tsover_mul(Gq, __tsover_mul(au, av)), cx), cy));
 		}
 	}
 	const Y = __tsover_add(__tsover_mul(acc, .25), .5);
-	let sumCb = d.f32(0);
-	let sumCr = d.f32(0);
+	let sumCb = f32(0);
+	let sumCr = f32(0);
 	for (let i = 0; i < 64; i++) {
 		sumCb = __tsover_add(sumCb, Cbv[i]);
 		sumCr = __tsover_add(sumCr, Crv[i]);
 	}
-	const qChroma = __tsover_div(std.clamp(std.floor(__tsover_div(__tsover_add(__tsover_mul(qScale, CHROMA_QUANT_C.$[0]), 50), 100)), 1, 255), 255);
+	const qChroma = __tsover_div(clamp(floor(__tsover_div(__tsover_add(__tsover_mul(qScale, CHROMA_QUANT_C.$[0]), 50), 100)), 1, 255), 255);
 	const GdcCb = __tsover_div(sumCb, 8);
 	const GdcCr = __tsover_div(sumCr, 8);
-	const Cb = __tsover_div(__tsover_mul(std.floor(__tsover_add(__tsover_div(GdcCb, qChroma), .5)), qChroma), 8);
-	const Cr = __tsover_div(__tsover_mul(std.floor(__tsover_add(__tsover_div(GdcCr, qChroma), .5)), qChroma), 8);
-	const r = __tsover_add(Y, __tsover_mul(Cr, 1.402));
-	const g = __tsover_sub(__tsover_sub(Y, __tsover_mul(Cb, .344136)), __tsover_mul(Cr, .714136));
-	const b = __tsover_add(Y, __tsover_mul(Cb, 1.772));
-	return std.clamp(d.vec3f(r, g, b), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
+	const Cb = __tsover_div(__tsover_mul(floor(__tsover_add(__tsover_div(GdcCb, qChroma), .5)), qChroma), 8);
+	const Cr = __tsover_div(__tsover_mul(floor(__tsover_add(__tsover_div(GdcCr, qChroma), .5)), qChroma), 8);
+	return clamp(vec3f(__tsover_add(Y, __tsover_mul(Cr, 1.402)), __tsover_sub(__tsover_sub(Y, __tsover_mul(Cb, .344136)), __tsover_mul(Cr, .714136)), __tsover_add(Y, __tsover_mul(Cb, 1.772))), vec3f(0, 0, 0), vec3f(1, 1, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1445,8 +1443,8 @@ const jpegBlockRgb = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		N_LUMA,
 		COS_LUT,
 		SQRT1_2,
@@ -1455,12 +1453,12 @@ const jpegBlockRgb = tgpu.fn([
 		CHROMA_QUANT_C
 	})
 }) && $.f)({}));
-const compressionCellUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
+const compressionCellUV = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
 	"use gpu";
-	const pPix = std.floor(uv.mul(viewport));
-	const cellX = std.clamp(std.floor(__tsover_div(pPix.x, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
-	const cellY = std.clamp(std.floor(__tsover_div(pPix.y, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
-	return d.vec2f(__tsover_div(__tsover_add(cellX, .5), MAX_CELLS), __tsover_div(__tsover_add(cellY, .5), MAX_CELLS));
+	const pPix = floor(uv.mul(viewport));
+	const cellX = clamp(floor(__tsover_div(pPix.x, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
+	const cellY = clamp(floor(__tsover_div(pPix.y, STRIDE)), 0, __tsover_sub(MAX_CELLS, 1));
+	return vec2f(__tsover_div(__tsover_add(cellX, .5), MAX_CELLS), __tsover_div(__tsover_add(cellY, .5), MAX_CELLS));
 }), {
 	v: 1,
 	name: void 0,
@@ -1610,52 +1608,52 @@ const compressionCellUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		STRIDE,
 		MAX_CELLS,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 function compressionParams() {
-	return d.struct({
-		inputWidth: d.f32,
-		inputHeight: d.f32,
-		quality: d.f32
+	return struct({
+		inputWidth: f32,
+		inputHeight: f32,
+		quality: f32
 	});
 }
 function buildCompressionGraph() {
 	const Params = compressionParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		input: { texture: d.texture2d(d.f32) },
-		cellTex: { storageTexture: d.textureStorage2d(CELL_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		input: { texture: texture2d(f32) },
+		cellTex: { storageTexture: textureStorage2d(CELL_FORMAT, "write-only") },
 		params: { uniform: Params }
 	}), "layout");
 	return {
 		layout,
-		kernel: tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 			"use gpu";
 			const p = layout.$.params;
-			const cellXf = d.f32(cx);
-			const cellYf = d.f32(cy);
-			const blockCol = std.floor(__tsover_div(cellXf, 8));
-			const blockRow = std.floor(__tsover_div(cellYf, 8));
+			const cellXf = f32(cx);
+			const cellYf = f32(cy);
+			const blockCol = floor(__tsover_div(cellXf, 8));
+			const blockRow = floor(__tsover_div(cellYf, 8));
 			const localX = __tsover_sub(cellXf, __tsover_mul(blockCol, 8));
 			const localY = __tsover_sub(cellYf, __tsover_mul(blockRow, 8));
 			const originX = __tsover_mul(blockCol, BLOCK_PX);
 			const originY = __tsover_mul(blockRow, BLOCK_PX);
-			const block = d.arrayOf(d.vec3f, 64)();
-			const wm1 = d.i32(__tsover_sub(p.inputWidth, 1));
-			const hm1 = d.i32(__tsover_sub(p.inputHeight, 1));
+			const block = arrayOf(vec3f, 64)();
+			const wm1 = i32(__tsover_sub(p.inputWidth, 1));
+			const hm1 = i32(__tsover_sub(p.inputHeight, 1));
 			for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
-				const px = __tsover_add(__tsover_add(originX, __tsover_mul(d.f32(x), STRIDE)), __tsover_mul(STRIDE, .5));
-				const py = __tsover_add(__tsover_add(originY, __tsover_mul(d.f32(y), STRIDE)), __tsover_mul(STRIDE, .5));
-				const ix = std.clamp(d.i32(px), 0, wm1);
-				const iy = std.clamp(d.i32(py), 0, hm1);
-				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(ix), d.u32(iy)), 0);
+				const px = __tsover_add(__tsover_add(originX, __tsover_mul(f32(x), STRIDE)), __tsover_mul(STRIDE, .5));
+				const py = __tsover_add(__tsover_add(originY, __tsover_mul(f32(y), STRIDE)), __tsover_mul(STRIDE, .5));
+				const ix = clamp(i32(px), 0, wm1);
+				const iy = clamp(i32(py), 0, hm1);
+				const texel = textureLoad(layout.$.input, vec2u(u32(ix), u32(iy)), 0);
 				block[__tsover_add(__tsover_mul(y, 8), x)] = unpremultiplyAlpha(texel).xyz;
 			}
 			const rgb = jpegBlockRgb(block, localX, localY, p.quality);
-			std.textureStore(layout.$.cellTex, d.vec2u(cx, cy), d.vec4f(rgb, 1));
+			textureStore(layout.$.cellTex, vec2u(cx, cy), vec4f(rgb, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -2163,8 +2161,8 @@ function buildCompressionGraph() {
 			},
 			externals: () => ({
 				layout,
-				d,
-				std,
+				d: data_exports,
+				std: std_exports,
 				BLOCK_PX,
 				STRIDE,
 				blend: blend_exports,

package/dist/core/{ConcentricSpin-D06hFXEb.js → ConcentricSpin-BPk-_egF.js}

@@ -1,11 +1,11 @@
-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 animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Ct as floor, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
 var PI = Math.PI;
 var TAU = Math.PI * 2;
-const csHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
+const csHash = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
 	"use gpu";
-	return __tsover_mul(__tsover_sub(std.fract(__tsover_mul(std.sin(__tsover_mul(x, 12.9898)), 43758.5453)), .5), 2);
+	return __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_mul(x, 12.9898)), 43758.5453)), .5), 2);
 }), {
 	v: 1,
 	name: void 0,
@@ -53,23 +53,23 @@ const csHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYP
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const csRotateUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, angle) => {
+const csRotateUV = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, center, angle) => {
 	"use gpu";
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const dx = __tsover_mul(__tsover_sub(uv.x, centerPos.x), aspect);
 	const dy = __tsover_sub(uv.y, centerPos.y);
-	const cosA = std.cos(angle);
-	const sinA = std.sin(angle);
+	const cosA = cos(angle);
+	const sinA = sin(angle);
 	const rotX = __tsover_sub(__tsover_mul(dx, cosA), __tsover_mul(dy, sinA));
 	const rotY = __tsover_add(__tsover_mul(dx, sinA), __tsover_mul(dy, cosA));
-	return d.vec2f(__tsover_add(__tsover_div(rotX, aspect), centerPos.x), __tsover_add(rotY, centerPos.y));
+	return vec2f(__tsover_add(__tsover_div(rotX, aspect), centerPos.x), __tsover_add(rotY, centerPos.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -262,43 +262,41 @@ const csRotateUV = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const concentricSpinUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, rings, smoothness, seed, speedRandomness, animTime, uv, aspect) => {
+const concentricSpinUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, rings, smoothness, seed, speedRandomness, animTime, uv, aspect) => {
 	"use gpu";
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
-	const dx = __tsover_mul(__tsover_sub(uv.x, centerPos.x), aspect);
-	const dy = __tsover_sub(uv.y, centerPos.y);
-	const dist = std.length(d.vec2f(dx, dy));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
+	const dist = length(vec2f(__tsover_mul(__tsover_sub(uv.x, centerPos.x), aspect), __tsover_sub(uv.y, centerPos.y)));
 	const ringCoord = __tsover_mul(dist, rings);
-	const ringIndex = std.floor(ringCoord);
-	const ringFrac = std.fract(ringCoord);
+	const ringIndex = floor(ringCoord);
+	const ringFrac = fract(ringCoord);
 	const maxAngle = __tsover_mul(intensity, .01745);
 	const seedOffset = __tsover_mul(seed, .137);
 	const staticA = __tsover_mul(csHash(__tsover_add(ringIndex, seedOffset)), maxAngle);
 	const staticB = __tsover_mul(csHash(__tsover_add(__tsover_add(ringIndex, 1), seedOffset)), maxAngle);
-	const ringSpeedA = std.mix(1, csHash(__tsover_add(ringIndex, 42.7)), speedRandomness);
-	const ringSpeedB = std.mix(1, csHash(__tsover_add(__tsover_add(ringIndex, 1), 42.7)), speedRandomness);
+	const ringSpeedA = mix(1, csHash(__tsover_add(ringIndex, 42.7)), speedRandomness);
+	const ringSpeedB = mix(1, csHash(__tsover_add(__tsover_add(ringIndex, 1), 42.7)), speedRandomness);
 	const animA = __tsover_mul(__tsover_mul(animTime, .25), ringSpeedA);
 	const animB = __tsover_mul(__tsover_mul(animTime, .25), ringSpeedB);
 	const totalA = __tsover_add(staticA, animA);
 	const totalB = __tsover_add(staticB, animB);
 	const wrapArg = __tsover_add(__tsover_sub(totalB, totalA), PI);
-	const diff = __tsover_sub(__tsover_sub(wrapArg, __tsover_mul(TAU, std.floor(__tsover_div(wrapArg, TAU)))), PI);
+	const diff = __tsover_sub(__tsover_sub(wrapArg, __tsover_mul(TAU, floor(__tsover_div(wrapArg, TAU)))), PI);
 	const halfEdge = __tsover_add(__tsover_mul(smoothness, .5), .001);
-	const blend = std.smoothstep(__tsover_sub(.5, halfEdge), __tsover_add(.5, halfEdge), ringFrac);
+	const blend = smoothstep(__tsover_sub(.5, halfEdge), __tsover_add(.5, halfEdge), ringFrac);
 	return csRotateUV(uv, aspect, center, __tsover_add(totalA, __tsover_mul(diff, blend)));
 }), {
 	v: 1,
@@ -763,8 +761,8 @@ const concentricSpinUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		csHash,
 		PI,
 		TAU,

package/dist/core/{ConicGradient-Cg6vy3gl.js → ConicGradient-B-tEhmfR.js}

@@ -1,26 +1,25 @@
-import { Et as mixColorStopsRuntime, 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 { h as colorStopsPropConfig } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Et as max, H as mixColorsLinear, U as mixColorsVariants, Vt as data_exports, an as f32, et as src_default, gt as atan2, nt as std_exports, p as call, wt as fract } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var TAU = 6.283185307179586;
 var INV_360 = 1 / 360;
-const conicFinalT = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, rotation, repeat, uv, viewport) => {
+const conicFinalT = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, rotation, repeat, uv, viewport) => {
 	"use gpu";
-	const safeViewportY = std.max(viewport.y, 1e-6);
+	const safeViewportY = max(viewport.y, 1e-6);
 	const aspect = __tsover_div(viewport.x, safeViewportY);
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const centerPos = d.vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
 	const dx = __tsover_sub(aspectUV.x, centerPos.x);
-	const dy = __tsover_sub(aspectUV.y, centerPos.y);
-	const angle = std.atan2(dy, dx);
+	const angle = atan2(__tsover_sub(aspectUV.y, centerPos.y), dx);
 	const normalized = __tsover_sub(.5, __tsover_div(angle, TAU));
 	const rotationFraction = __tsover_mul(rotation, INV_360);
-	return std.fract(__tsover_mul(__tsover_add(normalized, rotationFraction), repeat));
+	return fract(__tsover_mul(__tsover_add(normalized, rotationFraction), repeat));
 }), {
 	v: 1,
 	name: void 0,
@@ -238,8 +237,8 @@ const conicFinalT = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		TAU,
 		INV_360
 	})

package/dist/core/{ContourLines-Cg2Dlmcr.js → ContourLines-BlgCWFSy.js}

@@ -1,12 +1,12 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { At as pow, Et as max, Lt as smoothstep, Ot as mix, Vt as data_exports, _ as floatE, an as f32, bt as dot, ct as fwidth, 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, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, i as transformBoolean } from "./transformations-CsPUHppB.js";
 var transformSource = (value) => value === "alpha" ? 1 : 0;
 var transformColorMode = (value) => value === "custom" ? 1 : 0;
 var sourceModeOf = (raw) => typeof raw === "number" ? raw : raw === "alpha" ? 1 : 0;
 var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "custom" ? 1 : 0;
-const contourLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+const contourLuma = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	return std.dot(d.vec3f(color.x, color.y, color.z), d.vec3f(.2126, .7152, .0722));
+	return dot(vec3f(color.x, color.y, color.z), vec3f(.2126, .7152, .0722));
 }), {
 	v: 1,
 	name: void 0,
@@ -63,28 +63,27 @@ const contourLuma = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThi
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const contourLineMask = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceValue, levels, lineWidth, softness, gamma, invert) => {
+const contourLineMask = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceValue, levels, lineWidth, softness, gamma, invert) => {
 	"use gpu";
-	const invertedValue = std.select(sourceValue, __tsover_sub(1, sourceValue), invert > .5);
-	const sv = std.pow(invertedValue, gamma);
+	const sv = pow(select(sourceValue, __tsover_sub(1, sourceValue), invert > .5), gamma);
 	const scaledValue = __tsover_add(__tsover_mul(sv, levels), .5);
-	const fw = std.max(std.fwidth(scaledValue), 1e-4);
-	const distFromBoundary = std.abs(__tsover_sub(std.fract(__tsover_add(scaledValue, .5)), .5));
+	const fw = max(fwidth(scaledValue), 1e-4);
+	const distFromBoundary = abs(__tsover_sub(fract(__tsover_add(scaledValue, .5)), .5));
 	const normalizedDist = __tsover_div(distFromBoundary, fw);
 	const transitionFactor = __tsover_add(__tsover_mul(softness, .99), .01);
 	const innerEdge = __tsover_mul(lineWidth, __tsover_sub(1, transitionFactor));
-	return __tsover_sub(1, std.smoothstep(innerEdge, lineWidth, normalizedDist));
+	return __tsover_sub(1, smoothstep(innerEdge, lineWidth, normalizedDist));
 }), {
 	v: 1,
 	name: void 0,
@@ -284,17 +283,17 @@ const contourLineMask = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const contourCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bg, line, mask) => {
+const contourCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bg, line, mask) => {
 	"use gpu";
-	const rgb = std.mix(d.vec3f(bg.x, bg.y, bg.z), d.vec3f(line.x, line.y, line.z), d.vec3f(mask));
-	const alpha = std.mix(bg.w, line.w, mask);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, alpha);
+	const rgb = mix(vec3f(bg.x, bg.y, bg.z), vec3f(line.x, line.y, line.z), vec3f(mask));
+	const alpha = mix(bg.w, line.w, mask);
+	return vec4f(rgb.x, rgb.y, rgb.z, alpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -442,8 +441,8 @@ const contourCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {