framefields 2.13.0 → 2.13.1

package/dist/{dist-D3BeAZ7X.mjs → dist-DtPPPsZV.mjs}

@@ -1537,15 +1537,15 @@ var SignalRegistry = class {
 		res.lastProcessedFrame = cacheFrame;
 		res.lastFingerprint = fingerprint;
 		if (isSamplesArray(rawSamples) && rawSamples.length > 0) {
-			const flat = new Float32Array(numSamples);
+			const flat$1 = new Float32Array(numSamples);
 			const total = rawSamples.length;
 			const srcFps = Number(normalizedSd?.fps) || 24;
 			for (let i = 0; i < numSamples; i++) {
 				const t = elapsedTime + i / sampleRate;
 				const sIdx = Math.min(total - 1, Math.max(0, Math.round(t * srcFps)));
-				flat[i] = Number(rawSamples[sIdx]) || 0;
+				flat$1[i] = Number(rawSamples[sIdx]) || 0;
 			}
-			device.queue.writeBuffer(res.buffer, 0, flat);
+			device.queue.writeBuffer(res.buffer, 0, flat$1);
 		} else if (normalizedSd?.type === "generator" && (normalizedSd.customWGSL || normalizedSd.fnBody)) {
 			const signalEncoder = device.createCommandEncoder({ label: `signal_1d_encoder_${nodeId}` });
 			this.dispatch1DGenerator(device, signalEncoder, res, elapsedTime, duration$2, normalizedSd, numSamples, sampleRate, frame, fps);
@@ -1560,8 +1560,8 @@ var SignalRegistry = class {
 				device.queue.submit([signalEncoder.finish()]);
 			} else {
 				const val = Number(normalizedSd?.offset ?? 0);
-				const flat = new Float32Array(numSamples).fill(val);
-				device.queue.writeBuffer(res.buffer, 0, flat);
+				const flat$1 = new Float32Array(numSamples).fill(val);
+				device.queue.writeBuffer(res.buffer, 0, flat$1);
 			}
 		} else if (normalizedSd?.type === "signal_math") {
 			const sigAId = normalizedSd.signalA?.nodeId ?? `${nodeId}_a`;
@@ -1582,8 +1582,8 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 		} else {
 			const val = Number(normalizedSd?.offset ?? 0);
-			const flat = new Float32Array(numSamples).fill(val);
-			device.queue.writeBuffer(res.buffer, 0, flat);
+			const flat$1 = new Float32Array(numSamples).fill(val);
+			device.queue.writeBuffer(res.buffer, 0, flat$1);
 		}
 		return res.buffer;
 	}
@@ -1649,7 +1649,7 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 			return res.textureView;
 		} else if (isSamplesArray(rawSamples) && rawSamples.length > 0) {
-			const flat = new Float32Array(targetWidth * targetHeight * 4);
+			const flat$1 = new Float32Array(targetWidth * targetHeight * 4);
 			const total = rawSamples.length;
 			const baseTime = frame !== void 0 && fps !== void 0 && fps > 0 ? frame / fps : elapsedTime;
 			for (let i = 0; i < targetWidth; i++) {
@@ -1659,13 +1659,13 @@ var SignalRegistry = class {
 				const val = Number(rawSamples[sIdx]) || 0;
 				for (let row = 0; row < targetHeight; row++) {
 					const idx = (row * targetWidth + i) * 4;
-					flat[idx] = val;
-					flat[idx + 1] = val;
-					flat[idx + 2] = val;
-					flat[idx + 3] = val;
+					flat$1[idx] = val;
+					flat$1[idx + 1] = val;
+					flat$1[idx + 2] = val;
+					flat$1[idx + 3] = val;
 				}
 			}
-			const halfFlat = encodeFloat32ToFloat16(flat);
+			const halfFlat = encodeFloat32ToFloat16(flat$1);
 			device.queue.writeTexture({ texture: res.texture }, halfFlat, {
 				bytesPerRow: targetWidth * 8,
 				rowsPerImage: targetHeight
@@ -1691,14 +1691,14 @@ var SignalRegistry = class {
 			device.queue.submit([signalEncoder.finish()]);
 		} else {
 			const val = Number(normalizedSd?.offset ?? 0);
-			const flat = new Float32Array(targetWidth * targetHeight * 4);
+			const flat$1 = new Float32Array(targetWidth * targetHeight * 4);
 			for (let i = 0; i < targetWidth * targetHeight; i++) {
-				flat[i * 4] = val;
-				flat[i * 4 + 1] = val;
-				flat[i * 4 + 2] = val;
-				flat[i * 4 + 3] = 1;
+				flat$1[i * 4] = val;
+				flat$1[i * 4 + 1] = val;
+				flat$1[i * 4 + 2] = val;
+				flat$1[i * 4 + 3] = 1;
 			}
-			const halfFlat = encodeFloat32ToFloat16(flat);
+			const halfFlat = encodeFloat32ToFloat16(flat$1);
 			device.queue.writeTexture({ texture: res.texture }, halfFlat, {
 				bytesPerRow: targetWidth * 8,
 				rowsPerImage: targetHeight
@@ -27990,6 +27990,118 @@ var ClipStack = class {
 	}
 };
 /**
+* Filling compound paths: every subpath is a contour, contours nest, and a
+* region is filled by SVG's nonzero rule (the windings of the contours
+* around it, summed, are not zero). Each filled contour is triangulated with
+* its direct children as holes, so a map's coastlines and islands, a
+* letter's counter or a ring fill as drawn instead of being bridged into
+* one polygon.
+*
+* Contours are taken not to cross each other (each pair is nested or
+* apart), which holds for maps, glyphs and icons; a contour that crosses
+* itself is still triangulated as well as earcut can.
+*/
+function signedArea(points) {
+	let area = 0;
+	for (let i = 0; i < points.length; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % points.length];
+		area += a.x * b.y - b.x * a.y;
+	}
+	return area / 2;
+}
+function flat(points) {
+	const out = [];
+	for (const p of points) out.push(p.x, p.y);
+	return out;
+}
+function boxOf(points) {
+	const box = {
+		x0: Infinity,
+		y0: Infinity,
+		x1: -Infinity,
+		y1: -Infinity
+	};
+	for (const p of points) {
+		box.x0 = Math.min(box.x0, p.x);
+		box.y0 = Math.min(box.y0, p.y);
+		box.x1 = Math.max(box.x1, p.x);
+		box.y1 = Math.max(box.y1, p.y);
+	}
+	return box;
+}
+/** The centroid of the contour's largest triangle: inside it, away from its edges. */
+function insidePoint(points) {
+	const coords = flat(points);
+	const tris = earcut(coords);
+	const at = (k) => ({
+		x: coords[k * 2],
+		y: coords[k * 2 + 1]
+	});
+	let best = -1;
+	let inside = points[0];
+	for (let i = 0; i < tris.length; i += 3) {
+		const a = at(tris[i]);
+		const b = at(tris[i + 1]);
+		const c = at(tris[i + 2]);
+		const size = Math.abs((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y));
+		if (size > best) {
+			best = size;
+			inside = {
+				x: (a.x + b.x + c.x) / 3,
+				y: (a.y + b.y + c.y) / 3
+			};
+		}
+	}
+	return inside;
+}
+function contains(points, p) {
+	let inside = false;
+	for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+		const a = points[i];
+		const b = points[j];
+		if (a.y > p.y !== b.y > p.y && p.x < (b.x - a.x) * (p.y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+	}
+	return inside;
+}
+const encloses = (p, c) => p.box.x0 <= c.box.x0 && p.box.y0 <= c.box.y0 && p.box.x1 >= c.box.x1 && p.box.y1 >= c.box.y1 && contains(p.points, c.inside);
+/** Triangles filling closed `contours` by the nonzero rule, as flat [x, y, …] vertices. */
+function fillContours(contours) {
+	const all = contours.map((points) => ({
+		points,
+		area: signedArea(points),
+		box: boxOf(points),
+		inside: insidePoint(points),
+		parent: -1,
+		winding: 0
+	}));
+	const order = all.map((_, i) => i).sort((a, b) => Math.abs(all[b].area) - Math.abs(all[a].area));
+	order.forEach((ci, rank) => {
+		const c = all[ci];
+		for (let r = rank - 1; r >= 0; r--) {
+			const pi = order[r];
+			if (encloses(all[pi], c)) {
+				c.parent = pi;
+				break;
+			}
+		}
+		c.winding = (c.parent >= 0 ? all[c.parent].winding : 0) + Math.sign(c.area);
+	});
+	const out = [];
+	all.forEach((c, ci) => {
+		if (c.winding === 0) return;
+		const coords = flat(c.points);
+		const holeStarts = [];
+		for (const h of all) {
+			if (h.parent !== ci) continue;
+			holeStarts.push(coords.length / 2);
+			for (const p of h.points) coords.push(p.x, p.y);
+		}
+		for (const k of earcut(coords, holeStarts)) out.push(coords[k * 2], coords[k * 2 + 1]);
+	});
+	return new Float32Array(out);
+}
+/**
 * Sample a cubic bezier curve into linear segments.
 */
 function sampleCubicBezier(p0, p1, p2, p3, steps = 24) {
@@ -28097,8 +28209,26 @@ function sampleSvgArc(p0, rxIn, ryIn, rotationDeg, largeArc, sweep, p1) {
 * Parse an SVG path string (M, L, H, V, C, S, Q, T, A, Z) into line segments.
 */
 function parseSvgPathToSegments(d) {
+	return parseSvgPath(d).segments;
+}
+/**
+* The path's segments, and for each the subpath it belongs to (every M
+* starts one): fills need to know where each subpath begins.
+*/
+function parseSvgPath(d) {
 	const segments = [];
-	if (!d || typeof d !== "string") return segments;
+	const subpaths = [];
+	if (!d || typeof d !== "string") return {
+		segments,
+		subpaths
+	};
+	let subpath = -1;
+	const emit = (...added) => {
+		for (const seg of added) {
+			segments.push(seg);
+			subpaths.push(subpath);
+		}
+	};
 	const tokens = [];
 	const regex = /([a-df-z])|([-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?)/gi;
 	let match;
@@ -28144,9 +28274,10 @@ function parseSvgPathToSegments(d) {
 							x,
 							y
 						};
+						subpath++;
 						first = false;
 					} else {
-						segments.push({
+						emit({
 							p0: current,
 							p1: {
 								x,
@@ -28171,7 +28302,7 @@ function parseSvgPathToSegments(d) {
 						x += current.x;
 						y += current.y;
 					}
-					segments.push({
+					emit({
 						p0: current,
 						p1: {
 							x,
@@ -28194,7 +28325,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y: current.y
 					};
-					segments.push({
+					emit({
 						p0: current,
 						p1: next
 					});
@@ -28211,7 +28342,7 @@ function parseSvgPathToSegments(d) {
 						x: current.x,
 						y
 					};
-					segments.push({
+					emit({
 						p0: current,
 						p1: next
 					});
@@ -28248,7 +28379,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleCubicBezier(current, p1, p2, end));
+					emit(...sampleCubicBezier(current, p1, p2, end));
 					current = end;
 					lastCubicControl = p2;
 				}
@@ -28283,7 +28414,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleCubicBezier(current, p1, p2, end));
+					emit(...sampleCubicBezier(current, p1, p2, end));
 					current = end;
 					lastCubicControl = p2;
 				}
@@ -28309,7 +28440,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleQuadraticBezier(current, p1, end));
+					emit(...sampleQuadraticBezier(current, p1, end));
 					current = end;
 					lastQuadControl = p1;
 				}
@@ -28336,7 +28467,7 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleQuadraticBezier(current, p1, end));
+					emit(...sampleQuadraticBezier(current, p1, end));
 					current = end;
 					lastQuadControl = p1;
 				}
@@ -28359,14 +28490,14 @@ function parseSvgPathToSegments(d) {
 						x,
 						y
 					};
-					segments.push(...sampleSvgArc(current, rx, ry, rotation, largeArc, sweep, end));
+					emit(...sampleSvgArc(current, rx, ry, rotation, largeArc, sweep, end));
 					current = end;
 				}
 				lastCubicControl = null;
 				lastQuadControl = null;
 				break;
 			case "Z":
-				if (Math.hypot(current.x - subpathStart.x, current.y - subpathStart.y) > 1e-5) segments.push({
+				if (Math.hypot(current.x - subpathStart.x, current.y - subpathStart.y) > 1e-5) emit({
 					p0: current,
 					p1: subpathStart
 				});
@@ -28377,7 +28508,10 @@ function parseSvgPathToSegments(d) {
 			default: break;
 		}
 	}
-	return segments;
+	return {
+		segments,
+		subpaths
+	};
 }
 /**
 * Trim linear path segments using arc-length parameterization.
@@ -28438,6 +28572,19 @@ function trimPathSegments(segments, trimStart, trimEnd, trimOffset = 0) {
 	}
 }
 /**
+* A dash pattern as SVG's `stroke-dasharray` writes it ("16 12", "4,8") or as
+* numbers, ready for {@link dashPathSegments}. Following SVG, an odd list is
+* repeated to make it even, and a negative or unreadable entry, or a pattern
+* of zero length, means a solid stroke (`undefined`).
+*/
+function parseDashArray(value) {
+	if (value === void 0) return void 0;
+	const parts = typeof value === "string" ? value.trim().split(/[\s,]+/).filter(Boolean).map(Number) : [...value];
+	if (parts.length === 0 || parts.some((n) => !Number.isFinite(n) || n < 0)) return void 0;
+	if (parts.reduce((sum, n) => sum + n, 0) <= 0) return void 0;
+	return parts.length % 2 === 1 ? [...parts, ...parts] : parts;
+}
+/**
 * Apply dash patterns along linear path segments.
 */
 function dashPathSegments(segments, dashArray, dashOffset = 0) {
@@ -28649,6 +28796,44 @@ function triangulatePolygon(contour) {
 	if (rem.length === 3) triangles.push(rem[0], rem[1], rem[2]);
 	return triangles;
 }
+/** A path's subpaths as closed point lists, degenerate ones dropped. */
+function pathContours(d) {
+	const bySubpath = /* @__PURE__ */ new Map();
+	const { segments, subpaths } = parseSvgPath(d);
+	segments.forEach((seg, i) => {
+		const id = subpaths[i] ?? 0;
+		let points = bySubpath.get(id);
+		if (!points) {
+			points = [seg.p0];
+			bySubpath.set(id, points);
+		}
+		points.push(seg.p1);
+	});
+	const contours = [];
+	for (const points of bySubpath.values()) {
+		const first = points[0];
+		const last = points[points.length - 1];
+		if (Math.hypot(last.x - first.x, last.y - first.y) < 1e-5) points.pop();
+		if (points.length >= 3 && Math.abs(signedArea(points)) > 1e-6) contours.push(points);
+	}
+	return contours;
+}
+/** Path fills are redrawn every frame from the same data: keep the last few. */
+const PATH_FILL_CACHE = 64;
+const pathFills = /* @__PURE__ */ new Map();
+/** Triangles filling path `d` by the nonzero rule (see {@link fillContours}). */
+function cachedPathFill(d) {
+	const hit = pathFills.get(d);
+	if (hit) {
+		pathFills.delete(d);
+		pathFills.set(d, hit);
+		return hit;
+	}
+	const tris = fillContours(pathContours(d));
+	pathFills.set(d, tris);
+	if (pathFills.size > PATH_FILL_CACHE) pathFills.delete(pathFills.keys().next().value);
+	return tris;
+}
 /**
 * Triangulate a shape geometry into a flat Float32Array of 2D vertex pairs [x, y, x, y, ...].
 */
@@ -28773,19 +28958,16 @@ function triangulateShape(config$1) {
 			yBotHead
 		]);
 	}
-	if (shapeType === "path" && config$1.path) {
-		const segments = parseSvgPathToSegments(config$1.path);
-		if (segments.length === 0) return new Float32Array(0);
-		const tris = triangulatePolygon(segments.map((s) => s.p0));
-		const out = new Float32Array(tris.length * 2);
-		for (let i = 0; i < tris.length; i++) {
-			out[i * 2] = tris[i].x;
-			out[i * 2 + 1] = tris[i].y;
-		}
-		return out;
-	}
+	if (shapeType === "path" && config$1.path) return cachedPathFill(config$1.path);
 	return new Float32Array(0);
 }
+/**
+* Strokes a path in one instanced draw: each instance is one straight
+* segment (p0, p1), expanded by the vertex shader into a quad that covers it
+* plus half the stroke width and 2 px of antialiasing; the fragment shader
+* shades the segment's capped distance field. Everything shared by the
+* path (transform, colour, width, cap) is in the uniforms.
+*/
 const pathWgsl = `
 struct Uniforms {
     transformCol0 : vec4<f32>,
@@ -28794,8 +28976,6 @@ struct Uniforms {
     params        : vec4<f32>, // x = opacity, y = surfaceWidth, z = surfaceHeight, w = strokeWidth
     color         : vec4<f32>,
     style         : vec4<f32>, // x = capType (0 = round, 1 = butt, 2 = square)
-    p0            : vec2<f32>,
-    p1            : vec2<f32>,
 };
 
 @group(0) @binding(0) var<uniform> u : Uniforms;
@@ -28803,17 +28983,30 @@ struct Uniforms {
 struct VSOut {
     @builtin(position) pos : vec4<f32>,
     @location(0) localPos  : vec2<f32>,
+    @location(1) @interpolate(flat) p0 : vec2<f32>,
+    @location(2) @interpolate(flat) p1 : vec2<f32>,
 };
 
-@vertex fn vs(@location(0) xy : vec2<f32>) -> VSOut {
+@vertex fn vs(@builtin(vertex_index) corner : u32, @location(0) seg : vec4<f32>) -> VSOut {
+    let p0 = seg.xy;
+    let p1 = seg.zw;
+    let d = p1 - p0;
+    let len = max(length(d), 1e-6);
+    let padding = u.params.w * 0.5 + 2.0;
+    let along = (d / len) * padding;
+    let across = vec2<f32>(-along.y, along.x);
+    // Triangle strip: p0 −along ∓across, then p1 +along ∓across.
+    let atEnd = corner >= 2u;
+    let side = select(-1.0, 1.0, (corner & 1u) == 1u);
+    let xy = select(p0 - along, p1 + along, atEnd) + across * side;
+
     let transform = mat3x3<f32>(u.transformCol0.xyz, u.transformCol1.xyz, u.transformCol2.xyz);
     let p = transform * vec3<f32>(xy, 1.0);
-    
     let surfaceSize = u.params.yz;
     let clipX = (p.x / surfaceSize.x) * 2.0 - 1.0;
     let clipY = 1.0 - (p.y / surfaceSize.y) * 2.0;
 
-    return VSOut(vec4<f32>(clipX, clipY, 0.0, 1.0), xy);
+    return VSOut(vec4<f32>(clipX, clipY, 0.0, 1.0), xy, p0, p1);
 }
 
 fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capType: f32) -> f32 {
@@ -28825,10 +29018,10 @@ fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capTy
     let dir = ba / len;
     let normal = vec2<f32>(-dir.y, dir.x);
     let pa = p - a;
-    
+
     let proj = dot(pa, dir);
     let perp = abs(dot(pa, normal));
-    
+
     if (capType > 0.5 && capType < 1.5) {
         // Butt cap: terminates strictly at endpoints a and b
         let dx = max(-proj, proj - len);
@@ -28852,15 +29045,15 @@ fn sdSegmentWithCap(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>, radius: f32, capTy
 
 @fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
     let radius = u.params.w * 0.5;
-    let d = sdSegmentWithCap(in.localPos, u.p0, u.p1, radius, u.style.x);
-    
+    let d = sdSegmentWithCap(in.localPos, in.p0, in.p1, radius, u.style.x);
+
     let fw = max(fwidth(d), 1e-5);
     let edgeAlpha = clamp(0.5 - d / fw, 0.0, 1.0);
     let alpha = u.color.a * u.params.x * edgeAlpha;
     if (alpha <= 0.0) {
         discard;
     }
-    
+
     return vec4<f32>(u.color.rgb * alpha, alpha);
 }
 `;
@@ -28917,127 +29110,111 @@ function createVec2Pipeline(device, options) {
 		primitive: { topology: options.topology }
 	});
 }
+/** A straight segment's two ends, the instance the stroke shader expands into a quad. */
+const SEGMENT_FLOATS = 4;
 var PathPipeline = class {
 	device;
 	pipeline;
 	maxPipeline;
 	uniformLayout;
 	uniformPool;
-	vertexPool;
+	segmentPool;
 	uniformBindGroupCache = new UniformBindGroupCache();
-	scratchData = new Float32Array(28);
+	scratchData = new Float32Array(24);
 	constructor(device, format) {
 		this.device = device;
 		this.uniformPool = new BufferPool(4096, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
-		this.vertexPool = new BufferPool(4096, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST);
+		this.segmentPool = new BufferPool(4096, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST);
 		const module$1 = device.createShaderModule({
 			label: "path.wgsl",
 			code: pathWgsl
 		});
 		this.uniformLayout = createUniformLayout(device);
-		this.pipeline = createVec2Pipeline(device, {
-			label: "PathPipeline",
-			module: module$1,
-			uniformLayout: this.uniformLayout,
-			format,
-			topology: "triangle-strip"
+		const create = (label, blend) => device.createRenderPipeline({
+			label,
+			layout: device.createPipelineLayout({ bindGroupLayouts: [this.uniformLayout] }),
+			vertex: {
+				module: module$1,
+				entryPoint: "vs",
+				buffers: [{
+					arrayStride: SEGMENT_FLOATS * 4,
+					stepMode: "instance",
+					attributes: [{
+						shaderLocation: 0,
+						offset: 0,
+						format: "float32x4"
+					}]
+				}]
+			},
+			fragment: {
+				module: module$1,
+				entryPoint: "fs",
+				targets: [{
+					format,
+					blend
+				}]
+			},
+			primitive: { topology: "triangle-strip" }
 		});
-		this.maxPipeline = createVec2Pipeline(device, {
-			label: "PathPipeline.max",
-			module: module$1,
-			uniformLayout: this.uniformLayout,
-			format,
-			topology: "triangle-strip",
-			blend: {
-				color: {
-					srcFactor: "one",
-					dstFactor: "one",
-					operation: "max"
-				},
-				alpha: {
-					srcFactor: "one",
-					dstFactor: "one",
-					operation: "max"
-				}
+		this.pipeline = create("PathPipeline", PREMULTIPLIED_OVER);
+		this.maxPipeline = create("PathPipeline.max", {
+			color: {
+				srcFactor: "one",
+				dstFactor: "one",
+				operation: "max"
+			},
+			alpha: {
+				srcFactor: "one",
+				dstFactor: "one",
+				operation: "max"
 			}
 		});
 	}
 	resetPools() {
 		this.uniformPool.reset();
-		this.vertexPool.reset();
+		this.segmentPool.reset();
 	}
 	drawPath(pass, transformStack, pathStr, color, strokeWidth, surfaceWidth, surfaceHeight, opts) {
-		let segments = parseSvgPathToSegments(pathStr);
-		if (segments.length === 0) return;
-		if (opts?.trimStart !== void 0 || opts?.trimEnd !== void 0 || opts?.trimOffset !== void 0) segments = trimPathSegments(segments, opts.trimStart ?? 0, opts.trimEnd ?? 1, opts.trimOffset ?? 0);
-		if (opts?.strokeDashArray && opts.strokeDashArray.length > 0) segments = dashPathSegments(segments, opts.strokeDashArray, opts.strokeDashOffset ?? 0);
-		if (segments.length === 0) return;
-		const c = parseColor(color);
-		const opacity = opts?.opacity ?? 1;
-		let capType = 0;
-		if (opts?.strokeLineCap === "butt") capType = 1;
-		else if (opts?.strokeLineCap === "square") capType = 2;
-		for (const segment of segments) this.drawSegment(pass, transformStack, segment.p0, segment.p1, c, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts);
+		this.drawSegments(pass, transformStack, parseSvgPathToSegments(pathStr), color, strokeWidth, surfaceWidth, surfaceHeight, opts);
 	}
 	drawSegments(pass, transformStack, segments, color, strokeWidth, surfaceWidth, surfaceHeight, opts) {
 		let activeSegments = segments;
 		if (opts?.trimStart !== void 0 || opts?.trimEnd !== void 0 || opts?.trimOffset !== void 0) activeSegments = trimPathSegments(activeSegments, opts.trimStart ?? 0, opts.trimEnd ?? 1, opts.trimOffset ?? 0);
 		if (opts?.strokeDashArray && opts.strokeDashArray.length > 0) activeSegments = dashPathSegments(activeSegments, opts.strokeDashArray, opts.strokeDashOffset ?? 0);
-		if (activeSegments.length === 0) return;
+		const ends = new Float32Array(activeSegments.length * SEGMENT_FLOATS);
+		let count = 0;
+		for (const { p0, p1 } of activeSegments) {
+			if (Math.hypot(p1.x - p0.x, p1.y - p0.y) < 1e-6) continue;
+			const at = count++ * SEGMENT_FLOATS;
+			ends[at] = p0.x;
+			ends[at + 1] = p0.y;
+			ends[at + 2] = p1.x;
+			ends[at + 3] = p1.y;
+		}
+		if (count === 0) return;
 		const c = parseColor(color);
-		const opacity = opts?.opacity ?? 1;
-		let capType = 0;
-		if (opts?.strokeLineCap === "butt") capType = 1;
-		else if (opts?.strokeLineCap === "square") capType = 2;
-		for (const segment of activeSegments) this.drawSegment(pass, transformStack, segment.p0, segment.p1, c, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts);
-	}
-	drawSegment(pass, transformStack, p0, p1, color, strokeWidth, capType, surfaceWidth, surfaceHeight, opacity, opts) {
 		const data = this.scratchData;
-		transformStack.packIntoBuffer(data, opacity, surfaceWidth, surfaceHeight, opts?.transform);
+		transformStack.packIntoBuffer(data, opts?.opacity ?? 1, surfaceWidth, surfaceHeight, opts?.transform);
 		data[15] = strokeWidth;
-		data[16] = color.r;
-		data[17] = color.g;
-		data[18] = color.b;
-		data[19] = color.a;
-		data[20] = capType;
+		data[16] = c.r;
+		data[17] = c.g;
+		data[18] = c.b;
+		data[19] = c.a;
+		data[20] = opts?.strokeLineCap === "butt" ? 1 : opts?.strokeLineCap === "square" ? 2 : 0;
 		data[21] = 0;
 		data[22] = 0;
 		data[23] = 0;
-		data[24] = p0.x;
-		data[25] = p0.y;
-		data[26] = p1.x;
-		data[27] = p1.y;
 		const uniformBuffer = this.uniformPool.getBuffer(this.device, data);
-		const dx = p1.x - p0.x;
-		const dy = p1.y - p0.y;
-		const len = Math.sqrt(dx * dx + dy * dy);
-		if (len < 1e-6) return;
-		const padding = strokeWidth * .5 + 2;
-		const nx = dx / len * padding;
-		const ny = dy / len * padding;
-		const px = -ny;
-		const py = nx;
-		const vertexData = new Float32Array([
-			p0.x - nx - px,
-			p0.y - ny - py,
-			p0.x - nx + px,
-			p0.y - ny + py,
-			p1.x + nx - px,
-			p1.y + ny - py,
-			p1.x + nx + px,
-			p1.y + ny + py
-		]);
-		const vertexBuffer = this.vertexPool.getBuffer(this.device, vertexData);
-		const pipeline = opts?.blendMode === "max" ? this.maxPipeline : this.pipeline;
-		pass.setPipeline(pipeline);
-		const uniformBindGroup = this.uniformBindGroupCache.getBindGroup(this.device, this.uniformLayout, uniformBuffer);
-		pass.setBindGroup(0, uniformBindGroup);
-		pass.setVertexBuffer(0, vertexBuffer);
-		pass.draw(4);
+		const segmentBuffer = this.segmentPool.getBuffer(this.device, ends.subarray(0, count * SEGMENT_FLOATS));
+		const useMax = opts?.blendMode === "max";
+		pass.setPipeline(useMax ? this.maxPipeline : this.pipeline);
+		pass.setBindGroup(0, this.uniformBindGroupCache.getBindGroup(this.device, this.uniformLayout, uniformBuffer));
+		pass.setVertexBuffer(0, segmentBuffer);
+		pass.draw(4, count);
 	}
 	destroy() {
 		this.uniformPool.destroy();
-		this.vertexPool.destroy();
+		this.segmentPool.destroy();
 		this.uniformBindGroupCache.destroy();
 	}
 };
@@ -41608,5 +41785,5 @@ var NodeSurfaceProvider = class {
 if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
 
 //#endregion
-export { probeVideoSize as $, TextAnimatorBuilder as $t, emojiGraphemes as A, evaluateSpringProgress as An, AudioSignalComputePipeline as At, jointMatrices as B, samplePathChainGeometry as Bn, KineticMarqueeConfigSchema as Bt, drawGifNode as C, ellipseToCubicBeziers as Cn, resolveEnvironment as Ct, drawSignalNode as D, evaluateMarqueeOffset as Dn, AnchorGroupingSchema as Dt, drawParagraphNode as E, evaluateExpressionSelector as En, AdvancedTextAnimatorSchema as Et, getPrimitiveGeometry as F, getScramblePool as Fn, EnhancedTextNodeSchema as Ft, measureMaxCaptionHeight as G, SelectorModeSchema as Gt, loadModel3D as H, waveToCubicBeziers as Hn, LongShadowConfigSchema as Ht, getRegisteredFontSource as I, getShuffledOrder as In, ExpressionSelectorSchema as It, parseFBX as J, SignalRegistry as Jt, mediaDecoderCache as K, SelectorShapeSchema as Kt, getRenderer2D as L, parseSvgPathToCubicBeziers as Ln, ExtendedGlyphPropertiesSchema as Lt, fitSpansToText as M, evaluateVolumetricFormation as Mn, ChromaticGlitchConfigSchema as Mt, generateExtrudedTextGeometry as N, generateArcLengthLUT as Nn, CubicBezierSegmentSchema as Nt, drawSvgNode as O, evaluateSelectorCombination as On, AnchorPresetSchema as Ot, getHeadlessFontPath as P, generatePathSegments as Pn, DynamicStrokePropertiesSchema as Pt, poseNodes as Q, TextAnchorConfigSchema as Qt, initHeadlessWebGPU as R, sampleAudioSpectrumScale as Rn, GlyphAnchorGroupingSchema as Rt, drawCaptionNode as S, distanceToCurveParameter as Sn, parseColorToRgb as St, drawLottieNode as T, evaluateCubicBezierDerivative as Tn, AdvancedTextAnimatorBuilder as Tt, loadOBJ as U, ParticleDissolveConfigSchema as Ut, loadFBX as V, signalRegistry as Vn, LineSpacingDynamicsSchema as Vt, lutStore as W, SelectorBasedOnSchema as Wt, parseOBJ as X, Spatial3DPropertiesSchema as Xt, parseMTL as Y, SkewPropertiesSchema as Yt, parseSvgPathToSegments as Z, SpringPhysicsSchema as Zt, buildShapeSvgPath as _, buildWGSLSignalFn as _n, MAX_LIGHTS as _t, GlassPipeline as a, TextRangeSelectorSchema as an, shaderStore as at, colorMatrixWgsl as b, computeRangeSelectorWeight as bn, Vector3Math as bt, Renderer2D as c, TextSignalSelectorSchema as cn, textureCache as ct, ScreenSpaceRelightPipeline as d, TypingCadenceSchema as dn, GetFontAssetUrl as dt, TextCursorConfigSchema as en, registerHeadlessFont as et, ShadowPipeline as f, VariableFontAxesSchema as fn, resolveMediaSourceUrl as ft, WebGPUAudioProcessor as g, buildPathLUT as gn, Light3D as gt, SlugPipeline as h, VolumetricFormationModeSchema as hn, LIGHT_UNIFORM_SIZE_BYTES as ht, EffectPipeline as i, TextPathSourceSchema as in, setRegisteredFontSource as it, ensureDevice as j, evaluateTypewriterState as jn, AudioSpectrumTypographySchema as jt, drawVideoNode as k, evaluateSkewMatrix as kn, AnimatableGlyphPropsSchema as kt, Renderer3D as l, TextWigglySelectorSchema as ln, trackAudioPitch as lt, SlugGeometry as m, VolumetricFormationConfigSchema as mn, ENVIRONMENT_PRESETS as mt, AudioLatentTrackCache as n, TextPathBuilder as nn, resolveTextSpans as nt, MotionBlurPipeline as o, TextScrambleConfigSchema as on, spansText as ot, SlugFontCache as p, Vec2Schema as pn, Camera3D as pt, parseColor as q, SelectorUnitsSchema as qt, AudioMeshDeformPipeline as r, TextPathOptionsSchema as rn, sampleMorphWeights as rt, NodeSurfaceProvider as s, TextSelectorSchema as sn, srtLoader as st, AudioLatentEngine as t, TextCursorStyleSchema as tn, resolveInputUrl as tt, SSAOPipeline as u, TypewriterAnimatorSchema as un, transformScale as ut, clearAllVideoCache as v, computeAnchorPivotOffset as vn, Matrix4Math as vt, drawImageNode as w, evaluateCubicBezier as wn, AETextAnimatorSchema as wt, describeGpu as x, deterministicWigglyNoise as xn, linearRgb as xt, clearHeadlessFonts as y, computeLineLeadingDisplacement as yn, Path3D as yt, inputStore as z, sampleCurveGeometry as zn, GlyphAnchorPointSchema as zt };
-//# sourceMappingURL=dist-D3BeAZ7X.mjs.map
+export { poseNodes as $, TextAnchorConfigSchema as $t, emojiGraphemes as A, evaluateSkewMatrix as An, AnimatableGlyphPropsSchema as At, jointMatrices as B, sampleCurveGeometry as Bn, GlyphAnchorPointSchema as Bt, drawGifNode as C, distanceToCurveParameter as Cn, parseColorToRgb as Ct, drawSignalNode as D, evaluateExpressionSelector as Dn, AdvancedTextAnimatorSchema as Dt, drawParagraphNode as E, evaluateCubicBezierDerivative as En, AdvancedTextAnimatorBuilder as Et, getPrimitiveGeometry as F, generatePathSegments as Fn, DynamicStrokePropertiesSchema as Ft, measureMaxCaptionHeight as G, SelectorBasedOnSchema as Gt, loadModel3D as H, signalRegistry as Hn, LineSpacingDynamicsSchema as Ht, getRegisteredFontSource as I, getScramblePool as In, EnhancedTextNodeSchema as It, parseDashArray as J, SelectorUnitsSchema as Jt, mediaDecoderCache as K, SelectorModeSchema as Kt, getRenderer2D as L, getShuffledOrder as Ln, ExpressionSelectorSchema as Lt, fitSpansToText as M, evaluateTypewriterState as Mn, AudioSpectrumTypographySchema as Mt, generateExtrudedTextGeometry as N, evaluateVolumetricFormation as Nn, ChromaticGlitchConfigSchema as Nt, drawSvgNode as O, evaluateMarqueeOffset as On, AnchorGroupingSchema as Ot, getHeadlessFontPath as P, generateArcLengthLUT as Pn, CubicBezierSegmentSchema as Pt, parseSvgPathToSegments as Q, SpringPhysicsSchema as Qt, initHeadlessWebGPU as R, parseSvgPathToCubicBeziers as Rn, ExtendedGlyphPropertiesSchema as Rt, drawCaptionNode as S, deterministicWigglyNoise as Sn, linearRgb as St, drawLottieNode as T, evaluateCubicBezier as Tn, AETextAnimatorSchema as Tt, loadOBJ as U, waveToCubicBeziers as Un, LongShadowConfigSchema as Ut, loadFBX as V, samplePathChainGeometry as Vn, KineticMarqueeConfigSchema as Vt, lutStore as W, ParticleDissolveConfigSchema as Wt, parseMTL as X, SkewPropertiesSchema as Xt, parseFBX as Y, SignalRegistry as Yt, parseOBJ as Z, Spatial3DPropertiesSchema as Zt, buildShapeSvgPath as _, buildPathLUT as _n, Light3D as _t, GlassPipeline as a, TextPathSourceSchema as an, setRegisteredFontSource as at, colorMatrixWgsl as b, computeLineLeadingDisplacement as bn, Path3D as bt, Renderer2D as c, TextSelectorSchema as cn, srtLoader as ct, ScreenSpaceRelightPipeline as d, TypewriterAnimatorSchema as dn, transformScale as dt, TextAnimatorBuilder as en, probeVideoSize as et, ShadowPipeline as f, TypingCadenceSchema as fn, GetFontAssetUrl as ft, WebGPUAudioProcessor as g, VolumetricFormationModeSchema as gn, LIGHT_UNIFORM_SIZE_BYTES as gt, SlugPipeline as h, VolumetricFormationConfigSchema as hn, ENVIRONMENT_PRESETS as ht, EffectPipeline as i, TextPathOptionsSchema as in, sampleMorphWeights as it, ensureDevice as j, evaluateSpringProgress as jn, AudioSignalComputePipeline as jt, drawVideoNode as k, evaluateSelectorCombination as kn, AnchorPresetSchema as kt, Renderer3D as l, TextSignalSelectorSchema as ln, textureCache as lt, SlugGeometry as m, Vec2Schema as mn, Camera3D as mt, AudioLatentTrackCache as n, TextCursorStyleSchema as nn, resolveInputUrl as nt, MotionBlurPipeline as o, TextRangeSelectorSchema as on, shaderStore as ot, SlugFontCache as p, VariableFontAxesSchema as pn, resolveMediaSourceUrl as pt, parseColor as q, SelectorShapeSchema as qt, AudioMeshDeformPipeline as r, TextPathBuilder as rn, resolveTextSpans as rt, NodeSurfaceProvider as s, TextScrambleConfigSchema as sn, spansText as st, AudioLatentEngine as t, TextCursorConfigSchema as tn, registerHeadlessFont as tt, SSAOPipeline as u, TextWigglySelectorSchema as un, trackAudioPitch as ut, clearAllVideoCache as v, buildWGSLSignalFn as vn, MAX_LIGHTS as vt, drawImageNode as w, ellipseToCubicBeziers as wn, resolveEnvironment as wt, describeGpu as x, computeRangeSelectorWeight as xn, Vector3Math as xt, clearHeadlessFonts as y, computeAnchorPivotOffset as yn, Matrix4Math as yt, inputStore as z, sampleAudioSpectrumScale as zn, GlyphAnchorGroupingSchema as zt };
+//# sourceMappingURL=dist-DtPPPsZV.mjs.map