shaders 3.2.475 → 4.0.0

package/dist/core/compose-DNU_Ut36.js

@@ -1,46 +0,0 @@
-import { ct as call, n as paintFrame } from "./lower-DtoDQ7hV.js";
-import { r as rgbDither } from "./tone-CsRho9qb.js";
-import { t as animatedTime } from "./porters-CQwDd2t4.js";
-import { H as vec4, i as clamp, n as add, o as div, w as mul, x as max, y as local, z as sub } from "./math-7PlusTFx.js";
-function layered(layerData, build) {
-	let weightedSum;
-	let totalWeight;
-	layerData.forEach((layer, index) => {
-		const { value, weight } = build(layer, index);
-		const contribution = mul(value, weight);
-		weightedSum = weightedSum === void 0 ? contribution : add(weightedSum, contribution);
-		totalWeight = totalWeight === void 0 ? weight : add(totalWeight, weight);
-	});
-	if (!weightedSum || !totalWeight) throw new Error("std: layered([]) needs at least one layer");
-	return {
-		weightedSum,
-		totalWeight
-	};
-}
-function layers(entries) {
-	let acc;
-	for (const entry of entries) {
-		const spec = entry instanceof Object && "paint" in entry ? entry : { paint: entry };
-		let term = spec.paint;
-		if (spec.opacity !== void 0) term = mul(term, spec.opacity);
-		if (spec.behind) term = mul(term, spec.behind);
-		acc = acc === void 0 ? term : spec.blend === "screen" ? sub(add(acc, term), mul(acc, term)) : add(acc, term);
-	}
-	if (!acc) throw new Error("std: layers([]) needs at least one layer");
-	return acc;
-}
-function emissiveAlpha(rgb, hint = "emissive") {
-	const c = local(rgb, hint);
-	const a = local(clamp(max(max(c.member("x"), c.member("y")), c.member("z")), 0, 1), `${hint}A`);
-	return vec4(div(c, max(a, 1e-4)), a);
-}
-function dithered(color, params) {
-	const { uv, viewport } = paintFrame(params);
-	return call(rgbDither, "rgbDither", [
-		color,
-		uv,
-		viewport,
-		animatedTime(params)
-	]);
-}
-export { layers as i, emissiveAlpha as n, layered as r, dithered as t };

package/dist/core/device-m0ud8-Fn.js

@@ -1,10 +0,0 @@
-function isMobileGpuViewport() {
-	if (typeof window === "undefined") return false;
-	const coarse = !!(window.matchMedia && window.matchMedia("(pointer: coarse)").matches);
-	const cssLong = Math.max(window.innerWidth || 0, window.innerHeight || 0);
-	return coarse && cssLong > 0 && cssLong <= 1366;
-}
-function maxPixelRatioForDevice() {
-	return isMobileGpuViewport() ? 1.5 : 2;
-}
-export { maxPixelRatioForDevice as n, isMobileGpuViewport as t };

package/dist/core/feedback-yfT0pT6A.js

@@ -1,46 +0,0 @@
-import { F as createFluidKernelPass, St as createFeedbackTrailSim } from "./porters-CQwDd2t4.js";
-function feedbackSim(build) {
-	return { compute: (params) => {
-		const { childNode, gpu } = params;
-		if (!childNode) return null;
-		const root = gpu?.root;
-		if (!root) return null;
-		const cfg = build(params, root);
-		const paramsU = root.createUniform(cfg.paramsSchema);
-		const sim = createFeedbackTrailSim(params, {
-			size: cfg.size,
-			format: cfg.format,
-			extraSlots: cfg.extraSlots,
-			textures: cfg.textures,
-			speedProp: cfg.speedProp,
-			maxDeltaTime: cfg.maxDeltaTime,
-			bindGroups: (ctx, read, write) => cfg.bindGroups({
-				...ctx,
-				paramsBuffer: paramsU.buffer
-			}, read, write),
-			staticGroups: cfg.staticGroups ? (ctx) => cfg.staticGroups({
-				...ctx,
-				paramsBuffer: paramsU.buffer
-			}) : void 0
-		});
-		if (!sim) return null;
-		const pipeline = createFluidKernelPass(root, cfg.step, {
-			n: cfg.size,
-			bindGroup: void 0
-		});
-		return {
-			outputs: {
-				childTexture: sim.childTexture,
-				display: sim.display,
-				...cfg.outputs ?? {}
-			},
-			bindInputs: sim.bindInputs,
-			getComputeNodes: (frameParams) => sim.tick(frameParams, (t) => {
-				if (cfg.skip?.(t)) return null;
-				paramsU.write(cfg.values(t));
-				return [pipeline.with(t.groups)];
-			})
-		};
-	} };
-}
-export { feedbackSim as t };

package/dist/core/fields-CXwmEUsd.js

@@ -1,475 +0,0 @@
-import { Bt as mixPreconvertedVariants, Cn as mxNoiseFloat3, Dn as perlin13, Fn as GOLDEN, It as mixColorsLinear, Jt as domainWarp2, Kt as chainedWarpStep, Lt as mixColorsVariants, Qt as scatterFieldAnchored, Rt as mixPreconvertedInSpace, Zt as scatterField$1, a as resolveScalar, ct as call, ft as floatE, jn as value13, jt as convertP3ToMixSpaceCPU, mt as vec4, o as uniformOf, qt as domainWarp1, s as Scalar, st as asLocal, zn as TAU, zt as mixPreconvertedLinear } from "./lower-DtoDQ7hV.js";
-import { s as toneUnitPivotInverted } from "./tone-CsRho9qb.js";
-import { A as unitThreshold, C as radialDist, D as shimmerPulse, E as repeatWrap, O as spiralMask, S as plasmaTone, T as repeatRings, c as diamondDist, f as gradientClamp01, g as gradientTransparentAlpha, h as gradientRawT, j as volumeDomain, k as unitNoise3, l as flowLayers, m as gradientEdgeWrap, o as conicSweep, p as gradientEdgeMirror, w as rampWrap } from "./gradientPaints-Cx2bT20T.js";
-import { Dt as mixColorStopsRuntime, t as animatedTime } from "./porters-CQwDd2t4.js";
-import { o as transformColorSpace } from "./transformations-CzFmhZww.js";
-import { B as vec2, V as vec3, f as fract, i as clamp, t as abs, w as mul, y as local, z as sub } from "./math-7PlusTFx.js";
-const noiseToneKColor = toneUnitPivotInverted;
-function mixStopsOrColorsExpr(params, t, endpoints = {}) {
-	const { uniforms, propValues } = params;
-	const colorSpaceMode = propValues.colorSpace ?? 0;
-	if ((propValues.stopCount ?? 0) > 1) return mixColorStopsRuntime(t, {
-		colorsArray: uniforms.colorsArray,
-		positionsArray: uniforms.positionsArray,
-		convertedColorsArray: uniforms.convertedColorsArray,
-		stopCount: uniforms.stopCount
-	}, colorSpaceMode);
-	return call(mixColorsVariants[colorSpaceMode] ?? mixColorsLinear, "mixColors", [
-		uniforms[endpoints.colorA ?? "colorA"],
-		uniforms[endpoints.colorB ?? "colorB"],
-		t
-	]);
-}
-var f = Math.fround;
-var F_GOLDEN = f(GOLDEN);
-var F_TAU = f(TAU);
-const SCATTER_DRIFT_RATE = .11;
-var U32 = f(4294967295);
-var bitView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
-function floatBitsToUint(x) {
-	bitView.setFloat32(0, f(x), true);
-	return bitView.getUint32(0, true);
-}
-function umul(a, b) {
-	return Math.imul(a >>> 0, b >>> 0) >>> 0;
-}
-function hash11Cpu(p) {
-	const u = floatBitsToUint(f(f(p) * f(3141592653)));
-	return f(f(umul(umul(u, u), 3141592653)) / U32);
-}
-function hash22Cpu(x, y) {
-	const h = (floatBitsToUint(f(f(x) * f(141421356))) ^ floatBitsToUint(f(f(y) * f(2718281828)))) >>> 0;
-	return [f(f(umul(h, 3141592653)) / U32), f(f(umul(h, 1618033988)) / U32)];
-}
-function spiralScatterCpu(fi, count, seed, drift, aspect, animTime) {
-	const theta = f(f(fi * F_GOLDEN) + f(hash11Cpu(f(f(seed * f(.7311)) + f(1.618))) * F_TAU));
-	const r = f(Math.sqrt(f(f(fi + .5) / f(count))));
-	const jh = hash22Cpu(f(f(fi * f(3.77)) + f(.917)), f(f(seed * f(1.093)) + f(2.236)));
-	const jx = f(f(jh[0] - .5) * f(.26));
-	const jy = f(f(jh[1] - .5) * f(.26));
-	const ph = hash22Cpu(f(f(fi * f(7.13)) + f(1.618)), f(f(seed * f(.531)) + f(3.71)));
-	const phx = f(ph[0] * F_TAU);
-	const phy = f(ph[1] * F_TAU);
-	const w1 = f(.5 + f(hash11Cpu(f(f(f(fi * f(5.417)) + f(seed * f(.291))) + f(.917))) * f(.7)));
-	const tw = f(f(animTime * f(SCATTER_DRIFT_RATE)) * w1);
-	const dx = f(Math.sin(f(tw + phx)));
-	const dy = f(Math.cos(f(f(tw * f(1.37)) + phy)));
-	const nx = f(f(f(f(Math.cos(theta)) * r) * f(.62)) + jx) + f(f(dx * f(drift)) * f(.16));
-	const ny = f(f(f(f(Math.sin(theta)) * r) * f(.62)) + jy) + f(f(dy * f(drift)) * f(.16));
-	return [f(f(.5 + f(nx)) * f(aspect)), f(.5 + f(ny))];
-}
-function packScatterAnchors(count, seed, drift, aspect, animTime) {
-	const out = new Array(16);
-	for (let i = 0; i < 8; i++) {
-		const [x, y] = spiralScatterCpu(i, count, seed, drift, aspect, animTime);
-		out[i * 2] = x;
-		out[i * 2 + 1] = y;
-	}
-	return out;
-}
-function baseArg(spec, params) {
-	if (typeof spec === "number") return floatE(spec);
-	if (spec instanceof Scalar || spec.kind !== "ctx") return resolveScalar(spec, params);
-	return params.ctx[spec.name];
-}
-function fArg(spec, params) {
-	if (typeof spec === "object" && spec !== null && "base" in spec) {
-		let e = baseArg(spec.base, params);
-		if (spec.add !== void 0) e = e.add(spec.add);
-		if (spec.mul !== void 0) e = e.mul(spec.mul);
-		return e;
-	}
-	return baseArg(spec, params);
-}
-function frame(params) {
-	return {
-		uv: params.uvContext ?? params.ctx.uv,
-		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
-	};
-}
-function structural(ref, params) {
-	return params.propValues[ref.name];
-}
-function colorSpaceModeOf(raw) {
-	if (typeof raw === "number") return raw;
-	if (typeof raw === "string") return transformColorSpace(raw);
-	return 0;
-}
-function mixColorsIn(space, params) {
-	return mixColorsVariants[space ? colorSpaceModeOf(params.propValues[space.name]) : 0] ?? mixColorsLinear;
-}
-function colorLadder3(slots) {
-	return (t1, t2, params) => {
-		const variant = mixColorsIn(slots.space, params);
-		return call(variant, "mixColors", [
-			call(variant, "mixColors", [
-				uniformOf(slots.a, params),
-				uniformOf(slots.b, params),
-				t1
-			]),
-			uniformOf(slots.c, params),
-			t2
-		]);
-	};
-}
-function pair(a, b, space) {
-	return (t, params) => {
-		return call(mixColorsVariants[colorSpaceModeOf(structural(space, params))] ?? mixColorsLinear, "mixColors", [
-			uniformOf(a, params),
-			uniformOf(b, params),
-			t
-		]);
-	};
-}
-function stops(space) {
-	return (t, params) => {
-		const spaceMode = colorSpaceModeOf(structural(space, params));
-		if ((params.propValues.stopCount ?? 0) > 1) return mixColorStopsRuntime(t, {
-			colorsArray: params.uniforms.colorsArray,
-			positionsArray: params.uniforms.positionsArray,
-			convertedColorsArray: params.uniforms.convertedColorsArray,
-			stopCount: params.uniforms.stopCount
-		}, spaceMode);
-		return call(mixColorsVariants[spaceMode] ?? mixColorsLinear, "mixColors", [
-			params.uniforms.colorA,
-			params.uniforms.colorB,
-			t
-		]);
-	};
-}
-var TRANSPARENT = 1;
-var MIRROR = 2;
-var WRAP = 3;
-function rampOver(field, palette, opts) {
-	return (params) => {
-		const { uv } = frame(params);
-		const t = field(params, uv);
-		if (!opts?.edges) return palette(t, params);
-		const edgeMode = structural(opts.edges, params) ?? 0;
-		let finalT;
-		if (edgeMode === MIRROR) finalT = call(gradientEdgeMirror, "gradientEdgeMirror", [t]);
-		else if (edgeMode === WRAP) finalT = call(gradientEdgeWrap, "gradientEdgeWrap", [t]);
-		else if (edgeMode === TRANSPARENT) finalT = t;
-		else finalT = call(gradientClamp01, "gradientClamp01", [t]);
-		const color = palette(call(gradientClamp01, "gradientClamp01", [finalT]), params);
-		if (edgeMode === TRANSPARENT) {
-			const cut = call(gradientTransparentAlpha, "gradientTransparentAlpha", [t]);
-			return vec4(color.member("rgb"), color.member("a").mul(cut));
-		}
-		return color;
-	};
-}
-const dist = {
-	linear(slots) {
-		return (params, uv) => {
-			const { viewport } = frame(params);
-			return call(gradientRawT, "gradientRawT", [
-				uniformOf(slots.from, params),
-				uniformOf(slots.to, params),
-				fArg(slots.angle, params),
-				uv,
-				viewport
-			]);
-		};
-	},
-	radial(slots) {
-		return (params, uv) => {
-			const { viewport } = frame(params);
-			return call(radialDist, "radialDist", [
-				uniformOf(slots.center, params),
-				fArg(slots.skew, params),
-				fArg(slots.aspect, params),
-				fArg(slots.radius, params),
-				uv,
-				viewport
-			]);
-		};
-	},
-	conic(slots) {
-		return (params, uv) => {
-			const { viewport } = frame(params);
-			return call(conicSweep, "conicSweep", [
-				uniformOf(slots.center, params),
-				fArg(slots.rotation, params),
-				uv,
-				viewport
-			]);
-		};
-	},
-	diamond(slots) {
-		return (params, uv) => {
-			const { viewport } = frame(params);
-			return call(diamondDist, "diamondDist", [
-				uniformOf(slots.center, params),
-				fArg(slots.size, params),
-				fArg(slots.rotation, params),
-				fArg(slots.roundness, params),
-				uv,
-				viewport
-			]);
-		};
-	},
-	spiral(slots) {
-		return (params, uv) => {
-			const { viewport } = frame(params);
-			return call(spiralMask, "spiralMask", [
-				uniformOf(slots.center, params),
-				fArg(slots.scale, params),
-				fArg(slots.width, params),
-				fArg(slots.falloff, params),
-				fArg(slots.softness, params),
-				animatedTime(params),
-				uv,
-				viewport
-			]);
-		};
-	}
-};
-function rings(field, count) {
-	return (params, coord) => call(repeatRings, "repeatRings", [field(params, coord), fArg(count, params)]);
-}
-function tiles(field, count) {
-	return (params, coord) => call(repeatWrap, "repeatWrap", [field(params, coord), fArg(count, params)]);
-}
-function tone(field, opts) {
-	return (params, coord) => call(plasmaTone, "toneRemap", [
-		field(params, coord),
-		fArg(opts.glow, params),
-		fArg(opts.contrast, params),
-		fArg(opts.balance, params)
-	]);
-}
-function threshold(field, opts) {
-	return (params, coord) => call(unitThreshold, "unitThreshold", [
-		field(params, coord),
-		opts.bias !== void 0 ? fArg(opts.bias, params) : floatE(0),
-		floatE(opts.low),
-		floatE(opts.high)
-	]);
-}
-function share(field) {
-	const cache = /* @__PURE__ */ new WeakMap();
-	return (params, coord) => {
-		let bound = cache.get(params);
-		if (!bound) {
-			bound = asLocal(field(params, coord), "field");
-			cache.set(params, bound);
-		}
-		return bound;
-	};
-}
-var NOISE_BASES = {
-	mx3: {
-		fn: () => unitNoise3,
-		hint: "unitNoise3"
-	},
-	perlin: {
-		fn: () => perlin13,
-		hint: "perlin13"
-	},
-	value: {
-		fn: () => value13,
-		hint: "value13"
-	},
-	mx3signed: {
-		fn: () => mxNoiseFloat3,
-		hint: "mxNoiseFloat3"
-	}
-};
-function noiseField(basis) {
-	const entry = NOISE_BASES[basis];
-	return (_params, coord) => call(entry.fn(), entry.hint, [coord]);
-}
-function warped(field, opts) {
-	const warpFn = domainWarp2(mxNoiseFloat3, { name: "warpDomain" });
-	return (params, coord) => {
-		let amount = fArg(opts.amount, params);
-		if (opts.amountScale !== void 0) amount = amount.mul(opts.amountScale);
-		let time = animatedTime(params);
-		if (opts.timeScale !== void 0) time = time.mul(opts.timeScale);
-		return field(params, call(warpFn, "warpDomain", [
-			coord,
-			time,
-			amount
-		]));
-	};
-}
-function scaledVolume(field, opts) {
-	return (params, uv) => {
-		const { viewport } = frame(params);
-		return field(params, call(volumeDomain, "volumeDomain", [
-			uv,
-			viewport,
-			fArg(opts.scale, params)
-		]));
-	};
-}
-function flowField(slots) {
-	return (params, coord) => call(flowLayers, "flowLayers", [
-		coord,
-		fArg(slots.detail, params),
-		animatedTime(params)
-	]);
-}
-function pulse(field, opts) {
-	return (params, coord) => call(shimmerPulse, "shimmerPulse", [
-		field(params, coord),
-		animatedTime(params),
-		floatE(opts.speed),
-		floatE(opts.span),
-		floatE(opts.depth)
-	]);
-}
-function hueWheel(h) {
-	const x = local(mul(fract(h), 6), "hue6");
-	return vec3(clamp(sub(abs(sub(x, 3)), 1), 0, 1), clamp(sub(2, abs(sub(x, 2))), 0, 1), clamp(sub(2, abs(sub(x, 4))), 0, 1));
-}
-function shimmered(paint, gain) {
-	return (params) => paint(params).mul(gain(params, params.ctx.uv));
-}
-function scatterField(opts) {
-	const e = (v) => typeof v === "number" ? floatE(v) : v;
-	if (opts.anchors) return call(scatterFieldAnchored, "scatterField", [
-		opts.at,
-		e(opts.count),
-		e(opts.seed),
-		opts.anchors,
-		e(opts.softness)
-	]);
-	return call(scatterField$1, "scatterField", [
-		opts.at,
-		e(opts.count),
-		e(opts.seed),
-		e(opts.drift),
-		e(opts.aspect),
-		e(opts.time),
-		e(opts.softness)
-	]);
-}
-function scatteredAnchors(params, slots) {
-	let aspect = params.dimensions.width / Math.max(params.dimensions.height, 1e-6);
-	params.onResize(({ width, height }) => {
-		aspect = width / Math.max(height, 1e-6);
-	});
-	let lastKey = "";
-	params.onBeforeRender(() => {
-		const t = params.getCpuValue("_animTime");
-		const count = params.getCpuValue(slots.count.name);
-		const seed = params.getCpuValue(slots.seed.name);
-		const drift = params.getCpuValue(slots.drift.name);
-		if (typeof t !== "number" || typeof count !== "number" || typeof seed !== "number" || typeof drift !== "number") return;
-		const key = `${count}|${seed}|${drift}|${aspect}|${t}`;
-		if (key === lastKey) return;
-		lastKey = key;
-		params.setExtraField(slots.field, packScatterAnchors(count, seed, drift, aspect, t));
-	});
-	return params.uniforms[slots.field];
-}
-function wrapRamp(opts) {
-	return call(rampWrap, "rampWrap", [opts.t, typeof opts.cycles === "number" ? floatE(opts.cycles) : opts.cycles]);
-}
-function foldRamp(t) {
-	return call(gradientEdgeMirror, "gradientEdgeMirror", [t]);
-}
-function warpedPoint(opts) {
-	const e = (v) => typeof v === "number" ? floatE(v) : v;
-	if (opts.levels === 1) return call(domainWarp1(mxNoiseFloat3, { name: "warpDomain1" }), "warpDomain1", [
-		opts.at,
-		e(opts.time),
-		e(opts.amount)
-	]);
-	return call(domainWarp2(mxNoiseFloat3, { name: "warpDomain" }), "warpDomain", [
-		opts.at,
-		e(opts.time),
-		e(opts.amount)
-	]);
-}
-function warpStep(opts) {
-	const e = (v) => typeof v === "number" ? floatE(v) : v;
-	return call(chainedWarpStep, "chainedWarpStep", [
-		opts.at,
-		floatE(opts.scale),
-		e(opts.z),
-		vec2(opts.offsets[0][0], opts.offsets[0][1]),
-		vec2(opts.offsets[1][0], opts.offsets[1][1]),
-		floatE(opts.reach),
-		e(opts.strength)
-	]);
-}
-function standardPalette(t, params) {
-	return mixStopsOrColorsExpr(params, t);
-}
-function quadBlend(slots) {
-	return (t1, t2, params) => {
-		const { uniforms } = params;
-		const colorSpaceMode = colorSpaceModeOf(params.propValues[slots.space.name]);
-		const colorA = uniformOf(slots.a, params);
-		const colorB = uniformOf(slots.b, params);
-		const colorC = uniformOf(slots.c, params);
-		const colorD = uniformOf(slots.d, params);
-		if (colorSpaceMode !== 0) {
-			let lastKey = "";
-			params.onBeforeRender(() => {
-				const cols = [
-					slots.a.name,
-					slots.b.name,
-					slots.c.name,
-					slots.d.name
-				].map((prop) => params.getCpuValue(prop));
-				if (cols.some((c) => !c)) return;
-				const key = cols.map((c) => `${c.x},${c.y},${c.z}`).join("|");
-				if (key === lastKey) return;
-				lastKey = key;
-				const fields = [
-					"convA",
-					"convB",
-					"convC",
-					"convD"
-				];
-				cols.forEach((c, i) => {
-					const conv = convertP3ToMixSpaceCPU(c.x, c.y, c.z, colorSpaceMode);
-					params.setExtraField(fields[i], [
-						conv[0],
-						conv[1],
-						conv[2]
-					]);
-				});
-			});
-			const row1$1 = asLocal(call(mixPreconvertedInSpace, "mixInSpace", [
-				uniforms.convA,
-				colorA.member("a"),
-				uniforms.convB,
-				colorB.member("a"),
-				t1
-			]), "flowRow1");
-			const row2$1 = asLocal(call(mixPreconvertedInSpace, "mixInSpace", [
-				uniforms.convC,
-				colorC.member("a"),
-				uniforms.convD,
-				colorD.member("a"),
-				t1
-			]), "flowRow2");
-			return call(mixPreconvertedVariants[colorSpaceMode] ?? mixPreconvertedLinear, "mixPreconvertedColors", [
-				row1$1.member("conv"),
-				row2$1.member("conv"),
-				row1$1.member("alpha"),
-				row2$1.member("alpha"),
-				t2
-			]);
-		}
-		return call(mixColorsLinear, "mixColors", [
-			asLocal(call(mixColorsLinear, "mixColors", [
-				colorA,
-				colorB,
-				t1
-			]), "flowRow1"),
-			asLocal(call(mixColorsLinear, "mixColors", [
-				colorC,
-				colorD,
-				t1
-			]), "flowRow2"),
-			t2
-		]);
-	};
-}
-export { tone as C, wrapRamp as D, warpedPoint as E, noiseToneKColor as O, tiles as S, warped as T, share as _, foldRamp as a, stops as b, noiseField as c, quadBlend as d, rampOver as f, scatteredAnchors as g, scatterField as h, flowField as i, pair as l, scaledVolume as m, colorSpaceModeOf as n, hueWheel as o, rings as p, dist as r, mixColorsIn as s, colorLadder3 as t, pulse as u, shimmered as v, warpStep as w, threshold as x, standardPalette as y };

package/dist/core/figures-BRYcB-p2.js

@@ -1,48 +0,0 @@
-import { a as resolveScalar, ct as call, ft as floatE, mt as vec4, n as paintFrame, o as uniformOf, s as Scalar } from "./lower-DtoDQ7hV.js";
-import { t as animatedTime } from "./porters-CQwDd2t4.js";
-import { l as lineMask, u as sineWaveMask } from "./shapePaints-7HrXeLYX.js";
-function arg(spec, params) {
-	if (typeof spec === "number") return floatE(spec);
-	if (spec instanceof Scalar || spec.kind !== "ctx") return resolveScalar(spec, params);
-	return params.ctx[spec.name];
-}
-function maskedColor(color, mask, params) {
-	const c = uniformOf(color, params);
-	return vec4(c.member("rgb"), c.member("a").mul(mask));
-}
-function strokedSegment(slots) {
-	return (params) => {
-		const { uv, viewport } = paintFrame(params);
-		const mask = call(lineMask, "lineMask", [
-			uv,
-			viewport,
-			uniformOf(slots.from, params),
-			uniformOf(slots.to, params),
-			arg(slots.width, params),
-			arg(slots.style, params),
-			arg(slots.dashLength, params),
-			arg(slots.gapLength, params),
-			arg(slots.capStart, params),
-			arg(slots.capEnd, params)
-		]);
-		return maskedColor(slots.color, mask, params);
-	};
-}
-function sineStroke(slots) {
-	return (params) => {
-		const { uv, viewport } = paintFrame(params);
-		const mask = call(sineWaveMask, "sineWaveMask", [
-			uv,
-			viewport,
-			arg(slots.angle, params),
-			uniformOf(slots.position, params),
-			arg(slots.frequency, params),
-			arg(slots.amplitude, params),
-			arg(slots.thickness, params),
-			arg(slots.softness, params),
-			animatedTime(params)
-		]);
-		return maskedColor(slots.color, mask, params);
-	};
-}
-export { strokedSegment as n, sineStroke as t };

package/dist/core/filter-BrhpSs3Z.js

@@ -1,23 +0,0 @@
-function tintToward(color, opts) {
-	return {
-		kind: "tintToward",
-		color,
-		amount: opts.amount
-	};
-}
-function displaceBy(field, opts) {
-	return {
-		kind: "displaceBy",
-		field,
-		strength: opts.strength,
-		chromatic: opts.chromatic,
-		edges: opts.edges
-	};
-}
-function gather(config) {
-	return {
-		kind: "gather",
-		...config
-	};
-}
-export { gather as n, tintToward as r, displaceBy as t };