@quantiya/codevibe-codex-plugin 2.0.5 → 2.0.7

package/node_modules/uuid/dist/v35.js

@@ -27,6 +27,9 @@ export default function v35(version, hash, value, namespace, buf, offset) {
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
     if (buf) {
         offset = offset || 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
         }

package/node_modules/uuid/dist/v6.js

@@ -7,6 +7,9 @@ function v6(options, buf, offset) {
     let bytes = v1({ ...options, _v6: true }, new Uint8Array(16));
     bytes = v1ToV6(bytes);
     if (buf) {
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; i++) {
             buf[offset + i] = bytes[i];
         }

package/node_modules/uuid/dist-node/v35.js

@@ -27,6 +27,9 @@ export default function v35(version, hash, value, namespace, buf, offset) {
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
     if (buf) {
         offset = offset || 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
         }

package/node_modules/uuid/dist-node/v6.js

@@ -7,6 +7,9 @@ function v6(options, buf, offset) {
     let bytes = v1({ ...options, _v6: true }, new Uint8Array(16));
     bytes = v1ToV6(bytes);
     if (buf) {
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; i++) {
             buf[offset + i] = bytes[i];
         }

package/node_modules/uuid/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uuid",
-  "version": "13.0.0",
+  "version": "13.0.2",
   "description": "RFC9562 UUIDs",
   "type": "module",
   "funding": [

package/node_modules/which/README.md

@@ -9,40 +9,37 @@ needed when the PATH changes.
 ## USAGE
 
 ```javascript
-var which = require('which')
+const which = require('which')
 
 // async usage
-which('node', function (er, resolvedPath) {
-  // er is returned if no "node" is found on the PATH
-  // if it is found, then the absolute path to the exec is returned
-})
+// rejects if not found
+const resolved = await which('node')
 
-// or promise
-which('node').then(resolvedPath => { ... }).catch(er => { ... not found ... })
+// if nothrow option is used, returns null if not found
+const resolvedOrNull = await which('node', { nothrow: true })
 
 // sync usage
 // throws if not found
-var resolved = which.sync('node')
+const resolved = which.sync('node')
 
 // if nothrow option is used, returns null if not found
-resolved = which.sync('node', {nothrow: true})
+const resolvedOrNull = which.sync('node', { nothrow: true })
 
 // Pass options to override the PATH and PATHEXT environment vars.
-which('node', { path: someOtherPath }, function (er, resolved) {
-  if (er)
-    throw er
-  console.log('found at %j', resolved)
-})
+await which('node', { path: someOtherPath, pathExt: somePathExt })
 ```
 
 ## CLI USAGE
 
-Same as the BSD `which(1)` binary.
+Just like the BSD `which(1)` binary but using `node-which`.
 
 ```
-usage: which [-as] program ...
+usage: node-which [-as] program ...
 ```
 
+You can learn more about why the binary is `node-which` and not `which` 
+[here](https://github.com/npm/node-which/pull/67)
+
 ## OPTIONS
 
 You may pass an options object as the second argument.

package/node_modules/which/package.json

@@ -1,43 +1,57 @@
 {
-  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "author": "GitHub Inc.",
   "name": "which",
   "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
-  "version": "2.0.2",
+  "version": "4.0.0",
   "repository": {
     "type": "git",
-    "url": "git://github.com/isaacs/node-which.git"
+    "url": "https://github.com/npm/node-which.git"
   },
-  "main": "which.js",
+  "main": "lib/index.js",
   "bin": {
-    "node-which": "./bin/node-which"
+    "node-which": "./bin/which.js"
   },
   "license": "ISC",
   "dependencies": {
-    "isexe": "^2.0.0"
+    "isexe": "^3.1.1"
   },
   "devDependencies": {
-    "mkdirp": "^0.5.0",
-    "rimraf": "^2.6.2",
-    "tap": "^14.6.9"
+    "@npmcli/eslint-config": "^4.0.0",
+    "@npmcli/template-oss": "4.18.0",
+    "tap": "^16.3.0"
   },
   "scripts": {
     "test": "tap",
-    "preversion": "npm test",
-    "postversion": "npm publish",
-    "prepublish": "npm run changelog",
-    "prechangelog": "bash gen-changelog.sh",
-    "changelog": "git add CHANGELOG.md",
-    "postchangelog": "git commit -m 'update changelog - '${npm_package_version}",
-    "postpublish": "git push origin --follow-tags"
+    "lint": "eslint \"**/*.js\"",
+    "postlint": "template-oss-check",
+    "template-oss-apply": "template-oss-apply --force",
+    "lintfix": "npm run lint -- --fix",
+    "snap": "tap",
+    "posttest": "npm run lint"
   },
   "files": [
-    "which.js",
-    "bin/node-which"
+    "bin/",
+    "lib/"
   ],
   "tap": {
-    "check-coverage": true
+    "check-coverage": true,
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
   },
   "engines": {
-    "node": ">= 8"
+    "node": "^16.13.0 || >=18.0.0"
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "ciVersions": [
+      "16.13.0",
+      "16.x",
+      "18.0.0",
+      "18.x"
+    ],
+    "version": "4.18.0",
+    "publish": "true"
   }
 }

package/node_modules/wrap-ansi/index.d.ts

@@ -24,8 +24,8 @@ export type Options = {
 /**
 Wrap words to the specified column width.
 
-@param string - String with ANSI escape codes. Like one styled by [`chalk`](https://github.com/chalk/chalk). Newline characters will be normalized to `\n`.
-@param columns - Number of columns to wrap the text to.
+@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
 ```

package/node_modules/wrap-ansi/index.js

@@ -2,33 +2,253 @@ import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
 import ansiStyles from 'ansi-styles';
 
+const ANSI_ESCAPE = '\u001B';
+const ANSI_ESCAPE_CSI = '\u009B';
 const ESCAPES = new Set([
-	'\u001B',
-	'\u009B',
+	ANSI_ESCAPE,
+	ANSI_ESCAPE_CSI,
 ]);
 
-const END_CODE = 39;
 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 wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
+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(character => stringWidth(character));
+// 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
+// ANSI escape codes do not count towards length
 const wrapWord = (rows, word, columns) => {
-	const characters = [...word];
+	const characters = getGraphemes(word);
 
 	let isInsideEscape = false;
 	let isInsideLinkEscape = false;
-	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
+	let visible = stringWidth(stripAnsi(rows.at(-1)));
 
 	for (const [index, character] of characters.entries()) {
 		const characterLength = stringWidth(character);
@@ -40,14 +260,19 @@ const wrapWord = (rows, word, columns) => {
 			visible = 0;
 		}
 
-		if (ESCAPES.has(character)) {
+		if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === '\\')) {
 			isInsideEscape = true;
-			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
+
+			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) {
+				if (
+					character === ANSI_ESCAPE_BELL
+					|| (character === '\\' && index > 0 && characters[index - 1] === ANSI_ESCAPE) // ST terminator (ESC \)
+				) {
 					isInsideEscape = false;
 					isInsideLinkEscape = false;
 				}
@@ -67,8 +292,8 @@ const wrapWord = (rows, word, columns) => {
 	}
 
 	// It's possible that the last row we copy over is only
-	// ansi escape characters, handle this edge-case
-	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
+	// ANSI escape characters, handle this edge-case
+	if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
 		rows[rows.length - 2] += rows.pop();
 	}
 };
@@ -93,29 +318,52 @@ const stringVisibleTrimSpacesRight = string => {
 	return words.slice(0, last).join(' ') + words.slice(last).join('');
 };
 
-// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
+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
+// 'hard' will never allow a string to take up more than columns characters.
 //
-// 'soft' allows long words to expand past the column length
+// '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 escapeCode;
 	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[rows.length - 1].trimStart();
+			rows[rows.length - 1] = rows.at(-1).trimStart();
 		}
 
-		let rowLength = stringWidth(rows[rows.length - 1]);
+		let rowLength = stringWidth(rows.at(-1));
 
 		if (index !== 0) {
 			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
@@ -131,8 +379,8 @@ const exec = (string, columns, options = {}) => {
 		}
 
 		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
-		if (options.hard && lengths[index] > columns) {
-			const remainingColumns = (columns - 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) {
@@ -164,40 +412,46 @@ const exec = (string, columns, options = {}) => {
 		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
 	}
 
-	const pre = [...rows.join('\n')];
+	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 (ESCAPES.has(character)) {
-			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
-			if (groups.code !== undefined) {
-				const code = Number.parseFloat(groups.code);
-				escapeCode = code === END_CODE ? undefined : code;
+		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);
+			}
 		}
 
-		const code = ansiStyles.codes.get(Number(escapeCode));
-
 		if (pre[index + 1] === '\n') {
 			if (escapeUrl) {
 				returnValue += wrapAnsiHyperlink('');
 			}
 
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(code);
-			}
+			returnValue += getClosingSgrSequence(activeStyles);
 		} else if (character === '\n') {
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(escapeCode);
-			}
+			const openingStyles = [...activeStyles];
+			applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
+			returnValue += getOpeningSgrSequence(openingStyles);
 
 			if (escapeUrl) {
 				returnValue += wrapAnsiHyperlink(escapeUrl);
 			}
 		}
+
+		preStringIndex += character.length;
 	}
 
 	return returnValue;
@@ -207,8 +461,8 @@ const exec = (string, columns, options = {}) => {
 export default function wrapAnsi(string, columns, options) {
 	return String(string)
 		.normalize()
-		.replace(/\r\n/g, '\n')
+		.replaceAll('\r\n', '\n')
 		.split('\n')
-		.map(line => exec(line, columns, options))
+		.map(line => exec(expandTabs(line), columns, options))
 		.join('\n');
 }

package/node_modules/wrap-ansi/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrap-ansi",
-	"version": "8.1.0",
+	"version": "10.0.0",
 	"description": "Wordwrap a string with ANSI escape codes",
 	"license": "MIT",
 	"repository": "chalk/wrap-ansi",
@@ -16,7 +16,7 @@
 		"default": "./index.js"
 	},
 	"engines": {
-		"node": ">=12"
+		"node": ">=20"
 	},
 	"scripts": {
 		"test": "xo && nyc ava && tsd"
@@ -53,17 +53,17 @@
 		"text"
 	],
 	"dependencies": {
-		"ansi-styles": "^6.1.0",
-		"string-width": "^5.0.1",
-		"strip-ansi": "^7.0.1"
+		"ansi-styles": "^6.2.3",
+		"string-width": "^8.2.0",
+		"strip-ansi": "^7.1.2"
 	},
 	"devDependencies": {
-		"ava": "^3.15.0",
-		"chalk": "^4.1.2",
+		"ava": "^6.4.1",
+		"chalk": "^5.6.2",
 		"coveralls": "^3.1.1",
-		"has-ansi": "^5.0.1",
-		"nyc": "^15.1.0",
-		"tsd": "^0.25.0",
-		"xo": "^0.44.0"
+		"has-ansi": "^6.0.2",
+		"nyc": "^17.1.0",
+		"tsd": "^0.33.0",
+		"xo": "^1.2.3"
 	}
 }