chat-layout 0.0.19 → 0.1.0

package/index.mjs

@@ -0,0 +1,799 @@
+import { layoutWithLines, prepareWithSegments } from "@chenglou/pretext";
+//#region src/text.ts
+function preprocessSegments(text) {
+	return text.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function layoutFirstLine(ctx, text, maxWidth) {
+	if (maxWidth < 0) maxWidth = 0;
+	const segment = preprocessSegments(text)[0];
+	if (!segment) return {
+		width: 0,
+		text: "",
+		shift: 0
+	};
+	const { fontBoundingBoxAscent: ascent = 0, fontBoundingBoxDescent: descent = 0 } = ctx.graphics.measureText(segment);
+	const shift = ascent - descent;
+	if (maxWidth === 0) return {
+		width: 0,
+		text: "",
+		shift
+	};
+	const { lines } = layoutWithLines(prepareWithSegments(segment, ctx.graphics.font), maxWidth, 0);
+	if (lines.length === 0) return {
+		width: 0,
+		text: "",
+		shift
+	};
+	return {
+		width: lines[0].width,
+		text: lines[0].text,
+		shift
+	};
+}
+function layoutText(ctx, text, maxWidth) {
+	if (maxWidth < 0) maxWidth = 0;
+	const segments = preprocessSegments(text);
+	if (segments.length === 0 || maxWidth === 0) return {
+		width: 0,
+		lines: []
+	};
+	const font = ctx.graphics.font;
+	let width = 0;
+	const lines = [];
+	for (const segment of segments) {
+		const { fontBoundingBoxAscent: ascent = 0, fontBoundingBoxDescent: descent = 0 } = ctx.graphics.measureText(segment);
+		const shift = ascent - descent;
+		const { lines: segLines } = layoutWithLines(prepareWithSegments(segment, font), maxWidth, 0);
+		for (const segLine of segLines) {
+			width = Math.max(width, segLine.width);
+			lines.push({
+				width: segLine.width,
+				text: segLine.text,
+				shift
+			});
+		}
+	}
+	return {
+		width,
+		lines
+	};
+}
+//#endregion
+//#region src/utils.ts
+function shallow(object) {
+	return Object.create(object);
+}
+function shallowMerge(object, other) {
+	return {
+		__proto__: object,
+		...other
+	};
+}
+//#endregion
+//#region src/registry.ts
+const registry = /* @__PURE__ */ new WeakMap();
+function registerNodeParent(node, parent) {
+	registry.set(node, parent);
+}
+function unregisterNodeParent(node) {
+	registry.delete(node);
+}
+function getNodeParent(node) {
+	return registry.get(node);
+}
+//#endregion
+//#region src/nodes.ts
+var Group = class {
+	constructor(children) {
+		this.children = children;
+		for (const child of children) registerNodeParent(child, this);
+	}
+	get flex() {
+		return this.children.some((item) => item.flex);
+	}
+};
+var VStack = class extends Group {
+	constructor(children, options = {}) {
+		super(children);
+		this.options = options;
+	}
+	measure(ctx) {
+		let width = 0;
+		let height = 0;
+		if (this.options.alignment != null) ctx.alignment = this.options.alignment;
+		for (const [index, child] of this.children.entries()) {
+			if (this.options.gap != null && index !== 0) height += this.options.gap;
+			const result = shallow(ctx).measureNode(child);
+			height += result.height;
+			width = Math.max(width, result.width);
+		}
+		ctx.remainingWidth -= width;
+		return {
+			width,
+			height
+		};
+	}
+	draw(ctx, x, y) {
+		let result = false;
+		const fullWidth = ctx.measureNode(this).width;
+		const alignment = this.options.alignment ?? ctx.alignment;
+		if (this.options.alignment != null) ctx.alignment = this.options.alignment;
+		for (const [index, child] of this.children.entries()) {
+			if (this.options.gap != null && index !== 0) y += this.options.gap;
+			const { width, height } = shallow(ctx).measureNode(child);
+			const curCtx = shallow(ctx);
+			let requestRedraw;
+			if (alignment === "right") requestRedraw = child.draw(curCtx, x + fullWidth - width, y);
+			else if (alignment === "center") requestRedraw = child.draw(curCtx, x + (fullWidth - width) / 2, y);
+			else requestRedraw = child.draw(curCtx, x, y);
+			result ||= requestRedraw;
+			y += height;
+		}
+		return result;
+	}
+	hittest(ctx, test) {
+		let y = 0;
+		const fullWidth = ctx.measureNode(this).width;
+		const alignment = this.options.alignment ?? ctx.alignment;
+		if (this.options.alignment != null) ctx.alignment = this.options.alignment;
+		for (const [index, child] of this.children.entries()) {
+			if (this.options.gap != null && index !== 0) y += this.options.gap;
+			const { width, height } = shallow(ctx).measureNode(child);
+			const curCtx = shallow(ctx);
+			if (test.y >= y && test.y < y + height) {
+				let x;
+				if (alignment === "right") x = test.x - fullWidth + width;
+				else if (alignment === "center") x = test.x - (fullWidth - width) / 2;
+				else x = test.x;
+				if (x < 0 || x >= width) return false;
+				return child.hittest(curCtx, shallowMerge(test, {
+					x,
+					y: test.y - y
+				}));
+			}
+			y += height;
+		}
+		return false;
+	}
+};
+var HStack = class extends Group {
+	constructor(children, options = {}) {
+		super(children);
+		this.children = children;
+		this.options = options;
+	}
+	measure(ctx) {
+		let width = 0;
+		let height = 0;
+		let firstFlex;
+		for (const [index, child] of this.children.entries()) {
+			if (this.options.gap != null && index !== 0) width += this.options.gap;
+			if (firstFlex == null && child.flex) {
+				firstFlex = child;
+				continue;
+			}
+			const curCtx = shallow(ctx);
+			curCtx.remainingWidth = ctx.remainingWidth - width;
+			const result = curCtx.measureNode(child);
+			width += result.width;
+			height = Math.max(height, result.height);
+		}
+		if (firstFlex != null) {
+			const curCtx = shallow(ctx);
+			curCtx.remainingWidth = ctx.remainingWidth - width;
+			const result = curCtx.measureNode(firstFlex);
+			width += result.width;
+			height = Math.max(height, result.height);
+		}
+		return {
+			width,
+			height
+		};
+	}
+	draw(ctx, x, y) {
+		let result = false;
+		const reverse = this.options.reverse ?? ctx.reverse;
+		if (this.options.reverse) ctx.reverse = this.options.reverse;
+		if (reverse) {
+			x += ctx.measureNode(this).width;
+			for (const [index, child] of this.children.entries()) {
+				const gap = this.options.gap != null && index !== 0 ? this.options.gap : void 0;
+				if (gap) {
+					x -= gap;
+					ctx.remainingWidth -= gap;
+				}
+				const { width } = shallow(ctx).measureNode(child);
+				x -= width;
+				const requestRedraw = child.draw(shallow(ctx), x, y);
+				result ||= requestRedraw;
+				ctx.remainingWidth -= width;
+			}
+		} else for (const [index, child] of this.children.entries()) {
+			const gap = this.options.gap != null && index !== 0 ? this.options.gap : void 0;
+			if (gap) {
+				x += gap;
+				ctx.remainingWidth -= gap;
+			}
+			const requestRedraw = child.draw(shallow(ctx), x, y);
+			result ||= requestRedraw;
+			const { width } = shallow(ctx).measureNode(child);
+			ctx.remainingWidth -= width;
+			x += width;
+		}
+		return result;
+	}
+	hittest(ctx, test) {
+		const reverse = this.options.reverse ?? ctx.reverse;
+		if (this.options.reverse) ctx.reverse = this.options.reverse;
+		if (reverse) {
+			let x = ctx.measureNode(this).width;
+			for (const [index, child] of this.children.entries()) {
+				const gap = this.options.gap != null && index !== 0 ? this.options.gap : void 0;
+				if (gap) {
+					x -= gap;
+					ctx.remainingWidth -= gap;
+				}
+				const { width, height } = shallow(ctx).measureNode(child);
+				x -= width;
+				if (x <= test.x && test.x < x + width) {
+					if (test.y >= height) return false;
+					return child.hittest(shallow(ctx), shallowMerge(test, { x: test.x - x }));
+				}
+				ctx.remainingWidth -= width;
+			}
+		} else {
+			let x = 0;
+			for (const [index, child] of this.children.entries()) {
+				const gap = this.options.gap != null && index !== 0 ? this.options.gap : void 0;
+				if (gap) {
+					x += gap;
+					ctx.remainingWidth -= gap;
+				}
+				const { width, height } = shallow(ctx).measureNode(child);
+				if (x <= test.x && test.x < x + width) {
+					if (test.y >= height) return false;
+					return child.hittest(shallow(ctx), shallowMerge(test, { x: test.x - x }));
+				}
+				x += width;
+				ctx.remainingWidth -= width;
+			}
+		}
+		return false;
+	}
+};
+var Wrapper = class {
+	#inner;
+	constructor(inner) {
+		this.#inner = inner;
+		registerNodeParent(this.#inner, this);
+	}
+	get inner() {
+		return this.#inner;
+	}
+	set inner(newNode) {
+		if (newNode === this.#inner) return;
+		unregisterNodeParent(this.#inner);
+		this.#inner = newNode;
+		registerNodeParent(newNode, this);
+	}
+	get flex() {
+		return this.inner.flex;
+	}
+	measure(ctx) {
+		return this.inner.measure(ctx);
+	}
+	draw(ctx, x, y) {
+		return this.inner.draw(ctx, x, y);
+	}
+	hittest(ctx, test) {
+		return this.inner.hittest(ctx, test);
+	}
+};
+var PaddingBox = class extends Wrapper {
+	constructor(inner, padding = {}) {
+		super(inner);
+		this.padding = padding;
+	}
+	get #top() {
+		return this.padding.top ?? 0;
+	}
+	get #bottom() {
+		return this.padding.bottom ?? 0;
+	}
+	get #left() {
+		return this.padding.left ?? 0;
+	}
+	get #right() {
+		return this.padding.right ?? 0;
+	}
+	measure(ctx) {
+		ctx.remainingWidth -= this.#left + this.#right;
+		const { width, height } = ctx.measureNode(this.inner);
+		return {
+			width: width + this.#left + this.#right,
+			height: height + this.#top + this.#bottom
+		};
+	}
+	draw(ctx, x, y) {
+		ctx.remainingWidth -= this.#left + this.#right;
+		return this.inner.draw(ctx, x + this.#left, y + this.#top);
+	}
+	hittest(ctx, test) {
+		ctx.remainingWidth -= this.#left + this.#right;
+		const { width, height } = shallow(ctx).measureNode(this.inner);
+		if (0 <= test.x - this.#left && test.x - this.#left < width && 0 <= test.y - this.#top && test.y - this.#top < height) return this.inner.hittest(shallow(ctx), shallowMerge(test, {
+			x: test.x - this.#left,
+			y: test.y - this.#top
+		}));
+		return false;
+	}
+};
+var AlignBox = class extends Wrapper {
+	#shift = 0;
+	constructor(inner, options) {
+		super(inner);
+		this.options = options;
+	}
+	measure(ctx) {
+		ctx.alignment = this.options.alignment;
+		const { width, height } = ctx.measureNode(this.inner);
+		switch (this.options.alignment) {
+			case "center":
+				this.#shift = (ctx.remainingWidth - width) / 2;
+				break;
+			case "right":
+				this.#shift = ctx.remainingWidth - width;
+				break;
+			default: this.#shift = 0;
+		}
+		return {
+			width: ctx.remainingWidth,
+			height
+		};
+	}
+	draw(ctx, x, y) {
+		ctx.alignment = this.options.alignment;
+		return this.inner.draw(ctx, x + this.#shift, y);
+	}
+	hittest(ctx, test) {
+		ctx.alignment = this.options.alignment;
+		const { width } = shallow(ctx).measureNode(this.inner);
+		if (0 <= test.x - this.#shift && test.x - this.#shift < width) return this.inner.hittest(shallow(ctx), shallowMerge(test, { x: test.x - this.#shift }));
+		return false;
+	}
+};
+var MultilineText = class {
+	#width = 0;
+	#lines = [];
+	constructor(text, options) {
+		this.text = text;
+		this.options = options;
+	}
+	get flex() {
+		return true;
+	}
+	measure(ctx) {
+		return ctx.with((g) => {
+			g.font = this.options.font;
+			const { width, lines } = layoutText(ctx, this.text, ctx.remainingWidth);
+			this.#width = width;
+			this.#lines = lines;
+			return {
+				width: this.#width,
+				height: this.#lines.length * this.options.lineHeight
+			};
+		});
+	}
+	draw(ctx, x, y) {
+		return ctx.with((g) => {
+			g.font = this.options.font;
+			g.fillStyle = ctx.resolveDynValue(this.options.style);
+			switch (this.options.alignment) {
+				case "left":
+					for (const { text, shift } of this.#lines) {
+						g.fillText(text, x, y + (this.options.lineHeight + shift) / 2);
+						y += this.options.lineHeight;
+					}
+					break;
+				case "right":
+					x += this.#width;
+					g.textAlign = "right";
+					for (const { text, shift } of this.#lines) {
+						g.fillText(text, x, y + (this.options.lineHeight + shift) / 2);
+						y += this.options.lineHeight;
+					}
+					break;
+				case "center":
+					x += this.#width / 2;
+					g.textAlign = "center";
+					for (const { text, shift } of this.#lines) {
+						g.fillText(text, x, y + (this.options.lineHeight + shift) / 2);
+						y += this.options.lineHeight;
+					}
+					break;
+			}
+			return false;
+		});
+	}
+	hittest(_ctx, _test) {
+		return false;
+	}
+};
+var Text = class {
+	#width = 0;
+	#text = "";
+	#shift = 0;
+	constructor(text, options) {
+		this.text = text;
+		this.options = options;
+	}
+	get flex() {
+		return false;
+	}
+	measure(ctx) {
+		return ctx.with((g) => {
+			g.font = this.options.font;
+			const { width, text, shift } = layoutFirstLine(ctx, this.text, ctx.remainingWidth);
+			this.#width = width;
+			this.#text = text;
+			this.#shift = shift;
+			return {
+				width: this.#width,
+				height: this.options.lineHeight
+			};
+		});
+	}
+	draw(ctx, x, y) {
+		return ctx.with((g) => {
+			g.font = this.options.font;
+			g.fillStyle = ctx.resolveDynValue(this.options.style);
+			g.fillText(this.#text, x, y + (this.options.lineHeight + this.#shift) / 2);
+			return false;
+		});
+	}
+	hittest(_ctx, _test) {
+		return false;
+	}
+};
+var Fixed = class {
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+	}
+	get flex() {
+		return false;
+	}
+	measure(_ctx) {
+		return {
+			width: this.width,
+			height: this.height
+		};
+	}
+	draw(_ctx, _x, _y) {
+		return false;
+	}
+	hittest(_ctx, _test) {
+		return false;
+	}
+};
+//#endregion
+//#region src/renderer.ts
+var BaseRenderer = class {
+	graphics;
+	#ctx;
+	#lastWidth;
+	#cache = /* @__PURE__ */ new WeakMap();
+	get context() {
+		return shallow(this.#ctx);
+	}
+	constructor(graphics, options) {
+		this.options = options;
+		this.graphics = graphics;
+		this.graphics.textRendering = "optimizeLegibility";
+		const self = this;
+		this.#ctx = {
+			graphics: this.graphics,
+			get remainingWidth() {
+				return this.graphics.canvas.clientWidth;
+			},
+			set remainingWidth(value) {
+				Object.defineProperty(this, "remainingWidth", {
+					value,
+					writable: true
+				});
+			},
+			alignment: "left",
+			reverse: false,
+			measureNode(node) {
+				return self.measureNode(node, this);
+			},
+			invalidateNode: this.invalidateNode.bind(this),
+			resolveDynValue(value) {
+				if (typeof value === "function") return value(this.graphics);
+				return value;
+			},
+			with(cb) {
+				this.graphics.save();
+				try {
+					return cb(this.graphics);
+				} finally {
+					this.graphics.restore();
+				}
+			}
+		};
+		this.#lastWidth = this.graphics.canvas.clientWidth;
+	}
+	invalidateNode(node) {
+		this.#cache.delete(node);
+		let it = node;
+		while (it = getNodeParent(it)) this.#cache.delete(it);
+	}
+	measureNode(node, ctx) {
+		if (this.#lastWidth !== this.graphics.canvas.clientWidth) {
+			this.#cache = /* @__PURE__ */ new WeakMap();
+			this.#lastWidth = this.graphics.canvas.clientWidth;
+		} else {
+			const result = this.#cache.get(node);
+			if (result != null) return result;
+		}
+		const result = node.measure(ctx ?? this.context);
+		this.#cache.set(node, result);
+		return result;
+	}
+};
+var DebugRenderer = class extends BaseRenderer {
+	draw(node) {
+		const { clientWidth: viewportWidth, clientHeight: viewportHeight } = this.graphics.canvas;
+		this.graphics.clearRect(0, 0, viewportWidth, viewportHeight);
+		return node.draw(this.context, 0, 0);
+	}
+	hittest(node, test) {
+		return node.hittest(this.context, test);
+	}
+};
+function memoRenderItem(renderItem) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	function fn(item) {
+		const key = item;
+		const cached = cache.get(key);
+		if (cached != null) return cached;
+		const result = renderItem(item);
+		cache.set(key, result);
+		return result;
+	}
+	return Object.assign(fn, { reset: (key) => cache.delete(key) });
+}
+var ListState = class {
+	offset = 0;
+	position = NaN;
+	items = [];
+	unshift(...items) {
+		this.unshiftAll(items);
+	}
+	unshiftAll(items) {
+		this.position += items.length;
+		this.items = items.concat(this.items);
+	}
+	push(...items) {
+		this.pushAll(items);
+	}
+	pushAll(items) {
+		this.items.push(...items);
+	}
+	reset() {
+		this.items = [];
+		this.offset = 0;
+		this.position = NaN;
+	}
+	resetScroll() {
+		this.offset = 0;
+		this.position = NaN;
+	}
+	applyScroll(delta) {
+		this.offset += delta;
+	}
+};
+var VirtualizedRenderer = class extends BaseRenderer {
+	get position() {
+		return this.options.list.position;
+	}
+	set position(value) {
+		this.options.list.position = value;
+	}
+	get offset() {
+		return this.options.list.offset;
+	}
+	set offset(value) {
+		this.options.list.offset = value;
+	}
+	get items() {
+		return this.options.list.items;
+	}
+	set items(value) {
+		this.options.list.items = value;
+	}
+	_renderDrawList(list, shift, feedback) {
+		let result = false;
+		const viewportHeight = this.graphics.canvas.clientHeight;
+		for (const { idx, node, offset, height } of list) {
+			const y = offset + shift;
+			if (y + height < 0 || y > viewportHeight) continue;
+			if (feedback != null) {
+				feedback.minIdx = Number.isNaN(feedback.minIdx) ? idx : Math.min(idx, feedback.minIdx);
+				feedback.maxIdx = Number.isNaN(feedback.maxIdx) ? idx : Math.max(idx, feedback.maxIdx);
+				if (feedback.minIdx === idx) feedback.min = idx - Math.min(0, y) / height;
+				if (feedback.maxIdx === idx) feedback.max = idx - Math.max(0, y + height - viewportHeight) / height;
+			}
+			if (node.draw(this.context, 0, y)) result = true;
+		}
+		return result;
+	}
+};
+var TimelineRenderer = class extends VirtualizedRenderer {
+	render(feedback) {
+		const { clientWidth: viewportWidth, clientHeight: viewportHeight } = this.graphics.canvas;
+		this.graphics.clearRect(0, 0, viewportWidth, viewportHeight);
+		let drawLength = 0;
+		if (Number.isNaN(this.position)) this.position = 0;
+		if (this.offset > 0) if (this.position === 0) this.offset = 0;
+		else {
+			for (let i = this.position - 1; i >= 0; i -= 1) {
+				const item = this.items[i];
+				const node = this.options.renderItem(item);
+				const { height } = this.measureNode(node);
+				this.position = i;
+				this.offset -= height;
+				if (this.offset <= 0) break;
+			}
+			if (this.position === 0 && this.offset > 0) this.offset = 0;
+		}
+		let y = this.offset;
+		const drawList = [];
+		for (let i = this.position; i < this.items.length; i += 1) {
+			const item = this.items[i];
+			const node = this.options.renderItem(item);
+			const { height } = this.measureNode(node);
+			if (y + height > 0) {
+				drawList.push({
+					idx: i,
+					node,
+					offset: y,
+					height
+				});
+				drawLength += height;
+			} else {
+				this.offset += height;
+				this.position = i + 1;
+			}
+			y += height;
+			if (y >= viewportHeight) break;
+		}
+		let shift = 0;
+		if (y < viewportHeight) if (this.position === 0 && drawLength < viewportHeight) {
+			shift = -this.offset;
+			this.offset = 0;
+		} else {
+			shift = viewportHeight - y;
+			y = this.offset += shift;
+			let lastIdx = -1;
+			for (let i = this.position - 1; i >= 0; i -= 1) {
+				const item = this.items[lastIdx = i];
+				const node = this.options.renderItem(item);
+				const { height } = this.measureNode(node);
+				drawLength += height;
+				y -= height;
+				drawList.push({
+					idx: i,
+					node,
+					offset: y - shift,
+					height
+				});
+				if (y < 0) break;
+			}
+			if (lastIdx === 0 && drawLength < viewportHeight) {
+				shift = -drawList[drawList.length - 1].offset;
+				this.position = 0;
+				this.offset = 0;
+			}
+		}
+		return this._renderDrawList(drawList, shift, feedback);
+	}
+	hittest(test) {
+		const viewportHeight = this.graphics.canvas.clientHeight;
+		let y = this.offset;
+		for (let i = this.position; i < this.items.length; i += 1) {
+			const item = this.items[i];
+			const node = this.options.renderItem(item);
+			const { height } = this.measureNode(node);
+			if (test.y < y + height) return node.hittest(this.context, shallowMerge(test, { y: test.y - y }));
+			y += height;
+			if (y >= viewportHeight) break;
+		}
+		return false;
+	}
+};
+var ChatRenderer = class extends VirtualizedRenderer {
+	render(feedback) {
+		const { clientWidth: viewportWidth, clientHeight: viewportHeight } = this.graphics.canvas;
+		this.graphics.clearRect(0, 0, viewportWidth, viewportHeight);
+		let drawLength = 0;
+		if (Number.isNaN(this.position)) this.position = this.items.length - 1;
+		if (this.offset < 0) if (this.position === this.items.length - 1) this.offset = 0;
+		else for (let i = this.position + 1; i < this.items.length; i += 1) {
+			const item = this.items[i];
+			const node = this.options.renderItem(item);
+			const { height } = this.measureNode(node);
+			this.position = i;
+			this.offset += height;
+			if (this.offset > 0) break;
+		}
+		let y = viewportHeight + this.offset;
+		const drawList = [];
+		for (let i = this.position; i >= 0; i -= 1) {
+			const item = this.items[i];
+			const node = this.options.renderItem(item);
+			const { height } = this.measureNode(node);
+			y -= height;
+			if (y <= viewportHeight) {
+				drawList.push({
+					idx: i,
+					node,
+					offset: y,
+					height
+				});
+				drawLength += height;
+			} else {
+				this.offset -= height;
+				this.position = i - 1;
+			}
+			if (y < 0) break;
+		}
+		let shift = 0;
+		if (y > 0) {
+			shift = -y;
+			if (drawLength < viewportHeight) {
+				y = drawLength;
+				for (let i = this.position + 1; i < this.items.length; i += 1) {
+					const item = this.items[i];
+					const node = this.options.renderItem(item);
+					const { height } = this.measureNode(node);
+					drawList.push({
+						idx: i,
+						node,
+						offset: y - shift,
+						height
+					});
+					y = drawLength += height;
+					this.position = i;
+					if (y >= viewportHeight) break;
+				}
+				if (drawLength < viewportHeight) this.offset = 0;
+				else this.offset = drawLength - viewportHeight;
+			} else this.offset = drawLength - viewportHeight;
+		}
+		return this._renderDrawList(drawList, shift, feedback);
+	}
+	hittest(test) {
+		const viewportHeight = this.graphics.canvas.clientHeight;
+		let drawLength = 0;
+		const heights = [];
+		for (let i = this.position; i >= 0; i -= 1) {
+			const item = this.items[i];
+			const node = this.options.renderItem(item);
+			const { height } = this.measureNode(node);
+			drawLength += height;
+			heights.push([node, height]);
+		}
+		let y = drawLength < viewportHeight ? drawLength : viewportHeight + this.offset;
+		if (test.y > y) return false;
+		for (const [node, height] of heights) {
+			y -= height;
+			if (test.y > y) return node.hittest(this.context, shallowMerge(test, { y: test.y - y }));
+		}
+		return false;
+	}
+};
+//#endregion
+export { AlignBox, BaseRenderer, ChatRenderer, DebugRenderer, Fixed, Group, HStack, ListState, MultilineText, PaddingBox, Text, TimelineRenderer, VStack, VirtualizedRenderer, Wrapper, getNodeParent, memoRenderItem, registerNodeParent, unregisterNodeParent };
+
+//# sourceMappingURL=index.mjs.map