@node-core/utils 7.1.0 → 7.2.1

package/node_modules/log-update/node_modules/wrap-ansi/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrap-ansi",
-	"version": "9.0.0",
+	"version": "10.0.1",
 	"description": "Wordwrap a string with ANSI escape codes",
 	"license": "MIT",
 	"repository": "chalk/wrap-ansi",
@@ -16,10 +16,10 @@
 		"default": "./index.js"
 	},
 	"engines": {
-		"node": ">=18"
+		"node": ">=20"
 	},
 	"scripts": {
-		"test": "xo && nyc ava && tsd"
+		"test": "xo && node --test && tsd"
 	},
 	"files": [
 		"index.js",
@@ -53,17 +53,14 @@
 		"text"
 	],
 	"dependencies": {
-		"ansi-styles": "^6.2.1",
-		"string-width": "^7.0.0",
-		"strip-ansi": "^7.1.0"
+		"ansi-styles": "^6.2.3",
+		"string-width": "^8.2.0"
 	},
 	"devDependencies": {
-		"ava": "^5.3.1",
-		"chalk": "^5.3.0",
-		"coveralls": "^3.1.1",
-		"has-ansi": "^5.0.1",
-		"nyc": "^15.1.0",
-		"tsd": "^0.29.0",
-		"xo": "^0.56.0"
+		"chalk": "^5.6.2",
+		"has-ansi": "^6.0.2",
+		"strip-ansi": "^7.1.2",
+		"tsd": "^0.33.0",
+		"xo": "^1.2.3"
 	}
 }

package/node_modules/log-update/node_modules/wrap-ansi/readme.md

@@ -36,6 +36,8 @@ A string with ANSI escape codes, like one styled by [`chalk`](https://github.com
 
 Newline characters will be normalized to `\n`.
 
+Tab characters are expanded to spaces using 8-column tab stops before wrapping.
+
 #### columns
 
 Type: `number`

package/node_modules/log-update/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "log-update",
-	"version": "6.1.0",
+	"version": "8.0.0",
 	"description": "Log by overwriting the previous output in the terminal. Useful for rendering progress bars, animations, etc.",
 	"license": "MIT",
 	"repository": "sindresorhus/log-update",
@@ -17,10 +17,10 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=18"
+		"node": ">=22"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd"
+		"test": "xo && node --test && tsd"
 	},
 	"files": [
 		"index.js",
@@ -45,23 +45,25 @@
 		"animation"
 	],
 	"dependencies": {
-		"ansi-escapes": "^7.0.0",
+		"ansi-escapes": "^7.3.0",
 		"cli-cursor": "^5.0.0",
-		"slice-ansi": "^7.1.0",
-		"strip-ansi": "^7.1.0",
-		"wrap-ansi": "^9.0.0"
+		"slice-ansi": "^9.0.0",
+		"string-width": "^8.2.0",
+		"strip-ansi": "^7.2.0",
+		"wrap-ansi": "^10.0.0"
 	},
 	"devDependencies": {
-		"@types/node": "^20.14.12",
-		"ava": "^6.1.3",
+		"@types/node": "^25.5.2",
 		"terminal.js": "^1.0.11",
-		"tsd": "^0.31.1",
+		"tsd": "^0.33.0",
 		"wcwidth": "^1.0.1",
-		"xo": "^0.59.2"
+		"xo": "^2.0.2"
 	},
 	"xo": {
 		"rules": {
-			"@typescript-eslint/no-unsafe-argument": "off"
+			"@typescript-eslint/no-unsafe-argument": "off",
+			"import-x/no-extraneous-dependencies": "off",
+			"n/no-extraneous-import": "off"
 		}
 	}
 }

package/node_modules/log-update/readme.md

@@ -5,6 +5,8 @@
 
 ![](screenshot.gif)
 
+It performs partial redraws when possible to reduce flicker.
+
 ## Install
 
 ```sh
@@ -32,6 +34,8 @@ setInterval(() => {
 }, 80);
 ```
 
+You can use [yoctocolors](https://github.com/sindresorhus/yoctocolors) or [chalk](https://github.com/chalk/chalk) to colorize the output.
+
 ## API
 
 ### logUpdate(text…)
@@ -48,12 +52,33 @@ Persist the logged output.
 
 Useful if you want to start a new log session below the current one.
 
+### logUpdate.persist(text…)
+
+Write text to the terminal that persists, similar to `console.log()`.
+
+Unlike the main `logUpdate()` method which updates in place, `persist()` writes to the terminal in a way that preserves the output in the scrollback history.
+
+```js
+import logUpdate from 'log-update';
+
+// Update in place
+logUpdate('Processing...');
+logUpdate('Still processing...');
+
+// Write permanent output
+logUpdate.persist('✓ Task complete');
+
+// Continue updating
+logUpdate('Next task...');
+```
+
 ### logUpdateStderr(text…)
 
 Log to stderr.
 
 ### logUpdateStderr.clear()
 ### logUpdateStderr.done()
+### logUpdateStderr.persist(text…)
 
 ### createLogUpdate(stream, options?)
 
@@ -79,6 +104,42 @@ const log = createLogUpdate(process.stdout, {
 });
 ```
 
+##### defaultWidth
+
+Type: `number`\
+Default: `80`
+
+The width to use when the stream doesn't provide a `columns` property.
+
+This is useful when the output is piped, redirected, or in environments where the terminal size is not available.
+
+```js
+import {createLogUpdate} from 'log-update';
+
+// Use custom width when the stream doesn't provide columns
+const log = createLogUpdate(process.stdout, {
+	defaultWidth: 120
+});
+```
+
+##### defaultHeight
+
+Type: `number`\
+Default: `24`
+
+The height to use when the stream doesn't provide a `rows` property.
+
+This is useful when the output is piped, redirected, or in environments where the terminal size is not available.
+
+```js
+import {createLogUpdate} from 'log-update';
+
+// Use custom height when the stream doesn't provide rows
+const log = createLogUpdate(process.stdout, {
+	defaultHeight: 50
+});
+```
+
 ## Examples
 
 - [listr](https://github.com/SamVerschueren/listr) - Uses this module to render an interactive task list

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

@@ -2,8 +2,8 @@
 Slice a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
 
 @param string - A string with ANSI escape codes. Like one styled by [`chalk`](https://github.com/chalk/chalk).
-@param startSlice - Zero-based index at which to start the slice.
-@param endSlice - Zero-based index at which to end the slice.
+@param startSlice - Zero-based visible-column index at which to start the slice. Grapheme clusters are kept intact.
+@param endSlice - Zero-based visible-column index at which to end the slice. If a full grapheme cluster would cross `endSlice`, it is excluded.
 
 @example
 ```

package/node_modules/slice-ansi/index.js

@@ -1,169 +1,317 @@
-import ansiStyles from 'ansi-styles';
-import isFullwidthCodePoint from 'is-fullwidth-code-point';
+import tokenizeAnsi from './tokenize-ansi.js';
 
-// \x1b and \x9b
-const ESCAPES = new Set([27, 155]);
+function applySgrFragments(activeStyles, fragments) {
+	for (const fragment of fragments) {
+		switch (fragment.type) {
+			case 'reset': {
+				activeStyles.clear();
+				break;
+			}
+
+			case 'end': {
+				activeStyles.delete(fragment.endCode);
+				break;
+			}
+
+			case 'start': {
+				activeStyles.delete(fragment.endCode);
+				activeStyles.set(fragment.endCode, fragment.code);
+				break;
+			}
+
+			default: {
+				break;
+			}
+		}
+	}
+
+	return activeStyles;
+}
+
+function undoAnsiCodes(activeStyles) {
+	return [...activeStyles.keys()].toReversed().join('');
+}
+
+function closeHyperlink(hyperlinkToken) {
+	return `${hyperlinkToken.closePrefix}${hyperlinkToken.terminator}`;
+}
 
-const CODE_POINT_0 = '0'.codePointAt(0);
-const CODE_POINT_9 = '9'.codePointAt(0);
+function shouldIncludeSgrAfterEnd(token, activeStyles) {
+	let hasStartFragment = false;
+	let hasClosingEffect = false;
 
-const MAX_ANSI_SEQUENCE_LENGTH = 19;
+	for (const fragment of token.fragments) {
+		if (fragment.type === 'start') {
+			hasStartFragment = true;
+			continue;
+		}
+
+		if (fragment.type === 'reset' && activeStyles.size > 0) {
+			hasClosingEffect = true;
+			continue;
+		}
+
+		if (fragment.type === 'end' && activeStyles.has(fragment.endCode)) {
+			hasClosingEffect = true;
+		}
+	}
+
+	return hasClosingEffect && !hasStartFragment;
+}
 
-const endCodesSet = new Set();
-const endCodesMap = new Map();
-for (const [start, end] of ansiStyles.codes) {
-	endCodesSet.add(ansiStyles.color.ansi(end));
-	endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
+function hasSgrStartFragment(token) {
+	return token.fragments.some(fragment => fragment.type === 'start');
 }
 
-function getEndCode(code) {
-	if (endCodesSet.has(code)) {
-		return code;
+function discardPendingHyperlink(parameters) {
+	if (
+		parameters.activeHyperlink
+		&& !parameters.activeHyperlinkHasVisibleText
+		&& parameters.activeHyperlinkOutputIndex !== undefined
+	) {
+		const openCodeLength = parameters.activeHyperlink.code.length;
+		parameters.returnValue = parameters.returnValue.slice(0, parameters.activeHyperlinkOutputIndex) + parameters.returnValue.slice(parameters.activeHyperlinkOutputIndex + openCodeLength);
+
+		if (
+			parameters.pendingSgrOutputIndex !== undefined
+			&& parameters.pendingSgrOutputIndex > parameters.activeHyperlinkOutputIndex
+		) {
+			parameters.pendingSgrOutputIndex -= openCodeLength;
+		}
 	}
 
-	if (endCodesMap.has(code)) {
-		return endCodesMap.get(code);
+	parameters.activeHyperlink = undefined;
+	parameters.activeHyperlinkHasVisibleText = false;
+	parameters.activeHyperlinkOutputIndex = undefined;
+}
+
+function applySgrToken(parameters) {
+	if (
+		parameters.isPastEnd
+		&& !shouldIncludeSgrAfterEnd(parameters.token, parameters.activeStyles)
+	) {
+		return parameters;
 	}
 
-	code = code.slice(2);
-	if (code.includes(';')) {
-		code = code[0] + '0';
+	if (
+		parameters.include
+		&& hasSgrStartFragment(parameters.token)
+		&& parameters.pendingSgrOutputIndex === undefined
+	) {
+		parameters.pendingSgrOutputIndex = parameters.returnValue.length;
+		parameters.pendingSgrActiveStyles = new Map(parameters.activeStyles);
 	}
 
-	const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
-	if (returnValue) {
-		return ansiStyles.color.ansi(returnValue);
+	parameters.activeStyles = applySgrFragments(parameters.activeStyles, parameters.token.fragments);
+	if (parameters.include) {
+		parameters.returnValue += parameters.token.code;
 	}
 
-	return ansiStyles.reset.open;
+	return parameters;
 }
 
-function findNumberIndex(string) {
-	for (let index = 0; index < string.length; index++) {
-		const codePoint = string.codePointAt(index);
-		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
-			return index;
+function applyHyperlinkToken(parameters) {
+	if (
+		parameters.isPastEnd
+		&& (
+			parameters.token.action !== 'close'
+			|| !parameters.activeHyperlink
+		)
+	) {
+		return parameters;
+	}
+
+	if (parameters.token.action === 'open') {
+		parameters.activeHyperlink = parameters.token;
+		parameters.activeHyperlinkHasVisibleText = false;
+		parameters.activeHyperlinkOutputIndex = undefined;
+		if (parameters.include) {
+			parameters.activeHyperlinkOutputIndex = parameters.returnValue.length;
+		}
+	} else if (parameters.token.action === 'close') {
+		if (
+			parameters.include
+			&& parameters.activeHyperlink
+			&& !parameters.activeHyperlinkHasVisibleText
+		) {
+			discardPendingHyperlink(parameters);
+			return parameters;
 		}
+
+		parameters.activeHyperlink = undefined;
+		parameters.activeHyperlinkHasVisibleText = false;
+		parameters.activeHyperlinkOutputIndex = undefined;
 	}
 
-	return -1;
-}
+	if (parameters.include) {
+		parameters.returnValue += parameters.token.code;
+	}
 
-function parseAnsiCode(string, offset) {
-	string = string.slice(offset, offset + MAX_ANSI_SEQUENCE_LENGTH);
-	const startIndex = findNumberIndex(string);
-	if (startIndex !== -1) {
-		let endIndex = string.indexOf('m', startIndex);
-		if (endIndex === -1) {
-			endIndex = string.length;
-		}
+	return parameters;
+}
 
-		return string.slice(0, endIndex + 1);
+function applyControlToken(parameters) {
+	if (!parameters.isPastEnd && parameters.include) {
+		parameters.returnValue += parameters.token.code;
 	}
+
+	return parameters;
 }
 
-function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
-	const returnValue = [];
-
-	let index = 0;
-	let visibleCount = 0;
-	while (index < string.length) {
-		const codePoint = string.codePointAt(index);
-
-		if (ESCAPES.has(codePoint)) {
-			const code = parseAnsiCode(string, index);
-			if (code) {
-				returnValue.push({
-					type: 'ansi',
-					code,
-					endCode: getEndCode(code),
-				});
-				index += code.length;
-				continue;
-			}
+function applyCharacterToken(parameters) {
+	if (
+		!parameters.include
+		&& parameters.position >= parameters.start
+		&& !parameters.token.isGraphemeContinuation
+	) {
+		parameters.include = true;
+		parameters.returnValue = [...parameters.activeStyles.values()].join('');
+		if (parameters.activeHyperlink) {
+			parameters.activeHyperlinkOutputIndex = parameters.returnValue.length;
+			parameters.returnValue += parameters.activeHyperlink.code;
 		}
+	}
 
-		const isFullWidth = isFullwidthCodePoint(codePoint);
-		const character = String.fromCodePoint(codePoint);
+	if (parameters.include) {
+		parameters.returnValue += parameters.token.value;
+		parameters.pendingSgrOutputIndex = undefined;
+		parameters.pendingSgrActiveStyles = undefined;
+		if (parameters.activeHyperlink) {
+			parameters.activeHyperlinkHasVisibleText = true;
+		}
+	}
 
-		returnValue.push({
-			type: 'character',
-			value: character,
-			isFullWidth,
-		});
+	parameters.position += parameters.token.visibleWidth;
+	return parameters;
+}
 
-		index += character.length;
-		visibleCount += isFullWidth ? 2 : character.length;
+const tokenHandlers = {
+	sgr: applySgrToken,
+	hyperlink: applyHyperlinkToken,
+	control: applyControlToken,
+	character: applyCharacterToken,
+};
 
-		if (visibleCount >= endCharacter) {
-			break;
-		}
+function applyToken(parameters) {
+	const tokenHandler = tokenHandlers[parameters.token.type];
+	if (!tokenHandler) {
+		return parameters;
 	}
 
-	return returnValue;
+	return tokenHandler(parameters);
 }
 
-function reduceAnsiCodes(codes) {
-	let returnValue = [];
-
-	for (const code of codes) {
-		if (code.code === ansiStyles.reset.open) {
-			// Reset code, disable all codes
-			returnValue = [];
-		} else if (endCodesSet.has(code.code)) {
-			// This is an end code, disable all matching start codes
-			returnValue = returnValue.filter(returnValueCode => returnValueCode.endCode !== code.code);
-		} else {
-			// This is a start code. Disable all styles this "overrides", then enable it
-			returnValue = returnValue.filter(returnValueCode => returnValueCode.endCode !== code.endCode);
-			returnValue.push(code);
+function createHasContinuationAheadMap(tokens) {
+	const hasContinuationAhead = Array.from({length: tokens.length}, () => false);
+	let nextCharacterIsContinuation = false;
+
+	for (let tokenIndex = tokens.length - 1; tokenIndex >= 0; tokenIndex--) {
+		const token = tokens[tokenIndex];
+		hasContinuationAhead[tokenIndex] = nextCharacterIsContinuation;
+		if (token.type === 'character') {
+			nextCharacterIsContinuation = Boolean(token.isGraphemeContinuation);
 		}
 	}
 
-	return returnValue;
+	return hasContinuationAhead;
 }
 
-function undoAnsiCodes(codes) {
-	const reduced = reduceAnsiCodes(codes);
-	const endCodes = reduced.map(({endCode}) => endCode);
-	return endCodes.reverse().join('');
+function isPastEndBoundary(token, position, end) {
+	if (end === undefined) {
+		return false;
+	}
+
+	if (position >= end) {
+		return true;
+	}
+
+	return token.type === 'character'
+		&& !token.isGraphemeContinuation
+		&& position + token.visibleWidth > end;
 }
 
 export default function sliceAnsi(string, start, end) {
-	const tokens = tokenize(string, end);
-	let activeCodes = [];
+	const tokens = tokenizeAnsi(string, {endCharacter: end});
+	const hasContinuationAhead = createHasContinuationAheadMap(tokens);
+	let activeStyles = new Map();
+	let activeHyperlink;
+	let activeHyperlinkHasVisibleText = false;
+	let activeHyperlinkOutputIndex;
+	let pendingSgrOutputIndex;
+	let pendingSgrActiveStyles;
 	let position = 0;
 	let returnValue = '';
 	let include = false;
 
-	for (const token of tokens) {
-		if (end !== undefined && position >= end) {
-			break;
+	for (const [tokenIndex, token] of tokens.entries()) {
+		let isPastEnd = isPastEndBoundary(token, position, end);
+		if (
+			isPastEnd
+			&& token.type !== 'character'
+			&& hasContinuationAhead[tokenIndex]
+		) {
+			isPastEnd = false;
 		}
 
-		if (token.type === 'ansi') {
-			activeCodes.push(token);
-			if (include) {
-				returnValue += token.code;
-			}
-		} else {
-			// Character
-			if (!include && position >= start) {
-				include = true;
-				// Simplify active codes
-				activeCodes = reduceAnsiCodes(activeCodes);
-				returnValue = activeCodes.map(({code}) => code).join('');
+		if (
+			isPastEnd
+			&& token.type === 'character'
+			&& !token.isGraphemeContinuation
+		) {
+			if (activeHyperlink && !activeHyperlinkHasVisibleText) {
+				const hyperlinkState = {
+					activeHyperlink,
+					activeHyperlinkHasVisibleText,
+					activeHyperlinkOutputIndex,
+					pendingSgrOutputIndex,
+					returnValue,
+				};
+				discardPendingHyperlink(hyperlinkState);
+				({
+					activeHyperlink,
+					activeHyperlinkHasVisibleText,
+					activeHyperlinkOutputIndex,
+					pendingSgrOutputIndex,
+					returnValue,
+				} = hyperlinkState);
 			}
 
-			if (include) {
-				returnValue += token.value;
+			if (pendingSgrOutputIndex !== undefined) {
+				returnValue = returnValue.slice(0, pendingSgrOutputIndex);
+				activeStyles = pendingSgrActiveStyles;
+				pendingSgrOutputIndex = undefined;
+				pendingSgrActiveStyles = undefined;
 			}
 
-			position += token.isFullWidth ? 2 : token.value.length;
+			break;
 		}
+
+		({activeStyles, activeHyperlink, activeHyperlinkHasVisibleText, activeHyperlinkOutputIndex, pendingSgrOutputIndex, pendingSgrActiveStyles, position, returnValue, include} = applyToken({
+			token,
+			isPastEnd,
+			start,
+			activeStyles,
+			activeHyperlink,
+			activeHyperlinkHasVisibleText,
+			activeHyperlinkOutputIndex,
+			pendingSgrOutputIndex,
+			pendingSgrActiveStyles,
+			position,
+			returnValue,
+			include,
+		}));
+	}
+
+	if (!include) {
+		return '';
+	}
+
+	if (activeHyperlink) {
+		returnValue += closeHyperlink(activeHyperlink);
 	}
 
 	// Disable active codes at the end
-	returnValue += undoAnsiCodes(activeCodes);
+	returnValue += undoAnsiCodes(activeStyles);
+
 	return returnValue;
 }