@simon_he/vue-tui 0.0.6 → 0.0.8

package/dist/wheel-scroll-CiNsasLf.js

@@ -0,0 +1,825 @@
+import { computed, inject, onBeforeUnmount, provide, ref, vShow, watchEffect } from "vue";
+
+//#region src/vue/context.ts
+const TerminalContextKey = Symbol("TerminalContext");
+const LayoutContextKey = Symbol("LayoutContext");
+const VisibilityContextKey = Symbol("VisibilityContext");
+const EventZIndexContextKey = Symbol("EventZIndex");
+const RenderPlaneContextKey = Symbol("RenderPlane");
+const ImeAnchorContextKey = Symbol("ImeAnchor");
+const TInputPluginsContextKey = Symbol("TInputPlugins");
+const TPathPickerProviderContextKey = Symbol("TPathPickerProvider");
+const DialogContextKey = Symbol("DialogContext");
+
+//#endregion
+//#region src/vue/composables/use-layout.ts
+function useLayout() {
+	const ctx = inject(LayoutContextKey, null);
+	if (!ctx) throw new Error("LayoutContext is missing (TerminalProvider/TView)");
+	return ctx;
+}
+
+//#endregion
+//#region src/vue/render/context.ts
+const RenderStackKey = Symbol("RenderStack");
+
+//#endregion
+//#region src/vue/composables/use-render-stack.ts
+function useRenderStack() {
+	const stack = inject(RenderStackKey, null);
+	if (!stack) throw new Error("RenderStack is missing");
+	return stack;
+}
+
+//#endregion
+//#region src/vue/composables/use-terminal.ts
+function useTerminal() {
+	const ctx = inject(TerminalContextKey, null);
+	if (!ctx) throw new Error("TerminalProvider is missing");
+	return ctx;
+}
+
+//#endregion
+//#region src/vue/composables/use-render-node.ts
+const pendingInvalidateByScheduler = new WeakMap();
+function mergePriority(prev, next) {
+	if (prev === "high" || next === "high") return "high";
+	if (prev === "normal" || next === "normal") return "normal";
+	return "low";
+}
+function requestBatchedInvalidate(scheduler, plane, priority) {
+	let state = pendingInvalidateByScheduler.get(scheduler);
+	if (!state) {
+		state = {
+			queued: false,
+			plane: null,
+			priority: "low"
+		};
+		pendingInvalidateByScheduler.set(scheduler, state);
+	}
+	if (state.queued) {
+		if (state.plane !== null && state.plane !== plane) state.plane = null;
+		state.priority = mergePriority(state.priority, priority);
+		return;
+	}
+	state.plane = plane;
+	state.priority = priority;
+	state.queued = true;
+	queueMicrotask(() => {
+		state.queued = false;
+		const queuedPlane = state.plane;
+		const queuedPriority = state.priority;
+		state.plane = null;
+		state.priority = "low";
+		scheduler.invalidate({
+			plane: queuedPlane ?? void 0,
+			priority: queuedPriority
+		});
+	});
+}
+function useRenderNode(getOptions) {
+	const { scheduler, render } = useTerminal();
+	const parentStack = useRenderStack();
+	const plane = inject(RenderPlaneContextKey, ref("default"));
+	const id = ref(null);
+	const lastPlane = ref(plane.value);
+	const options = computed(() => getOptions());
+	const stop = watchEffect(() => {
+		const opt = options.value;
+		opt.deps;
+		const stack = opt.stack ?? parentStack.value;
+		const nextPlane = plane.value;
+		if (!stack) return;
+		if (!id.value) {
+			const node = render.register({
+				stack,
+				zIndex: opt.zIndex,
+				rect: opt.rect,
+				plane: nextPlane,
+				paint: opt.paint
+			});
+			id.value = node.id;
+			lastPlane.value = nextPlane;
+			requestBatchedInvalidate(scheduler, nextPlane, opt.priority ?? "normal");
+			return;
+		}
+		const prevPlane = lastPlane.value;
+		const updatePayload = {
+			stack,
+			zIndex: opt.zIndex ?? 0,
+			dirtyRowsHint: opt.dirtyRowsHint,
+			plane: nextPlane,
+			paint: opt.paint
+		};
+		if (Object.prototype.hasOwnProperty.call(opt, "rect")) updatePayload.rect = opt.rect ?? null;
+		render.update(id.value, updatePayload);
+		lastPlane.value = nextPlane;
+		const priority = opt.priority ?? "normal";
+		requestBatchedInvalidate(scheduler, prevPlane, priority);
+		if (prevPlane !== nextPlane) requestBatchedInvalidate(scheduler, nextPlane, priority);
+	});
+	onBeforeUnmount(() => {
+		stop();
+		if (id.value) {
+			render.unregister(id.value);
+			requestBatchedInvalidate(scheduler, lastPlane.value, "normal");
+		}
+	});
+	return { id };
+}
+
+//#endregion
+//#region src/vue/composables/use-terminal-node.ts
+function useTerminalNode(getOptions) {
+	const { events } = useTerminal();
+	const id = ref(null);
+	const options = computed(() => getOptions());
+	const stop = watchEffect(() => {
+		const manager = events.value;
+		if (!manager) return;
+		const opt = options.value;
+		if (!id.value) {
+			const node = manager.register({
+				rect: opt.rect,
+				zIndex: opt.zIndex ?? 0,
+				visible: opt.visible,
+				focusable: opt.focusable,
+				selectable: opt.selectable,
+				handlers: opt.handlers ?? {}
+			});
+			id.value = node.id;
+			return;
+		}
+		manager.update(id.value, {
+			rect: opt.rect,
+			zIndex: opt.zIndex ?? 0,
+			visible: opt.visible,
+			focusable: opt.focusable,
+			selectable: opt.selectable,
+			handlers: opt.handlers ?? {}
+		});
+	});
+	onBeforeUnmount(() => {
+		stop();
+		const manager = events.value;
+		if (manager && id.value) manager.unregister(id.value);
+	});
+	return { id };
+}
+
+//#endregion
+//#region src/vue/composables/use-visibility.ts
+const VUE_TERMINAL_SHOW_CB = "__vueTerminalOnShow";
+let vShowPatched = false;
+function patchVShow() {
+	if (vShowPatched) return;
+	vShowPatched = true;
+	const dir = vShow;
+	const origBeforeMount = dir.beforeMount;
+	const origUpdated = dir.updated;
+	const origBeforeUnmount = dir.beforeUnmount;
+	const notify = (el, value) => {
+		if (!el || typeof el !== "object") return;
+		const cb = el[VUE_TERMINAL_SHOW_CB];
+		cb === null || cb === void 0 || cb(Boolean(value));
+	};
+	if (typeof origBeforeMount === "function") dir.beforeMount = (el, binding, vnode) => {
+		origBeforeMount(el, binding, vnode);
+		notify(el, binding === null || binding === void 0 ? void 0 : binding.value);
+	};
+	if (typeof origUpdated === "function") dir.updated = (el, binding, vnode) => {
+		origUpdated(el, binding, vnode);
+		notify(el, binding === null || binding === void 0 ? void 0 : binding.value);
+	};
+	if (typeof origBeforeUnmount === "function") dir.beforeUnmount = (el, binding, vnode) => {
+		origBeforeUnmount(el, binding, vnode);
+		notify(el, binding === null || binding === void 0 ? void 0 : binding.value);
+	};
+}
+const PLACEHOLDER_STYLE = Object.freeze({
+	position: "absolute",
+	left: "-9999px",
+	top: "0",
+	width: "0",
+	height: "0",
+	overflow: "hidden"
+});
+function useVisibility(options) {
+	patchVShow();
+	const { scheduler } = useTerminal();
+	const parentVisible = inject(VisibilityContextKey, ref(true));
+	const localVisible = ref(true);
+	const visible = computed(() => parentVisible.value && localVisible.value);
+	if (options === null || options === void 0 ? void 0 : options.provide) provide(VisibilityContextKey, visible);
+	const onShow = (value) => {
+		localVisible.value = value;
+		scheduler.invalidate();
+	};
+	const rootProps = {
+		style: PLACEHOLDER_STYLE,
+		onVnodeBeforeMount: (vnode) => {
+			const el = vnode.el;
+			if (el && typeof el === "object") el[VUE_TERMINAL_SHOW_CB] = onShow;
+		},
+		onVnodeBeforeUnmount: (vnode) => {
+			const el = vnode.el;
+			if (el && typeof el === "object" && el[VUE_TERMINAL_SHOW_CB] === onShow) delete el[VUE_TERMINAL_SHOW_CB];
+		}
+	};
+	return {
+		visible,
+		rootProps
+	};
+}
+
+//#endregion
+//#region src/vue/utils/rect.ts
+function intersectRect(a, b) {
+	const x0 = Math.max(a.x, b.x);
+	const y0 = Math.max(a.y, b.y);
+	const x1 = Math.min(a.x + a.w, b.x + b.w);
+	const y1 = Math.min(a.y + a.h, b.y + b.h);
+	if (x1 <= x0 || y1 <= y0) return null;
+	return {
+		x: x0,
+		y: y0,
+		w: x1 - x0,
+		h: y1 - y0
+	};
+}
+function translateRect(rect, dx, dy) {
+	return {
+		x: rect.x + dx,
+		y: rect.y + dy,
+		w: rect.w,
+		h: rect.h
+	};
+}
+function normalizeCellRect(rect) {
+	const x0 = Math.floor(rect.x);
+	const y0 = Math.floor(rect.y);
+	const x1 = Math.floor(rect.x + rect.w);
+	const y1 = Math.floor(rect.y + rect.h);
+	return {
+		x: x0,
+		y: y0,
+		w: Math.max(0, x1 - x0),
+		h: Math.max(0, y1 - y0)
+	};
+}
+
+//#endregion
+//#region src/core/buffer/width.ts
+const fullWidthRanges = [
+	[4352, 4447],
+	[9001, 9002],
+	[11904, 42191],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65135],
+	[65280, 65376],
+	[65504, 65510]
+];
+function isFullWidthCodePoint(codePoint) {
+	if (codePoint < 4352 || codePoint > 65510) return false;
+	for (const [start, end] of fullWidthRanges) {
+		if (codePoint < start) return false;
+		if (codePoint <= end) return true;
+	}
+	return false;
+}
+function isEmojiLike(codePoint) {
+	return codePoint >= 127744 && codePoint <= 129791 || codePoint >= 127462 && codePoint <= 127487;
+}
+let extendedPictographicRe = null;
+try {
+	extendedPictographicRe = new RegExp("\\p{Extended_Pictographic}", "u");
+} catch {
+	extendedPictographicRe = null;
+}
+let emojiPresentationRe = null;
+try {
+	emojiPresentationRe = new RegExp("\\p{Emoji_Presentation}", "u");
+} catch {
+	emojiPresentationRe = null;
+}
+let emojiRe = null;
+try {
+	emojiRe = new RegExp("\\p{Emoji}", "u");
+} catch {
+	emojiRe = null;
+}
+function charCellWidth(text) {
+	if (!text) return 1;
+	if (text.length === 1) {
+		const code = text.charCodeAt(0);
+		if (code < 4352) return 1;
+	}
+	const codePoint = text.codePointAt(0);
+	if (codePoint == null) return 1;
+	const hasVs16 = text.includes("️");
+	if (isFullWidthCodePoint(codePoint)) return 2;
+	if (isEmojiLike(codePoint)) return 2;
+	if (emojiPresentationRe === null || emojiPresentationRe === void 0 ? void 0 : emojiPresentationRe.test(text)) return 2;
+	if (text.includes("⃣")) return 2;
+	if (hasVs16 && (emojiRe === null || emojiRe === void 0 ? void 0 : emojiRe.test(text))) return 2;
+	if (extendedPictographicRe === null || extendedPictographicRe === void 0 ? void 0 : extendedPictographicRe.test(text)) {
+		if (codePoint <= 65535) return hasVs16 ? 2 : 1;
+		return 2;
+	}
+	return 1;
+}
+
+//#endregion
+//#region src/vue/utils/text.ts
+let renderPassDepth = 0;
+const renderPassTextWidthCache = new Map();
+function withTextRenderPass(fn) {
+	renderPassDepth++;
+	try {
+		if (renderPassDepth === 1) renderPassTextWidthCache.clear();
+		return fn();
+	} finally {
+		renderPassDepth--;
+		if (renderPassDepth === 0) renderPassTextWidthCache.clear();
+	}
+}
+function isAscii(text) {
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 127) return false;
+	return true;
+}
+function needsGraphemeSegmentation(text) {
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (cp === 8205) return true;
+		if (cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999) return true;
+		if (cp >= 768 && cp <= 879 || cp >= 6832 && cp <= 6911 || cp >= 7616 && cp <= 7679 || cp >= 8400 && cp <= 8447 || cp >= 65056 && cp <= 65071) return true;
+		if (cp >= 127995 && cp <= 127999) return true;
+		if (cp >= 127462 && cp <= 127487) return true;
+	}
+	return false;
+}
+let graphemeSegmenter = null;
+try {
+	graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+} catch {
+	graphemeSegmenter = null;
+}
+function forEachGrapheme(text, cb) {
+	if (!text) return;
+	const seg = graphemeSegmenter;
+	if (!seg || !needsGraphemeSegmentation(text)) {
+		for (const ch of text) {
+			const r = cb(ch);
+			if (r === false) return;
+		}
+		return;
+	}
+	for (const part of seg.segment(text)) {
+		const r = cb(part.segment);
+		if (r === false) return;
+	}
+}
+function forEachTextCellSegment(text, cb) {
+	if (!text) return;
+	const seg = graphemeSegmenter;
+	if (!seg || !needsGraphemeSegmentation(text)) {
+		let index$1 = 0;
+		for (const ch of text) {
+			const next = index$1 + ch.length;
+			const result = cb({
+				text: ch,
+				cells: charCellWidth(ch),
+				start: index$1,
+				end: next
+			});
+			if (result === false) return;
+			index$1 = next;
+		}
+		return;
+	}
+	let index = 0;
+	for (const part of seg.segment(text)) {
+		const start = part.index ?? index;
+		const end = start + part.segment.length;
+		const result = cb({
+			text: part.segment,
+			cells: charCellWidth(part.segment),
+			start,
+			end
+		});
+		if (result === false) return;
+		index = end;
+	}
+}
+function graphemeRangeAt(text, index) {
+	if (!text) return null;
+	const len = text.length;
+	if (index < 0 || index >= len) return null;
+	if (isAscii(text)) return {
+		start: index,
+		end: index + 1
+	};
+	const seg = graphemeSegmenter;
+	if (seg && needsGraphemeSegmentation(text)) {
+		let pos$1 = 0;
+		for (const part of seg.segment(text)) {
+			const start = pos$1;
+			const end = start + part.segment.length;
+			if (index >= start && index < end) return {
+				start,
+				end
+			};
+			pos$1 = end;
+		}
+		return null;
+	}
+	let pos = 0;
+	for (const ch of text) {
+		const start = pos;
+		const end = start + ch.length;
+		if (index >= start && index < end) return {
+			start,
+			end
+		};
+		pos = end;
+	}
+	return null;
+}
+function sanitizeInlineText(text) {
+	if (!text) return "";
+	if (!/[\n\r\t]/.test(text)) return text;
+	return text.replace(/[\n\r\t]/g, " ");
+}
+function sanitizeTextBlock(text) {
+	if (!text) return "";
+	if (!/[\t\x00-\x08\x0B-\x1F\x7F]/.test(text)) return text;
+	const out = [];
+	out.length = 0;
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (cp === 13) continue;
+		if (cp === 9) {
+			out.push(" ");
+			continue;
+		}
+		if (cp <= 31 && cp !== 10 || cp === 127) continue;
+		out.push(ch);
+	}
+	return out.join("");
+}
+function textCellWidth(text) {
+	if (!text) return 0;
+	if (isAscii(text)) return text.length;
+	if (renderPassDepth > 0) {
+		const cached$1 = renderPassTextWidthCache.get(text);
+		if (cached$1 != null) return cached$1;
+	}
+	const cached = textWidthCacheGet(text);
+	if (cached != null) return cached;
+	let cells = 0;
+	forEachGrapheme(text, (g) => {
+		cells += charCellWidth(g);
+	});
+	if (renderPassDepth > 0) renderPassTextWidthCache.set(text, cells);
+	textWidthCacheSet(text, cells);
+	return cells;
+}
+const spaceCache = new Map();
+const MAX_CACHED_SPACES = 256;
+function spaces(count) {
+	count = Math.max(0, Math.floor(count));
+	if (count === 0) return "";
+	const cached = spaceCache.get(count);
+	if (cached) return cached;
+	const v = " ".repeat(count);
+	if (spaceCache.size >= MAX_CACHED_SPACES) spaceCache.clear();
+	spaceCache.set(count, v);
+	return v;
+}
+const repeatCharCache = new Map();
+const MAX_REPEAT_CHAR_KEYS = 8;
+const MAX_CACHED_REPEAT_CHAR = 256;
+function repeatChar(ch, count) {
+	count = Math.max(0, Math.floor(count));
+	if (count === 0) return "";
+	if (!ch) return "";
+	let bucket = repeatCharCache.get(ch);
+	if (!bucket) {
+		if (repeatCharCache.size >= MAX_REPEAT_CHAR_KEYS) repeatCharCache.clear();
+		bucket = new Map();
+		repeatCharCache.set(ch, bucket);
+	}
+	const cached = bucket.get(count);
+	if (cached) return cached;
+	const v = ch.repeat(count);
+	if (bucket.size >= MAX_CACHED_REPEAT_CHAR) bucket.clear();
+	bucket.set(count, v);
+	return v;
+}
+function sliceByCells(text, maxCells) {
+	maxCells = Math.max(0, Math.floor(maxCells));
+	if (maxCells <= 0) return "";
+	if (text && isAscii(text)) return text.slice(0, maxCells);
+	const out = [];
+	let cells = 0;
+	forEachGrapheme(text, (g) => {
+		const w = charCellWidth(g);
+		if (cells + w > maxCells) return false;
+		out.push(g);
+		cells += w;
+		return void 0;
+	});
+	return out.length ? out.join("") : "";
+}
+function sliceByCellsRange(text, startCells, endCells) {
+	startCells = Math.max(0, Math.floor(startCells));
+	endCells = Math.max(0, Math.floor(endCells));
+	if (endCells <= startCells) return "";
+	if (!text) return "";
+	if (isAscii(text)) return text.slice(startCells, endCells);
+	const out = [];
+	let cells = 0;
+	forEachGrapheme(text, (g) => {
+		const w = charCellWidth(g);
+		const next = cells + w;
+		if (cells >= endCells) return false;
+		if (next <= startCells) {
+			cells = next;
+			return void 0;
+		}
+		if (cells < startCells && next > startCells) {
+			out.push(spaces(Math.min(next, endCells) - startCells));
+			cells = next;
+			return void 0;
+		}
+		if (next > endCells) {
+			out.push(spaces(endCells - cells));
+			return false;
+		}
+		out.push(g);
+		cells = next;
+		return void 0;
+	});
+	return out.length ? out.join("") : "";
+}
+function padEndByCells(text, width) {
+	width = Math.max(0, Math.floor(width));
+	const cells = text && isAscii(text) ? text.length : textCellWidth(text);
+	if (cells >= width) return text;
+	return `${text}${spaces(width - cells)}`;
+}
+const inlineLineCacheByWidth = new Map();
+const MAX_INLINE_LINE_CACHE_BUCKETS = 32;
+const MAX_INLINE_LINE_CACHE_PER_WIDTH = 512;
+function getInlineLineBucket(width) {
+	let bucket = inlineLineCacheByWidth.get(width);
+	if (bucket) return bucket;
+	if (inlineLineCacheByWidth.size >= MAX_INLINE_LINE_CACHE_BUCKETS) inlineLineCacheByWidth.clear();
+	bucket = new Map();
+	inlineLineCacheByWidth.set(width, bucket);
+	return bucket;
+}
+function formatInlineCellLine(text, width) {
+	width = Math.max(0, Math.floor(width));
+	if (width === 0) return "";
+	if (!text) return spaces(width);
+	const bucket = getInlineLineBucket(width);
+	const cached = bucket.get(text);
+	if (cached != null) return cached;
+	const sanitized = sanitizeInlineText(text);
+	if (sanitized && isAscii(sanitized)) {
+		const out$1 = sanitized.length >= width ? sanitized.slice(0, width) : `${sanitized}${spaces(width - sanitized.length)}`;
+		if (bucket.size >= MAX_INLINE_LINE_CACHE_PER_WIDTH) bucket.clear();
+		bucket.set(text, out$1);
+		return out$1;
+	}
+	const out = padEndByCells(sliceByCells(sanitized, width), width);
+	if (bucket.size >= MAX_INLINE_LINE_CACHE_PER_WIDTH) bucket.clear();
+	bucket.set(text, out);
+	return out;
+}
+const wrapCacheByWidth = new Map();
+const MAX_WRAP_CACHE_BUCKETS = 32;
+const MAX_WRAP_CACHE_PER_WIDTH = 256;
+function getWrapBucket(width) {
+	let bucket = wrapCacheByWidth.get(width);
+	if (bucket) return bucket;
+	if (wrapCacheByWidth.size >= MAX_WRAP_CACHE_BUCKETS) wrapCacheByWidth.clear();
+	bucket = new Map();
+	wrapCacheByWidth.set(width, bucket);
+	return bucket;
+}
+const textWidthCache = new Map();
+const MAX_TEXT_WIDTH_CACHE = 1024;
+function textWidthCacheGet(text) {
+	const cached = textWidthCache.get(text);
+	if (cached == null) return null;
+	textWidthCache.delete(text);
+	textWidthCache.set(text, cached);
+	return cached;
+}
+function textWidthCacheSet(text, cells) {
+	textWidthCache.set(text, cells);
+	if (textWidthCache.size > MAX_TEXT_WIDTH_CACHE) {
+		const firstKey = textWidthCache.keys().next().value;
+		if (firstKey != null) textWidthCache.delete(firstKey);
+	}
+}
+function clearTextCaches() {
+	wrapCacheByWidth.clear();
+	spaceCache.clear();
+	repeatCharCache.clear();
+	textWidthCache.clear();
+	inlineLineCacheByWidth.clear();
+}
+function wrapByCells(text, width) {
+	width = Math.max(1, Math.floor(width));
+	const bucket = getWrapBucket(width);
+	if (text && isAscii(text)) {
+		const cached$1 = bucket.get(text);
+		if (cached$1) return cached$1;
+		const out$1 = [];
+		for (const rawLine of text.replace(/\r/g, "").split("\n")) {
+			if (rawLine.length === 0) {
+				out$1.push("");
+				continue;
+			}
+			for (let i = 0; i < rawLine.length; i += width) out$1.push(rawLine.slice(i, i + width));
+		}
+		if (bucket.size >= MAX_WRAP_CACHE_PER_WIDTH) bucket.clear();
+		bucket.set(text, out$1);
+		return out$1;
+	}
+	const cached = bucket.get(text);
+	if (cached) return cached;
+	const out = [];
+	for (const rawLine of text.replace(/\r/g, "").split("\n")) {
+		if (rawLine.length === 0) {
+			out.push("");
+			continue;
+		}
+		const seg = graphemeSegmenter;
+		if (seg && needsGraphemeSegmentation(rawLine)) {
+			let lineStart = 0;
+			let cells = 0;
+			for (const part of seg.segment(rawLine)) {
+				const g = part.segment;
+				const gIdx = part.index;
+				const w = charCellWidth(g);
+				if (cells > 0 && cells + w > width) {
+					out.push(rawLine.slice(lineStart, gIdx));
+					lineStart = gIdx;
+					cells = 0;
+				}
+				cells += w;
+				if (cells >= width) {
+					const end = gIdx + g.length;
+					out.push(rawLine.slice(lineStart, end));
+					lineStart = end;
+					cells = 0;
+				}
+			}
+			if (lineStart < rawLine.length) out.push(rawLine.slice(lineStart));
+		} else {
+			let lineStart = 0;
+			let pos = 0;
+			let cells = 0;
+			for (const ch of rawLine) {
+				const w = charCellWidth(ch);
+				if (cells > 0 && cells + w > width) {
+					out.push(rawLine.slice(lineStart, pos));
+					lineStart = pos;
+					cells = 0;
+				}
+				pos += ch.length;
+				cells += w;
+				if (cells >= width) {
+					out.push(rawLine.slice(lineStart, pos));
+					lineStart = pos;
+					cells = 0;
+				}
+			}
+			if (lineStart < rawLine.length) out.push(rawLine.slice(lineStart));
+		}
+	}
+	const res = out.length ? out : [""];
+	if (bucket.size >= MAX_WRAP_CACHE_PER_WIDTH) bucket.clear();
+	bucket.set(text, res);
+	return res;
+}
+
+//#endregion
+//#region src/vue/utils/wheel-scroll.ts
+const LINE_UNIT_THRESHOLD = 3;
+const PIXELS_PER_LINE = 16;
+const ACCEL_WINDOW_MS = 120;
+const MAX_ACCEL = 26;
+const EDGE_BOUNCE_MS = 120;
+const MIN_TICK_INTERVAL_MS = 6;
+function clamp(n, min, max) {
+	return Math.max(min, Math.min(max, n));
+}
+function isLineUnitDelta(deltaY, mode = "auto") {
+	if (mode === "line") return true;
+	if (mode === "pixel") return false;
+	const abs = Math.abs(deltaY);
+	return abs > 0 && abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY);
+}
+function normalizeDelta(deltaY, mode = "auto") {
+	if (mode === "line") return deltaY;
+	if (mode === "pixel") return deltaY / PIXELS_PER_LINE;
+	const abs = Math.abs(deltaY);
+	if (abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY)) return deltaY;
+	return deltaY / PIXELS_PER_LINE;
+}
+function accelFactor(now, lastAt) {
+	const dt = now - lastAt;
+	if (!Number.isFinite(dt) || dt <= 0 || dt > ACCEL_WINDOW_MS) return 1;
+	const t = 1 - dt / ACCEL_WINDOW_MS;
+	return 1 + t * (MAX_ACCEL - 1);
+}
+function createWheelScrollState() {
+	return {
+		accumulator: 0,
+		lastAt: 0,
+		lastEdgeDir: 0,
+		lastEdgeAt: 0
+	};
+}
+function resetWheelScrollState(state) {
+	state.accumulator = 0;
+	state.lastAt = 0;
+	state.lastEdgeDir = 0;
+	state.lastEdgeAt = 0;
+}
+function applyWheelScroll(state, deltaY, scrollTop, maxTop, now = Date.now(), deltaMode = "auto", options = {}) {
+	if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
+		if (maxTop <= 0) {
+			state.accumulator = 0;
+			state.lastEdgeDir = 0;
+			state.lastEdgeAt = 0;
+		}
+		return {
+			nextTop: scrollTop,
+			dir: 0,
+			lines: 0
+		};
+	}
+	const dt = state.lastAt ? now - state.lastAt : Infinity;
+	const lineUnits = isLineUnitDelta(deltaY, deltaMode);
+	if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS) return {
+		nextTop: scrollTop,
+		dir: 0,
+		lines: 0
+	};
+	const accel = lineUnits ? 1 : options.disableAcceleration ? 1 : state.lastAt ? accelFactor(now, state.lastAt) : 1;
+	state.lastAt = now;
+	state.accumulator += normalizeDelta(deltaY, deltaMode) * accel;
+	const lines = Math.trunc(state.accumulator);
+	if (lines === 0) return {
+		nextTop: scrollTop,
+		dir: 0,
+		lines: 0
+	};
+	state.accumulator -= lines;
+	const dir = lines > 0 ? 1 : -1;
+	const atTop = scrollTop <= 0;
+	const atBottom = scrollTop >= maxTop;
+	if (dir < 0 && atTop || dir > 0 && atBottom) {
+		state.lastEdgeDir = dir;
+		state.lastEdgeAt = now;
+		state.accumulator = 0;
+		return {
+			nextTop: scrollTop,
+			dir: 0,
+			lines: 0
+		};
+	}
+	if (state.lastEdgeDir !== 0 && now - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) return {
+		nextTop: scrollTop,
+		dir: 0,
+		lines: 0
+	};
+	const unclamped = scrollTop + lines;
+	const nextTop = clamp(unclamped, 0, maxTop);
+	if (nextTop === scrollTop) {
+		state.accumulator = 0;
+		return {
+			nextTop: scrollTop,
+			dir: 0,
+			lines: 0
+		};
+	}
+	if (nextTop !== unclamped) state.accumulator = 0;
+	state.lastEdgeDir = 0;
+	return {
+		nextTop,
+		dir: nextTop > scrollTop ? 1 : -1,
+		lines: nextTop - scrollTop
+	};
+}
+
+//#endregion
+export { DialogContextKey, EventZIndexContextKey, ImeAnchorContextKey, LayoutContextKey, RenderPlaneContextKey, RenderStackKey, TInputPluginsContextKey, TPathPickerProviderContextKey, TerminalContextKey, VisibilityContextKey, applyWheelScroll, charCellWidth, clearTextCaches, createWheelScrollState, forEachTextCellSegment, formatInlineCellLine, graphemeRangeAt, intersectRect, normalizeCellRect, padEndByCells, repeatChar, resetWheelScrollState, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, textCellWidth, translateRect, useLayout, useRenderNode, useRenderStack, useTerminal, useTerminalNode, useVisibility, withTextRenderPass, wrapByCells };