@aitty/browser 0.1.0

package/dist/frontend/browser-terminal-renderer.js

@@ -0,0 +1,546 @@
+import { isWideCodePoint } from "./cell-width.js";
+//#region src/frontend/browser-terminal-renderer.ts
+const DEFAULT_COLOR = 256;
+const FLAG_BOLD = 1;
+const FLAG_DIM = 2;
+const FLAG_ITALIC = 4;
+const FLAG_UNDERLINE = 8;
+const FLAG_REVERSE = 32;
+const FLAG_INVISIBLE = 64;
+const FLAG_STRIKETHROUGH = 128;
+function colorToCSS(index) {
+	if (index === DEFAULT_COLOR) return null;
+	if (index < 16) return `var(--term-color-${index})`;
+	if (index < 232) {
+		const value = index - 16;
+		return `rgb(${Math.floor(value / 36) * 51}, ${Math.floor(value / 6) % 6 * 51}, ${value % 6 * 51})`;
+	}
+	const level = (index - 232) * 10 + 8;
+	return `rgb(${level}, ${level}, ${level})`;
+}
+function resolveColorChannels(fg, bg, flags, override = null) {
+	let resolvedFg = override?.fg ?? colorToCSS(fg);
+	let resolvedBg = override?.bg ?? colorToCSS(bg);
+	if (flags & FLAG_REVERSE) {
+		[resolvedFg, resolvedBg] = [resolvedBg, resolvedFg];
+		if (resolvedFg === null) resolvedFg = colorToCSS(0);
+		if (resolvedBg === null) resolvedBg = colorToCSS(7);
+	}
+	return {
+		bg: resolvedBg,
+		fg: resolvedFg
+	};
+}
+function buildCellStyle(fg, bg, flags, override = null) {
+	const colors = resolveColorChannels(fg, bg, flags, override);
+	let style = "";
+	if (colors.fg) style += `color:${colors.fg};`;
+	if (colors.bg) style += `background:${colors.bg};`;
+	if (flags & FLAG_BOLD) style += "font-weight:bold;";
+	if (flags & FLAG_DIM) style += "opacity:0.5;";
+	if (flags & FLAG_ITALIC) style += "font-style:italic;";
+	const decorations = [];
+	if (flags & FLAG_UNDERLINE) decorations.push("underline");
+	if (flags & FLAG_STRIKETHROUGH) decorations.push("line-through");
+	if (decorations.length > 0) style += `text-decoration:${decorations.join(" ")};`;
+	if (flags & FLAG_INVISIBLE) style += "visibility:hidden;";
+	return style;
+}
+function appendRun(parent, text, style, className = "") {
+	const span = document.createElement("span");
+	if (className) span.className = className;
+	if (style) span.style.cssText = style;
+	span.textContent = text;
+	parent.appendChild(span);
+}
+function appendWideCell(parent, text, style, cursor = false) {
+	const span = document.createElement("span");
+	span.className = cursor ? "term-wide term-cursor" : "term-wide";
+	if (style) span.style.cssText = style;
+	span.style.width = "2ch";
+	span.style.minWidth = "2ch";
+	span.style.maxWidth = "2ch";
+	span.style.overflow = "hidden";
+	span.textContent = text;
+	parent.appendChild(span);
+}
+function isWideContinuationCell(cell) {
+	return (cell?.char ?? 0) === 0;
+}
+function serializeRowText(getCell, lineLength) {
+	let text = "";
+	for (let col = 0; col < lineLength; col += 1) {
+		const codePoint = getCell(col)?.char ?? 0;
+		if (isWideCodePoint(codePoint)) {
+			text += String.fromCodePoint(codePoint);
+			if (col + 1 < lineLength && isWideContinuationCell(getCell(col + 1))) col += 1;
+			continue;
+		}
+		text += codePoint >= 32 ? String.fromCodePoint(codePoint) : " ";
+	}
+	return normalizeRowText(text);
+}
+function normalizeRowText(text) {
+	return text.trimEnd();
+}
+function cloneSnapshotRow(snapshot) {
+	const rowElement = snapshot.element.cloneNode(true);
+	rowElement.className = "term-row term-scrollback-row term-restored-scrollback-row";
+	rowElement.querySelectorAll(".term-cursor").forEach((cursor) => {
+		cursor.classList.remove("term-cursor");
+	});
+	return rowElement;
+}
+function resolveSnapshotPrefixMatch(snapshotRows, currentRows) {
+	const meaningfulSnapshotRows = snapshotRows.filter((row) => row.text.length > 0);
+	const meaningfulCurrentRows = currentRows.filter((row) => row.length > 0);
+	if (meaningfulSnapshotRows.length === 0) return {
+		missingPrefixCount: 0,
+		overlapCount: 0
+	};
+	if (meaningfulCurrentRows.length === 0) return {
+		missingPrefixCount: meaningfulSnapshotRows.length,
+		overlapCount: 0
+	};
+	let bestStart = meaningfulSnapshotRows.length;
+	let bestOverlap = 0;
+	for (let start = 0; start < meaningfulSnapshotRows.length; start += 1) {
+		let overlap = 0;
+		while (start + overlap < meaningfulSnapshotRows.length && overlap < meaningfulCurrentRows.length && meaningfulSnapshotRows[start + overlap].text === meaningfulCurrentRows[overlap]) overlap += 1;
+		if (overlap > bestOverlap) {
+			bestOverlap = overlap;
+			bestStart = start;
+		}
+	}
+	if (bestOverlap === 0) return {
+		missingPrefixCount: 0,
+		overlapCount: 0
+	};
+	return {
+		missingPrefixCount: bestStart,
+		overlapCount: bestOverlap
+	};
+}
+function findRowSequence(rows, sequence, minStart = 0) {
+	if (sequence.length === 0) return Math.max(0, minStart);
+	outer: for (let start = Math.max(0, minStart); start <= rows.length - sequence.length; start += 1) {
+		for (let index = 0; index < sequence.length; index += 1) if (rows[start + index] !== sequence[index]) continue outer;
+		return start;
+	}
+	return -1;
+}
+function resolveColors(fg, bg, flags, override = null) {
+	const colors = resolveColorChannels(fg, bg, flags, override);
+	return {
+		bg: colors.bg ?? "var(--term-bg)",
+		fg: colors.fg ?? "var(--term-fg)"
+	};
+}
+function getBlockBackground(codePoint, fg, bg) {
+	switch (codePoint) {
+		case 9600: return `linear-gradient(${fg} 50%,${bg} 50%)`;
+		case 9601: return `linear-gradient(${bg} 87.5%,${fg} 87.5%)`;
+		case 9602: return `linear-gradient(${bg} 75%,${fg} 75%)`;
+		case 9603: return `linear-gradient(${bg} 62.5%,${fg} 62.5%)`;
+		case 9604: return `linear-gradient(${bg} 50%,${fg} 50%)`;
+		case 9605: return `linear-gradient(${bg} 37.5%,${fg} 37.5%)`;
+		case 9606: return `linear-gradient(${bg} 25%,${fg} 25%)`;
+		case 9607: return `linear-gradient(${bg} 12.5%,${fg} 12.5%)`;
+		case 9608: return fg;
+		case 9609: return `linear-gradient(to right,${fg} 87.5%,${bg} 87.5%)`;
+		case 9610: return `linear-gradient(to right,${fg} 75%,${bg} 75%)`;
+		case 9611: return `linear-gradient(to right,${fg} 62.5%,${bg} 62.5%)`;
+		case 9612: return `linear-gradient(to right,${fg} 50%,${bg} 50%)`;
+		case 9613: return `linear-gradient(to right,${fg} 37.5%,${bg} 37.5%)`;
+		case 9614: return `linear-gradient(to right,${fg} 25%,${bg} 25%)`;
+		case 9615: return `linear-gradient(to right,${fg} 12.5%,${bg} 12.5%)`;
+		case 9616: return `linear-gradient(to right,${bg} 50%,${fg} 50%)`;
+		case 9617: return `color-mix(in srgb,${fg} 25%,${bg})`;
+		case 9618: return `color-mix(in srgb,${fg} 50%,${bg})`;
+		case 9619: return `color-mix(in srgb,${fg} 75%,${bg})`;
+		case 9620: return `linear-gradient(${fg} 12.5%,${bg} 12.5%)`;
+		case 9621: return `linear-gradient(to right,${bg} 87.5%,${fg} 87.5%)`;
+		default: {
+			const cells = {
+				9622: [
+					false,
+					false,
+					true,
+					false
+				],
+				9623: [
+					false,
+					false,
+					false,
+					true
+				],
+				9624: [
+					true,
+					false,
+					false,
+					false
+				],
+				9625: [
+					true,
+					false,
+					true,
+					true
+				],
+				9626: [
+					true,
+					false,
+					false,
+					true
+				],
+				9627: [
+					true,
+					true,
+					true,
+					false
+				],
+				9628: [
+					true,
+					true,
+					false,
+					true
+				],
+				9629: [
+					false,
+					true,
+					false,
+					false
+				],
+				9630: [
+					false,
+					true,
+					true,
+					false
+				],
+				9631: [
+					false,
+					true,
+					true,
+					true
+				]
+			}[codePoint];
+			if (!cells) return fg;
+			const [topLeft, topRight, bottomLeft, bottomRight] = cells;
+			const layers = [];
+			const positions = [
+				"0 0",
+				"100% 0",
+				"0 100%",
+				"100% 100%"
+			];
+			[
+				topLeft,
+				topRight,
+				bottomLeft,
+				bottomRight
+			].forEach((filled, index) => {
+				if (filled) layers.push(`linear-gradient(${fg},${fg}) ${positions[index]}/50% 50% no-repeat`);
+			});
+			layers.push(bg);
+			return layers.join(",");
+		}
+	}
+}
+var BrowserTerminalRenderer = class {
+	_altScreenMeaningfulScrollbackCount;
+	_altScreenVisibleRowSnapshot;
+	_lastAltScreenState;
+	_renderedScrollbackCount;
+	_restoreSnapshotCount;
+	_scrollbackRowEls;
+	cols;
+	container;
+	prevContainerBg;
+	prevCursorCol;
+	prevCursorRow;
+	prevCursorVisible;
+	prevRowBg;
+	rowEls;
+	rows;
+	styleTracker;
+	constructor(container, styleTracker) {
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+		this._lastAltScreenState = false;
+		this._restoreSnapshotCount = 0;
+		this.cols = 0;
+		this.container = container;
+		this.prevContainerBg = "";
+		this.prevCursorCol = -1;
+		this.prevCursorRow = -1;
+		this.prevCursorVisible = false;
+		this.prevRowBg = [];
+		this.rowEls = [];
+		this.rows = 0;
+		this.styleTracker = styleTracker;
+		this._renderedScrollbackCount = 0;
+		this._scrollbackRowEls = [];
+	}
+	_resolveFirstLiveGridRow() {
+		return Array.from(this.container.children).find((child) => child instanceof HTMLElement && child.classList.contains("term-row") && !child.classList.contains("term-scrollback-row")) ?? null;
+	}
+	_insertScrollbackFragment(fragment) {
+		const firstGridRow = this._resolveFirstLiveGridRow();
+		if (firstGridRow instanceof HTMLElement) {
+			this.container.insertBefore(fragment, firstGridRow);
+			return;
+		}
+		this.container.appendChild(fragment);
+	}
+	setup(cols, rows) {
+		this.cols = cols;
+		this.rows = rows;
+		this.container.innerHTML = "";
+		this.rowEls = [];
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._renderedScrollbackCount = 0;
+		this.prevCursorVisible = false;
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+		this._lastAltScreenState = false;
+		this._restoreSnapshotCount = 0;
+		const fragment = document.createDocumentFragment();
+		for (let row = 0; row < rows; row += 1) {
+			const rowElement = document.createElement("div");
+			rowElement.className = "term-row";
+			fragment.appendChild(rowElement);
+			this.rowEls.push(rowElement);
+		}
+		this.container.appendChild(fragment);
+	}
+	_buildRowContent(rowEl, getCell, getOverride, lineLen, cursorCol, rowIndex) {
+		if (rowIndex >= 0) rowEl.className = "term-row";
+		rowEl.textContent = "";
+		let runStart = 0;
+		let runStyle = "";
+		let runText = "";
+		const flushRun = (endCol) => {
+			if (!runText) return;
+			if (cursorCol >= runStart && cursorCol < endCol) {
+				const offset = cursorCol - runStart;
+				const before = runText.slice(0, offset);
+				const cursorChar = runText[offset];
+				const after = runText.slice(offset + 1);
+				if (before) appendRun(rowEl, before, runStyle);
+				appendRun(rowEl, cursorChar, runStyle, "term-cursor");
+				if (after) appendRun(rowEl, after, runStyle);
+			} else appendRun(rowEl, runText, runStyle);
+		};
+		for (let col = 0; col < this.cols; col += 1) {
+			const cell = getCell(col);
+			const inBounds = col < lineLen;
+			const codePoint = inBounds ? cell.char : 0;
+			const override = getOverride(col);
+			if (override?.hidden === true) {
+				flushRun(col);
+				runStart = col + 1;
+				runStyle = "";
+				runText = "";
+				continue;
+			}
+			if (inBounds && isWideCodePoint(codePoint)) {
+				const consumedColumns = (col + 1 < lineLen && isWideContinuationCell(getCell(col + 1)) ? getCell(col + 1) : null) ? 2 : 1;
+				const style = buildCellStyle(cell.fg, cell.bg, cell.flags, override);
+				const cursorOnWideCell = cursorCol === col || consumedColumns === 2 && cursorCol === col + 1 || cursorCol === col + 1 && getOverride(cursorCol)?.hidden === true;
+				flushRun(col);
+				appendWideCell(rowEl, String.fromCodePoint(codePoint), style, cursorOnWideCell);
+				runStart = col + consumedColumns;
+				runStyle = "";
+				runText = "";
+				col += consumedColumns - 1;
+				continue;
+			}
+			if (inBounds && codePoint >= 9600 && codePoint <= 9631) {
+				flushRun(col);
+				const colors = resolveColors(cell.fg, cell.bg, cell.flags, override);
+				const span = document.createElement("span");
+				span.className = col === cursorCol ? "term-block term-cursor" : "term-block";
+				span.style.background = getBlockBackground(codePoint, colors.fg, colors.bg);
+				if (cell.flags & FLAG_DIM) span.style.opacity = "0.5";
+				rowEl.appendChild(span);
+				runStart = col + 1;
+				runStyle = "";
+				runText = "";
+				continue;
+			}
+			const character = inBounds && codePoint >= 32 ? String.fromCodePoint(codePoint) : " ";
+			const style = inBounds ? buildCellStyle(cell.fg, cell.bg, cell.flags, override) : "";
+			if (style !== runStyle) {
+				flushRun(col);
+				runStart = col;
+				runStyle = style;
+				runText = character;
+			} else runText += character;
+		}
+		flushRun(this.cols);
+		if (rowIndex >= 0) {
+			if (this.prevRowBg[rowIndex] !== "") {
+				rowEl.style.background = "";
+				rowEl.style.boxShadow = "";
+				this.prevRowBg[rowIndex] = "";
+			}
+			return;
+		}
+		rowEl.style.background = "";
+		rowEl.style.boxShadow = "";
+	}
+	_buildScrollbackRowEl(bridge, offset) {
+		const rowElement = document.createElement("div");
+		rowElement.className = "term-row term-scrollback-row";
+		const lineLength = bridge.getScrollbackLineLen(offset);
+		this._buildRowContent(rowElement, (col) => bridge.getScrollbackCell(offset, col), (col) => this.styleTracker.getScrollbackOverride(offset, col), lineLength, -1, -1);
+		return rowElement;
+	}
+	_captureVisibleRowSnapshot() {
+		this._altScreenMeaningfulScrollbackCount = this._scrollbackRowEls.reduce((count, rowElement) => count + (normalizeRowText(rowElement.textContent ?? "").length > 0 ? 1 : 0), 0);
+		this._altScreenVisibleRowSnapshot = this.rowEls.map((rowElement) => ({
+			element: rowElement.cloneNode(true),
+			text: normalizeRowText(rowElement.textContent ?? "")
+		}));
+	}
+	_clearAltScreenRestoreSnapshot() {
+		this._altScreenVisibleRowSnapshot = [];
+		this._altScreenMeaningfulScrollbackCount = 0;
+	}
+	_readGridRowText(bridge, row) {
+		return serializeRowText((col) => bridge.getCell(row, col), this.cols);
+	}
+	getVisibleRowTexts(bridge, { trimPadding = true } = {}) {
+		const rows = [];
+		for (let row = 0; row < this.rows; row += 1) rows.push(this._readGridRowText(bridge, row));
+		if (!trimPadding) return rows;
+		let start = 0;
+		let end = rows.length;
+		while (start < end && rows[start] === "") start += 1;
+		while (end > start && rows[end - 1] === "") end -= 1;
+		return rows.slice(start, end);
+	}
+	_readScrollbackRowText(bridge, offset) {
+		return serializeRowText((col) => bridge.getScrollbackCell(offset, col), bridge.getScrollbackLineLen(offset));
+	}
+	_readLiveTranscriptRows(bridge, currentVisibleRows) {
+		const liveRows = [];
+		for (let offset = bridge.getScrollbackCount() - 1; offset >= 0; offset -= 1) {
+			const rowText = this._readScrollbackRowText(bridge, offset);
+			if (rowText.length > 0) liveRows.push(rowText);
+		}
+		for (const rowText of currentVisibleRows) if (rowText.length > 0) liveRows.push(rowText);
+		return liveRows;
+	}
+	_liveTranscriptContainsSnapshots(bridge, snapshots, currentVisibleRows) {
+		if (snapshots.length === 0) return true;
+		return findRowSequence(this._readLiveTranscriptRows(bridge, currentVisibleRows), snapshots.map((snapshot) => snapshot.text), this._altScreenMeaningfulScrollbackCount) !== -1;
+	}
+	_getRestoredScrollbackSnapshots(bridge) {
+		if (bridge.usingAltScreen() || this._altScreenVisibleRowSnapshot.length === 0) return [];
+		const meaningfulSnapshotRows = this._altScreenVisibleRowSnapshot.filter((row) => row.text.length > 0);
+		if (meaningfulSnapshotRows.length === 0) {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		const currentVisibleRows = [];
+		for (let row = 0; row < this.rows; row += 1) currentVisibleRows.push(this._readGridRowText(bridge, row));
+		let { missingPrefixCount, overlapCount } = resolveSnapshotPrefixMatch(this._altScreenVisibleRowSnapshot, currentVisibleRows);
+		if (missingPrefixCount <= 0) if (overlapCount === 0 && this._lastAltScreenState) missingPrefixCount = meaningfulSnapshotRows.length;
+		else if (overlapCount === 0 && this._restoreSnapshotCount > 0) missingPrefixCount = Math.min(this._restoreSnapshotCount, meaningfulSnapshotRows.length);
+		else {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		const restoredSnapshots = meaningfulSnapshotRows.slice(0, missingPrefixCount);
+		if (this._liveTranscriptContainsSnapshots(bridge, restoredSnapshots, currentVisibleRows)) {
+			this._clearAltScreenRestoreSnapshot();
+			return [];
+		}
+		return restoredSnapshots;
+	}
+	_rebuildScrollback(bridge, restoredSnapshots) {
+		for (const rowElement of this._scrollbackRowEls) rowElement.remove();
+		this._scrollbackRowEls = [];
+		if (bridge.usingAltScreen()) {
+			this._renderedScrollbackCount = 0;
+			this._restoreSnapshotCount = 0;
+			return;
+		}
+		const scrollbackCount = bridge.getScrollbackCount();
+		const rowElements = [];
+		for (let offset = scrollbackCount - 1; offset >= 0; offset -= 1) rowElements.push(this._buildScrollbackRowEl(bridge, offset));
+		if (restoredSnapshots.length > 0) {
+			const restoredRowElements = restoredSnapshots.map((snapshot) => cloneSnapshotRow(snapshot));
+			const preservedRowCount = Math.max(0, rowElements.length - restoredRowElements.length);
+			rowElements.splice(preservedRowCount, rowElements.length - preservedRowCount, ...restoredRowElements);
+		}
+		const fragment = document.createDocumentFragment();
+		for (const rowElement of rowElements) fragment.appendChild(rowElement);
+		this._insertScrollbackFragment(fragment);
+		this._scrollbackRowEls = rowElements;
+		this._renderedScrollbackCount = scrollbackCount;
+		this._restoreSnapshotCount = restoredSnapshots.length;
+	}
+	syncScrollback(bridge, restoredSnapshots = []) {
+		const scrollbackCount = bridge.usingAltScreen() ? 0 : bridge.getScrollbackCount();
+		if (bridge.usingAltScreen() !== this._lastAltScreenState || restoredSnapshots.length > 0 || this._restoreSnapshotCount > 0) {
+			this._rebuildScrollback(bridge, restoredSnapshots);
+			return;
+		}
+		if (scrollbackCount === this._renderedScrollbackCount) return;
+		if (scrollbackCount > this._renderedScrollbackCount) {
+			const newCount = scrollbackCount - this._renderedScrollbackCount;
+			const fragment = document.createDocumentFragment();
+			for (let offset = newCount - 1; offset >= 0; offset -= 1) {
+				const rowElement = this._buildScrollbackRowEl(bridge, offset);
+				fragment.appendChild(rowElement);
+				this._scrollbackRowEls.push(rowElement);
+			}
+			this._insertScrollbackFragment(fragment);
+		} else {
+			const removeCount = this._renderedScrollbackCount - scrollbackCount;
+			for (let index = 0; index < removeCount; index += 1) this._scrollbackRowEls.shift()?.remove();
+		}
+		this._renderedScrollbackCount = scrollbackCount;
+	}
+	render(bridge, options = {}) {
+		const rows = bridge.getRows();
+		const cols = bridge.getCols();
+		const altScreenActive = bridge.usingAltScreen();
+		const forceRender = options.force === true;
+		let resized = false;
+		if (rows !== this.rows || cols !== this.cols) {
+			this.setup(cols, rows);
+			resized = true;
+		}
+		if (altScreenActive && !this._lastAltScreenState) this._captureVisibleRowSnapshot();
+		const restoredSnapshots = this._getRestoredScrollbackSnapshots(bridge);
+		this.syncScrollback(bridge, restoredSnapshots);
+		const cursor = bridge.getCursor();
+		const cursorVisible = cursor.visible;
+		const needsCursorUpdate = cursor.row !== this.prevCursorRow || cursor.col !== this.prevCursorCol || cursorVisible !== this.prevCursorVisible;
+		for (let row = 0; row < this.rows; row += 1) {
+			const isDirty = forceRender || resized || bridge.isDirtyRow(row);
+			const hadCursor = row === this.prevCursorRow && (needsCursorUpdate || this.prevCursorVisible);
+			const hasCursor = row === cursor.row;
+			if (isDirty || hadCursor || hasCursor && needsCursorUpdate) {
+				const cursorCol = hasCursor && cursorVisible ? cursor.col : -1;
+				this._buildRowContent(this.rowEls[row], (col) => bridge.getCell(row, col), (col) => this.styleTracker.getGridOverride(row, col), this.cols, cursorCol, row);
+			}
+		}
+		this.prevCursorRow = cursor.row;
+		this.prevCursorCol = cursor.col;
+		this.prevCursorVisible = cursorVisible;
+		if (this.prevContainerBg !== "") {
+			this.container.style.background = "";
+			this.prevContainerBg = "";
+		}
+		bridge.clearDirty();
+		this._lastAltScreenState = altScreenActive;
+	}
+};
+//#endregion
+export { BrowserTerminalRenderer };

package/dist/frontend/cell-width.d.ts

@@ -0,0 +1,5 @@
+//#region src/frontend/cell-width.d.ts
+declare function isWideCodePoint(codePoint: number): boolean;
+declare function cellWidthForCodePoint(codePoint: number): 1 | 2;
+//#endregion
+export { cellWidthForCodePoint, isWideCodePoint };

package/dist/frontend/cell-width.js

@@ -0,0 +1,9 @@
+//#region src/frontend/cell-width.ts
+function isWideCodePoint(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+function cellWidthForCodePoint(codePoint) {
+	return isWideCodePoint(codePoint) ? 2 : 1;
+}
+//#endregion
+export { cellWidthForCodePoint, isWideCodePoint };