shaders 3.1.463 → 3.2.464

package/dist/core/ObjectTracker-dN9-Jxz9.js

@@ -1,617 +0,0 @@
-import { P as unpremultiplyAlpha, S as formatFloat, d as ZERO, x as Expr } from "./edges-CV-BHMpI.js";
-import { a as transformColor, i as transformBoolean } from "./transformations-u-UZrXjj.js";
-import { t as createSwappableMediaTexture } from "./mediaLifecycle-DHrjB2zB.js";
-import { n as createFontDependentRaster, r as createRasterInvalidator, t as createCanvasRasterTarget } from "./canvasRaster-B41z007g.js";
-import { n as loadGoogleFont } from "./fonts-BMxmjoBM.js";
-var ATLAS_GLYPHS = "0123456789x%";
-var ATLAS_SLOTS = 16;
-var ATLAS_CELL_W = 64;
-var ATLAS_CELL_H = 96;
-var ATLAS_W = ATLAS_SLOTS * ATLAS_CELL_W;
-var ATLAS_H = ATLAS_CELL_H;
-var WALK_SCAN = 3;
-var LEAF_SCAN = 4;
-var REFERENCE_HEIGHT = 1080;
-var LUM = "vec3f(0.299, 0.587, 0.114)";
-var num = (v, f) => typeof v === "number" ? v : f;
-const componentDefinition = {
-	name: "ObjectTracker",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Stylize",
-	description: "Computer-vision style object detection overlay — draws bounding boxes and labels around detected regions of the content below, with grid, quadtree and mosaic layouts.",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		detectionMode: {
-			default: "bright",
-			compileTime: true,
-			description: "What counts as a detectable object.",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Transparency",
-						value: "alpha"
-					},
-					{
-						label: "Brightness",
-						value: "bright"
-					},
-					{
-						label: "Darkness",
-						value: "dark"
-					},
-					{
-						label: "Red",
-						value: "red"
-					},
-					{
-						label: "Green",
-						value: "green"
-					},
-					{
-						label: "Blue",
-						value: "blue"
-					}
-				],
-				label: "Detect",
-				group: "Detection"
-			}
-		},
-		threshold: {
-			default: .25,
-			description: "Detection cut-off.",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Threshold",
-				group: "Detection"
-			}
-		},
-		layout: {
-			default: "mosaic",
-			compileTime: true,
-			description: "How the canvas is partitioned into detection cells.",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Grid",
-						value: "grid"
-					},
-					{
-						label: "Quadtree",
-						value: "quadtree"
-					},
-					{
-						label: "Mosaic",
-						value: "mosaic"
-					}
-				],
-				label: "Layout",
-				group: "Detection"
-			}
-		},
-		cellSize: {
-			default: 400,
-			description: "Base cell size in pixels",
-			ui: {
-				type: "range",
-				min: 24,
-				max: 800,
-				step: 1,
-				label: "Base Cell Size",
-				group: "Detection"
-			}
-		},
-		maxDepth: {
-			default: 2,
-			compileTime: true,
-			description: "Maximum subdivision levels for Quadtree/Mosaic layouts (each level can quarter a cell).",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 5,
-				step: 1,
-				label: "Subdivision",
-				group: "Detection",
-				condition: { layout: ["quadtree", "mosaic"] }
-			}
-		},
-		boxStyle: {
-			default: "corners",
-			compileTime: true,
-			description: "Bounding box outline style",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Full",
-					value: "full"
-				}, {
-					label: "Corners",
-					value: "corners"
-				}],
-				label: "Box Style",
-				group: "Boxes"
-			}
-		},
-		lineWidth: {
-			default: 1.5,
-			description: "Thickness of the box outline in pixels.",
-			ui: {
-				type: "range",
-				min: .5,
-				max: 12,
-				step: .5,
-				label: "Line Width",
-				group: "Boxes"
-			}
-		},
-		cornerRadius: {
-			default: 0,
-			description: "Corner radius of the box outline in pixels",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 40,
-				step: 1,
-				label: "Corner Radius",
-				group: "Boxes",
-				condition: { boxStyle: "full" }
-			}
-		},
-		strokeColor: {
-			default: "#ffffff",
-			transform: transformColor,
-			description: "Bounding box outline colour.",
-			ui: {
-				type: "color",
-				label: "Stroke",
-				group: "Colors"
-			}
-		},
-		fillColor: {
-			default: "#5a79911a",
-			transform: transformColor,
-			description: "Bounding box fill color.",
-			ui: {
-				type: "color",
-				label: "Fill",
-				group: "Colors"
-			}
-		},
-		labelColor: {
-			default: "#000000",
-			transform: transformColor,
-			description: "Label text color.",
-			ui: {
-				type: "color",
-				label: "Label",
-				group: "Colors",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		labelBackgroundColor: {
-			default: "#ffffff",
-			transform: transformColor,
-			description: "Label pill background color.",
-			ui: {
-				type: "color",
-				label: "Label Background",
-				group: "Colors",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		labelMode: {
-			default: "none",
-			compileTime: true,
-			description: "What each label shows.",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "None",
-						value: "none"
-					},
-					{
-						label: "Dimensions",
-						value: "dimensions"
-					},
-					{
-						label: "Percentage",
-						value: "percentage"
-					}
-				],
-				label: "Label",
-				group: "Labels"
-			}
-		},
-		labelPosition: {
-			default: "bottom-right",
-			compileTime: true,
-			description: "Which corner of the box the label anchors to.",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Bottom Left",
-						value: "bottom-left"
-					},
-					{
-						label: "Bottom Right",
-						value: "bottom-right"
-					},
-					{
-						label: "Top Left",
-						value: "top-left"
-					},
-					{
-						label: "Top Right",
-						value: "top-right"
-					}
-				],
-				label: "Label Position",
-				group: "Labels",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		labelRadius: {
-			default: 0,
-			description: "Corner radius of the label pill in pixels.",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 30,
-				step: 1,
-				label: "Border Radius",
-				group: "Labels",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		labelInset: {
-			default: true,
-			transform: transformBoolean,
-			description: "Place the label inside or outside the box.",
-			ui: {
-				type: "checkbox",
-				label: "Label Inset",
-				group: "Labels",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		fontFamily: {
-			default: "Inter",
-			description: "Google Fonts family used for label text.",
-			ui: {
-				type: "font-family",
-				label: "Font",
-				group: "Typography",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		fontWeight: {
-			default: 500,
-			description: "Font weight for label text.",
-			ui: {
-				type: "font-weight",
-				label: "Weight",
-				group: "Typography",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		fontSize: {
-			default: .015,
-			description: "Label text size as a fraction of canvas height.",
-			ui: {
-				type: "range",
-				min: .01,
-				max: .5,
-				step: .005,
-				label: "Size",
-				group: "Typography",
-				dimensional: "canvas-height",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		},
-		letterSpacing: {
-			default: 0,
-			description: "Letter spacing for label text, in em units.",
-			ui: {
-				type: "range",
-				min: -.1,
-				max: .5,
-				step: .005,
-				label: "Letter Spacing",
-				group: "Typography",
-				condition: { labelMode: ["dimensions", "percentage"] }
-			}
-		}
-	},
-	fragment: (params) => {
-		const { uniforms, ctx, childNode, convertToTexture, propValues, getCpuValue } = params;
-		if (!childNode) return ZERO;
-		const texKey = convertToTexture(childNode).key;
-		const modeMap = {
-			alpha: 0,
-			bright: 1,
-			dark: 2,
-			red: 3,
-			green: 4,
-			blue: 5
-		};
-		const layoutMap = {
-			grid: 0,
-			quadtree: 1,
-			mosaic: 2
-		};
-		const labelMap = {
-			none: 0,
-			dimensions: 1,
-			percentage: 2
-		};
-		const posMap = {
-			"bottom-left": 0,
-			"bottom-right": 1,
-			"top-left": 2,
-			"top-right": 3
-		};
-		const modeStr = [
-			"alpha",
-			"bright",
-			"dark",
-			"red",
-			"green",
-			"blue"
-		][typeof propValues.detectionMode === "number" ? propValues.detectionMode : modeMap[propValues.detectionMode] ?? 1];
-		const layoutStr = [
-			"grid",
-			"quadtree",
-			"mosaic"
-		][typeof propValues.layout === "number" ? propValues.layout : layoutMap[propValues.layout] ?? 2];
-		let D = Math.round(num(propValues.maxDepth, 2));
-		if (!Number.isFinite(D)) D = 2;
-		D = Math.max(0, Math.min(5, D));
-		if (layoutStr === "grid") D = 0;
-		const cornerStyle = (typeof propValues.boxStyle === "string" ? propValues.boxStyle : "corners") === "corners";
-		const labelStr = [
-			"none",
-			"dimensions",
-			"percentage"
-		][typeof propValues.labelMode === "number" ? propValues.labelMode : labelMap[propValues.labelMode] ?? 0];
-		const labelsOn = labelStr !== "none";
-		const labelPos = typeof propValues.labelPosition === "number" ? propValues.labelPosition : posMap[propValues.labelPosition] ?? 1;
-		let atlasKit = null;
-		if (labelsOn) {
-			const glyphTex = createSwappableMediaTexture(params, {
-				label: "ObjectTracker:atlas",
-				initial: {
-					width: ATLAS_W,
-					height: ATLAS_H
-				}
-			});
-			atlasKit = glyphTex.kit;
-			const target = createCanvasRasterTarget(params, { contextAttributes: { willReadFrequently: true } });
-			const readFont = () => ({
-				family: String(getCpuValue("fontFamily") ?? "Inter"),
-				weight: num(getCpuValue("fontWeight"), 500)
-			});
-			const build = (family, weight) => {
-				if (glyphTex.disposed) return;
-				const c = target.canvas() ? target.context() : target.resize(ATLAS_W, ATLAS_H);
-				if (!c) return;
-				c.clearRect(0, 0, ATLAS_W, ATLAS_H);
-				c.fillStyle = "#ffffff";
-				c.font = `${weight} ${Math.round(ATLAS_CELL_H * .62)}px "${family}", ui-monospace, monospace`;
-				c.textAlign = "center";
-				c.textBaseline = "middle";
-				for (let i = 0; i < 12; i++) c.fillText(ATLAS_GLYPHS[i], i * ATLAS_CELL_W + ATLAS_CELL_W / 2, ATLAS_CELL_H / 2 + 1);
-				glyphTex.write(target.canvas());
-			};
-			const fp0 = readFont();
-			build(fp0.family, fp0.weight);
-			const rebuild = () => {
-				const fp = readFont();
-				build(fp.family, fp.weight);
-			};
-			const font = createFontDependentRaster({
-				key: () => {
-					const fp = readFont();
-					return `${fp.family}|${fp.weight}`;
-				},
-				load: () => {
-					const fp = readFont();
-					return loadGoogleFont(fp.family, fp.weight);
-				},
-				onLoaded: rebuild
-			});
-			setTimeout(() => font.ensure(), 0);
-			createRasterInvalidator(params, {
-				initialKey: `${fp0.family}|${fp0.weight}`,
-				minIntervalMs: 100,
-				key: () => {
-					const fp = readFont();
-					return `${fp.family}|${fp.weight}`;
-				},
-				run: () => {
-					rebuild();
-					font.ensure();
-				}
-			});
-		}
-		const atlasKey = atlasKit?.key;
-		return new Expr((ec) => {
-			const U = (name) => uniforms[name]._emit(ec);
-			const L = (n) => formatFloat(n);
-			const UN = ec.external(unpremultiplyAlpha, "unpremultiplyAlpha");
-			const p = ec.freshLocal("ot");
-			const s = [];
-			const sampleChild = (uvWgsl) => `textureSampleLevel(tex.$.${texKey}, samp.$.linearClamp, ${uvWgsl}, 0.0)`;
-			s.push(`let ${p}_res = ${ctx.logicalViewportSize._emit(ec)};`);
-			s.push(`let ${p}_scaleFactor = ${p}_res.y / ${L(REFERENCE_HEIGHT)};`);
-			const uvE = ctx.uv._emit(ec);
-			s.push(`let ${p}_fragPx = vec2f((${uvE}).x * ${p}_res.x, (${uvE}).y * ${p}_res.y);`);
-			s.push(`let ${p}_aa = max(max(fwidth(${p}_fragPx.x), fwidth(${p}_fragPx.y)), ${L(1e-4)});`);
-			s.push(`let ${p}_cellPx = max(${U("cellSize")} * ${p}_scaleFactor, ${L(4)});`);
-			s.push(`let ${p}_minSize = ${L(3)} * ${p}_scaleFactor;`);
-			s.push(`let ${p}_lineHalf = max(${U("lineWidth")} * ${p}_scaleFactor * ${L(.5)}, ${L(.5)});`);
-			s.push(`let ${p}_cornerRadiusPx = ${U("cornerRadius")} * ${p}_scaleFactor;`);
-			s.push(`let ${p}_boxInset = ${p}_lineHalf + ${p}_scaleFactor * ${L(1.5)};`);
-			s.push(`let ${p}_thr = ${U("threshold")};`);
-			const contentBool = (sVar, uVar) => {
-				if (modeStr === "alpha") return `${sVar}.a > ${p}_thr`;
-				if (modeStr === "bright") return `dot(${uVar}.rgb, ${LUM}) > ${p}_thr && ${sVar}.a > ${L(.02)}`;
-				if (modeStr === "dark") return `dot(${uVar}.rgb, ${LUM}) < ${p}_thr && ${sVar}.a > ${L(.5)}`;
-				if (modeStr === "red") return `${uVar}.r > ${p}_thr && ${uVar}.r >= ${uVar}.g && ${uVar}.r >= ${uVar}.b && ${sVar}.a > ${L(.02)}`;
-				if (modeStr === "green") return `${uVar}.g > ${p}_thr && ${uVar}.g >= ${uVar}.r && ${uVar}.g >= ${uVar}.b && ${sVar}.a > ${L(.02)}`;
-				return `${uVar}.b > ${p}_thr && ${uVar}.b >= ${uVar}.r && ${uVar}.b >= ${uVar}.g && ${sVar}.a > ${L(.02)}`;
-			};
-			const scanCell = (sfx, originX, originY, sizeV, N, wantBounds) => {
-				s.push(`var ${sfx}_cnt = ${L(0)};`);
-				if (wantBounds) s.push(`var ${sfx}_minX = ${L(1e9)}; var ${sfx}_maxX = ${L(-1e9)}; var ${sfx}_minY = ${L(1e9)}; var ${sfx}_maxY = ${L(-1e9)};`);
-				const inv = 1 / N;
-				let k = 0;
-				for (let sy = 0; sy < N; sy++) for (let sx = 0; sx < N; sx++) {
-					const pxX = `${sfx}_px${k}x`;
-					const pxY = `${sfx}_px${k}y`;
-					s.push(`let ${pxX} = ${originX} + ${sizeV} * ${L((sx + .5) * inv)};`);
-					s.push(`let ${pxY} = ${originY} + ${sizeV} * ${L((sy + .5) * inv)};`);
-					s.push(`let ${sfx}_s${k} = ${sampleChild(`vec2f(${pxX}, ${pxY}) / ${p}_res`)};`);
-					if (modeStr !== "alpha") s.push(`let ${sfx}_u${k} = ${UN}(${sfx}_s${k});`);
-					s.push(`let ${sfx}_c${k} = ${contentBool(`${sfx}_s${k}`, `${sfx}_u${k}`)};`);
-					s.push(`${sfx}_cnt = ${sfx}_cnt + select(${L(0)}, ${L(1)}, ${sfx}_c${k});`);
-					if (wantBounds) {
-						s.push(`${sfx}_minX = select(${sfx}_minX, min(${sfx}_minX, ${pxX}), ${sfx}_c${k});`);
-						s.push(`${sfx}_maxX = select(${sfx}_maxX, max(${sfx}_maxX, ${pxX}), ${sfx}_c${k});`);
-						s.push(`${sfx}_minY = select(${sfx}_minY, min(${sfx}_minY, ${pxY}), ${sfx}_c${k});`);
-						s.push(`${sfx}_maxY = select(${sfx}_maxY, max(${sfx}_maxY, ${pxY}), ${sfx}_c${k});`);
-					}
-					k++;
-				}
-				s.push(`let ${sfx}_coverage = ${sfx}_cnt / ${L(N * N)};`);
-			};
-			s.push(`var ${p}_origin = floor(${p}_fragPx / ${p}_cellPx) * ${p}_cellPx;`);
-			s.push(`var ${p}_size = ${p}_cellPx;`);
-			for (let lvl = 0; lvl < D; lvl++) {
-				const sfx = `${p}_w${lvl}`;
-				if (layoutStr === "mosaic") {
-					s.push(`let ${sfx}_cellIx = ${p}_origin / ${p}_size;`);
-					s.push(`let ${sfx}_doSplit = fract(sin(dot(${sfx}_cellIx, vec2f(${L(127.1)}, ${L(311.7)})) + ${L(lvl * 53.13)}) * ${L(43758.5453)}) > ${L(.5)};`);
-				} else {
-					scanCell(sfx, `${p}_origin.x`, `${p}_origin.y`, `${p}_size`, WALK_SCAN, false);
-					s.push(`let ${sfx}_doSplit = ${sfx}_coverage > ${L(.02)} && ${sfx}_coverage < ${L(.98)};`);
-				}
-				s.push(`let ${sfx}_half = ${p}_size * ${L(.5)};`);
-				s.push(`let ${sfx}_qx = step(${p}_origin.x + ${sfx}_half, ${p}_fragPx.x);`);
-				s.push(`let ${sfx}_qy = step(${p}_origin.y + ${sfx}_half, ${p}_fragPx.y);`);
-				s.push(`let ${sfx}_childOrigin = vec2f(${p}_origin.x + ${sfx}_qx * ${sfx}_half, ${p}_origin.y + ${sfx}_qy * ${sfx}_half);`);
-				s.push(`${p}_origin = select(${p}_origin, ${sfx}_childOrigin, ${sfx}_doSplit);`);
-				s.push(`${p}_size = select(${p}_size, ${sfx}_half, ${sfx}_doSplit);`);
-			}
-			scanCell(`${p}_leaf`, `${p}_origin.x`, `${p}_origin.y`, `${p}_size`, LEAF_SCAN, true);
-			s.push(`let ${p}_halfStep = ${p}_size / ${L(LEAF_SCAN)} * ${L(.5)};`);
-			s.push(`let ${p}_innerMinX = ${p}_origin.x + ${p}_boxInset;`);
-			s.push(`let ${p}_innerMaxX = max(${p}_origin.x + ${p}_size - ${p}_boxInset, ${p}_innerMinX);`);
-			s.push(`let ${p}_innerMinY = ${p}_origin.y + ${p}_boxInset;`);
-			s.push(`let ${p}_innerMaxY = max(${p}_origin.y + ${p}_size - ${p}_boxInset, ${p}_innerMinY);`);
-			s.push(`let ${p}_bMinX = clamp(${p}_leaf_minX - ${p}_halfStep, ${p}_innerMinX, ${p}_innerMaxX);`);
-			s.push(`let ${p}_bMaxX = clamp(${p}_leaf_maxX + ${p}_halfStep, ${p}_innerMinX, ${p}_innerMaxX);`);
-			s.push(`let ${p}_bMinY = clamp(${p}_leaf_minY - ${p}_halfStep, ${p}_innerMinY, ${p}_innerMaxY);`);
-			s.push(`let ${p}_bMaxY = clamp(${p}_leaf_maxY + ${p}_halfStep, ${p}_innerMinY, ${p}_innerMaxY);`);
-			s.push(`let ${p}_boxW = ${p}_bMaxX - ${p}_bMinX;`);
-			s.push(`let ${p}_boxH = ${p}_bMaxY - ${p}_bMinY;`);
-			s.push(`let ${p}_detected = ${p}_leaf_coverage > ${L(.02)} && ${p}_boxW > ${p}_minSize && ${p}_boxH > ${p}_minSize;`);
-			s.push(`let ${p}_detF = select(${L(0)}, ${L(1)}, ${p}_detected);`);
-			s.push(`var ${p}_dst = ${sampleChild(`(${uvE})`)};`);
-			s.push(`let ${p}_center = vec2f((${p}_bMinX + ${p}_bMaxX) * ${L(.5)}, (${p}_bMinY + ${p}_bMaxY) * ${L(.5)});`);
-			s.push(`let ${p}_halfB = vec2f(${p}_boxW * ${L(.5)}, ${p}_boxH * ${L(.5)});`);
-			const cRExpr = cornerStyle ? L(0) : `${p}_cornerRadiusPx`;
-			s.push(`let ${p}_cR = max(min(min(${cRExpr}, ${p}_halfB.x), ${p}_halfB.y), ${L(0)});`);
-			s.push(`let ${p}_pp = ${p}_fragPx - ${p}_center;`);
-			s.push(`let ${p}_q = abs(${p}_pp) - ${p}_halfB + ${p}_cR;`);
-			s.push(`let ${p}_sd = length(max(${p}_q, vec2f(0.0))) + min(max(${p}_q.x, ${p}_q.y), ${L(0)}) - ${p}_cR;`);
-			s.push(`let ${p}_fillA = (${L(1)} - smoothstep(${L(0)}, ${p}_aa, ${p}_sd)) * ${U("fillColor")}.a * ${p}_detF;`);
-			s.push(`var ${p}_strokeA = ${L(1)} - smoothstep(${L(0)}, ${p}_aa, abs(${p}_sd) - ${p}_lineHalf);`);
-			if (cornerStyle) {
-				s.push(`let ${p}_bl = min(${p}_halfB.x, ${p}_halfB.y) * ${L(.35)};`);
-				s.push(`let ${p}_inCorner = abs(${p}_pp.x) > ${p}_halfB.x - ${p}_bl && abs(${p}_pp.y) > ${p}_halfB.y - ${p}_bl;`);
-				s.push(`${p}_strokeA = ${p}_strokeA * select(${L(0)}, ${L(1)}, ${p}_inCorner);`);
-			}
-			s.push(`${p}_strokeA = ${p}_strokeA * ${U("strokeColor")}.a * ${p}_detF;`);
-			const overP = (rgb, a) => {
-				s.push(`{ let av = clamp(${a}, 0.0, 1.0); ${p}_dst = vec4f((${rgb}) * av + ${p}_dst.rgb * (1.0 - av), av + ${p}_dst.a * (1.0 - av)); }`);
-			};
-			overP(`${U("fillColor")}.rgb`, `${p}_fillA`);
-			overP(`${U("strokeColor")}.rgb`, `${p}_strokeA`);
-			if (labelsOn && atlasKey) {
-				s.push(`let ${p}_textH = max(${U("fontSize")} * ${p}_res.y, ${L(1)});`);
-				s.push(`let ${p}_glyphW = ${p}_textH * ${L(ATLAS_CELL_W / ATLAS_CELL_H)};`);
-				s.push(`let ${p}_advance = ${p}_glyphW + ${p}_textH * ${U("letterSpacing")};`);
-				s.push(`let ${p}_padX = ${p}_textH * ${L(.38)};`);
-				s.push(`let ${p}_padY = ${p}_textH * ${L(.24)};`);
-				s.push(`let ${p}_gap = ${p}_textH * ${L(.28)};`);
-				const digitsOf = (v) => `(${L(1)} + step(${L(10)}, ${v}) + step(${L(100)}, ${v}) + step(${L(1e3)}, ${v}) + step(${L(1e4)}, ${v}))`;
-				const digitAt = (v, e) => {
-					const x = `floor(${v} / pow(${L(10)}, ${e}))`;
-					return `(${x} - ${L(10)} * floor((${x}) / ${L(10)}))`;
-				};
-				if (labelStr === "dimensions") {
-					s.push(`let ${p}_w = clamp(floor(${p}_boxW + ${L(.5)}), ${L(1)}, ${L(99999)});`);
-					s.push(`let ${p}_h = clamp(floor(${p}_boxH + ${L(.5)}), ${L(1)}, ${L(99999)});`);
-					s.push(`let ${p}_dw = ${digitsOf(`${p}_w`)};`);
-					s.push(`let ${p}_dh = ${digitsOf(`${p}_h`)};`);
-					s.push(`let ${p}_total = ${p}_dw + ${L(1)} + ${p}_dh;`);
-				} else {
-					s.push(`let ${p}_pc = clamp(floor(${p}_leaf_coverage * ${L(100)} + ${L(.5)}), ${L(0)}, ${L(100)});`);
-					s.push(`let ${p}_dp = ${digitsOf(`${p}_pc`)};`);
-					s.push(`let ${p}_total = ${p}_dp + ${L(1)};`);
-				}
-				s.push(`let ${p}_labelW = ${p}_total * ${p}_advance + ${p}_padX * ${L(2)};`);
-				s.push(`let ${p}_labelH = ${p}_textH + ${p}_padY * ${L(2)};`);
-				const isRight = labelPos === 1 || labelPos === 3;
-				const isTop = labelPos === 2 || labelPos === 3;
-				s.push(`let ${p}_inset = ${U("labelInset")} > ${L(.5)};`);
-				const leftIn = isRight ? `${p}_bMaxX - ${p}_labelW - ${p}_gap` : `${p}_bMinX + ${p}_gap`;
-				const leftOut = isRight ? `${p}_bMaxX - ${p}_labelW` : `${p}_bMinX`;
-				s.push(`var ${p}_labelLeft = select(${leftOut}, ${leftIn}, ${p}_inset);`);
-				const topIn = isTop ? `${p}_bMinY + ${p}_gap` : `${p}_bMaxY - ${p}_labelH - ${p}_gap`;
-				const topOut = isTop ? `${p}_bMinY - ${p}_labelH - ${p}_gap` : `${p}_bMaxY + ${p}_gap`;
-				s.push(`var ${p}_labelTop = select(${topOut}, ${topIn}, ${p}_inset);`);
-				s.push(`let ${p}_cellMaxX = ${p}_origin.x + ${p}_size;`);
-				s.push(`let ${p}_cellMaxY = ${p}_origin.y + ${p}_size;`);
-				s.push(`${p}_labelLeft = clamp(${p}_labelLeft, ${p}_origin.x, max(${p}_cellMaxX - ${p}_labelW, ${p}_origin.x));`);
-				s.push(`${p}_labelTop = clamp(${p}_labelTop, ${p}_origin.y, max(${p}_cellMaxY - ${p}_labelH, ${p}_origin.y));`);
-				s.push(`let ${p}_labelCenter = vec2f(${p}_labelLeft + ${p}_labelW * ${L(.5)}, ${p}_labelTop + ${p}_labelH * ${L(.5)});`);
-				s.push(`let ${p}_pillHalf = vec2f(${p}_labelW * ${L(.5)}, ${p}_labelH * ${L(.5)});`);
-				s.push(`let ${p}_pillR = max(min(min(${U("labelRadius")} * ${p}_scaleFactor, ${p}_pillHalf.x), ${p}_pillHalf.y), ${L(0)});`);
-				s.push(`let ${p}_pillP = ${p}_fragPx - ${p}_labelCenter;`);
-				s.push(`let ${p}_pillQ = abs(${p}_pillP) - ${p}_pillHalf + ${p}_pillR;`);
-				s.push(`let ${p}_pillSD = length(max(${p}_pillQ, vec2f(0.0))) + min(max(${p}_pillQ.x, ${p}_pillQ.y), ${L(0)}) - ${p}_pillR;`);
-				s.push(`let ${p}_pillA = (${L(1)} - smoothstep(${L(0)}, ${p}_aa, ${p}_pillSD)) * ${U("labelBackgroundColor")}.a * ${p}_detF;`);
-				overP(`${U("labelBackgroundColor")}.rgb`, `${p}_pillA`);
-				s.push(`let ${p}_rel = ${p}_fragPx.x - ${p}_labelLeft - ${p}_padX;`);
-				s.push(`let ${p}_slot = floor(${p}_rel / ${p}_advance);`);
-				s.push(`let ${p}_within = fract(${p}_rel / ${p}_advance);`);
-				s.push(`let ${p}_uInChar = ${p}_within * (${p}_advance / ${p}_glyphW);`);
-				s.push(`let ${p}_vInChar = (${p}_fragPx.y - ${p}_labelTop - ${p}_padY) / ${p}_textH;`);
-				if (labelStr === "dimensions") {
-					s.push(`let ${p}_wDigit = ${digitAt(`${p}_w`, `${p}_dw - ${L(1)} - ${p}_slot`)};`);
-					s.push(`let ${p}_hDigit = ${digitAt(`${p}_h`, `${p}_dh + ${p}_dw - ${p}_slot`)};`);
-					s.push(`var ${p}_g = ${p}_hDigit;`);
-					s.push(`${p}_g = select(${p}_g, ${L(10)}, ${p}_slot == ${p}_dw);`);
-					s.push(`${p}_g = select(${p}_g, ${p}_wDigit, ${p}_slot < ${p}_dw);`);
-				} else s.push(`var ${p}_g = select(${L(11)}, ${digitAt(`${p}_pc`, `${p}_dp - ${L(1)} - ${p}_slot`)}, ${p}_slot < ${p}_dp);`);
-				s.push(`let ${p}_atlasU = (${p}_g + clamp(${p}_uInChar, ${L(0)}, ${L(1)})) / ${L(ATLAS_SLOTS)};`);
-				s.push(`let ${p}_glyphCov = textureSampleLevel(tex.$.${atlasKey}, samp.$.linearClamp, vec2f(${p}_atlasU, ${p}_vInChar), 0.0).a;`);
-				s.push(`let ${p}_inText = ${p}_rel >= ${L(0)} && ${p}_slot >= ${L(0)} && ${p}_slot < ${p}_total && ${p}_uInChar <= ${L(1)} && ${p}_vInChar >= ${L(0)} && ${p}_vInChar <= ${L(1)};`);
-				s.push(`let ${p}_textA = ${p}_glyphCov * select(${L(0)}, ${L(1)}, ${p}_inText) * ${U("labelColor")}.a * ${p}_detF;`);
-				overP(`${U("labelColor")}.rgb`, `${p}_textA`);
-			}
-			for (const line of s) ec.statement(line);
-			return `vec4f(${p}_dst.rgb / max(${p}_dst.a, ${L(1e-4)}), ${p}_dst.a)`;
-		});
-	}
-};
-var ObjectTracker_default = componentDefinition;
-export { componentDefinition as n, ObjectTracker_default as t };