shaders 3.1.462 → 3.2.464

package/dist/core/Ascii-D4tzJH13.js

@@ -1,1099 +0,0 @@
-import { Ft as vec3f, Lt as vec4f, Mt as vec2f, P as unpremultiplyAlpha, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, ht as fract, it as abs, m as call, mt as floor, qt as struct, rt as select, sn as f32, xt as pow } from "./edges-CV-BHMpI.js";
-import { 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";
-var ATLAS_TEXTURE_SIZE = 2048;
-var REFERENCE_HEIGHT = 1080;
-var GOOGLE_FONTS_MAP = {
-	"JetBrains Mono": "JetBrains+Mono",
-	"Fira Code": "Fira+Code",
-	"Source Code Pro": "Source+Code+Pro",
-	"IBM Plex Mono": "IBM+Plex+Mono",
-	"Space Mono": "Space+Mono",
-	"Roboto Mono": "Roboto+Mono",
-	"Courier Prime": "Courier+Prime",
-	"Geist Mono": "Geist+Mono",
-	"VT323": "VT323",
-	"Press Start 2P": "Press+Start+2P",
-	"Silkscreen": "Silkscreen",
-	"Major Mono Display": "Major+Mono+Display",
-	"Syne Mono": "Syne+Mono",
-	"Nova Mono": "Nova+Mono",
-	"Xanh Mono": "Xanh+Mono",
-	"Cutive Mono": "Cutive+Mono",
-	"Share Tech Mono": "Share+Tech+Mono",
-	"Martian Mono": "Martian+Mono",
-	"Azeret Mono": "Azeret+Mono"
-};
-var loadedFonts = /* @__PURE__ */ new Set();
-async function loadAsciiFont(fontFamily) {
-	if (loadedFonts.has(fontFamily) || !GOOGLE_FONTS_MAP[fontFamily]) return;
-	const googleFontName = GOOGLE_FONTS_MAP[fontFamily];
-	if (!document.querySelector(`link[href*="${googleFontName}"]`)) {
-		const link = document.createElement("link");
-		link.rel = "stylesheet";
-		link.href = `https://fonts.googleapis.com/css2?family=${googleFontName}:wght@400&display=swap`;
-		document.head.appendChild(link);
-	}
-	try {
-		if (document.fonts && document.fonts.load) {
-			for (const spec of [
-				`400 12px "${fontFamily}"`,
-				`12px "${fontFamily}"`,
-				`400 12px ${fontFamily}`,
-				`12px ${fontFamily}`
-			]) try {
-				await document.fonts.load(spec);
-				break;
-			} catch {}
-			await new Promise((r) => setTimeout(r, 500));
-		} else await new Promise((r) => setTimeout(r, 1e3));
-		loadedFonts.add(fontFamily);
-	} catch {}
-}
-var num = (v, f) => typeof v === "number" ? v : f;
-var AsciiGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	cellCenter: vec2f,
-	cellUV: vec2f,
-	isOutside: f32
-}), "AsciiGrid");
-const asciiGrid = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], AsciiGrid)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellSize, spacing) => {
-	"use gpu";
-	const scaleFactor = __tsover_div(viewport.y, REFERENCE_HEIGHT);
-	const effectiveCellSize = __tsover_mul(cellSize, scaleFactor);
-	const mainGridSize = vec2f(__tsover_div(viewport.x, effectiveCellSize), __tsover_div(viewport.y, effectiveCellSize));
-	const gridCoords = vec2f(__tsover_mul(uv.x, mainGridSize.x), __tsover_mul(uv.y, mainGridSize.y));
-	const cellCoords = floor(gridCoords);
-	const rawCellUV = fract(gridCoords);
-	const centeredU = __tsover_sub(rawCellUV.x, .5);
-	const centeredV = __tsover_sub(rawCellUV.y, .5);
-	const cellUV = vec2f(__tsover_add(__tsover_div(centeredU, spacing), .5), __tsover_add(__tsover_div(centeredV, spacing), .5));
-	const half = __tsover_mul(spacing, .5);
-	const isOutside = select(f32(0), f32(1), abs(centeredU) > half || abs(centeredV) > half);
-	return AsciiGrid({
-		cellCenter: vec2f(__tsover_div(__tsover_add(cellCoords.x, .5), mainGridSize.x), __tsover_div(__tsover_add(cellCoords.y, .5), mainGridSize.y)),
-		cellUV,
-		isOutside
-	});
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "cellSize"
-			},
-			{
-				"type": "i",
-				"name": "spacing"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"scaleFactor",
-				[
-					1,
-					[
-						7,
-						"viewport",
-						"y"
-					],
-					"/",
-					"REFERENCE_HEIGHT"
-				]
-			],
-			[
-				13,
-				"effectiveCellSize",
-				[
-					1,
-					"cellSize",
-					"*",
-					"scaleFactor"
-				]
-			],
-			[
-				13,
-				"mainGridSize",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"viewport",
-							"x"
-						],
-						"/",
-						"effectiveCellSize"
-					], [
-						1,
-						[
-							7,
-							"viewport",
-							"y"
-						],
-						"/",
-						"effectiveCellSize"
-					]]
-				]
-			],
-			[
-				13,
-				"gridCoords",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"mainGridSize",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"mainGridSize",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"cellCoords",
-				[
-					6,
-					"std.floor",
-					["gridCoords"]
-				]
-			],
-			[
-				13,
-				"rawCellUV",
-				[
-					6,
-					"std.fract",
-					["gridCoords"]
-				]
-			],
-			[
-				13,
-				"centeredU",
-				[
-					1,
-					[
-						7,
-						"rawCellUV",
-						"x"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"centeredV",
-				[
-					1,
-					[
-						7,
-						"rawCellUV",
-						"y"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"cellUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							1,
-							"centeredU",
-							"/",
-							"spacing"
-						],
-						"+",
-						[5, "0.5"]
-					], [
-						1,
-						[
-							1,
-							"centeredV",
-							"/",
-							"spacing"
-						],
-						"+",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"half",
-				[
-					1,
-					"spacing",
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"isOutside",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							3,
-							[
-								1,
-								[
-									6,
-									"std.abs",
-									["centeredU"]
-								],
-								">",
-								"half"
-							],
-							"||",
-							[
-								1,
-								[
-									6,
-									"std.abs",
-									["centeredV"]
-								],
-								">",
-								"half"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"cellCenter",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"cellCoords",
-								"x"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							7,
-							"mainGridSize",
-							"x"
-						]
-					], [
-						1,
-						[
-							1,
-							[
-								7,
-								"cellCoords",
-								"y"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							7,
-							"mainGridSize",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"AsciiGrid",
-				[[104, {
-					"cellCenter": "cellCenter",
-					"cellUV": "cellUV",
-					"isOutside": "isOutside"
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"REFERENCE_HEIGHT": () => REFERENCE_HEIGHT,
-		"d.vec2f": () => vec2f,
-		"std.floor": () => floor,
-		"std.fract": () => fract,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"std.abs": () => abs,
-		"AsciiGrid": () => AsciiGrid
-	}
-}) && $.f)({})).$name("asciiGrid");
-const asciiAtlasUV = typegpu_default.fn([
-	vec3f,
-	f32,
-	f32,
-	f32,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellRgb, gamma, charCount, atlasSize, atlasScale, cellUV) => {
-	"use gpu";
-	const adjustedBrightness = pow(dot(cellRgb, vec3f(.299, .587, .114)), gamma);
-	const invertedBrightness = __tsover_sub(1, adjustedBrightness);
-	const charIndex = clamp(floor(__tsover_mul(invertedBrightness, charCount)), 0, __tsover_sub(charCount, 1));
-	const atlasCol = __tsover_sub(charIndex, __tsover_mul(atlasSize, floor(__tsover_div(charIndex, atlasSize))));
-	const atlasRow = floor(__tsover_div(charIndex, atlasSize));
-	const atlasCellSize = __tsover_mul(__tsover_div(1, atlasSize), atlasScale);
-	const baseU = __tsover_mul(atlasCol, atlasCellSize);
-	const baseV = __tsover_mul(atlasRow, atlasCellSize);
-	return vec2f(__tsover_add(baseU, __tsover_mul(cellUV.x, atlasCellSize)), __tsover_add(baseV, __tsover_mul(cellUV.y, atlasCellSize)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "cellRgb"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "charCount"
-			},
-			{
-				"type": "i",
-				"name": "atlasSize"
-			},
-			{
-				"type": "i",
-				"name": "atlasScale"
-			},
-			{
-				"type": "i",
-				"name": "cellUV"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rawBrightness",
-				[
-					6,
-					"std.dot",
-					["cellRgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"adjustedBrightness",
-				[
-					6,
-					"std.pow",
-					["rawBrightness", "gamma"]
-				]
-			],
-			[
-				13,
-				"invertedBrightness",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"adjustedBrightness"
-				]
-			],
-			[
-				13,
-				"scaledBrightness",
-				[
-					1,
-					"invertedBrightness",
-					"*",
-					"charCount"
-				]
-			],
-			[
-				13,
-				"charIndex",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"std.floor",
-							["scaledBrightness"]
-						],
-						[5, "0"],
-						[
-							1,
-							"charCount",
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"atlasCol",
-				[
-					1,
-					"charIndex",
-					"-",
-					[
-						1,
-						"atlasSize",
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"charIndex",
-								"/",
-								"atlasSize"
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"atlasRow",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"charIndex",
-						"/",
-						"atlasSize"
-					]]
-				]
-			],
-			[
-				13,
-				"atlasCellSize",
-				[
-					1,
-					[
-						1,
-						[5, "1"],
-						"/",
-						"atlasSize"
-					],
-					"*",
-					"atlasScale"
-				]
-			],
-			[
-				13,
-				"baseU",
-				[
-					1,
-					"atlasCol",
-					"*",
-					"atlasCellSize"
-				]
-			],
-			[
-				13,
-				"baseV",
-				[
-					1,
-					"atlasRow",
-					"*",
-					"atlasCellSize"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					"baseU",
-					"+",
-					[
-						1,
-						[
-							7,
-							"cellUV",
-							"x"
-						],
-						"*",
-						"atlasCellSize"
-					]
-				], [
-					1,
-					"baseV",
-					"+",
-					[
-						1,
-						[
-							7,
-							"cellUV",
-							"y"
-						],
-						"*",
-						"atlasCellSize"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.pow": () => pow,
-		"std.clamp": () => clamp,
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({})).$name("asciiAtlasUV");
-const asciiCompose = typegpu_default.fn([
-	vec3f,
-	vec4f,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((asciiRgb, cellColor, isOutside, alphaThreshold, preserveAlpha) => {
-	"use gpu";
-	const isBackground = dot(asciiRgb, vec3f(.299, .587, .114)) < .1;
-	const sourceAlpha = cellColor.w;
-	const isBelowThreshold = sourceAlpha < alphaThreshold;
-	const outputAlpha = select(f32(1), sourceAlpha, preserveAlpha > .5);
-	const hide = isBackground || isOutside > .5 || isBelowThreshold;
-	const finalAlpha = select(outputAlpha, f32(0), hide);
-	return vec4f(__tsover_mul(asciiRgb.x, cellColor.x), __tsover_mul(asciiRgb.y, cellColor.y), __tsover_mul(asciiRgb.z, cellColor.z), finalAlpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "asciiRgb"
-			},
-			{
-				"type": "i",
-				"name": "cellColor"
-			},
-			{
-				"type": "i",
-				"name": "isOutside"
-			},
-			{
-				"type": "i",
-				"name": "alphaThreshold"
-			},
-			{
-				"type": "i",
-				"name": "preserveAlpha"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"charBrightness",
-				[
-					6,
-					"std.dot",
-					["asciiRgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"isBackground",
-				[
-					1,
-					"charBrightness",
-					"<",
-					[5, "0.1"]
-				]
-			],
-			[
-				13,
-				"sourceAlpha",
-				[
-					7,
-					"cellColor",
-					"w"
-				]
-			],
-			[
-				13,
-				"isBelowThreshold",
-				[
-					1,
-					"sourceAlpha",
-					"<",
-					"alphaThreshold"
-				]
-			],
-			[
-				13,
-				"outputAlpha",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						"sourceAlpha",
-						[
-							1,
-							"preserveAlpha",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"hide",
-				[
-					3,
-					[
-						3,
-						"isBackground",
-						"||",
-						[
-							1,
-							"isOutside",
-							">",
-							[5, "0.5"]
-						]
-					],
-					"||",
-					"isBelowThreshold"
-				]
-			],
-			[
-				13,
-				"finalAlpha",
-				[
-					6,
-					"std.select",
-					[
-						"outputAlpha",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"hide"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"x"
-						]
-					],
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"y"
-						]
-					],
-					[
-						1,
-						[
-							7,
-							"asciiRgb",
-							"z"
-						],
-						"*",
-						[
-							7,
-							"cellColor",
-							"z"
-						]
-					],
-					"finalAlpha"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("asciiCompose");
-const componentDefinition = {
-	name: "Ascii",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Stylize",
-	description: "Convert imagery to ASCII character art",
-	requiresRTT: true,
-	requiresChild: true,
-	extraFields: {
-		_charCount: {
-			schema: f32,
-			initial: 9
-		},
-		_atlasScale: {
-			schema: f32,
-			initial: 1
-		},
-		_atlasSize: {
-			schema: f32,
-			initial: 3
-		}
-	},
-	props: {
-		characters: {
-			default: "@%#*+=-:.",
-			description: "Characters ordered from dense to sparse. First character is used for bright areas, last for dark areas.",
-			ui: {
-				type: "text",
-				label: "Characters",
-				group: "Effect"
-			}
-		},
-		cellSize: {
-			default: 30,
-			description: "Size of each ASCII character cell (normalized to 1080p reference, scales proportionally at other resolutions)",
-			ui: {
-				type: "range",
-				min: 8,
-				max: 100,
-				step: 1,
-				label: "Cell Size",
-				group: "Effect"
-			}
-		},
-		fontFamily: {
-			default: "JetBrains Mono",
-			description: "Font family for characters",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Azeret Mono",
-						value: "Azeret Mono"
-					},
-					{
-						label: "Courier Prime",
-						value: "Courier Prime"
-					},
-					{
-						label: "Cutive Mono",
-						value: "Cutive Mono"
-					},
-					{
-						label: "Fira Code",
-						value: "Fira Code"
-					},
-					{
-						label: "Geist Mono",
-						value: "Geist Mono"
-					},
-					{
-						label: "IBM Plex Mono",
-						value: "IBM Plex Mono"
-					},
-					{
-						label: "JetBrains Mono",
-						value: "JetBrains Mono"
-					},
-					{
-						label: "Major Mono Display",
-						value: "Major Mono Display"
-					},
-					{
-						label: "Martian Mono",
-						value: "Martian Mono"
-					},
-					{
-						label: "Nova Mono",
-						value: "Nova Mono"
-					},
-					{
-						label: "Press Start 2P",
-						value: "Press Start 2P"
-					},
-					{
-						label: "Roboto Mono",
-						value: "Roboto Mono"
-					},
-					{
-						label: "Share Tech Mono",
-						value: "Share Tech Mono"
-					},
-					{
-						label: "Silkscreen",
-						value: "Silkscreen"
-					},
-					{
-						label: "Source Code Pro",
-						value: "Source Code Pro"
-					},
-					{
-						label: "Space Mono",
-						value: "Space Mono"
-					},
-					{
-						label: "Syne Mono",
-						value: "Syne Mono"
-					},
-					{
-						label: "VT323",
-						value: "VT323"
-					},
-					{
-						label: "Xanh Mono",
-						value: "Xanh Mono"
-					}
-				],
-				label: "Font Family",
-				group: "Font"
-			}
-		},
-		spacing: {
-			default: 1,
-			description: "Character size within each cell (1.0 = optimal size, 0.0 = smallest)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Character Size",
-				group: "Effect"
-			},
-			transform: (value) => .1 + value * 1.4
-		},
-		gamma: {
-			default: 1,
-			description: "Brightness curve adjustment. <1 brightens darks (more light characters), >1 darkens midtones (more dark characters). Use to better fit characters to image brightness range.",
-			ui: {
-				type: ["range", "map"],
-				min: .25,
-				max: 3,
-				step: .01,
-				label: "Gamma",
-				group: "Effect"
-			}
-		},
-		alphaThreshold: {
-			default: 0,
-			description: "Pixels with alpha below this threshold become fully transparent.",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Alpha Threshold",
-				group: "Effect"
-			}
-		},
-		preserveAlpha: {
-			default: true,
-			description: "When enabled, output alpha matches input alpha. When disabled, pixels above the alpha threshold become fully opaque.",
-			ui: {
-				type: "checkbox",
-				label: "Preserve Alpha",
-				group: "Effect"
-			},
-			transform: transformBoolean
-		}
-	},
-	fragment: (params) => {
-		const { uniforms, ctx, childNode, convertToTexture, getCpuValue, setExtraField } = params;
-		if (!childNode) return ZERO;
-		const child = convertToTexture(childNode);
-		const glyphTex = createSwappableMediaTexture(params, {
-			label: "Ascii:atlas",
-			initial: {
-				width: ATLAS_TEXTURE_SIZE,
-				height: ATLAS_TEXTURE_SIZE
-			}
-		});
-		const atlasKit = glyphTex.kit;
-		const target = createCanvasRasterTarget(params, { contextAttributes: { willReadFrequently: true } });
-		const buildAtlas = (characters, spacing, fontFamily) => {
-			if (glyphTex.disposed || !characters || characters.length === 0) return;
-			const charCount = characters.length;
-			const atlasSize = Math.max(2, Math.ceil(Math.sqrt(charCount)));
-			const baseAtlasCellSize = 128;
-			const spacingMultiplier = Math.max(1, 2 / spacing);
-			const actualCellSize = Math.min(baseAtlasCellSize * spacingMultiplier, ATLAS_TEXTURE_SIZE / atlasSize);
-			const fontSize = actualCellSize * .75;
-			const c = target.canvas() ? target.context() : target.resize(ATLAS_TEXTURE_SIZE, ATLAS_TEXTURE_SIZE);
-			if (!c) return;
-			c.clearRect(0, 0, ATLAS_TEXTURE_SIZE, ATLAS_TEXTURE_SIZE);
-			c.fillStyle = "#ffffff";
-			c.font = `${fontSize}px "${fontFamily}", ${fontFamily}, monospace`;
-			if (!c.font.includes(fontFamily) && !c.font.includes("IBM") && !c.font.includes("Plex")) c.font = `${fontSize}px ${fontFamily}, monospace`;
-			c.textAlign = "center";
-			c.textBaseline = "middle";
-			for (let i = 0; i < charCount; i++) {
-				const row = Math.floor(i / atlasSize);
-				const col = i % atlasSize;
-				c.fillText(characters[i], col * actualCellSize + actualCellSize / 2, row * actualCellSize + actualCellSize / 2);
-			}
-			glyphTex.write(target.canvas());
-			const uvScale = atlasSize * actualCellSize / ATLAS_TEXTURE_SIZE;
-			setExtraField("_charCount", charCount);
-			setExtraField("_atlasScale", uvScale);
-			setExtraField("_atlasSize", atlasSize);
-		};
-		const readProps = () => ({
-			characters: String(getCpuValue("characters") ?? componentDefinition.props.characters.default),
-			fontFamily: String(getCpuValue("fontFamily") ?? componentDefinition.props.fontFamily.default),
-			spacing: num(getCpuValue("spacing"), 1.5)
-		});
-		const rebuild = () => {
-			const p = readProps();
-			buildAtlas(p.characters, p.spacing, p.fontFamily);
-		};
-		const font = createFontDependentRaster({
-			key: () => readProps().fontFamily,
-			load: () => loadAsciiFont(readProps().fontFamily),
-			onLoaded: rebuild
-		});
-		setTimeout(() => {
-			rebuild();
-			font.ensure();
-		}, 0);
-		createRasterInvalidator(params, {
-			key: () => {
-				const p = readProps();
-				return `${p.characters}|${p.fontFamily}|${p.spacing}`;
-			},
-			run: () => {
-				rebuild();
-				font.ensure();
-			}
-		});
-		const grid = call(asciiGrid, "asciiGrid", [
-			ctx.uv,
-			ctx.viewportSize,
-			uniforms.cellSize,
-			uniforms.spacing
-		]);
-		const cellColor = call(unpremultiplyAlpha, "unpremultiplyAlpha", [child.sample(grid.member("cellCenter"))]);
-		const atlasUV = call(asciiAtlasUV, "asciiAtlasUV", [
-			cellColor.member("rgb"),
-			uniforms.gamma,
-			uniforms._charCount,
-			uniforms._atlasSize,
-			uniforms._atlasScale,
-			grid.member("cellUV")
-		]);
-		return call(asciiCompose, "asciiCompose", [
-			atlasKit.sample(atlasUV, "nearestClamp").member("rgb"),
-			cellColor,
-			grid.member("isOutside"),
-			uniforms.alphaThreshold,
-			uniforms.preserveAlpha
-		]);
-	}
-};
-var Ascii_default = componentDefinition;
-export { componentDefinition as a, asciiGrid as i, asciiAtlasUV as n, asciiCompose as r, Ascii_default as t };