shaders 3.1.463 → 3.2.464

package/dist/core/{ThinFilm-ztJ8IZSo.js → ThinFilm-CrslR7Dx.js}

@@ -1,9 +1,8 @@
-import { Dt as sin, Ft as vec3f, H as mixColorsLinear, Lt as vec4f, Mt as vec2f, U as mixColorsVariants, _t as max, ct as clamp, et as typegpu_default, hn as __export, ht as fract, kt as sqrt, lt as cos, m as call, mt as floor, rt as select, sn as f32, v as floatE, xt as pow, y as mixExpr, yt as mix } from "./edges-CV-BHMpI.js";
-import { C as sdf_exports } from "./device-DKcu50_C.js";
-import { t as cosinePalette } from "./lighting-CBczjo6Y.js";
-import { i as shapeEffectBoundingBoxDeclaration, n as sdf3d_exports } from "./sdf3d-B8EwGL7R.js";
-import { i as sdfSpaceUV, r as offsetUV, t as glassGradient } from "./glass-Di_yYrw1.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
+import { $n as vec4f, Cr as __export, En as cos, Gn as sqrt, In as mix, Jn as vec2f, Mn as fract, Nt as mixColorsLinear, Pn as max, Pt as mixColorsVariants, Rn as pow, Tn as clamp, Un as sin, Zn as vec3f, at as call, bn as select, hr as f32, jn as floor, lt as floatE, mn as typegpu_default, t as defineStd, ut as mixExpr } from "./lower-z2vuXP8M.js";
+import { X as cosinePalette, j as shapedSurface } from "./materials-D7QX3H4h.js";
+import { v as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BD5m6HR6.js";
+import { i as sdfSpaceUV, r as offsetUV, t as glassGradient } from "./glass-DxE2Cy6_.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
 var thinFilm_exports = /* @__PURE__ */ __export({
 	applyThinFilmEffect: () => applyThinFilmEffect$1,
 	thinFilmCompose: () => thinFilmCompose,
@@ -922,22 +921,28 @@ function applyThinFilmEffect$1(params, sdfSampler, options) {
 	]);
 }
 var { applyThinFilmEffect } = thinFilm_exports;
-var { ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
-var { createVolumetricFieldComputeNode, resolveShapeFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "circleSDF",
 	radius: .35
 });
-const componentDefinition = {
+const componentDefinition = defineStd({
 	name: "ThinFilm",
+	role: "shapeEffect",
+	species: "custom",
 	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
 	category: "Shape Effects",
 	description: "Iridescent thin-film edge",
 	animatedTime: { speed: "speed" },
-	extraFields: {
-		...VOLUMETRIC_FIELD_EXTRA_FIELDS,
-		...ANALYTIC_SDF_EXTRA_FIELDS
-	},
+	...shapedSurface({
+		chord: "firstLobe",
+		gradSampler: "same",
+		bakedGradients: "volumetric",
+		stencil: "none",
+		surface: (frame, params) => applyThinFilmEffect(params, frame.sampler, {
+			volumetric: frame.volumetric,
+			bakedGradients: frame.bakedGradients
+		})
+	}),
 	props: {
 		origin: {
 			default: "center",
@@ -1176,20 +1181,7 @@ const componentDefinition = {
 			compileTime: true,
 			description: "Active SDF shape type — triggers recompile when shape is switched. When empty, derived from shape JSON at mount time."
 		}
-	},
-	compute: (params) => {
-		return createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "none", "firstLobe");
-	},
-	fragment: (params) => {
-		const { sampler, volumetric, bakedGradients } = resolveShapeFieldSampler(params, {
-			gradSampler: "same",
-			bakedGradients: "volumetric"
-		});
-		return applyThinFilmEffect(params, sampler, {
-			volumetric,
-			bakedGradients
-		});
 	}
-};
+});
 var ThinFilm_default = componentDefinition;
 export { componentDefinition as n, ThinFilm_default as t };

package/dist/core/TiltShift-DxfHWzYk.js

@@ -0,0 +1,86 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { c as transformPosition, r as transformAngle } from "./transformations-CoIwF5JU.js";
+import { G as tiltShift } from "./blurs-O1YbZEVw.js";
+const componentDefinition = defineStd({
+	name: "TiltShift",
+	role: "filter",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Blurs",
+	description: "Selective focus blur mimicking tilt-shift photography",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 50,
+			description: "Maximum blur intensity at edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		width: {
+			default: .3,
+			description: "Width of the sharp focus area",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Width",
+				group: "Effect"
+			}
+		},
+		falloff: {
+			default: .3,
+			description: "Distance over which blur transitions to full strength",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Falloff",
+				group: "Effect"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation angle of the focus line (in degrees)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center point of the focus line",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		}
+	},
+	...tiltShift({
+		intensity: p("intensity"),
+		width: p("width"),
+		falloff: p("falloff"),
+		angle: p("angle"),
+		center: p("center")
+	})
+});
+var TiltShift_default = componentDefinition;
+export { componentDefinition as n, TiltShift_default as t };

package/dist/core/TimeTrail-CSy6Y7hh.js

@@ -0,0 +1,360 @@
+import { Ct as blendModes, Tt as unpremultiplyAlpha, at as call, lt as floatE, nt as ZERO, t as defineStd } from "./lower-z2vuXP8M.js";
+import { i as buildFeedbackTrailStep } from "./porters-B1UjrM1y.js";
+import { t as isMobileGpuViewport } from "./device-DLKcFOd2.js";
+import { a as transformColor } from "./transformations-CoIwF5JU.js";
+import { N as vec3, P as vec4, _ as local, o as div, s as dot, v as max, x as mul } from "./math-BF-GBlb4.js";
+import { t as feedbackSim } from "./feedback-ZMsR_fKB.js";
+var STATE_RES = isMobileGpuViewport() ? 384 : 640;
+var STATE_FORMAT = "rgba16float";
+var DIFFUSE_HALF_UV = 2.5 * .5 / STATE_RES;
+var DRIFT_SCALE = .5;
+var RAINBOW_RATE = .35;
+var TINT_MODES = {
+	none: 0,
+	color: 1,
+	rainbow: 2
+};
+var SOURCE_MODES = {
+	motion: 1,
+	alpha: 0
+};
+var buildTrailKernel = (source, hueCycle) => buildFeedbackTrailStep({
+	res: STATE_RES,
+	format: STATE_FORMAT,
+	namePrefix: "timeTrail",
+	source,
+	hueCycle,
+	diffuseHalfUv: DIFFUSE_HALF_UV,
+	driftScale: DRIFT_SCALE
+});
+const timeTrailKernel = buildTrailKernel("motion", false).kernel;
+var resolveBlendKey = (v) => {
+	const key = v === "add" ? "linearDodge" : String(v ?? "normal");
+	return key in blendModes ? key : "normal";
+};
+var stampModeFor = (key) => key === "screen" ? 1 : key === "linearDodge" ? 2 : 0;
+const componentDefinition = defineStd({
+	name: "TimeTrail",
+	role: "simulation",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "An Echo-style temporal trail — whatever moves sheds a smooth, decaying long-exposure ghost trail (frame-difference Motion mode works on opaque images and video; Alpha mode trails a shape's coverage), with optional zoom-feedback tunnels and rainbow light-painting",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		trailSource: {
+			default: "motion",
+			description: "What sheds the trail — Motion trails whatever changes frame-to-frame (works on opaque images and video), Alpha trails the child's transparency coverage (best for a clean shape over empty canvas)",
+			compileTime: true,
+			transform: (v) => SOURCE_MODES[v] ?? 1,
+			ui: {
+				type: "select",
+				options: [{
+					label: "Motion",
+					value: "motion"
+				}, {
+					label: "Alpha",
+					value: "alpha"
+				}],
+				label: "Source",
+				group: "Trail"
+			}
+		},
+		motionThreshold: {
+			default: .06,
+			description: "How much a pixel must change between frames to shed a trail (Motion source only) — lower catches subtle movement, higher only fast motion",
+			ui: {
+				type: ["range", "map"],
+				min: .01,
+				max: .5,
+				step: .01,
+				label: "Motion Threshold",
+				group: "Trail"
+			}
+		},
+		trailLength: {
+			default: .6,
+			description: "How long the trail lingers, in seconds — the time constant of the fade (the star control)",
+			ui: {
+				type: ["range", "map"],
+				min: .05,
+				max: 4,
+				step: .01,
+				label: "Trail Length",
+				group: "Trail"
+			}
+		},
+		diffusion: {
+			default: 1,
+			description: "How much the trail smears and softens as it fades — 0 keeps crisp ghost frames, higher melts them together",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Diffusion",
+				group: "Trail"
+			}
+		},
+		trailOpacity: {
+			default: 1,
+			description: "Overall strength of the trail behind the live frame",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Trail Opacity",
+				group: "Trail"
+			}
+		},
+		trailBlend: {
+			default: "normal",
+			description: "How the trail combines with the frame — Add / Screen build glowing light-painting trails, Multiply lays down dark ink ghosts, plus the full standard blend set",
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Normal",
+						value: "normal"
+					},
+					{
+						label: "Add",
+						value: "add"
+					},
+					{
+						label: "Screen",
+						value: "screen"
+					},
+					{
+						label: "Multiply",
+						value: "multiply"
+					},
+					{
+						label: "Overlay",
+						value: "overlay"
+					},
+					{
+						label: "Soft Light",
+						value: "softLight"
+					},
+					{
+						label: "Hard Light",
+						value: "hardLight"
+					},
+					{
+						label: "Darken",
+						value: "darken"
+					},
+					{
+						label: "Lighten",
+						value: "lighten"
+					},
+					{
+						label: "Color Dodge",
+						value: "colorDodge"
+					},
+					{
+						label: "Color Burn",
+						value: "colorBurn"
+					},
+					{
+						label: "Linear Burn",
+						value: "linearBurn"
+					},
+					{
+						label: "Difference",
+						value: "difference"
+					},
+					{
+						label: "Exclusion",
+						value: "exclusion"
+					},
+					{
+						label: "Hue",
+						value: "hue"
+					},
+					{
+						label: "Saturation",
+						value: "saturation"
+					},
+					{
+						label: "Color",
+						value: "color"
+					},
+					{
+						label: "Luminosity",
+						value: "luminosity"
+					}
+				],
+				label: "Blend",
+				group: "Trail"
+			}
+		},
+		driftX: {
+			default: 0,
+			description: "Sideways drift of the trail per second — smears the trail in a direction",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Drift X",
+				group: "Feedback"
+			}
+		},
+		driftY: {
+			default: 0,
+			description: "Vertical drift of the trail per second",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Drift Y",
+				group: "Feedback"
+			}
+		},
+		zoom: {
+			default: 1,
+			description: "Per-frame zoom of the trail around the centre — above 1 pulls the trail into an outward tunnel, below 1 sucks it inward",
+			ui: {
+				type: ["range", "map"],
+				min: .9,
+				max: 1.1,
+				step: .001,
+				label: "Zoom",
+				group: "Feedback"
+			}
+		},
+		tintMode: {
+			default: "none",
+			description: "Colour the trail — Color tints it a single hue, Rainbow cycles hue as the trail ages",
+			compileTime: true,
+			transform: (v) => TINT_MODES[v] ?? 0,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "None",
+						value: "none"
+					},
+					{
+						label: "Color",
+						value: "color"
+					},
+					{
+						label: "Rainbow",
+						value: "rainbow"
+					}
+				],
+				label: "Tint Mode",
+				group: "Color"
+			}
+		},
+		tint: {
+			default: "#33aaff",
+			transform: transformColor,
+			description: "Trail tint colour (used in Color mode)",
+			ui: {
+				type: "color",
+				label: "Tint",
+				group: "Color"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Simulation speed. 0 freezes the trail in place.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		}
+	},
+	...feedbackSim((params, root) => {
+		const { getCpuValue, propValues } = params;
+		const tintMode = Number(propValues.tintMode) || 0;
+		const blendMode = stampModeFor(resolveBlendKey(propValues.trailBlend));
+		const isMotion = (propValues.trailSource == null ? 1 : Number(propValues.trailSource)) > .5;
+		const trailSampler = root.createSampler({
+			magFilter: "linear",
+			minFilter: "linear",
+			addressModeU: "clamp-to-edge",
+			addressModeV: "clamp-to-edge"
+		});
+		const trail = buildTrailKernel(isMotion ? "motion" : "alpha", tintMode === 2);
+		return {
+			size: STATE_RES,
+			format: STATE_FORMAT,
+			extraSlots: { prevLive: isMotion ? STATE_RES : [1, 1] },
+			speedProp: "speed",
+			paramsSchema: trail.Params,
+			bindGroups: ({ childTexture, display, paramsBuffer }, read, write) => root.createBindGroup(trail.layout, {
+				src: childTexture,
+				prev: read.state,
+				next: write.state,
+				display,
+				prevLive: read.extra.prevLive,
+				prevLiveOut: write.extra.prevLive,
+				samp: trailSampler,
+				params: paramsBuffer
+			}),
+			step: trail.kernel,
+			skip: () => (getCpuValue("trailOpacity") ?? 1) === 0,
+			values: ({ dt }) => {
+				const zoom = getCpuValue("zoom") ?? 1;
+				const trailLength = Math.max(getCpuValue("trailLength") ?? .6, .001);
+				return {
+					persistence: Math.exp(-dt / trailLength),
+					diffusion: getCpuValue("diffusion") ?? .3,
+					driftX: getCpuValue("driftX") ?? 0,
+					driftY: getCpuValue("driftY") ?? 0,
+					dt,
+					zoom: Math.pow(zoom, dt * 60),
+					hueRate: tintMode === 2 ? RAINBOW_RATE * dt : 0,
+					blendMode,
+					motionThreshold: getCpuValue("motionThreshold") ?? .06
+				};
+			}
+		};
+	}),
+	gpu: { fragment: ({ childNode, ctx, computeOutputs, uniforms, propValues, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const display = computeOutputs?.display;
+		const live = (computeOutputs?.childTexture ?? convertToTexture(childNode)).sample(ctx.uv);
+		if (!display) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [live]);
+		const blendKey = resolveBlendKey(propValues.trailBlend);
+		const blendFn = blendModes[blendKey];
+		const tintMode = Number(propValues.tintMode) || 0;
+		const sourceMode = propValues.trailSource == null ? 1 : Number(propValues.trailSource);
+		let trail = local(display.sample(ctx.uv, "linearClamp"), "trail");
+		if (tintMode === 1) {
+			const a = max(trail.member("a"), 1e-4);
+			const lum = dot(div(trail.member("rgb"), a), vec3(.299, .587, .114));
+			trail = local(vec4(mul(mul(uniforms.tint.member("rgb"), mul(lum, 1.5)), trail.member("a")), trail.member("a")), "tinted");
+		}
+		const liveStraight = call(unpremultiplyAlpha, "unpremultiplyLive", [live]);
+		if (sourceMode === 1) {
+			const trailStraight$1 = call(unpremultiplyAlpha, "unpremultiplyTrail", [trail]);
+			return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
+				liveStraight,
+				trailStraight$1,
+				uniforms.trailOpacity
+			])]);
+		}
+		const trailStraight = call(unpremultiplyAlpha, "unpremultiplyTrail", [mul(trail, uniforms.trailOpacity)]);
+		return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
+			trailStraight,
+			liveStraight,
+			floatE(1)
+		])]);
+	} }
+});
+var TimeTrail_default = componentDefinition;
+export { componentDefinition as n, timeTrailKernel as r, TimeTrail_default as t };

package/dist/core/Tint-DOCp2b8s.js

@@ -0,0 +1,54 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { m as tint } from "./color-C9iR6boM.js";
+import { a as transformColor } from "./transformations-CoIwF5JU.js";
+const componentDefinition = defineStd({
+	name: "Tint",
+	role: "filter",
+	species: "pointwise",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Adjustments",
+	description: "Apply a color tint to the image",
+	props: {
+		color: {
+			default: "#ff8800",
+			transform: transformColor,
+			description: "Tint color",
+			ui: {
+				type: "color",
+				label: "Tint Color",
+				group: "Colors"
+			}
+		},
+		amount: {
+			default: .5,
+			description: "Tint amount (0 = no tint, 1 = full tint)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Amount",
+				group: "Effect"
+			}
+		},
+		preserveLuminosity: {
+			default: true,
+			compileTime: true,
+			description: "Preserve original brightness",
+			transform: (v) => v ? 1 : 0,
+			ui: {
+				type: "checkbox",
+				label: "Preserve Luminosity",
+				group: "Effect"
+			}
+		}
+	},
+	effect: tint({
+		color: p("color"),
+		amount: p("amount"),
+		preserveLuminosity: p("preserveLuminosity")
+	}),
+	missingChildMessage: "You must pass a child component into the Tint shader."
+});
+var Tint_default = componentDefinition;
+export { componentDefinition as n, Tint_default as t };

package/dist/core/Trapezoid-CtfXCYGA.js

@@ -0,0 +1,123 @@
+import { t as defineStd } from "./lower-z2vuXP8M.js";
+import { h as trapezoid } from "./shape-BMO1cLTt.js";
+function halfUvFromProp(value, canvasHeight, fallback) {
+	const safeFallback = Number.isFinite(fallback) ? fallback : .5;
+	if (value != null && typeof value === "object" && typeof value.value === "number") {
+		const dv = value;
+		if (!Number.isFinite(dv.value)) return safeFallback;
+		if (dv.unit !== "px") return dv.value;
+		return Number.isFinite(canvasHeight) && canvasHeight !== 0 ? dv.value / (2 * canvasHeight) : safeFallback;
+	}
+	return typeof value === "number" && Number.isFinite(value) ? value : safeFallback;
+}
+const componentDefinition = defineStd({
+	role: "shape",
+	name: "Trapezoid",
+	description: "Trapezoid with adjustable top and bottom widths and height",
+	shape: {
+		distance: ({ x, y }, u) => trapezoid(x, y, u("topWidth"), u("bottomWidth"), u("height")),
+		colorDescription: "Fill color of the trapezoid",
+		centerDescription: "Center position of the trapezoid",
+		bounds: { custom: {
+			propBindings: {
+				x: {
+					prop: "center",
+					as: "position-x"
+				},
+				y: {
+					prop: "center",
+					as: "position-y"
+				},
+				rotation: {
+					prop: "rotation",
+					as: "degrees"
+				}
+			},
+			computeBounds(props, cw, ch) {
+				const bottom = halfUvFromProp(props.bottomWidth, ch, .35);
+				const top = typeof props.topWidth === "number" ? props.topWidth : .2;
+				const halfH = halfUvFromProp(props.height, ch, .25);
+				const cx = typeof props.center?.x === "number" ? props.center.x : .5;
+				const cy = typeof props.center?.y === "number" ? props.center.y : .5;
+				return {
+					centerXPx: cx * cw,
+					centerYPx: cy * ch,
+					widthPx: Math.max(top, bottom) * 2 * ch,
+					heightPx: halfH * 2 * ch,
+					rotationDeg: props.rotation ?? 0
+				};
+			},
+			writeBounds(bounds, currentProps, cw, ch) {
+				const keepUnit = (cur, newHalfUV) => cur != null && typeof cur === "object" && cur.unit === "px" ? {
+					value: Math.max(0, Math.round(newHalfUV * 2 * ch)),
+					unit: "px"
+				} : Math.max(.001, newHalfUV);
+				const bottom = halfUvFromProp(currentProps.bottomWidth, ch, .35);
+				const top = typeof currentProps.topWidth === "number" ? currentProps.topWidth : .2;
+				const oldMax = Math.max(top, bottom);
+				const newMax = ch > 0 ? bounds.widthPx / (2 * ch) : oldMax;
+				const factor = oldMax > 0 ? newMax / oldMax : 1;
+				const prevCenter = currentProps.center ?? {
+					x: .5,
+					y: .5
+				};
+				return {
+					center: {
+						...prevCenter,
+						x: cw > 0 ? bounds.centerXPx / cw : prevCenter.x ?? .5,
+						y: ch > 0 ? bounds.centerYPx / ch : prevCenter.y ?? .5
+					},
+					bottomWidth: keepUnit(currentProps.bottomWidth, bottom * factor),
+					topWidth: Math.max(.001, top * factor),
+					height: keepUnit(currentProps.height, ch > 0 ? bounds.heightPx / (2 * ch) : halfUvFromProp(currentProps.height, ch, .25)),
+					rotation: bounds.rotationDeg
+				};
+			},
+			freeResize: true
+		} },
+		shapeProps: {
+			bottomWidth: {
+				default: .35,
+				description: "Half-width of the bottom edge",
+				ui: {
+					type: "range",
+					min: .01,
+					max: 1,
+					step: .01,
+					label: "Bottom Width",
+					group: "Shape",
+					units: ["%", "px"],
+					dimensional: "half-canvas-height"
+				}
+			},
+			topWidth: {
+				default: .2,
+				description: "Half-width of the top edge",
+				ui: {
+					type: "range",
+					min: .01,
+					max: 1,
+					step: .01,
+					label: "Top Width",
+					group: "Shape"
+				}
+			},
+			height: {
+				default: .25,
+				description: "Half-height of the trapezoid",
+				ui: {
+					type: "range",
+					min: .01,
+					max: 1,
+					step: .01,
+					label: "Height",
+					group: "Shape",
+					units: ["%", "px"],
+					dimensional: "half-canvas-height"
+				}
+			}
+		}
+	}
+});
+var Trapezoid_default = componentDefinition;
+export { componentDefinition as n, Trapezoid_default as t };