New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
improve performance, alternative approach (+149% throughput and more) #38
Merged
+140
−77
Merged
Changes from all commits
Commits
Show all changes
2 commits
Select commit
Hold shift + click to select a range
File filter
Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,105 +1,164 @@ | ||
import isFullwidthCodePoint from 'is-fullwidth-code-point'; | ||
import ansiStyles from 'ansi-styles'; | ||
import isFullwidthCodePoint from 'is-fullwidth-code-point'; | ||
|
||
const astralRegex = /^[\uD800-\uDBFF][\uDC00-\uDFFF]$/; | ||
// \x1b and \x9b | ||
const ESCAPES = new Set([27, 155]); | ||
|
||
const ESCAPES = [ | ||
'\u001B', | ||
'\u009B' | ||
]; | ||
const CHAR_CODE_0 = '0'.charCodeAt(0); | ||
const CHAR_CODE_9 = '9'.charCodeAt(0); | ||
|
||
const wrapAnsi = code => `${ESCAPES[0]}[${code}m`; | ||
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)); | ||
} | ||
|
||
const checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => { | ||
let output = []; | ||
ansiCodes = [...ansiCodes]; | ||
function getEndCode(code) { | ||
if (endCodesSet.has(code)) { | ||
return code; | ||
} | ||
|
||
for (let ansiCode of ansiCodes) { | ||
const ansiCodeOrigin = ansiCode; | ||
if (ansiCode.includes(';')) { | ||
ansiCode = ansiCode.split(';')[0][0] + '0'; | ||
} | ||
if (endCodesMap.has(code)) { | ||
return endCodesMap.get(code); | ||
} | ||
|
||
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)); | ||
} | ||
code = code.slice(2); | ||
if (code.includes(';')) { | ||
code = code[0] + '0'; | ||
} | ||
|
||
if (isEscapes) { | ||
output = output.filter((element, index) => output.indexOf(element) === index); | ||
const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10)); | ||
if (returnValue) { | ||
return ansiStyles.color.ansi(returnValue); | ||
} | ||
|
||
return ansiStyles.reset.open; | ||
} | ||
|
||
if (endAnsiCode !== undefined) { | ||
const fistEscapeCode = wrapAnsi(ansiStyles.codes.get(Number.parseInt(endAnsiCode, 10))); | ||
// TODO: Remove the use of `.reduce` here. | ||
// eslint-disable-next-line unicorn/no-array-reduce | ||
output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []); | ||
function findNumberIndex(string) { | ||
for (let index = 0; index < string.length; index++) { | ||
const charCode = string.charCodeAt(index); | ||
if (charCode >= CHAR_CODE_0 && charCode <= CHAR_CODE_9) { | ||
return index; | ||
} | ||
} | ||
|
||
return output.join(''); | ||
}; | ||
return -1; | ||
} | ||
|
||
export default function sliceAnsi(string, begin, end) { | ||
const characters = [...string]; | ||
const ansiCodes = []; | ||
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; | ||
} | ||
|
||
let stringEnd = typeof end === 'number' ? end : characters.length; | ||
let isInsideEscape = false; | ||
let ansiCode; | ||
let visible = 0; | ||
let output = ''; | ||
return string.slice(0, endIndex + 1); | ||
} | ||
} | ||
|
||
for (const [index, character] of characters.entries()) { | ||
let leftEscape = false; | ||
function tokenize(string, endChar = 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; | ||
} | ||
} | ||
|
||
if (ESCAPES.includes(character)) { | ||
const code = /\d[^m]*/.exec(string.slice(index, index + 18)); | ||
ansiCode = code && code.length > 0 ? code[0] : undefined; | ||
const isFullWidth = isFullwidthCodePoint(codePoint); | ||
const character = String.fromCodePoint(codePoint); | ||
|
||
returnValue.push({ | ||
type: 'character', | ||
value: character, | ||
isFullWidth | ||
}); | ||
index += character.length; | ||
visibleCount += isFullWidth ? 2 : character.length; | ||
if (visibleCount >= endChar) { | ||
break; | ||
} | ||
} | ||
|
||
if (visible < stringEnd) { | ||
isInsideEscape = true; | ||
return returnValue; | ||
} | ||
|
||
if (ansiCode !== undefined) { | ||
ansiCodes.push(ansiCode); | ||
} | ||
} | ||
} else if (isInsideEscape && character === 'm') { | ||
isInsideEscape = false; | ||
leftEscape = true; | ||
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); | ||
} | ||
} | ||
|
||
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, begin, 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.test(character) && isFullwidthCodePoint(character.codePointAt())) { | ||
visible++; | ||
if (token.type === 'ansi') { | ||
activeCodes.push(token); | ||
if (include) { | ||
returnValue += token.code; | ||
} | ||
} else { | ||
// Char | ||
if (!include && position >= begin) { | ||
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; | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
|
@@ -83,22 +83,26 @@ test('weird null issue', t => { | |
}); | ||
|
||
test('support true color escape sequences', t => { | ||
t.is(sliceAnsi('\u001B[1m\u001B[48;2;255;255;255m\u001B[38;2;255;0;0municorn\u001B[39m\u001B[49m\u001B[22m', 0, 3), '\u001B[1m\u001B[48;2;255;255;255m\u001B[38;2;255;0;0muni\u001B[22m\u001B[49m\u001B[39m'); | ||
t.is(sliceAnsi('\u001B[1m\u001B[48;2;255;255;255m\u001B[38;2;255;0;0municorn\u001B[39m\u001B[49m\u001B[22m', 0, 3), '\u001B[1m\u001B[48;2;255;255;255m\u001B[38;2;255;0;0muni\u001B[39m\u001B[49m\u001B[22m'); | ||
}); | ||
|
||
// See https://github.com/chalk/slice-ansi/issues/24 | ||
test('doesn\'t add extra escapes', t => { | ||
const output = `${chalk.black.bgYellow(' RUNS ')} ${chalk.green('test')}`; | ||
t.is(sliceAnsi(output, 0, 7), `${chalk.black.bgYellow(' RUNS ')} `); | ||
t.is(sliceAnsi(output, 0, 8), `${chalk.black.bgYellow(' RUNS ')} `); | ||
t.is(JSON.stringify(sliceAnsi('\u001B[31m' + output, 0, 4)), JSON.stringify(`\u001B[31m${chalk.black.bgYellow(' RUN')}`)); | ||
t.is(JSON.stringify(sliceAnsi('\u001B[31m' + output, 0, 4)), JSON.stringify(chalk.black.bgYellow(' RUN'))); | ||
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. The ANSI code for yellow is unnecessary in the output, because it immediately gets overwritten with black |
||
}); | ||
|
||
// See https://github.com/chalk/slice-ansi/issues/26 | ||
test('does not lose fullwidth characters', t => { | ||
t.is(sliceAnsi('古古test', 0), '古古test'); | ||
}); | ||
|
||
test('can create empty slices', t => { | ||
t.is(sliceAnsi('test', 0, 0), ''); | ||
}); | ||
|
||
test.failing('slice links', t => { | ||
const link = '\u001B]8;;https://google.com\u0007Google\u001B]8;;\u0007'; | ||
t.is(sliceAnsi(link, 0, 6), link); | ||
|
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
after this change, the start codes get undone in the same order as in the input string.