@cjser/wrap-ansi 10.0.0-cjser.2

package/dist-cjser/index.cjs

@@ -0,0 +1,380 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/@cjser/wrap-ansi/index.js
+var index_exports = {};
+__export(index_exports, {
+  default: () => wrapAnsi
+});
+module.exports = __toCommonJS(index_exports);
+var import_string_width = __toESM(require("@cjser/string-width"), 1);
+var import_strip_ansi = __toESM(require("@cjser/strip-ansi"), 1);
+var import_ansi_styles = __toESM(require("@cjser/ansi-styles"), 1);
+var ANSI_ESCAPE = "\x1B";
+var ANSI_ESCAPE_CSI = "\x9B";
+var ESCAPES = /* @__PURE__ */ new Set([
+  ANSI_ESCAPE,
+  ANSI_ESCAPE_CSI
+]);
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_SGR_RESET = 0;
+var ANSI_SGR_RESET_FOREGROUND = 39;
+var ANSI_SGR_RESET_BACKGROUND = 49;
+var ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+var ANSI_SGR_FOREGROUND_EXTENDED = 38;
+var ANSI_SGR_BACKGROUND_EXTENDED = 48;
+var ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+var ANSI_SGR_COLOR_MODE_256 = 5;
+var ANSI_SGR_COLOR_MODE_RGB = 2;
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
+var ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
+var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(import_ansi_styles.default.codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+var segmenter = new Intl.Segmenter();
+var getGraphemes = (string) => Array.from(segmenter.segment(string), ({ segment }) => segment);
+var TAB_SIZE = 8;
+var wrapAnsiCode = (code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var getSgrTokens = (sgrParameters) => {
+  const codes = sgrParameters.split(";").map((sgrParameter) => sgrParameter === "" ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
+  const sgrTokens = [];
+  for (let index = 0; index < codes.length; index++) {
+    const code = codes[index];
+    if (!Number.isFinite(code)) {
+      continue;
+    }
+    if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
+      if (index + 1 >= codes.length) {
+        break;
+      }
+      const mode = codes[index + 1];
+      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
+        sgrTokens.push([code, mode, codes[index + 2]]);
+        index += 2;
+        continue;
+      }
+      const red = codes[index + 2];
+      const green = codes[index + 3];
+      const blue = codes[index + 4];
+      if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue)) {
+        sgrTokens.push([code, mode, red, green, blue]);
+        index += 4;
+        continue;
+      }
+      break;
+    }
+    sgrTokens.push([code]);
+  }
+  return sgrTokens;
+};
+var removeActiveStyle = (activeStyles, family) => {
+  const activeStyleIndex = activeStyles.findIndex((activeStyle) => activeStyle.family === family);
+  if (activeStyleIndex !== -1) {
+    activeStyles.splice(activeStyleIndex, 1);
+  }
+};
+var upsertActiveStyle = (activeStyles, nextActiveStyle) => {
+  removeActiveStyle(activeStyles, nextActiveStyle.family);
+  activeStyles.push(nextActiveStyle);
+};
+var removeModifierStylesByClose = (activeStyles, closeCode) => {
+  for (let index = activeStyles.length - 1; index >= 0; index--) {
+    const activeStyle = activeStyles[index];
+    if (activeStyle.family.startsWith("modifier-") && activeStyle.close === closeCode) {
+      activeStyles.splice(index, 1);
+    }
+  }
+};
+var getColorStyle = (code, sgrToken) => {
+  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "foreground",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_FOREGROUND
+    };
+  }
+  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "background",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_BACKGROUND
+    };
+  }
+  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "underlineColor",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_UNDERLINE_COLOR
+    };
+  }
+};
+var applySgrResetCode = (code, activeStyles) => {
+  if (code === ANSI_SGR_RESET) {
+    activeStyles.length = 0;
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_FOREGROUND) {
+    removeActiveStyle(activeStyles, "foreground");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_BACKGROUND) {
+    removeActiveStyle(activeStyles, "background");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
+    removeActiveStyle(activeStyles, "underlineColor");
+    return true;
+  }
+  if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
+    removeModifierStylesByClose(activeStyles, code);
+    return true;
+  }
+  return false;
+};
+var applySgrToken = (sgrToken, activeStyles) => {
+  const [code] = sgrToken;
+  if (applySgrResetCode(code, activeStyles)) {
+    return;
+  }
+  const colorStyle = getColorStyle(code, sgrToken);
+  if (colorStyle) {
+    upsertActiveStyle(activeStyles, colorStyle);
+    return;
+  }
+  const close = import_ansi_styles.default.codes.get(code);
+  if (close !== void 0 && close !== ANSI_SGR_RESET) {
+    upsertActiveStyle(activeStyles, {
+      family: `modifier-${code}`,
+      open: sgrToken.join(";"),
+      close
+    });
+  }
+};
+var applySgrParameters = (sgrParameters, activeStyles) => {
+  for (const sgrToken of getSgrTokens(sgrParameters)) {
+    applySgrToken(sgrToken, activeStyles);
+  }
+};
+var applySgrResets = (sgrParameters, activeStyles) => {
+  for (const sgrToken of getSgrTokens(sgrParameters)) {
+    const [code] = sgrToken;
+    applySgrResetCode(code, activeStyles);
+  }
+};
+var applyLeadingSgrResets = (string, activeStyles) => {
+  let remainder = string;
+  while (remainder.length > 0) {
+    if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== "\\") {
+      const match = ANSI_ESCAPE_REGEX.exec(remainder);
+      if (!match) {
+        break;
+      }
+      if (match.groups.sgr !== void 0) {
+        applySgrResets(match.groups.sgr, activeStyles);
+      }
+      remainder = remainder.slice(match[0].length);
+      continue;
+    }
+    if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
+      const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
+      if (!match || match.groups.sgr === void 0) {
+        break;
+      }
+      applySgrResets(match.groups.sgr, activeStyles);
+      remainder = remainder.slice(match[0].length);
+      continue;
+    }
+    break;
+  }
+};
+var getClosingSgrSequence = (activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join("");
+var getOpeningSgrSequence = (activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join("");
+var wordLengths = (string) => string.split(" ").map((word) => (0, import_string_width.default)(word));
+var wrapWord = (rows, word, columns) => {
+  const characters = getGraphemes(word);
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let visible = (0, import_string_width.default)((0, import_strip_ansi.default)(rows.at(-1)));
+  for (const [index, character] of characters.entries()) {
+    const characterLength = (0, import_string_width.default)(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === "\\")) {
+      isInsideEscape = true;
+      const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
+      isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL || character === "\\" && index > 0 && characters[index - 1] === ANSI_ESCAPE) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+      continue;
+    }
+    visible += characterLength;
+    if (visible === columns && index < characters.length - 1) {
+      rows.push("");
+      visible = 0;
+    }
+  }
+  if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last > 0) {
+    if ((0, import_string_width.default)(words[last - 1]) > 0) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var expandTabs = (line) => {
+  if (!line.includes("	")) {
+    return line;
+  }
+  const segments = line.split("	");
+  let visible = 0;
+  let expandedLine = "";
+  for (const [index, segment] of segments.entries()) {
+    expandedLine += segment;
+    visible += (0, import_string_width.default)(segment);
+    if (index < segments.length - 1) {
+      const spaces = TAB_SIZE - visible % TAB_SIZE;
+      expandedLine += " ".repeat(spaces);
+      visible += spaces;
+    }
+  }
+  return expandedLine;
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeUrl;
+  const activeStyles = [];
+  const lengths = wordLengths(string);
+  let rows = [""];
+  for (const [index, word] of string.split(" ").entries()) {
+    if (options.trim !== false) {
+      rows[rows.length - 1] = rows.at(-1).trimStart();
+    }
+    let rowLength = (0, import_string_width.default)(rows.at(-1));
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength > 0 || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      continue;
+    }
+    if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        continue;
+      }
+      rows.push("");
+    }
+    if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      continue;
+    }
+    rows[rows.length - 1] += word;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  const pre = getGraphemes(preString);
+  let preStringIndex = 0;
+  for (const [index, character] of pre.entries()) {
+    returnValue += character;
+    if (character === ANSI_ESCAPE && pre[index + 1] !== "\\") {
+      const { groups } = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      } else if (groups.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    } else if (character === ANSI_ESCAPE_CSI) {
+      const { groups } = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      }
+    }
+    if (pre[index + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      returnValue += getClosingSgrSequence(activeStyles);
+    } else if (character === "\n") {
+      const openingStyles = [...activeStyles];
+      applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
+      returnValue += getOpeningSgrSequence(openingStyles);
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+    preStringIndex += character.length;
+  }
+  return returnValue;
+};
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+}

package/index.d.ts

@@ -0,0 +1,41 @@
+export type Options = {
+	/**
+	By default the wrap is soft, meaning long words may extend past the column width. Setting this to `true` will make it hard wrap at the column width.
+
+	@default false
+	*/
+	readonly hard?: boolean;
+
+	/**
+	By default, an attempt is made to split words at spaces, ensuring that they don't extend past the configured columns. If wordWrap is `false`, each column will instead be completely filled splitting words as necessary.
+
+	@default true
+	*/
+	readonly wordWrap?: boolean;
+
+	/**
+	Whitespace on all lines is removed by default. Set this option to `false` if you don't want to trim.
+
+	@default true
+	*/
+	readonly trim?: boolean;
+};
+
+/**
+Wrap words to the specified column width.
+
+@param string - A string with ANSI escape codes, like one styled by [`chalk`](https://github.com/chalk/chalk). Newline characters will be normalized to `\n`. Tab characters are expanded to spaces using 8-column tab stops before wrapping.
+@param columns - The number of columns to wrap the text to.
+
+@example
+```
+import chalk from 'chalk';
+import wrapAnsi from '@cjser/wrap-ansi';
+
+const input = 'The quick brown ' + chalk.red('fox jumped over ') +
+	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
+
+console.log(wrapAnsi(input, 20));
+```
+*/
+export default function wrapAnsi(string: string, columns: number, options?: Options): string;

package/index.js

@@ -0,0 +1,468 @@
+import stringWidth from '@cjser/string-width';
+import stripAnsi from '@cjser/strip-ansi';
+import ansiStyles from '@cjser/ansi-styles';
+
+const ANSI_ESCAPE = '\u001B';
+const ANSI_ESCAPE_CSI = '\u009B';
+const ESCAPES = new Set([
+	ANSI_ESCAPE,
+	ANSI_ESCAPE_CSI,
+]);
+
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_SGR_RESET = 0;
+const ANSI_SGR_RESET_FOREGROUND = 39;
+const ANSI_SGR_RESET_BACKGROUND = 49;
+const ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+const ANSI_SGR_FOREGROUND_EXTENDED = 38;
+const ANSI_SGR_BACKGROUND_EXTENDED = 48;
+const ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+const ANSI_SGR_COLOR_MODE_256 = 5;
+const ANSI_SGR_COLOR_MODE_RGB = 2;
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
+const ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
+const ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(ansiStyles.codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+
+const segmenter = new Intl.Segmenter();
+const getGraphemes = string => Array.from(segmenter.segment(string), ({segment}) => segment);
+const TAB_SIZE = 8;
+
+const wrapAnsiCode = code => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = url => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+
+const getSgrTokens = sgrParameters => {
+	const codes = sgrParameters.split(';').map(sgrParameter => sgrParameter === '' ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
+	const sgrTokens = [];
+
+	for (let index = 0; index < codes.length; index++) {
+		const code = codes[index];
+
+		if (!Number.isFinite(code)) {
+			continue;
+		}
+
+		if (
+			(
+				code === ANSI_SGR_FOREGROUND_EXTENDED
+				|| code === ANSI_SGR_BACKGROUND_EXTENDED
+				|| code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED
+			)
+		) {
+			if (index + 1 >= codes.length) {
+				break;
+			}
+
+			const mode = codes[index + 1];
+
+			if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
+				sgrTokens.push([code, mode, codes[index + 2]]);
+				index += 2;
+				continue;
+			}
+
+			const red = codes[index + 2];
+			const green = codes[index + 3];
+			const blue = codes[index + 4];
+			if (
+				mode === ANSI_SGR_COLOR_MODE_RGB
+				&& Number.isFinite(red)
+				&& Number.isFinite(green)
+				&& Number.isFinite(blue)
+			) {
+				sgrTokens.push([code, mode, red, green, blue]);
+				index += 4;
+				continue;
+			}
+
+			break;
+		}
+
+		sgrTokens.push([code]);
+	}
+
+	return sgrTokens;
+};
+
+const removeActiveStyle = (activeStyles, family) => {
+	const activeStyleIndex = activeStyles.findIndex(activeStyle => activeStyle.family === family);
+
+	if (activeStyleIndex !== -1) {
+		activeStyles.splice(activeStyleIndex, 1);
+	}
+};
+
+const upsertActiveStyle = (activeStyles, nextActiveStyle) => {
+	removeActiveStyle(activeStyles, nextActiveStyle.family);
+	activeStyles.push(nextActiveStyle);
+};
+
+const removeModifierStylesByClose = (activeStyles, closeCode) => {
+	for (let index = activeStyles.length - 1; index >= 0; index--) {
+		const activeStyle = activeStyles[index];
+		if (activeStyle.family.startsWith('modifier-') && activeStyle.close === closeCode) {
+			activeStyles.splice(index, 1);
+		}
+	}
+};
+
+const getColorStyle = (code, sgrToken) => {
+	if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97) || (code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1)) {
+		return {
+			family: 'foreground',
+			open: sgrToken.join(';'),
+			close: ANSI_SGR_RESET_FOREGROUND,
+		};
+	}
+
+	if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107) || (code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1)) {
+		return {
+			family: 'background',
+			open: sgrToken.join(';'),
+			close: ANSI_SGR_RESET_BACKGROUND,
+		};
+	}
+
+	if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
+		return {
+			family: 'underlineColor',
+			open: sgrToken.join(';'),
+			close: ANSI_SGR_RESET_UNDERLINE_COLOR,
+		};
+	}
+};
+
+const applySgrResetCode = (code, activeStyles) => {
+	if (code === ANSI_SGR_RESET) {
+		activeStyles.length = 0;
+		return true;
+	}
+
+	if (code === ANSI_SGR_RESET_FOREGROUND) {
+		removeActiveStyle(activeStyles, 'foreground');
+		return true;
+	}
+
+	if (code === ANSI_SGR_RESET_BACKGROUND) {
+		removeActiveStyle(activeStyles, 'background');
+		return true;
+	}
+
+	if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
+		removeActiveStyle(activeStyles, 'underlineColor');
+		return true;
+	}
+
+	if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
+		removeModifierStylesByClose(activeStyles, code);
+		return true;
+	}
+
+	return false;
+};
+
+const applySgrToken = (sgrToken, activeStyles) => {
+	const [code] = sgrToken;
+
+	if (applySgrResetCode(code, activeStyles)) {
+		return;
+	}
+
+	const colorStyle = getColorStyle(code, sgrToken);
+	if (colorStyle) {
+		upsertActiveStyle(activeStyles, colorStyle);
+		return;
+	}
+
+	const close = ansiStyles.codes.get(code);
+	if (close !== undefined && close !== ANSI_SGR_RESET) {
+		upsertActiveStyle(activeStyles, {
+			family: `modifier-${code}`,
+			open: sgrToken.join(';'),
+			close,
+		});
+	}
+};
+
+const applySgrParameters = (sgrParameters, activeStyles) => {
+	for (const sgrToken of getSgrTokens(sgrParameters)) {
+		applySgrToken(sgrToken, activeStyles);
+	}
+};
+
+const applySgrResets = (sgrParameters, activeStyles) => {
+	for (const sgrToken of getSgrTokens(sgrParameters)) {
+		const [code] = sgrToken;
+		applySgrResetCode(code, activeStyles);
+	}
+};
+
+const applyLeadingSgrResets = (string, activeStyles) => {
+	let remainder = string;
+
+	while (remainder.length > 0) {
+		if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== '\\') {
+			const match = ANSI_ESCAPE_REGEX.exec(remainder);
+			if (!match) {
+				break;
+			}
+
+			if (match.groups.sgr !== undefined) {
+				applySgrResets(match.groups.sgr, activeStyles);
+			}
+
+			remainder = remainder.slice(match[0].length);
+			continue;
+		}
+
+		if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
+			const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
+			if (!match || match.groups.sgr === undefined) {
+				break;
+			}
+
+			applySgrResets(match.groups.sgr, activeStyles);
+			remainder = remainder.slice(match[0].length);
+			continue;
+		}
+
+		break;
+	}
+};
+
+const getClosingSgrSequence = activeStyles => [...activeStyles].reverse().map(activeStyle => wrapAnsiCode(activeStyle.close)).join('');
+const getOpeningSgrSequence = activeStyles => activeStyles.map(activeStyle => wrapAnsiCode(activeStyle.open)).join('');
+
+// Calculate the length of words split on ' ', ignoring
+// the extra characters added by ANSI escape codes
+const wordLengths = string => string.split(' ').map(word => stringWidth(word));
+
+// Wrap a long word across multiple rows
+// ANSI escape codes do not count towards length
+const wrapWord = (rows, word, columns) => {
+	const characters = getGraphemes(word);
+
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let visible = stringWidth(stripAnsi(rows.at(-1)));
+
+	for (const [index, character] of characters.entries()) {
+		const characterLength = stringWidth(character);
+
+		if (visible + characterLength <= columns) {
+			rows[rows.length - 1] += character;
+		} else {
+			rows.push(character);
+			visible = 0;
+		}
+
+		if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === '\\')) {
+			isInsideEscape = true;
+
+			const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join('');
+			isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+		}
+
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (
+					character === ANSI_ESCAPE_BELL
+					|| (character === '\\' && index > 0 && characters[index - 1] === ANSI_ESCAPE) // ST terminator (ESC \)
+				) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) {
+				isInsideEscape = false;
+			}
+
+			continue;
+		}
+
+		visible += characterLength;
+
+		if (visible === columns && index < characters.length - 1) {
+			rows.push('');
+			visible = 0;
+		}
+	}
+
+	// It's possible that the last row we copy over is only
+	// ANSI escape characters, handle this edge-case
+	if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+		rows[rows.length - 2] += rows.pop();
+	}
+};
+
+// Trims spaces from a string ignoring invisible sequences
+const stringVisibleTrimSpacesRight = string => {
+	const words = string.split(' ');
+	let last = words.length;
+
+	while (last > 0) {
+		if (stringWidth(words[last - 1]) > 0) {
+			break;
+		}
+
+		last--;
+	}
+
+	if (last === words.length) {
+		return string;
+	}
+
+	return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
+
+const expandTabs = line => {
+	if (!line.includes('\t')) {
+		return line;
+	}
+
+	const segments = line.split('\t');
+	let visible = 0;
+	let expandedLine = '';
+
+	for (const [index, segment] of segments.entries()) {
+		expandedLine += segment;
+		visible += stringWidth(segment);
+
+		if (index < segments.length - 1) {
+			const spaces = TAB_SIZE - (visible % TAB_SIZE);
+			expandedLine += ' '.repeat(spaces);
+			visible += spaces;
+		}
+	}
+
+	return expandedLine;
+};
+
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode.
+//
+// 'hard' will never allow a string to take up more than columns characters.
+//
+// 'soft' allows long words to expand past the column length.
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === '') {
+		return '';
+	}
+
+	let returnValue = '';
+	let escapeUrl;
+	const activeStyles = [];
+
+	const lengths = wordLengths(string);
+	let rows = [''];
+
+	for (const [index, word] of string.split(' ').entries()) {
+		if (options.trim !== false) {
+			rows[rows.length - 1] = rows.at(-1).trimStart();
+		}
+
+		let rowLength = stringWidth(rows.at(-1));
+
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				// If we start with a new word but the current row length equals the length of the columns, add a new row
+				rows.push('');
+				rowLength = 0;
+			}
+
+			if (rowLength > 0 || options.trim === false) {
+				rows[rows.length - 1] += ' ';
+				rowLength++;
+			}
+		}
+
+		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
+		if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+			if (breaksStartingNextLine < breaksStartingThisLine) {
+				rows.push('');
+			}
+
+			wrapWord(rows, word, columns);
+			continue;
+		}
+
+		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				continue;
+			}
+
+			rows.push('');
+		}
+
+		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			continue;
+		}
+
+		rows[rows.length - 1] += word;
+	}
+
+	if (options.trim !== false) {
+		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
+	}
+
+	const preString = rows.join('\n');
+	const pre = getGraphemes(preString);
+
+	// We need to keep a separate index as `String#slice()` works on Unicode code units, while `pre` is an array of grapheme clusters.
+	let preStringIndex = 0;
+
+	for (const [index, character] of pre.entries()) {
+		returnValue += character;
+
+		if (character === ANSI_ESCAPE && pre[index + 1] !== '\\') {
+			const {groups} = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || {groups: {}};
+			if (groups.sgr !== undefined) {
+				applySgrParameters(groups.sgr, activeStyles);
+			} else if (groups.uri !== undefined) {
+				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+			}
+		} else if (character === ANSI_ESCAPE_CSI) {
+			const {groups} = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || {groups: {}};
+			if (groups.sgr !== undefined) {
+				applySgrParameters(groups.sgr, activeStyles);
+			}
+		}
+
+		if (pre[index + 1] === '\n') {
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink('');
+			}
+
+			returnValue += getClosingSgrSequence(activeStyles);
+		} else if (character === '\n') {
+			const openingStyles = [...activeStyles];
+			applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
+			returnValue += getOpeningSgrSequence(openingStyles);
+
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink(escapeUrl);
+			}
+		}
+
+		preStringIndex += character.length;
+	}
+
+	return returnValue;
+};
+
+// For each newline, invoke the method separately
+export default function wrapAnsi(string, columns, options) {
+	return String(string)
+		.normalize()
+		.replaceAll('\r\n', '\n')
+		.split('\n')
+		.map(line => exec(expandTabs(line), columns, options))
+		.join('\n');
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@cjser/wrap-ansi",
+  "version": "10.0.0-cjser.2",
+  "description": "Wordwrap a string with ANSI escape codes",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://code.moenext.com/3rdeye/cjser.git"
+  },
+  "funding": "https://github.com/chalk/wrap-ansi?sponsor=1",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "require": "./dist-cjser/index.cjs",
+    "default": "./index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "xo && nyc ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "dist-cjser"
+  ],
+  "keywords": [
+    "wrap",
+    "break",
+    "wordwrap",
+    "wordbreak",
+    "linewrap",
+    "ansi",
+    "styles",
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "tty",
+    "escape",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "dependencies": {
+    "@cjser/ansi-styles": "6.2.3-cjser.2",
+    "@cjser/string-width": "8.2.1-cjser.2",
+    "@cjser/strip-ansi": "7.2.0-cjser.2"
+  },
+  "devDependencies": {
+    "ava": "^6.4.1",
+    "chalk": "^5.6.2",
+    "coveralls": "^3.1.1",
+    "has-ansi": "^6.0.2",
+    "nyc": "^17.1.0",
+    "tsd": "^0.33.0",
+    "xo": "^1.2.3"
+  },
+  "types": "./index.d.ts",
+  "main": "./dist-cjser/index.cjs",
+  "cjser": {
+    "sourceVersion": "10.0.0",
+    "cjserVersion": 2,
+    "original": {
+      "name": "wrap-ansi",
+      "version": "10.0.0",
+      "exports": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "repository": "chalk/wrap-ansi",
+      "dependencies": {
+        "ansi-styles": "^6.2.3",
+        "string-width": "^8.2.0",
+        "strip-ansi": "^7.1.2"
+      },
+      "files": [
+        "index.js",
+        "index.d.ts"
+      ],
+      "scripts": {
+        "test": "xo && nyc ava && tsd"
+      }
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,82 @@
+# wrap-ansi
+
+> Wordwrap a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
+
+## Install
+
+```sh
+npm install wrap-ansi
+```
+
+## Usage
+
+```js
+import chalk from 'chalk';
+import wrapAnsi from 'wrap-ansi';
+
+const input = 'The quick brown ' + chalk.red('fox jumped over ') +
+	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
+
+console.log(wrapAnsi(input, 20));
+```
+
+<img width="331" src="screenshot.png">
+
+## API
+
+### wrapAnsi(string, columns, options?)
+
+Wrap words to the specified column width.
+
+#### string
+
+Type: `string`
+
+A string with ANSI escape codes, like one styled by [`chalk`](https://github.com/chalk/chalk).
+
+Newline characters will be normalized to `\n`.
+
+Tab characters are expanded to spaces using 8-column tab stops before wrapping.
+
+#### columns
+
+Type: `number`
+
+The number of columns to wrap the text to.
+
+#### options
+
+Type: `object`
+
+##### hard
+
+Type: `boolean`\
+Default: `false`
+
+By default the wrap is soft, meaning long words may extend past the column width. Setting this to `true` will make it hard wrap at the column width.
+
+##### wordWrap
+
+Type: `boolean`\
+Default: `true`
+
+By default, an attempt is made to split words at spaces, ensuring that they don't extend past the configured columns. If wordWrap is `false`, each column will instead be completely filled splitting words as necessary.
+
+##### trim
+
+Type: `boolean`\
+Default: `true`
+
+Whitespace on all lines is removed by default. Set this option to `false` if you don't want to trim.
+
+## Related
+
+- [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes
+- [cli-truncate](https://github.com/sindresorhus/cli-truncate) - Truncate a string to a specific width in the terminal
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
+- [jsesc](https://github.com/mathiasbynens/jsesc) - Generate ASCII-only output from Unicode strings. Useful for creating test fixtures.
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/chalk/wrap-ansi