@codehz/draw-call 0.1.1 → 0.1.2

package/engine-C88lMGbX.mjs

@@ -1,606 +0,0 @@
-//#region src/types/base.ts
-function linearGradient(angle, ...stops) {
-	return {
-		type: "linear-gradient",
-		angle,
-		stops: stops.map((stop, index) => {
-			if (typeof stop === "string") return {
-				offset: stops.length > 1 ? index / (stops.length - 1) : 0,
-				color: stop
-			};
-			return {
-				offset: stop[0],
-				color: stop[1]
-			};
-		})
-	};
-}
-function radialGradient(options, ...stops) {
-	const colorStops = stops.map((stop, index) => {
-		if (typeof stop === "string") return {
-			offset: stops.length > 1 ? index / (stops.length - 1) : 0,
-			color: stop
-		};
-		return {
-			offset: stop[0],
-			color: stop[1]
-		};
-	});
-	return {
-		type: "radial-gradient",
-		...options,
-		stops: colorStops
-	};
-}
-function normalizeSpacing(value) {
-	if (value === void 0) return {
-		top: 0,
-		right: 0,
-		bottom: 0,
-		left: 0
-	};
-	if (typeof value === "number") return {
-		top: value,
-		right: value,
-		bottom: value,
-		left: value
-	};
-	return {
-		top: value.top ?? 0,
-		right: value.right ?? 0,
-		bottom: value.bottom ?? 0,
-		left: value.left ?? 0
-	};
-}
-function normalizeBorderRadius(value) {
-	if (value === void 0) return [
-		0,
-		0,
-		0,
-		0
-	];
-	if (typeof value === "number") return [
-		value,
-		value,
-		value,
-		value
-	];
-	return value;
-}
-
-//#endregion
-//#region src/types/layout.ts
-function resolveSize(size, available, auto) {
-	if (size === void 0 || size === "auto") return auto;
-	if (size === "fill") return available;
-	if (typeof size === "number") return size;
-	return available * parseFloat(size) / 100;
-}
-function sizeNeedsParent(size) {
-	if (size === void 0 || size === "auto") return false;
-	if (size === "fill") return true;
-	if (typeof size === "string" && size.endsWith("%")) return true;
-	return false;
-}
-
-//#endregion
-//#region src/layout/measure.ts
-function buildFontString(font) {
-	return `${font.style ?? "normal"} ${font.weight ?? "normal"} ${font.size ?? 16}px ${font.family ?? "sans-serif"}`;
-}
-function createCanvasMeasureContext(ctx) {
-	return { measureText(text, font) {
-		ctx.font = buildFontString(font);
-		ctx.textBaseline = "middle";
-		const metrics = ctx.measureText(text);
-		const height = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
-		return {
-			width: metrics.width,
-			height: height || font.size || 16,
-			offset: (metrics.actualBoundingBoxAscent - metrics.actualBoundingBoxDescent) / 2
-		};
-	} };
-}
-function wrapText(ctx, text, maxWidth, font) {
-	if (maxWidth <= 0) {
-		const { offset } = ctx.measureText(text, font);
-		return {
-			lines: [text],
-			offsets: [offset]
-		};
-	}
-	const lines = [];
-	const offsets = [];
-	const paragraphs = text.split("\n");
-	for (const paragraph of paragraphs) {
-		if (paragraph === "") {
-			lines.push("");
-			offsets.push(0);
-			continue;
-		}
-		const words = paragraph.split(/(\s+)/);
-		let currentLine = "";
-		for (const word of words) {
-			const testLine = currentLine + word;
-			const { width } = ctx.measureText(testLine, font);
-			if (width > maxWidth && currentLine !== "") {
-				const trimmed = currentLine.trim();
-				lines.push(trimmed);
-				offsets.push(ctx.measureText(trimmed, font).offset);
-				currentLine = word.trimStart();
-			} else currentLine = testLine;
-		}
-		if (currentLine) {
-			const trimmed = currentLine.trim();
-			lines.push(trimmed);
-			offsets.push(ctx.measureText(trimmed, font).offset);
-		}
-	}
-	return lines.length > 0 ? {
-		lines,
-		offsets
-	} : {
-		lines: [""],
-		offsets: [0]
-	};
-}
-function truncateText(ctx, text, maxWidth, font, ellipsis = "...") {
-	const measured = ctx.measureText(text, font);
-	if (measured.width <= maxWidth) return {
-		text,
-		offset: measured.offset
-	};
-	const availableWidth = maxWidth - ctx.measureText(ellipsis, font).width;
-	if (availableWidth <= 0) {
-		const { offset } = ctx.measureText(ellipsis, font);
-		return {
-			text: ellipsis,
-			offset
-		};
-	}
-	let left = 0;
-	let right = text.length;
-	while (left < right) {
-		const mid = Math.floor((left + right + 1) / 2);
-		const truncated = text.slice(0, mid);
-		const { width: truncatedWidth } = ctx.measureText(truncated, font);
-		if (truncatedWidth <= availableWidth) left = mid;
-		else right = mid - 1;
-	}
-	const result = text.slice(0, left) + ellipsis;
-	const { offset } = ctx.measureText(result, font);
-	return {
-		text: result,
-		offset
-	};
-}
-
-//#endregion
-//#region src/layout/engine.ts
-function measureIntrinsicSize(element, ctx, availableWidth) {
-	switch (element.type) {
-		case "text": {
-			const font = element.font ?? {};
-			const lineHeightPx = (font.size ?? 16) * (element.lineHeight ?? 1.2);
-			if (element.wrap && availableWidth > 0 && availableWidth < Infinity) {
-				const { lines } = wrapText(ctx, element.content, availableWidth, font);
-				const { width: maxLineWidth } = lines.reduce((max, line) => {
-					const { width } = ctx.measureText(line, font);
-					return width > max.width ? { width } : max;
-				}, { width: 0 });
-				return {
-					width: maxLineWidth,
-					height: lines.length * lineHeightPx
-				};
-			}
-			const { width, height } = ctx.measureText(element.content, font);
-			return {
-				width,
-				height: Math.max(height, lineHeightPx)
-			};
-		}
-		case "box":
-		case "stack": {
-			const padding = normalizeSpacing(element.padding);
-			const gap = element.type === "box" ? element.gap ?? 0 : 0;
-			const direction = element.direction ?? "row";
-			const isRow = direction === "row" || direction === "row-reverse";
-			let contentWidth = 0;
-			let contentHeight = 0;
-			const children = element.children ?? [];
-			if (element.type === "stack") for (const child of children) {
-				const childMargin = normalizeSpacing(child.margin);
-				const childSize = measureIntrinsicSize(child, ctx, availableWidth - padding.left - padding.right - childMargin.left - childMargin.right);
-				contentWidth = Math.max(contentWidth, childSize.width + childMargin.left + childMargin.right);
-				contentHeight = Math.max(contentHeight, childSize.height + childMargin.top + childMargin.bottom);
-			}
-			else for (let i = 0; i < children.length; i++) {
-				const child = children[i];
-				const childMargin = normalizeSpacing(child.margin);
-				const childSize = measureIntrinsicSize(child, ctx, availableWidth - padding.left - padding.right - childMargin.left - childMargin.right);
-				if (isRow) {
-					contentWidth += childSize.width + childMargin.left + childMargin.right;
-					contentHeight = Math.max(contentHeight, childSize.height + childMargin.top + childMargin.bottom);
-					if (i > 0) contentWidth += gap;
-				} else {
-					contentHeight += childSize.height + childMargin.top + childMargin.bottom;
-					contentWidth = Math.max(contentWidth, childSize.width + childMargin.left + childMargin.right);
-					if (i > 0) contentHeight += gap;
-				}
-			}
-			const intrinsicWidth = contentWidth + padding.left + padding.right;
-			const intrinsicHeight = contentHeight + padding.top + padding.bottom;
-			return {
-				width: typeof element.width === "number" ? element.width : intrinsicWidth,
-				height: typeof element.height === "number" ? element.height : intrinsicHeight
-			};
-		}
-		case "image": return {
-			width: 0,
-			height: 0
-		};
-		case "shape": return {
-			width: 0,
-			height: 0
-		};
-		default: return {
-			width: 0,
-			height: 0
-		};
-	}
-}
-function computeLayout(element, ctx, constraints, x = 0, y = 0) {
-	const margin = normalizeSpacing(element.margin);
-	const padding = normalizeSpacing("padding" in element ? element.padding : void 0);
-	const availableWidth = constraints.maxWidth - margin.left - margin.right;
-	const availableHeight = constraints.maxHeight - margin.top - margin.bottom;
-	const intrinsic = measureIntrinsicSize(element, ctx, availableWidth);
-	let width = constraints.minWidth === constraints.maxWidth && constraints.minWidth > 0 ? constraints.maxWidth - margin.left - margin.right : resolveSize(element.width, availableWidth, intrinsic.width);
-	let height = constraints.minHeight === constraints.maxHeight && constraints.minHeight > 0 ? constraints.maxHeight - margin.top - margin.bottom : resolveSize(element.height, availableHeight, intrinsic.height);
-	if (element.minWidth !== void 0) width = Math.max(width, element.minWidth);
-	if (element.maxWidth !== void 0) width = Math.min(width, element.maxWidth);
-	if (element.minHeight !== void 0) height = Math.max(height, element.minHeight);
-	if (element.maxHeight !== void 0) height = Math.min(height, element.maxHeight);
-	const actualX = x + margin.left;
-	const actualY = y + margin.top;
-	const contentX = actualX + padding.left;
-	const contentY = actualY + padding.top;
-	const contentWidth = width - padding.left - padding.right;
-	const contentHeight = height - padding.top - padding.bottom;
-	const node = {
-		element,
-		layout: {
-			x: actualX,
-			y: actualY,
-			width,
-			height,
-			contentX,
-			contentY,
-			contentWidth,
-			contentHeight
-		},
-		children: []
-	};
-	if (element.type === "text") {
-		const font = element.font ?? {};
-		if (element.wrap && contentWidth > 0) {
-			let { lines, offsets } = wrapText(ctx, element.content, contentWidth, font);
-			if (element.maxLines && lines.length > element.maxLines) {
-				lines = lines.slice(0, element.maxLines);
-				offsets = offsets.slice(0, element.maxLines);
-				if (element.ellipsis && lines.length > 0) {
-					const lastIdx = lines.length - 1;
-					const truncated = truncateText(ctx, lines[lastIdx], contentWidth, font);
-					lines[lastIdx] = truncated.text;
-					offsets[lastIdx] = truncated.offset;
-				}
-			}
-			node.lines = lines;
-			node.lineOffsets = offsets;
-		} else {
-			const { text, offset } = truncateText(ctx, element.content, contentWidth > 0 && element.ellipsis ? contentWidth : Infinity, font);
-			node.lines = [text];
-			node.lineOffsets = [offset];
-		}
-	}
-	if (element.type === "box" || element.type === "stack") {
-		const children = element.children ?? [];
-		if (element.type === "stack") for (const child of children) {
-			const childNode = computeLayout(child, ctx, {
-				minWidth: 0,
-				maxWidth: contentWidth,
-				minHeight: 0,
-				maxHeight: contentHeight
-			}, contentX, contentY);
-			node.children.push(childNode);
-		}
-		else {
-			const direction = element.direction ?? "row";
-			const justify = element.justify ?? "start";
-			const align = element.align ?? "stretch";
-			const gap = element.gap ?? 0;
-			const isRow = direction === "row" || direction === "row-reverse";
-			const isReverse = direction === "row-reverse" || direction === "column-reverse";
-			const childInfos = [];
-			let totalFixed = 0;
-			let totalFlex = 0;
-			let totalGap = children.length > 1 ? gap * (children.length - 1) : 0;
-			for (const child of children) {
-				const childMargin = normalizeSpacing(child.margin);
-				const childFlex = child.flex ?? 0;
-				if (childFlex > 0) {
-					totalFlex += childFlex;
-					childInfos.push({
-						element: child,
-						width: 0,
-						height: 0,
-						flex: childFlex,
-						margin: childMargin
-					});
-				} else {
-					const size = measureIntrinsicSize(child, ctx, isRow ? contentWidth - childMargin.left - childMargin.right : contentWidth - childMargin.left - childMargin.right);
-					const shouldStretchWidth = !isRow && child.width === void 0 && align === "stretch";
-					const shouldStretchHeight = isRow && child.height === void 0 && align === "stretch";
-					let w = sizeNeedsParent(child.width) ? resolveSize(child.width, contentWidth - childMargin.left - childMargin.right, size.width) : resolveSize(child.width, 0, size.width);
-					let h = sizeNeedsParent(child.height) ? resolveSize(child.height, contentHeight - childMargin.top - childMargin.bottom, size.height) : resolveSize(child.height, 0, size.height);
-					if (shouldStretchWidth) w = contentWidth - childMargin.left - childMargin.right;
-					if (shouldStretchHeight) h = contentHeight - childMargin.top - childMargin.bottom;
-					if (isRow) totalFixed += w + childMargin.left + childMargin.right;
-					else totalFixed += h + childMargin.top + childMargin.bottom;
-					childInfos.push({
-						element: child,
-						width: w,
-						height: h,
-						flex: 0,
-						margin: childMargin
-					});
-				}
-			}
-			const availableForFlex = isRow ? Math.max(0, contentWidth - totalFixed - totalGap) : Math.max(0, contentHeight - totalFixed - totalGap);
-			for (const info of childInfos) if (info.flex > 0) {
-				const flexSize = availableForFlex * info.flex / totalFlex;
-				if (isRow) {
-					info.width = flexSize;
-					const size = measureIntrinsicSize(info.element, ctx, flexSize);
-					info.height = sizeNeedsParent(info.element.height) ? resolveSize(info.element.height, contentHeight - info.margin.top - info.margin.bottom, size.height) : resolveSize(info.element.height, 0, size.height);
-				} else {
-					info.height = flexSize;
-					const size = measureIntrinsicSize(info.element, ctx, contentWidth - info.margin.left - info.margin.right);
-					info.width = sizeNeedsParent(info.element.width) ? resolveSize(info.element.width, contentWidth - info.margin.left - info.margin.right, size.width) : resolveSize(info.element.width, 0, size.width);
-				}
-			}
-			const totalSize = childInfos.reduce((sum, info) => {
-				if (isRow) return sum + info.width + info.margin.left + info.margin.right;
-				else return sum + info.height + info.margin.top + info.margin.bottom;
-			}, 0) + totalGap;
-			const freeSpace = (isRow ? contentWidth : contentHeight) - totalSize;
-			let mainStart = 0;
-			let mainGap = gap;
-			switch (justify) {
-				case "start":
-					mainStart = 0;
-					break;
-				case "end":
-					mainStart = freeSpace;
-					break;
-				case "center":
-					mainStart = freeSpace / 2;
-					break;
-				case "space-between":
-					mainStart = 0;
-					if (children.length > 1) mainGap = gap + freeSpace / (children.length - 1);
-					break;
-				case "space-around":
-					if (children.length > 0) {
-						const spacing = freeSpace / children.length;
-						mainStart = spacing / 2;
-						mainGap = gap + spacing;
-					}
-					break;
-				case "space-evenly":
-					if (children.length > 0) {
-						const spacing = freeSpace / (children.length + 1);
-						mainStart = spacing;
-						mainGap = gap + spacing;
-					}
-					break;
-			}
-			let mainOffset = mainStart;
-			const orderedInfos = isReverse ? [...childInfos].reverse() : childInfos;
-			for (let i = 0; i < orderedInfos.length; i++) {
-				const info = orderedInfos[i];
-				const crossAxisSize = isRow ? contentHeight : contentWidth;
-				const childCrossSize = isRow ? info.height + info.margin.top + info.margin.bottom : info.width + info.margin.left + info.margin.right;
-				let crossOffset = 0;
-				switch (info.element.alignSelf === "auto" || info.element.alignSelf === void 0 ? align : info.element.alignSelf) {
-					case "start":
-						crossOffset = 0;
-						break;
-					case "end":
-						crossOffset = crossAxisSize - childCrossSize;
-						break;
-					case "center":
-						crossOffset = (crossAxisSize - childCrossSize) / 2;
-						break;
-					case "stretch":
-						crossOffset = 0;
-						if (isRow && info.element.height === void 0) info.height = crossAxisSize - info.margin.top - info.margin.bottom;
-						else if (!isRow && info.element.width === void 0) info.width = crossAxisSize - info.margin.left - info.margin.right;
-						break;
-					case "baseline":
-						crossOffset = 0;
-						break;
-				}
-				const childX = isRow ? contentX + mainOffset + info.margin.left : contentX + crossOffset + info.margin.left;
-				const childY = isRow ? contentY + crossOffset + info.margin.top : contentY + mainOffset + info.margin.top;
-				const stretchWidth = !isRow && info.element.width === void 0 && align === "stretch" ? contentWidth - info.margin.left - info.margin.right : null;
-				const stretchHeight = isRow && info.element.height === void 0 && align === "stretch" ? contentHeight - info.margin.top - info.margin.bottom : null;
-				const childNode = computeLayout(info.element, ctx, {
-					minWidth: stretchWidth ?? 0,
-					maxWidth: stretchWidth ?? info.width,
-					minHeight: stretchHeight ?? 0,
-					maxHeight: stretchHeight ?? info.height
-				}, childX - info.margin.left, childY - info.margin.top);
-				node.children.push(childNode);
-				mainOffset += isRow ? info.width + info.margin.left + info.margin.right : info.height + info.margin.top + info.margin.bottom;
-				if (i < orderedInfos.length - 1) mainOffset += mainGap;
-			}
-			if (isReverse) node.children.reverse();
-		}
-	}
-	return node;
-}
-
-//#endregion
-//#region src/render/engine.ts
-function isGradientDescriptor(color) {
-	return typeof color === "object" && color !== null && "type" in color && (color.type === "linear-gradient" || color.type === "radial-gradient");
-}
-function resolveGradient(ctx, descriptor, x, y, width, height) {
-	if (descriptor.type === "linear-gradient") {
-		const angleRad = (descriptor.angle - 90) * Math.PI / 180;
-		const centerX = x + width / 2;
-		const centerY = y + height / 2;
-		const diagLength = Math.sqrt(width * width + height * height) / 2;
-		const x0 = centerX - Math.cos(angleRad) * diagLength;
-		const y0 = centerY - Math.sin(angleRad) * diagLength;
-		const x1 = centerX + Math.cos(angleRad) * diagLength;
-		const y1 = centerY + Math.sin(angleRad) * diagLength;
-		const gradient = ctx.createLinearGradient(x0, y0, x1, y1);
-		for (const stop of descriptor.stops) gradient.addColorStop(stop.offset, stop.color);
-		return gradient;
-	} else {
-		const diagLength = Math.sqrt(width * width + height * height);
-		const startX = x + (descriptor.startX ?? .5) * width;
-		const startY = y + (descriptor.startY ?? .5) * height;
-		const startRadius = (descriptor.startRadius ?? 0) * diagLength;
-		const endX = x + (descriptor.endX ?? .5) * width;
-		const endY = y + (descriptor.endY ?? .5) * height;
-		const endRadius = (descriptor.endRadius ?? .5) * diagLength;
-		const gradient = ctx.createRadialGradient(startX, startY, startRadius, endX, endY, endRadius);
-		for (const stop of descriptor.stops) gradient.addColorStop(stop.offset, stop.color);
-		return gradient;
-	}
-}
-function resolveColor(ctx, color, x, y, width, height) {
-	if (isGradientDescriptor(color)) return resolveGradient(ctx, color, x, y, width, height);
-	return color;
-}
-function roundRectPath(ctx, x, y, width, height, radius) {
-	const [tl, tr, br, bl] = radius;
-	ctx.beginPath();
-	ctx.moveTo(x + tl, y);
-	ctx.lineTo(x + width - tr, y);
-	ctx.quadraticCurveTo(x + width, y, x + width, y + tr);
-	ctx.lineTo(x + width, y + height - br);
-	ctx.quadraticCurveTo(x + width, y + height, x + width - br, y + height);
-	ctx.lineTo(x + bl, y + height);
-	ctx.quadraticCurveTo(x, y + height, x, y + height - bl);
-	ctx.lineTo(x, y + tl);
-	ctx.quadraticCurveTo(x, y, x + tl, y);
-	ctx.closePath();
-}
-function applyShadow(ctx, shadow) {
-	if (shadow) {
-		ctx.shadowOffsetX = shadow.offsetX ?? 0;
-		ctx.shadowOffsetY = shadow.offsetY ?? 0;
-		ctx.shadowBlur = shadow.blur ?? 0;
-		ctx.shadowColor = shadow.color ?? "rgba(0,0,0,0.5)";
-	} else {
-		ctx.shadowOffsetX = 0;
-		ctx.shadowOffsetY = 0;
-		ctx.shadowBlur = 0;
-		ctx.shadowColor = "transparent";
-	}
-}
-function clearShadow(ctx) {
-	ctx.shadowOffsetX = 0;
-	ctx.shadowOffsetY = 0;
-	ctx.shadowBlur = 0;
-	ctx.shadowColor = "transparent";
-}
-function renderBox(ctx, node) {
-	const element = node.element;
-	const { x, y, width, height } = node.layout;
-	const border = element.border;
-	const radius = normalizeBorderRadius(border?.radius);
-	const hasRadius = radius.some((r) => r > 0);
-	if (element.opacity !== void 0 && element.opacity < 1) ctx.globalAlpha = element.opacity;
-	if (element.shadow && element.background) applyShadow(ctx, element.shadow);
-	if (element.background) {
-		ctx.fillStyle = resolveColor(ctx, element.background, x, y, width, height);
-		if (hasRadius) {
-			roundRectPath(ctx, x, y, width, height, radius);
-			ctx.fill();
-		} else ctx.fillRect(x, y, width, height);
-		clearShadow(ctx);
-	}
-	if (border && border.width && border.width > 0) {
-		ctx.strokeStyle = border.color ? resolveColor(ctx, border.color, x, y, width, height) : "#000";
-		ctx.lineWidth = border.width;
-		if (hasRadius) {
-			roundRectPath(ctx, x, y, width, height, radius);
-			ctx.stroke();
-		} else ctx.strokeRect(x, y, width, height);
-	}
-	if (element.opacity !== void 0 && element.opacity < 1) ctx.globalAlpha = 1;
-}
-function renderText(ctx, node) {
-	const element = node.element;
-	const { contentX, contentY, contentWidth, contentHeight } = node.layout;
-	const lines = node.lines ?? [element.content];
-	const font = element.font ?? {};
-	const lineHeightPx = (font.size ?? 16) * (element.lineHeight ?? 1.2);
-	ctx.font = buildFontString(font);
-	ctx.fillStyle = element.color ? resolveColor(ctx, element.color, contentX, contentY, contentWidth, contentHeight) : "#000";
-	let textAlign = "left";
-	if (element.align === "center") textAlign = "center";
-	else if (element.align === "right") textAlign = "right";
-	ctx.textAlign = textAlign;
-	ctx.textBaseline = "middle";
-	const totalTextHeight = lines.length * lineHeightPx;
-	let verticalOffset = 0;
-	if (element.verticalAlign === "middle") verticalOffset = (contentHeight - totalTextHeight) / 2;
-	else if (element.verticalAlign === "bottom") verticalOffset = contentHeight - totalTextHeight;
-	let textX = contentX;
-	if (element.align === "center") textX = contentX + contentWidth / 2;
-	else if (element.align === "right") textX = contentX + contentWidth;
-	if (element.shadow) applyShadow(ctx, element.shadow);
-	for (let i = 0; i < lines.length; i++) {
-		const correctedLineY = contentY + verticalOffset + i * lineHeightPx + lineHeightPx / 2 + (node.lineOffsets?.[i] ?? 0);
-		if (element.stroke) {
-			ctx.strokeStyle = resolveColor(ctx, element.stroke.color, contentX, contentY, contentWidth, contentHeight);
-			ctx.lineWidth = element.stroke.width;
-			ctx.strokeText(lines[i], textX, correctedLineY);
-		}
-		ctx.fillText(lines[i], textX, correctedLineY);
-	}
-	if (element.shadow) clearShadow(ctx);
-}
-function renderNode(ctx, node) {
-	const element = node.element;
-	switch (element.type) {
-		case "box":
-		case "stack": {
-			renderBox(ctx, node);
-			const shouldClip = element.clip === true;
-			if (shouldClip) {
-				ctx.save();
-				const { x, y, width, height } = node.layout;
-				roundRectPath(ctx, x, y, width, height, normalizeBorderRadius(element.border?.radius));
-				ctx.clip();
-			}
-			for (const child of node.children) renderNode(ctx, child);
-			if (shouldClip) ctx.restore();
-			break;
-		}
-		case "text":
-			renderText(ctx, node);
-			break;
-		case "image": break;
-		case "shape": break;
-	}
-}
-
-//#endregion
-export { radialGradient as a, linearGradient as i, computeLayout as n, createCanvasMeasureContext as r, renderNode as t };