shaders 3.0.447 → 3.0.449

package/dist/core/{GradientMap-DOVK05_a.js → GradientMap-DxsOInED.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Tn as d, Xt as formatFloat, 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 vec2f, Ct as floor, Et as max, H as mixColorsLinear, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, g as expr, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, wt as fract, x as formatFloat } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var PALETTES = {
 	0: {
 		a: [
@@ -147,17 +147,17 @@ var transformPalette = (value) => {
 };
 var TWO_PI = 6.283185307179586;
 var vec3E = (v) => expr(`vec3f(${formatFloat(v[0])}, ${formatFloat(v[1])}, ${formatFloat(v[2])})`);
-const gradientMapT = tgpu.fn([
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, black, white, contrast) => {
+const gradientMapT = src_default.fn([
+	vec4f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, black, white, contrast) => {
 	"use gpu";
-	const luma = std.dot(color.xyz, d.vec3f(.2126, .7152, .0722));
-	const range = std.max(__tsover_sub(white, black), 1e-4);
-	let t = std.clamp(__tsover_div(__tsover_sub(luma, black), range), 0, 1);
-	t = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(t, .5), contrast), .5), 0, 1);
+	const luma = dot(color.xyz, vec3f(.2126, .7152, .0722));
+	const range = max(__tsover_sub(white, black), 1e-4);
+	let t = clamp(__tsover_div(__tsover_sub(luma, black), range), 0, 1);
+	t = clamp(__tsover_add(__tsover_mul(__tsover_sub(t, .5), contrast), .5), 0, 1);
 	return t;
 }), {
 	v: 1,
@@ -294,22 +294,21 @@ const gradientMapT = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gradientMapCosine = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase, pa, pb, pc, pd) => {
+const gradientMapCosine = src_default.fn([
+	f32,
+	f32,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase, pa, pb, pc, pd) => {
 	"use gpu";
-	const arg = pc.mul(t).add(pd).add(d.vec3f(phase, phase, phase)).mul(TWO_PI);
-	const mapped = pa.add(pb.mul(std.cos(arg)));
-	return std.clamp(mapped, d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
+	const arg = pc.mul(t).add(pd).add(vec3f(phase, phase, phase)).mul(TWO_PI);
+	return clamp(pa.add(pb.mul(cos(arg))), vec3f(0, 0, 0), vec3f(1, 1, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -464,16 +463,16 @@ const gradientMapCosine = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		TWO_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const gradientMapCustomPhase = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase) => {
+const gradientMapCustomPhase = src_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phase) => {
 	"use gpu";
-	const t01 = std.fract(__tsover_add(t, phase));
+	const t01 = fract(__tsover_add(t, phase));
 	const t3 = __tsover_mul(t01, 3);
-	return d.vec2f(std.fract(t3), std.floor(t3));
+	return vec2f(fract(t3), floor(t3));
 }), {
 	v: 1,
 	name: void 0,
@@ -543,19 +542,18 @@ const gradientMapCustomPhase = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gradientMapSelect = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((seg0, seg1, seg2, i) => {
+const gradientMapSelect = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((seg0, seg1, seg2, i) => {
 	"use gpu";
-	const upper = std.select(seg2, seg1, i < 2);
-	return std.select(upper, seg0, i < 1);
+	return select(select(seg2, seg1, i < 2), seg0, i < 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -619,16 +617,15 @@ const gradientMapSelect = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gradientMapCompose = tgpu.fn([
-	d.vec4f,
-	d.vec3f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, mapped, strength) => {
+const gradientMapCompose = src_default.fn([
+	vec4f,
+	vec3f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, mapped, strength) => {
 	"use gpu";
-	const outRgb = std.mix(color.xyz, mapped, d.vec3f(strength, strength, strength));
-	return d.vec4f(outRgb, color.w);
+	return vec4f(mix(color.xyz, mapped, vec3f(strength, strength, strength)), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -695,8 +692,8 @@ const gradientMapCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Grayscale-Uv_6LYA9.js → Grayscale-DSHs9mZd.js}

@@ -1,8 +1,8 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const grayscaleColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+import { Vt as data_exports, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+const grayscaleColor = src_default.fn([vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	const luminance = std.dot(color.xyz, d.vec3f(.2126, .7152, .0722));
-	return d.vec4f(luminance, luminance, luminance, color.w);
+	const luminance = dot(color.xyz, vec3f(.2126, .7152, .0722));
+	return vec4f(luminance, luminance, luminance, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -60,8 +60,8 @@ const grayscaleColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (glob
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Grid-Dbp4DoXZ.js → Grid-aO3wzf4X.js}

@@ -1,32 +1,32 @@
-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 vec2f, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, et as src_default, mt as abs, nt as std_exports, ot as dpdx, p as call, st as dpdy, vt as cos, wt as fract, y as vec4, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const gridCellCenterUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, rotation) => {
+const gridCellCenterUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, rotation) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const correctedX = __tsover_mul(uv.x, aspect);
 	const correctedY = __tsover_sub(1, uv.y);
 	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedX, centerX);
 	const cy = __tsover_sub(correctedY, centerY);
 	const rotX = __tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX);
 	const rotY = __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY);
-	const cellRX = __tsover_div(__tsover_add(std.floor(__tsover_mul(rotX, cells)), .5), cells);
-	const cellRY = __tsover_div(__tsover_add(std.floor(__tsover_mul(rotY, cells)), .5), cells);
+	const cellRX = __tsover_div(__tsover_add(floor(__tsover_mul(rotX, cells)), .5), cells);
+	const cellRY = __tsover_div(__tsover_add(floor(__tsover_mul(rotY, cells)), .5), cells);
 	const ccx = __tsover_sub(cellRX, centerX);
 	const ccy = __tsover_sub(cellRY, centerY);
 	const unrotX = __tsover_add(__tsover_add(__tsover_mul(ccx, cosR), __tsover_mul(ccy, sinR)), centerX);
 	const unrotY = __tsover_add(__tsover_add(__tsover_mul(ccx, -sinR), __tsover_mul(ccy, cosR)), centerY);
-	return d.vec2f(__tsover_div(unrotX, aspect), __tsover_sub(1, unrotY));
+	return vec2f(__tsover_div(unrotX, aspect), __tsover_sub(1, unrotY));
 }), {
 	v: 1,
 	name: void 0,
@@ -375,19 +375,19 @@ const gridCellCenterUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gridFilterAxis = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, wx, N) => {
+const gridFilterAxis = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, wx, N) => {
 	"use gpu";
 	const a = __tsover_add(px, __tsover_mul(wx, .5));
 	const b = __tsover_sub(px, __tsover_mul(wx, .5));
-	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(std.floor(a), std.min(__tsover_mul(std.fract(a), N), 1)), std.floor(b)), std.min(__tsover_mul(std.fract(b), N), 1)), __tsover_mul(N, wx));
+	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(floor(a), min(__tsover_mul(fract(a), N), 1)), floor(b)), min(__tsover_mul(fract(b), N), 1)), __tsover_mul(N, wx));
 }), {
 	v: 1,
 	name: void 0,
@@ -524,50 +524,48 @@ const gridFilterAxis = tgpu.fn([
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const gridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
+const gridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const correctedX = __tsover_mul(uv.x, aspect);
 	const correctedY = __tsover_sub(1, uv.y);
 	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedX, centerX);
 	const cy = __tsover_sub(correctedY, centerY);
 	const rotX = __tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX);
 	const rotY = __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY);
-	const gridUV = d.vec2f(__tsover_mul(rotX, cells), __tsover_mul(rotY, cells));
+	const gridUV = vec2f(__tsover_mul(rotX, cells), __tsover_mul(rotY, cells));
 	const lineWidth = __tsover_mul(thickness, .01);
-	const safeLine = std.max(lineWidth, 1e-4);
+	const safeLine = max(lineWidth, 1e-4);
 	const lineFraction = __tsover_mul(safeLine, 2);
 	const N = __tsover_div(1, lineFraction);
 	const p = gridUV.add(safeLine);
-	const dpx = std.dpdx(p);
-	const dpy = std.dpdy(p);
-	const wx = __tsover_add(std.max(std.max(std.abs(dpx.x), std.abs(dpy.x)), 1e-5), softness);
-	const wy = __tsover_add(std.max(std.max(std.abs(dpx.y), std.abs(dpy.y)), 1e-5), softness);
+	const dpx = dpdx(p);
+	const dpy = dpdy(p);
+	const wx = __tsover_add(max(max(abs(dpx.x), abs(dpy.x)), 1e-5), softness);
+	const wy = __tsover_add(max(max(abs(dpx.y), abs(dpy.y)), 1e-5), softness);
 	const iX = gridFilterAxis(p.x, wx, N);
 	const iY = gridFilterAxis(p.y, wy, N);
 	const gapBoth = __tsover_mul(__tsover_sub(1, iX), __tsover_sub(1, iY));
-	const gridMask = __tsover_mul(__tsover_sub(1, gapBoth), std.step(1e-4, lineWidth));
-	const cellId = std.floor(gridUV);
-	const q0 = std.fract(cellId.mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	return d.vec2f(gridMask, variedFactor);
+	const gridMask = __tsover_mul(__tsover_sub(1, gapBoth), step(1e-4, lineWidth));
+	const q0 = fract(floor(gridUV).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	return vec2f(gridMask, max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -1201,8 +1199,8 @@ const gridField = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		gridFilterAxis
 	})
 }) && $.f)({}));

package/dist/core/{GridDistortion-D_21zIrm.js → GridDistortion-DsHsHda7.js}

@@ -1,57 +1,58 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Et as max, Gt as textureStorage2d, N as unpremultiplyAlpha, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, c as sampleRemappedExpr, d as ZERO, et as src_default, g as expr, in as vec4f, mt as abs, n as composeEdgeRemapExpr, nt as std_exports, p as call, pt as select, sn as u32, tn as vec2u, xt as exp } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEFAULT_GRID_SIZE = 20;
 var MIN_GRID = 8;
 var MAX_GRID = 128;
 var MAX_CELLS = MAX_GRID * MAX_GRID;
 var STATE_FORMAT = "rgba16float";
 var clampGrid = (v) => Math.max(MIN_GRID, Math.min(MAX_GRID, Math.floor(v)));
-var updateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var updateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	buffer: {
-		storage: d.arrayOf(d.vec4f, MAX_CELLS),
+		storage: arrayOf(vec4f, MAX_CELLS),
 		access: "mutable"
 	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-		cursorX: d.f32,
-		cursorY: d.f32,
-		mouseVelX: d.f32,
-		mouseVelY: d.f32,
-		dt: d.f32,
-		decay: d.f32,
-		intensity: d.f32,
-		radius: d.f32,
-		aspect: d.f32
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		cursorX: f32,
+		cursorY: f32,
+		mouseVelX: f32,
+		mouseVelY: f32,
+		dt: f32,
+		decay: f32,
+		intensity: f32,
+		radius: f32,
+		aspect: f32
 	}), "uniform") }
 }), "updateLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	buffer: {
-		storage: d.arrayOf(d.vec4f, MAX_CELLS),
+		storage: arrayOf(vec4f, MAX_CELLS),
 		access: "readonly"
 	},
-	dispTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	dispTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
 function makeUpdateKernel(gridSize) {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 		"use gpu";
 		const p = updateLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(gridSize)), cx);
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
 		const cell = updateLayout.$.buffer[idx];
 		let dx = __tsover_mul(cell.x, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
 		let dy = __tsover_mul(cell.y, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
-		const cellX = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(gridSize));
-		const cellY = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(gridSize));
-		const ddx = std.select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
-		const ddy = std.select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
+		const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(gridSize));
+		const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(gridSize));
+		const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
+		const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
 		const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
 		const radius2 = __tsover_mul(p.radius, 2);
-		if (distSq < __tsover_mul(radius2, radius2) && __tsover_add(std.abs(p.mouseVelX), std.abs(p.mouseVelY)) > .01) {
-			const influence = std.exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
+		if (distSq < __tsover_mul(radius2, radius2) && __tsover_add(abs(p.mouseVelX), abs(p.mouseVelY)) > .01) {
+			const influence = exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
 			dx = __tsover_add(dx, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelX, influence), p.intensity), p.dt), .5));
 			dy = __tsover_add(dy, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelY, influence), p.intensity), p.dt), .5));
 		}
-		dx = std.clamp(dx, -1, 1);
-		dy = std.clamp(dy, -1, 1);
-		updateLayout.$.buffer[idx] = d.vec4f(dx, dy, 0, 0);
+		dx = clamp(dx, -1, 1);
+		dy = clamp(dy, -1, 1);
+		updateLayout.$.buffer[idx] = vec4f(dx, dy, 0, 0);
 	}), {
 		v: 1,
 		name: void 0,
@@ -649,18 +650,18 @@ function makeUpdateKernel(gridSize) {
 		},
 		externals: () => ({
 			updateLayout,
-			d,
+			d: data_exports,
 			gridSize,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name("gridDistortionUpdate");
 }
 function makeOutputKernel(gridSize) {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 		"use gpu";
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(gridSize)), cx);
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
 		const cell = outputLayout.$.buffer[idx];
-		std.textureStore(outputLayout.$.dispTex, d.vec2u(cx, cy), d.vec4f(cell.x, cell.y, 0, 1));
+		textureStore(outputLayout.$.dispTex, vec2u(cx, cy), vec4f(cell.x, cell.y, 0, 1));
 	}), {
 		v: 1,
 		name: void 0,
@@ -772,25 +773,25 @@ function makeOutputKernel(gridSize) {
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			gridSize,
 			outputLayout,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name("gridDistortionOutput");
 }
-const gridCellSnap = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridSize, aspect) => {
+const gridCellSnap = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridSize, aspect) => {
 	"use gpu";
 	const isWide = aspect > 1;
-	const cellsX = std.max(std.select(__tsover_mul(gridSize, aspect), gridSize, isWide), 1);
-	const cellsY = std.max(std.select(gridSize, __tsover_div(gridSize, aspect), isWide), 1);
-	const cellIndexX = std.floor(__tsover_mul(uv.x, cellsX));
-	const cellIndexY = std.floor(__tsover_mul(uv.y, cellsY));
-	return d.vec2f(__tsover_div(__tsover_add(cellIndexX, .5), cellsX), __tsover_div(__tsover_add(cellIndexY, .5), cellsY));
+	const cellsX = max(select(__tsover_mul(gridSize, aspect), gridSize, isWide), 1);
+	const cellsY = max(select(gridSize, __tsover_div(gridSize, aspect), isWide), 1);
+	const cellIndexX = floor(__tsover_mul(uv.x, cellsX));
+	const cellIndexY = floor(__tsover_mul(uv.y, cellsY));
+	return vec2f(__tsover_div(__tsover_add(cellIndexX, .5), cellsX), __tsover_div(__tsover_add(cellIndexY, .5), cellsY));
 }), {
 	v: 1,
 	name: void 0,
@@ -957,14 +958,14 @@ const gridCellSnap = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gridDistortOffsetUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp) => {
+const gridDistortOffsetUV = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp) => {
 	"use gpu";
 	const maxDisp = .1;
-	const clamped = std.clamp(disp, d.vec2f(-maxDisp, -maxDisp), d.vec2f(maxDisp, maxDisp));
+	const clamped = clamp(disp, vec2f(-maxDisp, -maxDisp), vec2f(maxDisp, maxDisp));
 	return uv.sub(clamped);
 }), {
 	v: 1,
@@ -1037,8 +1038,8 @@ const gridDistortOffsetUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -1134,23 +1135,23 @@ const componentDefinition = {
 		const root = gpu?.root;
 		if (!root) return null;
 		const gridSize = clampGrid(getCpuValue("gridSize") ?? DEFAULT_GRID_SIZE);
-		const buffer = createStateBuffer(root, d.vec4f, MAX_CELLS);
+		const buffer = createStateBuffer(root, vec4f, MAX_CELLS);
 		const dispTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [gridSize, gridSize],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "dispTex");
 		onCleanup(() => dispTex.destroy());
 		const displacement = registerComputeTexture(dispTex);
-		const updateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
-			cursorX: d.f32,
-			cursorY: d.f32,
-			mouseVelX: d.f32,
-			mouseVelY: d.f32,
-			dt: d.f32,
-			decay: d.f32,
-			intensity: d.f32,
-			radius: d.f32,
-			aspect: d.f32
+		const updateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			cursorX: f32,
+			cursorY: f32,
+			mouseVelX: f32,
+			mouseVelY: f32,
+			dt: f32,
+			decay: f32,
+			intensity: f32,
+			radius: f32,
+			aspect: f32
 		})), "updateParams");
 		let curW = Math.max(1, Math.round(dimensions.width));
 		let curH = Math.max(1, Math.round(dimensions.height));

package/dist/core/{Group-DXiB5Qrx.js → Group-CCcDbysC.js}

@@ -1,4 +1,4 @@
-import { Bt as ZERO } from "./coords-BkIjixe_.js";
+import { d as ZERO } from "./edges-BXNBKxSN.js";
 const componentDefinition = {
 	name: "Group",
 	category: "Utilities",

package/dist/core/{HTMLInCanvas-xXPLTYIv.js → HTMLInCanvas-B2OooKKr.js}

@@ -1,4 +1,4 @@
-import { Ht as call, Jt as vec4, in as srgbToLinear } from "./coords-BkIjixe_.js";
+import { k as srgbToLinear, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
 const componentDefinition = {
 	name: "HTMLInCanvas",
 	deprecatedNames: ["DOMTexture"],