@vitest/utils
Advanced tools
Comparing version 1.1.3 to 1.2.0
@@ -77,2 +77,2 @@ const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS"); | ||
export { SAFE_TIMERS_SYMBOL as S, SAFE_COLORS_SYMBOL as a, getColors as b, createColors as c, getDefaultColors as g, setupColors as s }; | ||
export { SAFE_TIMERS_SYMBOL as S, SAFE_COLORS_SYMBOL as a, getDefaultColors as b, createColors as c, getColors as g, setupColors as s }; |
@@ -123,6 +123,7 @@ import { format as format$1, plugins } from 'pretty-format'; | ||
function objDisplay(obj, options = {}) { | ||
const truncateThreshold = options.truncate ?? 40; | ||
if (typeof options.truncate === "undefined") | ||
options.truncate = 40; | ||
const str = inspect(obj, options); | ||
const type = Object.prototype.toString.call(obj); | ||
if (truncateThreshold && str.length >= truncateThreshold) { | ||
if (options.truncate && str.length >= options.truncate) { | ||
if (type === "[object Function]") { | ||
@@ -129,0 +130,0 @@ const fn = obj; |
import { format, plugins } from 'pretty-format'; | ||
import * as diff$1 from 'diff-sequences'; | ||
import { b as getColors } from './chunk-colors.js'; | ||
import { g as getColors } from './chunk-colors.js'; | ||
@@ -5,0 +5,0 @@ function getType(value) { |
@@ -73,3 +73,3 @@ import { diff } from './diff.js'; | ||
function normalizeErrorMessage(message) { | ||
return message.replace(/__vite_ssr_import_\d+__\./g, ""); | ||
return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, ""); | ||
} | ||
@@ -76,0 +76,0 @@ function processError(err, diffOptions) { |
@@ -38,3 +38,3 @@ export { DeferPromise, assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js'; | ||
declare function format(...args: unknown[]): string; | ||
declare function inspect(obj: unknown, options?: LoupeOptions): any; | ||
declare function inspect(obj: unknown, options?: LoupeOptions): string; | ||
declare function objDisplay(obj: unknown, options?: LoupeOptions): string; | ||
@@ -72,17 +72,18 @@ | ||
type ColorName = keyof typeof colorsMap; | ||
interface ColorMethod { | ||
(input: unknown): string; | ||
open: string; | ||
close: string; | ||
} | ||
type ColorsMethods = { | ||
[Key in ColorName]: { | ||
(input: unknown): string; | ||
open: string; | ||
close: string; | ||
}; | ||
[Key in ColorName]: ColorMethod; | ||
}; | ||
type Colors = ColorsMethods & { | ||
type Colors$1 = ColorsMethods & { | ||
isColorSupported: boolean; | ||
reset: (input: unknown) => string; | ||
}; | ||
declare function getDefaultColors(): Colors; | ||
declare function getColors(): Colors; | ||
declare function createColors(isTTY?: boolean): Colors; | ||
declare function setupColors(colors: Colors): void; | ||
declare function getDefaultColors(): Colors$1; | ||
declare function getColors(): Colors$1; | ||
declare function createColors(isTTY?: boolean): Colors$1; | ||
declare function setupColors(colors: Colors$1): void; | ||
@@ -104,2 +105,9 @@ interface ErrorOptions { | ||
export { SAFE_COLORS_SYMBOL, SAFE_TIMERS_SYMBOL, createColors, createSimpleStackTrace, format, getColors, getDefaultColors, getSafeTimers, inspect, lineSplitRE, objDisplay, offsetToLineNumber, positionToOffset, setSafeTimers, setupColors, shuffle, stringify }; | ||
type Colors = Record<ColorName, (input: string) => string>; | ||
interface HighlightOptions { | ||
jsx?: boolean; | ||
colors?: Colors; | ||
} | ||
declare function highlight(code: string, options?: HighlightOptions): string; | ||
export { type ColorMethod, type ColorName, type Colors$1 as Colors, type ColorsMethods, SAFE_COLORS_SYMBOL, SAFE_TIMERS_SYMBOL, createColors, createSimpleStackTrace, format, getColors, getDefaultColors, getSafeTimers, highlight, inspect, lineSplitRE, objDisplay, offsetToLineNumber, positionToOffset, setSafeTimers, setupColors, shuffle, stringify }; |
export { assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js'; | ||
export { f as format, i as inspect, o as objDisplay, s as stringify } from './chunk-display.js'; | ||
import { S as SAFE_TIMERS_SYMBOL } from './chunk-colors.js'; | ||
export { a as SAFE_COLORS_SYMBOL, c as createColors, b as getColors, g as getDefaultColors, s as setupColors } from './chunk-colors.js'; | ||
import { S as SAFE_TIMERS_SYMBOL, g as getColors } from './chunk-colors.js'; | ||
export { a as SAFE_COLORS_SYMBOL, c as createColors, b as getDefaultColors, s as setupColors } from './chunk-colors.js'; | ||
import 'pretty-format'; | ||
@@ -114,2 +114,531 @@ import 'loupe'; | ||
export { SAFE_TIMERS_SYMBOL, createSimpleStackTrace, getSafeTimers, lineSplitRE, offsetToLineNumber, positionToOffset, setSafeTimers, shuffle }; | ||
function getDefaultExportFromCjs (x) { | ||
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; | ||
} | ||
// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell | ||
// License: MIT. | ||
var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace; | ||
RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu; | ||
Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y; | ||
Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu; | ||
StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y; | ||
NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y; | ||
Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y; | ||
WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu; | ||
LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y; | ||
MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y; | ||
SingleLineComment = /\/\/.*/y; | ||
JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y; | ||
JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu; | ||
JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y; | ||
JSXText = /[^<>{}]+/y; | ||
TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/; | ||
TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/; | ||
KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/; | ||
KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/; | ||
Newline = RegExp(LineTerminatorSequence.source); | ||
var jsTokens_1 = function*(input, {jsx = false} = {}) { | ||
var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack; | ||
({length} = input); | ||
lastIndex = 0; | ||
lastSignificantToken = ""; | ||
stack = [ | ||
{tag: "JS"} | ||
]; | ||
braces = []; | ||
parenNesting = 0; | ||
postfixIncDec = false; | ||
while (lastIndex < length) { | ||
mode = stack[stack.length - 1]; | ||
switch (mode.tag) { | ||
case "JS": | ||
case "JSNonExpressionParen": | ||
case "InterpolationInTemplate": | ||
case "InterpolationInJSX": | ||
if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { | ||
RegularExpressionLiteral.lastIndex = lastIndex; | ||
if (match = RegularExpressionLiteral.exec(input)) { | ||
lastIndex = RegularExpressionLiteral.lastIndex; | ||
lastSignificantToken = match[0]; | ||
postfixIncDec = true; | ||
yield ({ | ||
type: "RegularExpressionLiteral", | ||
value: match[0], | ||
closed: match[1] !== void 0 && match[1] !== "\\" | ||
}); | ||
continue; | ||
} | ||
} | ||
Punctuator.lastIndex = lastIndex; | ||
if (match = Punctuator.exec(input)) { | ||
punctuator = match[0]; | ||
nextLastIndex = Punctuator.lastIndex; | ||
nextLastSignificantToken = punctuator; | ||
switch (punctuator) { | ||
case "(": | ||
if (lastSignificantToken === "?NonExpressionParenKeyword") { | ||
stack.push({ | ||
tag: "JSNonExpressionParen", | ||
nesting: parenNesting | ||
}); | ||
} | ||
parenNesting++; | ||
postfixIncDec = false; | ||
break; | ||
case ")": | ||
parenNesting--; | ||
postfixIncDec = true; | ||
if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) { | ||
stack.pop(); | ||
nextLastSignificantToken = "?NonExpressionParenEnd"; | ||
postfixIncDec = false; | ||
} | ||
break; | ||
case "{": | ||
Punctuator.lastIndex = 0; | ||
isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken)); | ||
braces.push(isExpression); | ||
postfixIncDec = false; | ||
break; | ||
case "}": | ||
switch (mode.tag) { | ||
case "InterpolationInTemplate": | ||
if (braces.length === mode.nesting) { | ||
Template.lastIndex = lastIndex; | ||
match = Template.exec(input); | ||
lastIndex = Template.lastIndex; | ||
lastSignificantToken = match[0]; | ||
if (match[1] === "${") { | ||
lastSignificantToken = "?InterpolationInTemplate"; | ||
postfixIncDec = false; | ||
yield ({ | ||
type: "TemplateMiddle", | ||
value: match[0] | ||
}); | ||
} else { | ||
stack.pop(); | ||
postfixIncDec = true; | ||
yield ({ | ||
type: "TemplateTail", | ||
value: match[0], | ||
closed: match[1] === "`" | ||
}); | ||
} | ||
continue; | ||
} | ||
break; | ||
case "InterpolationInJSX": | ||
if (braces.length === mode.nesting) { | ||
stack.pop(); | ||
lastIndex += 1; | ||
lastSignificantToken = "}"; | ||
yield ({ | ||
type: "JSXPunctuator", | ||
value: "}" | ||
}); | ||
continue; | ||
} | ||
} | ||
postfixIncDec = braces.pop(); | ||
nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}"; | ||
break; | ||
case "]": | ||
postfixIncDec = true; | ||
break; | ||
case "++": | ||
case "--": | ||
nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec"; | ||
break; | ||
case "<": | ||
if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { | ||
stack.push({tag: "JSXTag"}); | ||
lastIndex += 1; | ||
lastSignificantToken = "<"; | ||
yield ({ | ||
type: "JSXPunctuator", | ||
value: punctuator | ||
}); | ||
continue; | ||
} | ||
postfixIncDec = false; | ||
break; | ||
default: | ||
postfixIncDec = false; | ||
} | ||
lastIndex = nextLastIndex; | ||
lastSignificantToken = nextLastSignificantToken; | ||
yield ({ | ||
type: "Punctuator", | ||
value: punctuator | ||
}); | ||
continue; | ||
} | ||
Identifier.lastIndex = lastIndex; | ||
if (match = Identifier.exec(input)) { | ||
lastIndex = Identifier.lastIndex; | ||
nextLastSignificantToken = match[0]; | ||
switch (match[0]) { | ||
case "for": | ||
case "if": | ||
case "while": | ||
case "with": | ||
if (lastSignificantToken !== "." && lastSignificantToken !== "?.") { | ||
nextLastSignificantToken = "?NonExpressionParenKeyword"; | ||
} | ||
} | ||
lastSignificantToken = nextLastSignificantToken; | ||
postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]); | ||
yield ({ | ||
type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
StringLiteral.lastIndex = lastIndex; | ||
if (match = StringLiteral.exec(input)) { | ||
lastIndex = StringLiteral.lastIndex; | ||
lastSignificantToken = match[0]; | ||
postfixIncDec = true; | ||
yield ({ | ||
type: "StringLiteral", | ||
value: match[0], | ||
closed: match[2] !== void 0 | ||
}); | ||
continue; | ||
} | ||
NumericLiteral.lastIndex = lastIndex; | ||
if (match = NumericLiteral.exec(input)) { | ||
lastIndex = NumericLiteral.lastIndex; | ||
lastSignificantToken = match[0]; | ||
postfixIncDec = true; | ||
yield ({ | ||
type: "NumericLiteral", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
Template.lastIndex = lastIndex; | ||
if (match = Template.exec(input)) { | ||
lastIndex = Template.lastIndex; | ||
lastSignificantToken = match[0]; | ||
if (match[1] === "${") { | ||
lastSignificantToken = "?InterpolationInTemplate"; | ||
stack.push({ | ||
tag: "InterpolationInTemplate", | ||
nesting: braces.length | ||
}); | ||
postfixIncDec = false; | ||
yield ({ | ||
type: "TemplateHead", | ||
value: match[0] | ||
}); | ||
} else { | ||
postfixIncDec = true; | ||
yield ({ | ||
type: "NoSubstitutionTemplate", | ||
value: match[0], | ||
closed: match[1] === "`" | ||
}); | ||
} | ||
continue; | ||
} | ||
break; | ||
case "JSXTag": | ||
case "JSXTagEnd": | ||
JSXPunctuator.lastIndex = lastIndex; | ||
if (match = JSXPunctuator.exec(input)) { | ||
lastIndex = JSXPunctuator.lastIndex; | ||
nextLastSignificantToken = match[0]; | ||
switch (match[0]) { | ||
case "<": | ||
stack.push({tag: "JSXTag"}); | ||
break; | ||
case ">": | ||
stack.pop(); | ||
if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") { | ||
nextLastSignificantToken = "?JSX"; | ||
postfixIncDec = true; | ||
} else { | ||
stack.push({tag: "JSXChildren"}); | ||
} | ||
break; | ||
case "{": | ||
stack.push({ | ||
tag: "InterpolationInJSX", | ||
nesting: braces.length | ||
}); | ||
nextLastSignificantToken = "?InterpolationInJSX"; | ||
postfixIncDec = false; | ||
break; | ||
case "/": | ||
if (lastSignificantToken === "<") { | ||
stack.pop(); | ||
if (stack[stack.length - 1].tag === "JSXChildren") { | ||
stack.pop(); | ||
} | ||
stack.push({tag: "JSXTagEnd"}); | ||
} | ||
} | ||
lastSignificantToken = nextLastSignificantToken; | ||
yield ({ | ||
type: "JSXPunctuator", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
JSXIdentifier.lastIndex = lastIndex; | ||
if (match = JSXIdentifier.exec(input)) { | ||
lastIndex = JSXIdentifier.lastIndex; | ||
lastSignificantToken = match[0]; | ||
yield ({ | ||
type: "JSXIdentifier", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
JSXString.lastIndex = lastIndex; | ||
if (match = JSXString.exec(input)) { | ||
lastIndex = JSXString.lastIndex; | ||
lastSignificantToken = match[0]; | ||
yield ({ | ||
type: "JSXString", | ||
value: match[0], | ||
closed: match[2] !== void 0 | ||
}); | ||
continue; | ||
} | ||
break; | ||
case "JSXChildren": | ||
JSXText.lastIndex = lastIndex; | ||
if (match = JSXText.exec(input)) { | ||
lastIndex = JSXText.lastIndex; | ||
lastSignificantToken = match[0]; | ||
yield ({ | ||
type: "JSXText", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
switch (input[lastIndex]) { | ||
case "<": | ||
stack.push({tag: "JSXTag"}); | ||
lastIndex++; | ||
lastSignificantToken = "<"; | ||
yield ({ | ||
type: "JSXPunctuator", | ||
value: "<" | ||
}); | ||
continue; | ||
case "{": | ||
stack.push({ | ||
tag: "InterpolationInJSX", | ||
nesting: braces.length | ||
}); | ||
lastIndex++; | ||
lastSignificantToken = "?InterpolationInJSX"; | ||
postfixIncDec = false; | ||
yield ({ | ||
type: "JSXPunctuator", | ||
value: "{" | ||
}); | ||
continue; | ||
} | ||
} | ||
WhiteSpace.lastIndex = lastIndex; | ||
if (match = WhiteSpace.exec(input)) { | ||
lastIndex = WhiteSpace.lastIndex; | ||
yield ({ | ||
type: "WhiteSpace", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
LineTerminatorSequence.lastIndex = lastIndex; | ||
if (match = LineTerminatorSequence.exec(input)) { | ||
lastIndex = LineTerminatorSequence.lastIndex; | ||
postfixIncDec = false; | ||
if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) { | ||
lastSignificantToken = "?NoLineTerminatorHere"; | ||
} | ||
yield ({ | ||
type: "LineTerminatorSequence", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
MultiLineComment.lastIndex = lastIndex; | ||
if (match = MultiLineComment.exec(input)) { | ||
lastIndex = MultiLineComment.lastIndex; | ||
if (Newline.test(match[0])) { | ||
postfixIncDec = false; | ||
if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) { | ||
lastSignificantToken = "?NoLineTerminatorHere"; | ||
} | ||
} | ||
yield ({ | ||
type: "MultiLineComment", | ||
value: match[0], | ||
closed: match[1] !== void 0 | ||
}); | ||
continue; | ||
} | ||
SingleLineComment.lastIndex = lastIndex; | ||
if (match = SingleLineComment.exec(input)) { | ||
lastIndex = SingleLineComment.lastIndex; | ||
postfixIncDec = false; | ||
yield ({ | ||
type: "SingleLineComment", | ||
value: match[0] | ||
}); | ||
continue; | ||
} | ||
firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex)); | ||
lastIndex += firstCodePoint.length; | ||
lastSignificantToken = firstCodePoint; | ||
postfixIncDec = false; | ||
yield ({ | ||
type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid", | ||
value: firstCodePoint | ||
}); | ||
} | ||
return void 0; | ||
}; | ||
var jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokens_1); | ||
// src/index.ts | ||
var reservedWords = { | ||
keyword: [ | ||
"break", | ||
"case", | ||
"catch", | ||
"continue", | ||
"debugger", | ||
"default", | ||
"do", | ||
"else", | ||
"finally", | ||
"for", | ||
"function", | ||
"if", | ||
"return", | ||
"switch", | ||
"throw", | ||
"try", | ||
"var", | ||
"const", | ||
"while", | ||
"with", | ||
"new", | ||
"this", | ||
"super", | ||
"class", | ||
"extends", | ||
"export", | ||
"import", | ||
"null", | ||
"true", | ||
"false", | ||
"in", | ||
"instanceof", | ||
"typeof", | ||
"void", | ||
"delete" | ||
], | ||
strict: [ | ||
"implements", | ||
"interface", | ||
"let", | ||
"package", | ||
"private", | ||
"protected", | ||
"public", | ||
"static", | ||
"yield" | ||
] | ||
}, keywords = new Set(reservedWords.keyword), reservedWordsStrictSet = new Set(reservedWords.strict), sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]); | ||
function isReservedWord(word) { | ||
return word === "await" || word === "enum"; | ||
} | ||
function isStrictReservedWord(word) { | ||
return isReservedWord(word) || reservedWordsStrictSet.has(word); | ||
} | ||
function isKeyword(word) { | ||
return keywords.has(word); | ||
} | ||
var BRACKET = /^[()[\]{}]$/, getTokenType = function(token) { | ||
if (token.type === "IdentifierName") { | ||
if (isKeyword(token.value) || isStrictReservedWord(token.value) || sometimesKeywords.has(token.value)) | ||
return "Keyword"; | ||
if (token.value[0] && token.value[0] !== token.value[0].toLowerCase()) | ||
return "IdentifierCapitalized"; | ||
} | ||
return token.type === "Punctuator" && BRACKET.test(token.value) ? "Bracket" : token.type === "Invalid" && (token.value === "@" || token.value === "#") ? "Punctuator" : token.type; | ||
}; | ||
function getCallableType(token) { | ||
if (token.type === "IdentifierName") | ||
return "IdentifierCallable"; | ||
if (token.type === "PrivateIdentifier") | ||
return "PrivateIdentifierCallable"; | ||
throw new Error("Not a callable token"); | ||
} | ||
var colorize = (defs, type, value) => { | ||
let colorize2 = defs[type]; | ||
return colorize2 ? colorize2(value) : value; | ||
}, highlightTokens = (defs, text, jsx) => { | ||
let highlighted = "", lastPotentialCallable = null, stackedHighlight = ""; | ||
for (let token of jsTokens(text, { jsx })) { | ||
let type = getTokenType(token); | ||
if (type === "IdentifierName" || type === "PrivateIdentifier") { | ||
lastPotentialCallable && (highlighted += colorize(defs, getTokenType(lastPotentialCallable), lastPotentialCallable.value) + stackedHighlight, stackedHighlight = ""), lastPotentialCallable = token; | ||
continue; | ||
} | ||
if (lastPotentialCallable && (token.type === "WhiteSpace" || token.type === "LineTerminatorSequence" || token.type === "Punctuator" && (token.value === "?." || token.value === "!"))) { | ||
stackedHighlight += colorize(defs, type, token.value); | ||
continue; | ||
} | ||
if (stackedHighlight && !lastPotentialCallable && (highlighted += stackedHighlight, stackedHighlight = ""), lastPotentialCallable) { | ||
let type2 = token.type === "Punctuator" && token.value === "(" ? getCallableType(lastPotentialCallable) : getTokenType(lastPotentialCallable); | ||
highlighted += colorize(defs, type2, lastPotentialCallable.value) + stackedHighlight, stackedHighlight = "", lastPotentialCallable = null; | ||
} | ||
highlighted += colorize(defs, type, token.value); | ||
} | ||
return highlighted; | ||
}; | ||
function highlight$1(code, options = { jsx: !1, colors: {} }) { | ||
return code && highlightTokens(options.colors || {}, code, options.jsx); | ||
} | ||
function getDefs(c) { | ||
const Invalid = (text) => c.white(c.bgRed(c.bold(text))); | ||
return { | ||
Keyword: c.magenta, | ||
IdentifierCapitalized: c.yellow, | ||
Punctuator: c.yellow, | ||
StringLiteral: c.green, | ||
NoSubstitutionTemplate: c.green, | ||
MultiLineComment: c.gray, | ||
SingleLineComment: c.gray, | ||
RegularExpressionLiteral: c.cyan, | ||
NumericLiteral: c.blue, | ||
TemplateHead: (text) => c.green(text.slice(0, text.length - 2)) + c.cyan(text.slice(-2)), | ||
TemplateTail: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1)), | ||
TemplateMiddle: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1, text.length - 2)) + c.cyan(text.slice(-2)), | ||
IdentifierCallable: c.blue, | ||
PrivateIdentifierCallable: (text) => `#${c.blue(text.slice(1))}`, | ||
Invalid, | ||
JSXString: c.green, | ||
JSXIdentifier: c.yellow, | ||
JSXInvalid: Invalid, | ||
JSXPunctuator: c.yellow | ||
}; | ||
} | ||
function highlight(code, options = { jsx: false }) { | ||
return highlight$1(code, { | ||
jsx: options.jsx, | ||
colors: getDefs(options.colors || getColors()) | ||
}); | ||
} | ||
export { SAFE_TIMERS_SYMBOL, createSimpleStackTrace, getColors, getSafeTimers, highlight, lineSplitRE, offsetToLineNumber, positionToOffset, setSafeTimers, shuffle }; |
@@ -36,4 +36,5 @@ type Awaitable<T> = T | PromiseLike<T>; | ||
diff?: string; | ||
codeFrame?: string; | ||
} | ||
export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack }; |
{ | ||
"name": "@vitest/utils", | ||
"type": "module", | ||
"version": "1.1.3", | ||
"version": "1.2.0", | ||
"description": "Shared Vitest utility functions", | ||
@@ -67,3 +67,4 @@ "license": "MIT", | ||
"@jridgewell/trace-mapping": "^0.3.20", | ||
"@types/estree": "^1.0.5" | ||
"@types/estree": "^1.0.5", | ||
"tinyhighlight": "^0.3.2" | ||
}, | ||
@@ -70,0 +71,0 @@ "scripts": { |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
152605
4249
3