@dungle-scrubs/tallow 0.9.4 → 0.9.7

package/node_modules/@mariozechner/pi-tui/src/utils.ts

@@ -39,6 +39,117 @@ const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
 const WIDTH_CACHE_SIZE = 512;
 const widthCache = new Map<string, number>();
 
+function isPrintableAscii(str: string): boolean {
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code < 0x20 || code > 0x7e) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function truncateFragmentToWidth(text: string, maxWidth: number): { text: string; width: number } {
+	if (maxWidth <= 0 || text.length === 0) {
+		return { text: "", width: 0 };
+	}
+
+	if (isPrintableAscii(text)) {
+		const clipped = text.slice(0, maxWidth);
+		return { text: clipped, width: clipped.length };
+	}
+
+	const hasAnsi = text.includes("\x1b");
+	const hasTabs = text.includes("\t");
+	if (!hasAnsi && !hasTabs) {
+		let result = "";
+		let width = 0;
+		for (const { segment } of segmenter.segment(text)) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) {
+				break;
+			}
+			result += segment;
+			width += w;
+		}
+		return { text: result, width };
+	}
+
+	let result = "";
+	let width = 0;
+	let i = 0;
+	let pendingAnsi = "";
+
+	while (i < text.length) {
+		const ansi = extractAnsiCode(text, i);
+		if (ansi) {
+			pendingAnsi += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+
+		if (text[i] === "\t") {
+			if (width + 3 > maxWidth) {
+				break;
+			}
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += "\t";
+			width += 3;
+			i++;
+			continue;
+		}
+
+		let end = i;
+		while (end < text.length && text[end] !== "\t") {
+			const nextAnsi = extractAnsiCode(text, end);
+			if (nextAnsi) {
+				break;
+			}
+			end++;
+		}
+
+		for (const { segment } of segmenter.segment(text.slice(i, end))) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) {
+				return { text: result, width };
+			}
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += segment;
+			width += w;
+		}
+		i = end;
+	}
+
+	return { text: result, width };
+}
+
+function finalizeTruncatedResult(
+	prefix: string,
+	prefixWidth: number,
+	ellipsis: string,
+	ellipsisWidth: number,
+	maxWidth: number,
+	pad: boolean
+): string {
+	const reset = "\x1b[0m";
+	const visibleWidth = prefixWidth + ellipsisWidth;
+	let result: string;
+
+	if (ellipsis.length > 0) {
+		result = `${prefix}${reset}${ellipsis}${reset}`;
+	} else {
+		result = `${prefix}${reset}`;
+	}
+
+	return pad ? result + " ".repeat(Math.max(0, maxWidth - visibleWidth)) : result;
+}
+
 /**
  * Calculate the terminal width of a single grapheme cluster.
  * Based on code from the string-width library, but includes a possible-emoji
@@ -62,6 +173,13 @@ function graphemeWidth(segment: string): number {
 		return 0;
 	}
 
+	// Regional indicator symbols (U+1F1E6..U+1F1FF) are often rendered as
+	// full-width emoji in terminals, even when isolated during streaming.
+	// Keep width conservative (2) to avoid terminal auto-wrap drift artifacts.
+	if (cp >= 0x1f1e6 && cp <= 0x1f1ff) {
+		return 2;
+	}
+
 	let width = eastAsianWidth(cp);
 
 	// Trailing halfwidth/fullwidth forms
@@ -86,15 +204,7 @@ export function visibleWidth(str: string): number {
 	}
 
 	// Fast path: pure ASCII printable
-	let isPureAscii = true;
-	for (let i = 0; i < str.length; i++) {
-		const code = str.charCodeAt(i);
-		if (code < 0x20 || code > 0x7e) {
-			isPureAscii = false;
-			break;
-		}
-	}
-	if (isPureAscii) {
+	if (isPrintableAscii(str)) {
 		return str.length;
 	}
 
@@ -110,22 +220,21 @@ export function visibleWidth(str: string): number {
 		clean = clean.replace(/\t/g, "   ");
 	}
 	if (clean.includes("\x1b")) {
-		// Order matters: strip OSC/APC BEFORE CSI. Unterminated OSC sequences
-		// use [^\x07\x1b]* which stops at the next ESC byte. If CSI sequences
-		// (like \x1b[39m) are stripped first, the ESC boundary disappears and
-		// the unterminated OSC consumes visible text that followed the CSI.
-		//
-		// Strip all OSC sequences: \x1b]...\x07 or \x1b]...\x1b\\
-		// Also handles unterminated OSC sequences (no BEL/ST) that run to
-		// the next ESC or end-of-string. Programs like bun test emit bare
-		// \x1b]1337;SetUserVar=... without a terminator.
-		clean = clean.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "");
-		// Strip APC sequences: \x1b_...\x07 or \x1b_...\x1b\\
-		// Also handles unterminated APC sequences.
-		clean = clean.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)?/g, "");
-		// Strip all CSI sequences: ESC [ (optional ?/!/>) params final-byte (0x40-0x7E)
-		// Covers SGR (m), cursor movement (A-H), erase (J/K), DEC private mode (?25l/h), etc.
-		clean = clean.replace(/\x1b\[[?!>]?[0-9;]*[\x40-\x7e]/g, "");
+		// Strip supported ANSI/OSC/APC escape sequences in one pass.
+		// This covers CSI styling/cursor codes, OSC hyperlinks and prompt markers,
+		// and APC sequences like CURSOR_MARKER.
+		let stripped = "";
+		let i = 0;
+		while (i < clean.length) {
+			const ansi = extractAnsiCode(clean, i);
+			if (ansi) {
+				i += ansi.length;
+				continue;
+			}
+			stripped += clean[i];
+			i++;
+		}
+		clean = stripped;
 	}
 
 	// Calculate width
@@ -154,19 +263,11 @@ export function extractAnsiCode(str: string, pos: number): { code: string; lengt
 
 	const next = str[pos + 1];
 
-	// CSI sequence: ESC [ (optional ?/!/>) digits/semicolons then final byte (0x40-0x7E)
-	// Covers SGR, cursor movement, erase, DEC private mode, etc.
+	// CSI sequence: ESC [ ... m/G/K/H/J
 	if (next === "[") {
 		let j = pos + 2;
-		// Skip optional DEC private mode prefix (?, !, >)
-		if (j < str.length && (str[j] === "?" || str[j] === "!" || str[j] === ">")) j++;
-		// Skip parameter bytes (digits and semicolons)
-		while (j < str.length && /[0-9;]/.test(str[j]!)) j++;
-		// Must end with a final byte in the 0x40-0x7E range (@ through ~)
-		const code = str.charCodeAt(j);
-		if (j < str.length && code >= 0x40 && code <= 0x7e) {
-			return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-		}
+		while (j < str.length && !/[mGKHJ]/.test(str[j]!)) j++;
+		if (j < str.length) return { code: str.substring(pos, j + 1), length: j + 1 - pos };
 		return null;
 	}
 
@@ -214,8 +315,16 @@ class AnsiCodeTracker {
 	private strikethrough = false;
 	private fgColor: string | null = null; // Stores the full code like "31" or "38;5;240"
 	private bgColor: string | null = null; // Stores the full code like "41" or "48;5;240"
+	private activeHyperlink: string | null = null; // Active OSC 8 hyperlink URL, or null
 
 	process(ansiCode: string): void {
+		// OSC 8 hyperlink: \x1b]8;;<url>\x1b\\ (open) or \x1b]8;;\x1b\\ (close)
+		if (ansiCode.startsWith("\x1b]8;")) {
+			const m = ansiCode.match(/^\x1b\]8;[^;]*;([^\x1b\x07]*)/);
+			this.activeHyperlink = m?.[1] ? m[1] : null;
+			return;
+		}
+
 		if (!ansiCode.endsWith("m")) {
 			return;
 		}
@@ -350,11 +459,13 @@ class AnsiCodeTracker {
 		this.strikethrough = false;
 		this.fgColor = null;
 		this.bgColor = null;
+		// SGR reset does not affect OSC 8 hyperlink state
 	}
 
 	/** Clear all state for reuse. */
 	clear(): void {
 		this.reset();
+		this.activeHyperlink = null;
 	}
 
 	getActiveCodes(): string {
@@ -370,8 +481,11 @@ class AnsiCodeTracker {
 		if (this.fgColor) codes.push(this.fgColor);
 		if (this.bgColor) codes.push(this.bgColor);
 
-		if (codes.length === 0) return "";
-		return `\x1b[${codes.join(";")}m`;
+		let result = codes.length > 0 ? `\x1b[${codes.join(";")}m` : "";
+		if (this.activeHyperlink) {
+			result += `\x1b]8;;${this.activeHyperlink}\x1b\\`;
+		}
+		return result;
 	}
 
 	hasActiveCodes(): boolean {
@@ -385,22 +499,26 @@ class AnsiCodeTracker {
 			this.hidden ||
 			this.strikethrough ||
 			this.fgColor !== null ||
-			this.bgColor !== null
+			this.bgColor !== null ||
+			this.activeHyperlink !== null
 		);
 	}
 
 	/**
-	 * Get reset codes for attributes that need to be turned off at line end,
-	 * specifically underline which bleeds into padding.
-	 * Returns empty string if no problematic attributes are active.
+	 * Get reset codes for attributes that need to be turned off at line end.
+	 * Underline must be closed to prevent bleeding into padding.
+	 * Active OSC 8 hyperlinks must be closed and re-opened on the next line.
+	 * Returns empty string if no attributes need closing.
 	 */
 	getLineEndReset(): string {
-		// Only underline causes visual bleeding into padding
-		// Other attributes like colors don't visually bleed to padding
+		let result = "";
 		if (this.underline) {
-			return "\x1b[24m"; // Underline off only
+			result += "\x1b[24m"; // Underline off only
 		}
-		return "";
+		if (this.activeHyperlink) {
+			result += "\x1b]8;;\x1b\\"; // Close hyperlink; re-opened at line start via getActiveCodes()
+		}
+		return result;
 	}
 }
 
@@ -705,77 +823,150 @@ export function truncateToWidth(
 	ellipsis: string = "...",
 	pad: boolean = false
 ): string {
-	const textVisibleWidth = visibleWidth(text);
+	if (maxWidth <= 0) {
+		return "";
+	}
 
-	if (textVisibleWidth <= maxWidth) {
-		return pad ? text + " ".repeat(maxWidth - textVisibleWidth) : text;
+	if (text.length === 0) {
+		return pad ? " ".repeat(maxWidth) : "";
 	}
 
 	const ellipsisWidth = visibleWidth(ellipsis);
-	const targetWidth = maxWidth - ellipsisWidth;
+	if (ellipsisWidth >= maxWidth) {
+		const textWidth = visibleWidth(text);
+		if (textWidth <= maxWidth) {
+			return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+		}
+
+		const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+		if (clippedEllipsis.width === 0) {
+			return pad ? " ".repeat(maxWidth) : "";
+		}
+		return finalizeTruncatedResult(
+			"",
+			0,
+			clippedEllipsis.text,
+			clippedEllipsis.width,
+			maxWidth,
+			pad
+		);
+	}
 
-	if (targetWidth <= 0) {
-		return ellipsis.substring(0, maxWidth);
+	if (isPrintableAscii(text)) {
+		if (text.length <= maxWidth) {
+			return pad ? text + " ".repeat(maxWidth - text.length) : text;
+		}
+		const targetWidth = maxWidth - ellipsisWidth;
+		return finalizeTruncatedResult(
+			text.slice(0, targetWidth),
+			targetWidth,
+			ellipsis,
+			ellipsisWidth,
+			maxWidth,
+			pad
+		);
 	}
 
-	// Separate ANSI codes from visible content using grapheme segmentation
-	let i = 0;
-	const segments: Array<{ type: "ansi" | "grapheme"; value: string }> = [];
+	const targetWidth = maxWidth - ellipsisWidth;
+	let result = "";
+	let pendingAnsi = "";
+	let visibleSoFar = 0;
+	let keptWidth = 0;
+	let keepContiguousPrefix = true;
+	let overflowed = false;
+	let exhaustedInput = false;
+	const hasAnsi = text.includes("\x1b");
+	const hasTabs = text.includes("\t");
+
+	if (!hasAnsi && !hasTabs) {
+		for (const { segment } of segmenter.segment(text)) {
+			const width = graphemeWidth(segment);
+			if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+				result += segment;
+				keptWidth += width;
+			} else {
+				keepContiguousPrefix = false;
+			}
+			visibleSoFar += width;
+			if (visibleSoFar > maxWidth) {
+				overflowed = true;
+				break;
+			}
+		}
+		exhaustedInput = !overflowed;
+	} else {
+		let i = 0;
+		while (i < text.length) {
+			const ansi = extractAnsiCode(text, i);
+			if (ansi) {
+				pendingAnsi += ansi.code;
+				i += ansi.length;
+				continue;
+			}
+
+			if (text[i] === "\t") {
+				if (keepContiguousPrefix && keptWidth + 3 <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += "\t";
+					keptWidth += 3;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+				visibleSoFar += 3;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+				i++;
+				continue;
+			}
 
-	while (i < text.length) {
-		const ansiResult = extractAnsiCode(text, i);
-		if (ansiResult) {
-			segments.push({ type: "ansi", value: ansiResult.code });
-			i += ansiResult.length;
-		} else {
-			// Find the next ANSI code or end of string
 			let end = i;
-			while (end < text.length) {
+			while (end < text.length && text[end] !== "\t") {
 				const nextAnsi = extractAnsiCode(text, end);
-				if (nextAnsi) break;
+				if (nextAnsi) {
+					break;
+				}
 				end++;
 			}
-			// Segment this non-ANSI portion into graphemes
-			const textPortion = text.slice(i, end);
-			for (const seg of segmenter.segment(textPortion)) {
-				segments.push({ type: "grapheme", value: seg.segment });
+
+			for (const { segment } of segmenter.segment(text.slice(i, end))) {
+				const width = graphemeWidth(segment);
+				if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += segment;
+					keptWidth += width;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+
+				visibleSoFar += width;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+			}
+			if (overflowed) {
+				break;
 			}
 			i = end;
 		}
+		exhaustedInput = i >= text.length;
 	}
 
-	// Build truncated string from segments
-	let result = "";
-	let currentWidth = 0;
-
-	for (const seg of segments) {
-		if (seg.type === "ansi") {
-			result += seg.value;
-			continue;
-		}
-
-		const grapheme = seg.value;
-		// Skip empty graphemes to avoid issues with string-width calculation
-		if (!grapheme) continue;
-
-		const graphemeWidth = visibleWidth(grapheme);
-
-		if (currentWidth + graphemeWidth > targetWidth) {
-			break;
-		}
-
-		result += grapheme;
-		currentWidth += graphemeWidth;
+	if (!overflowed && exhaustedInput) {
+		return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleSoFar)) : text;
 	}
 
-	// Reset AFTER ellipsis so it inherits the line's current ANSI state
-	// (e.g. red/green foreground on diff lines) but doesn't leak into subsequent content
-	const truncated = `${result}${ellipsis}\x1b[0m`;
-	if (pad) {
-		const truncatedWidth = visibleWidth(truncated);
-		return truncated + " ".repeat(Math.max(0, maxWidth - truncatedWidth));
-	}
-	return truncated;
+	return finalizeTruncatedResult(result, keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
 }
 
 /**
@@ -919,30 +1110,3 @@ export function extractSegments(
 
 	return { before, beforeWidth, after, afterWidth };
 }
-
-// ─── OSC 8 Hyperlinks ────────────────────────────────────────────────────────
-
-/**
- * Wrap visible text in an OSC 8 terminal hyperlink.
- * The text remains visible; clicking it opens the URL in the terminal's handler.
- *
- * @param url - Target URL (e.g. "file:///path/to/file", "https://...")
- * @param text - Visible text to display
- * @returns Text wrapped in OSC 8 escape sequences
- */
-export function hyperlink(url: string, text: string): string {
-	return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
-}
-
-/**
- * Wrap a file path in an OSC 8 hyperlink using the file:// protocol.
- * The display text is the path itself (or a custom label).
- *
- * @param filePath - Absolute file path
- * @param displayText - Optional display text (defaults to filePath)
- * @returns Path wrapped in a file:// OSC 8 hyperlink
- */
-export function fileLink(filePath: string, displayText?: string): string {
-	const url = `file://${encodeURI(filePath)}`;
-	return hyperlink(url, displayText ?? filePath);
-}

package/node_modules/@mariozechner/pi-tui/tsconfig.build.json

@@ -4,6 +4,7 @@
 		"module": "ES2022",
 		"moduleResolution": "bundler",
 		"lib": ["ES2024"],
+		"types": ["node"],
 		"declaration": true,
 		"declarationMap": true,
 		"sourceMap": true,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dungle-scrubs/tallow",
-	"version": "0.9.4",
+	"version": "0.9.7",
 	"description": "An opinionated coding agent. Built on pi.",
 	"piConfig": {
 		"name": "tallow",
@@ -73,26 +73,26 @@
 		]
 	},
 	"dependencies": {
-		"@clack/prompts": "^1.1.0",
+		"@clack/prompts": "^1.2.0",
 		"@dungle-scrubs/synapse": "0.1.8",
-		"@mariozechner/pi-coding-agent": "^0.64.0",
-		"@mariozechner/pi-tui": "^0.62.0",
-		"@opentelemetry/api": "^1.9.0",
-		"@sinclair/typebox": "0.34.48",
-		"ai": "^6.0.116",
+		"@mariozechner/pi-coding-agent": "^0.70.0",
+		"@mariozechner/pi-tui": "^0.70.0",
+		"@opentelemetry/api": "^1.9.1",
+		"@sinclair/typebox": "0.34.49",
+		"ai": "^6.0.162",
 		"commander": "^14.0.3",
-		"unpdf": "^1.4.0",
+		"unpdf": "^1.6.0",
 		"vscode-jsonrpc": "8.2.1",
 		"vscode-languageserver-protocol": "3.17.5"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.4.2",
-		"@mariozechner/pi-agent-core": "^0.64.0",
-		"@mariozechner/pi-ai": "^0.64.0",
-		"@types/node": "25.2.3",
+		"@biomejs/biome": "2.4.12",
+		"@mariozechner/pi-agent-core": "^0.70.0",
+		"@mariozechner/pi-ai": "^0.70.0",
+		"@types/node": "25.6.0",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.4.0",
-		"typescript": "^5.9.3"
+		"typescript": "^6.0.2"
 	},
 	"engines": {
 		"node": ">=22"

package/packages/tallow-tui/node_modules/@types/mime-types/README.md

@@ -9,20 +9,26 @@ Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree
 ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mime-types/index.d.ts)
 ````ts
 export function lookup(filenameOrExt: string): string | false;
+
 export function contentType(filenameOrExt: string): string | false;
+
 export function extension(typeString: string): string | false;
+
 export function charset(typeString: string): string | false;
+
 export namespace charsets {
     const lookup: typeof charset;
 }
+
 export const types: { [key: string]: string };
+
 export const extensions: { [key: string]: string[] };
 
 ````
 
 ### Additional Details
- * Last updated: Tue, 07 Nov 2023 09:09:39 GMT
+ * Last updated: Sat, 07 Jun 2025 02:15:25 GMT
  * Dependencies: none
 
 # Credits
-These definitions were written by [Gyusun Yeom](https://github.com/Perlmint).
+These definitions were written by [Gyusun Yeom](https://github.com/Perlmint), and [Sebastian Beltran](https://github.com/bjohansebas).

package/packages/tallow-tui/node_modules/@types/mime-types/index.d.ts

@@ -1,9 +1,15 @@
 export function lookup(filenameOrExt: string): string | false;
+
 export function contentType(filenameOrExt: string): string | false;
+
 export function extension(typeString: string): string | false;
+
 export function charset(typeString: string): string | false;
+
 export namespace charsets {
     const lookup: typeof charset;
 }
+
 export const types: { [key: string]: string };
+
 export const extensions: { [key: string]: string[] };

package/packages/tallow-tui/node_modules/@types/mime-types/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/mime-types",
-    "version": "2.1.4",
+    "version": "3.0.1",
     "description": "TypeScript definitions for mime-types",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mime-types",
     "license": "MIT",
@@ -9,6 +9,11 @@
             "name": "Gyusun Yeom",
             "githubUsername": "Perlmint",
             "url": "https://github.com/Perlmint"
+        },
+        {
+            "name": "Sebastian Beltran",
+            "githubUsername": "bjohansebas",
+            "url": "https://github.com/bjohansebas"
         }
     ],
     "main": "",
@@ -20,6 +25,7 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "4fc952c6b156849cee9d95c0ab6082b55a05cd04a2e69589aab53982b696da9c",
-    "typeScriptVersion": "4.5"
+    "peerDependencies": {},
+    "typesPublisherContentHash": "a40f1b8ad7a6df5e0c5217e98b92e81fb5d70013ac677ddd1dd4203cfbb7f7a3",
+    "typeScriptVersion": "5.1"
 }

package/packages/tallow-tui/node_modules/get-east-asian-width/lookup-data.js

@@ -0,0 +1,18 @@
+// Generated by scripts/build.js
+
+// prettier-ignore
+const ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+
+// prettier-ignore
+const fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+
+// prettier-ignore
+const halfwidthRanges = [8361, 8361, 65377, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65512, 65518];
+
+// prettier-ignore
+const narrowRanges = [32, 126, 162, 163, 165, 166, 172, 172, 175, 175, 10214, 10221, 10629, 10630];
+
+// prettier-ignore
+const wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+export {ambiguousRanges, fullwidthRanges, halfwidthRanges, narrowRanges, wideRanges};