slice-ansi 4.0.0 → 6.0.0

package/index.js

@@ -1,103 +1,167 @@
-'use strict';
-const isFullwidthCodePoint = require('is-fullwidth-code-point');
-const astralRegex = require('astral-regex');
-const ansiStyles = require('ansi-styles');
-
-const ESCAPES = [
-	'\u001B',
-	'\u009B'
-];
-
-const wrapAnsi = code => `${ESCAPES[0]}[${code}m`;
-
-const checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
-	let output = [];
-	ansiCodes = [...ansiCodes];
-
-	for (let ansiCode of ansiCodes) {
-		const ansiCodeOrigin = ansiCode;
-		if (ansiCode.includes(';')) {
-			ansiCode = ansiCode.split(';')[0][0] + '0';
-		}
+import ansiStyles from 'ansi-styles';
+import isFullwidthCodePoint from 'is-fullwidth-code-point';
 
-		const item = ansiStyles.codes.get(Number.parseInt(ansiCode, 10));
-		if (item) {
-			const indexEscape = ansiCodes.indexOf(item.toString());
-			if (indexEscape === -1) {
-				output.push(wrapAnsi(isEscapes ? item : ansiCodeOrigin));
-			} else {
-				ansiCodes.splice(indexEscape, 1);
-			}
-		} else if (isEscapes) {
-			output.push(wrapAnsi(0));
-			break;
-		} else {
-			output.push(wrapAnsi(ansiCodeOrigin));
+// \x1b and \x9b
+const ESCAPES = new Set([27, 155]);
+
+const CODE_POINT_0 = '0'.codePointAt(0);
+const CODE_POINT_9 = '9'.codePointAt(0);
+
+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 getEndCode(code) {
+	if (endCodesSet.has(code)) {
+		return code;
+	}
+
+	if (endCodesMap.has(code)) {
+		return endCodesMap.get(code);
+	}
+
+	code = code.slice(2);
+	if (code.includes(';')) {
+		code = code[0] + '0';
+	}
+
+	const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
+	if (returnValue) {
+		return ansiStyles.color.ansi(returnValue);
+	}
+
+	return ansiStyles.reset.open;
+}
+
+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;
 		}
 	}
 
-	if (isEscapes) {
-		output = output.filter((element, index) => output.indexOf(element) === index);
+	return -1;
+}
 
-		if (endAnsiCode !== undefined) {
-			const fistEscapeCode = wrapAnsi(ansiStyles.codes.get(Number.parseInt(endAnsiCode, 10)));
-			output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
+function parseAnsiCode(string, offset) {
+	string = string.slice(offset, offset + 19);
+	const startIndex = findNumberIndex(string);
+	if (startIndex !== -1) {
+		let endIndex = string.indexOf('m', startIndex);
+		if (endIndex === -1) {
+			endIndex = string.length;
 		}
+
+		return string.slice(0, endIndex + 1);
 	}
+}
+
+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;
+			}
+		}
 
-	return output.join('');
-};
+		const isFullWidth = isFullwidthCodePoint(codePoint);
+		const character = String.fromCodePoint(codePoint);
 
-module.exports = (string, begin, end) => {
-	const characters = [...string];
-	const ansiCodes = [];
+		returnValue.push({
+			type: 'character',
+			value: character,
+			isFullWidth,
+		});
 
-	let stringEnd = typeof end === 'number' ? end : characters.length;
-	let isInsideEscape = false;
-	let ansiCode;
-	let visible = 0;
-	let output = '';
+		index += character.length;
+		visibleCount += isFullWidth ? 2 : character.length;
 
-	for (const [index, character] of characters.entries()) {
-		let leftEscape = false;
+		if (visibleCount >= endCharacter) {
+			break;
+		}
+	}
 
-		if (ESCAPES.includes(character)) {
-			const code = /\d[^m]*/.exec(string.slice(index, index + 18));
-			ansiCode = code && code.length > 0 ? code[0] : undefined;
+	return returnValue;
+}
 
-			if (visible < stringEnd) {
-				isInsideEscape = true;
+function reduceAnsiCodes(codes) {
+	let returnValue = [];
 
-				if (ansiCode !== undefined) {
-					ansiCodes.push(ansiCode);
-				}
-			}
-		} else if (isInsideEscape && character === 'm') {
-			isInsideEscape = false;
-			leftEscape = true;
+	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);
 		}
+	}
+
+	return returnValue;
+}
 
-		if (!isInsideEscape && !leftEscape) {
-			visible++;
+function undoAnsiCodes(codes) {
+	const reduced = reduceAnsiCodes(codes);
+	const endCodes = reduced.map(({endCode}) => endCode);
+	return endCodes.reverse().join('');
+}
+
+export default function sliceAnsi(string, start, end) {
+	const tokens = tokenize(string, end);
+	let activeCodes = [];
+	let position = 0;
+	let returnValue = '';
+	let include = false;
+
+	for (const token of tokens) {
+		if (end !== undefined && position >= end) {
+			break;
 		}
 
-		if (!astralRegex({exact: true}).test(character) && isFullwidthCodePoint(character.codePointAt())) {
-			visible++;
+		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 (typeof end !== 'number') {
-				stringEnd++;
+			if (include) {
+				returnValue += token.value;
 			}
-		}
 
-		if (visible > begin && visible <= stringEnd) {
-			output += character;
-		} else if (visible === begin && !isInsideEscape && ansiCode !== undefined) {
-			output = checkAnsi(ansiCodes);
-		} else if (visible >= stringEnd) {
-			output += checkAnsi(ansiCodes, true, ansiCode);
-			break;
+			position += token.isFullWidth ? 2 : token.value.length;
 		}
 	}
 
-	return output;
-};
+	// Disable active codes at the end
+	returnValue += undoAnsiCodes(activeCodes);
+	return returnValue;
+}

package/package.json

@@ -1,12 +1,14 @@
 {
 	"name": "slice-ansi",
-	"version": "4.0.0",
+	"version": "6.0.0",
 	"description": "Slice a string with ANSI escape codes",
 	"license": "MIT",
 	"repository": "chalk/slice-ansi",
 	"funding": "https://github.com/chalk/slice-ansi?sponsor=1",
+	"type": "module",
+	"exports": "./index.js",
 	"engines": {
-		"node": ">=10"
+		"node": ">=14.16"
 	},
 	"scripts": {
 		"test": "xo && ava"
@@ -38,15 +40,14 @@
 		"text"
 	],
 	"dependencies": {
-		"ansi-styles": "^4.0.0",
-		"astral-regex": "^2.0.0",
-		"is-fullwidth-code-point": "^3.0.0"
+		"ansi-styles": "^6.2.1",
+		"is-fullwidth-code-point": "^4.0.0"
 	},
 	"devDependencies": {
-		"ava": "^2.1.0",
-		"chalk": "^3.0.0",
-		"random-item": "^3.0.0",
-		"strip-ansi": "^6.0.0",
-		"xo": "^0.26.1"
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"random-item": "^4.0.1",
+		"strip-ansi": "^7.0.1",
+		"xo": "^0.53.1"
 	}
 }

package/readme.md

@@ -1,18 +1,18 @@
-# slice-ansi [![Build Status](https://travis-ci.org/chalk/slice-ansi.svg?branch=master)](https://travis-ci.org/chalk/slice-ansi) [![XO: Linted](https://img.shields.io/badge/xo-linted-blue.svg)](https://github.com/xojs/xo)
+# slice-ansi [![XO: Linted](https://img.shields.io/badge/xo-linted-blue.svg)](https://github.com/xojs/xo)
 
 > Slice a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
 
 ## Install
 
-```
-$ npm install slice-ansi
+```sh
+npm install slice-ansi
 ```
 
 ## Usage
 
 ```js
-const chalk = require('chalk');
-const sliceAnsi = require('slice-ansi');
+import chalk from 'chalk';
+import sliceAnsi from 'slice-ansi';
 
 const string = 'The quick brown ' + chalk.red('fox jumped over ') +
 	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
@@ -22,7 +22,7 @@ console.log(sliceAnsi(string, 20, 30));
 
 ## API
 
-### sliceAnsi(string, beginSlice, endSlice?)
+### sliceAnsi(string, startSlice, endSlice?)
 
 #### string
 
@@ -30,11 +30,11 @@ Type: `string`
 
 String with ANSI escape codes. Like one styled by [`chalk`](https://github.com/chalk/chalk).
 
-#### beginSlice
+#### startSlice
 
 Type: `number`
 
-Zero-based index at which to begin the slice.
+Zero-based index at which to start the slice.
 
 #### endSlice
 
@@ -52,15 +52,3 @@ Zero-based index at which to end the slice.
 
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Josh Junon](https://github.com/qix-)
-
----
-
-<div align="center">
-	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-slice_ansi?utm_source=npm-slice-ansi&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
-	</b>
-	<br>
-	<sub>
-		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
-	</sub>
-</div>