787 lines
24 KiB
JavaScript
787 lines
24 KiB
JavaScript
|
const matchers = [
|
||
|
|
[/^(<!--)(.+)(-->)$/, false],
|
||
|
|
[/^(\/\*)(.+)(\*\/)$/, false],
|
||
|
|
[/^(\/\/|["'#]|;{1,2}|%{1,2}|--)(.*)$/, true],
|
||
|
|
/**
|
||
|
|
* for multi-line comments like this
|
||
|
|
*/
|
||
|
|
[/^(\*)(.+)$/, true]
|
||
|
|
];
|
||
|
|
function parseComments(lines, jsx, matchAlgorithm) {
|
||
|
|
const out = [];
|
||
|
|
for (const line of lines) {
|
||
|
|
if (matchAlgorithm === "v3") {
|
||
|
|
const splittedElements = line.children.flatMap((element, idx) => {
|
||
|
|
if (element.type !== "element")
|
||
|
|
return element;
|
||
|
|
const token = element.children[0];
|
||
|
|
if (token.type !== "text")
|
||
|
|
return element;
|
||
|
|
const isLast = idx === line.children.length - 1;
|
||
|
|
const isComment = matchToken(token.value, isLast);
|
||
|
|
if (!isComment)
|
||
|
|
return element;
|
||
|
|
const rawSplits = token.value.split(/(\s+\/\/)/);
|
||
|
|
if (rawSplits.length <= 1)
|
||
|
|
return element;
|
||
|
|
let splits = [rawSplits[0]];
|
||
|
|
for (let i = 1; i < rawSplits.length; i += 2) {
|
||
|
|
splits.push(rawSplits[i] + (rawSplits[i + 1] || ""));
|
||
|
|
}
|
||
|
|
splits = splits.filter(Boolean);
|
||
|
|
if (splits.length <= 1)
|
||
|
|
return element;
|
||
|
|
return splits.map((split) => {
|
||
|
|
return {
|
||
|
|
...element,
|
||
|
|
children: [
|
||
|
|
{
|
||
|
|
type: "text",
|
||
|
|
value: split
|
||
|
|
}
|
||
|
|
]
|
||
|
|
};
|
||
|
|
});
|
||
|
|
});
|
||
|
|
if (splittedElements.length !== line.children.length)
|
||
|
|
line.children = splittedElements;
|
||
|
|
}
|
||
|
|
const elements = line.children;
|
||
|
|
let start = elements.length - 1;
|
||
|
|
if (matchAlgorithm === "v1")
|
||
|
|
start = 0;
|
||
|
|
else if (jsx)
|
||
|
|
start = elements.length - 2;
|
||
|
|
for (let i = Math.max(start, 0); i < elements.length; i++) {
|
||
|
|
const token = elements[i];
|
||
|
|
if (token.type !== "element")
|
||
|
|
continue;
|
||
|
|
const head = token.children.at(0);
|
||
|
|
if (head?.type !== "text")
|
||
|
|
continue;
|
||
|
|
const isLast = i === elements.length - 1;
|
||
|
|
let match = matchToken(head.value, isLast);
|
||
|
|
let additionalTokens;
|
||
|
|
if (!match && i > 0 && head.value.trim().startsWith("[!code")) {
|
||
|
|
const prevToken = elements[i - 1];
|
||
|
|
if (prevToken?.type === "element") {
|
||
|
|
const prevHead = prevToken.children.at(0);
|
||
|
|
if (prevHead?.type === "text" && prevHead.value.includes("//")) {
|
||
|
|
const combinedValue = prevHead.value + head.value;
|
||
|
|
const combinedMatch = matchToken(combinedValue, isLast);
|
||
|
|
if (combinedMatch) {
|
||
|
|
match = combinedMatch;
|
||
|
|
out.push({
|
||
|
|
info: combinedMatch,
|
||
|
|
line,
|
||
|
|
token: prevToken,
|
||
|
|
// Use the previous token as the main token
|
||
|
|
isLineCommentOnly: elements.length === 2 && prevToken.children.length === 1 && token.children.length === 1,
|
||
|
|
isJsxStyle: false,
|
||
|
|
additionalTokens: [token]
|
||
|
|
// Current token is the additional one
|
||
|
|
});
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!match)
|
||
|
|
continue;
|
||
|
|
if (jsx && !isLast && i !== 0) {
|
||
|
|
const isJsxStyle = isValue(elements[i - 1], "{") && isValue(elements[i + 1], "}");
|
||
|
|
out.push({
|
||
|
|
info: match,
|
||
|
|
line,
|
||
|
|
token,
|
||
|
|
isLineCommentOnly: elements.length === 3 && token.children.length === 1,
|
||
|
|
isJsxStyle,
|
||
|
|
additionalTokens
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
out.push({
|
||
|
|
info: match,
|
||
|
|
line,
|
||
|
|
token,
|
||
|
|
isLineCommentOnly: elements.length === 1 && token.children.length === 1,
|
||
|
|
isJsxStyle: false,
|
||
|
|
additionalTokens
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
function isValue(element, value) {
|
||
|
|
if (element.type !== "element")
|
||
|
|
return false;
|
||
|
|
const text = element.children[0];
|
||
|
|
if (text.type !== "text")
|
||
|
|
return false;
|
||
|
|
return text.value.trim() === value;
|
||
|
|
}
|
||
|
|
function matchToken(text, isLast) {
|
||
|
|
let trimmed = text.trimStart();
|
||
|
|
const spaceFront = text.length - trimmed.length;
|
||
|
|
trimmed = trimmed.trimEnd();
|
||
|
|
const spaceEnd = text.length - trimmed.length - spaceFront;
|
||
|
|
for (const [matcher, endOfLine] of matchers) {
|
||
|
|
if (endOfLine && !isLast)
|
||
|
|
continue;
|
||
|
|
const result = matcher.exec(trimmed);
|
||
|
|
if (!result)
|
||
|
|
continue;
|
||
|
|
return [
|
||
|
|
" ".repeat(spaceFront) + result[1],
|
||
|
|
result[2],
|
||
|
|
result[3] ? result[3] + " ".repeat(spaceEnd) : void 0
|
||
|
|
];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function v1ClearEndCommentPrefix(text) {
|
||
|
|
const match = text.match(/(?:\/\/|["'#]|;{1,2}|%{1,2}|--)(\s*)$/);
|
||
|
|
if (match && match[1].trim().length === 0) {
|
||
|
|
return text.slice(0, match.index);
|
||
|
|
}
|
||
|
|
return text;
|
||
|
|
}
|
||
|
|
|
||
|
|
function createCommentNotationTransformer(name, regex, onMatch, matchAlgorithm) {
|
||
|
|
if (matchAlgorithm == null) {
|
||
|
|
matchAlgorithm = "v3";
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
name,
|
||
|
|
code(code) {
|
||
|
|
const lines = code.children.filter((i) => i.type === "element");
|
||
|
|
const linesToRemove = [];
|
||
|
|
code.data ??= {};
|
||
|
|
const data = code.data;
|
||
|
|
data._shiki_notation ??= parseComments(lines, ["jsx", "tsx"].includes(this.options.lang), matchAlgorithm);
|
||
|
|
const parsed = data._shiki_notation;
|
||
|
|
for (const comment of parsed) {
|
||
|
|
if (comment.info[1].length === 0)
|
||
|
|
continue;
|
||
|
|
let lineIdx = lines.indexOf(comment.line);
|
||
|
|
if (comment.isLineCommentOnly && matchAlgorithm !== "v1")
|
||
|
|
lineIdx++;
|
||
|
|
let replaced = false;
|
||
|
|
comment.info[1] = comment.info[1].replace(regex, (...match) => {
|
||
|
|
if (onMatch.call(this, match, comment.line, comment.token, lines, lineIdx)) {
|
||
|
|
replaced = true;
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
return match[0];
|
||
|
|
});
|
||
|
|
if (!replaced)
|
||
|
|
continue;
|
||
|
|
if (matchAlgorithm === "v1")
|
||
|
|
comment.info[1] = v1ClearEndCommentPrefix(comment.info[1]);
|
||
|
|
const isEmpty = comment.info[1].trim().length === 0;
|
||
|
|
if (isEmpty)
|
||
|
|
comment.info[1] = "";
|
||
|
|
if (isEmpty && comment.isLineCommentOnly) {
|
||
|
|
linesToRemove.push(comment.line);
|
||
|
|
} else if (isEmpty && comment.isJsxStyle) {
|
||
|
|
comment.line.children.splice(comment.line.children.indexOf(comment.token) - 1, 3);
|
||
|
|
} else if (isEmpty) {
|
||
|
|
if (comment.additionalTokens) {
|
||
|
|
for (let j = comment.additionalTokens.length - 1; j >= 0; j--) {
|
||
|
|
const additionalToken = comment.additionalTokens[j];
|
||
|
|
const tokenIndex = comment.line.children.indexOf(additionalToken);
|
||
|
|
if (tokenIndex !== -1) {
|
||
|
|
comment.line.children.splice(tokenIndex, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
comment.line.children.splice(comment.line.children.indexOf(comment.token), 1);
|
||
|
|
} else {
|
||
|
|
const head = comment.token.children[0];
|
||
|
|
if (head.type === "text") {
|
||
|
|
head.value = comment.info.join("");
|
||
|
|
if (comment.additionalTokens) {
|
||
|
|
for (const additionalToken of comment.additionalTokens) {
|
||
|
|
const additionalHead = additionalToken.children[0];
|
||
|
|
if (additionalHead?.type === "text") {
|
||
|
|
additionalHead.value = "";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (const line of linesToRemove) {
|
||
|
|
const index = code.children.indexOf(line);
|
||
|
|
const nextLine = code.children[index + 1];
|
||
|
|
let removeLength = 1;
|
||
|
|
if (nextLine?.type === "text" && nextLine?.value === "\n")
|
||
|
|
removeLength = 2;
|
||
|
|
code.children.splice(index, removeLength);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerCompactLineOptions(lineOptions = []) {
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:compact-line-options",
|
||
|
|
line(node, line) {
|
||
|
|
const lineOption = lineOptions.find((o) => o.line === line);
|
||
|
|
if (lineOption?.classes)
|
||
|
|
this.addClassToHast(node, lineOption.classes);
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function parseMetaHighlightString(meta) {
|
||
|
|
if (!meta)
|
||
|
|
return null;
|
||
|
|
const match = meta.match(/\{([\d,-]+)\}/);
|
||
|
|
if (!match)
|
||
|
|
return null;
|
||
|
|
const lines = match[1].split(",").flatMap((v) => {
|
||
|
|
const num = v.split("-").map((v2) => Number.parseInt(v2, 10));
|
||
|
|
if (num.length === 1)
|
||
|
|
return [num[0]];
|
||
|
|
return Array.from({ length: num[1] - num[0] + 1 }, (_, i) => i + num[0]);
|
||
|
|
});
|
||
|
|
return lines;
|
||
|
|
}
|
||
|
|
const symbol = Symbol("highlighted-lines");
|
||
|
|
function transformerMetaHighlight(options = {}) {
|
||
|
|
const {
|
||
|
|
className = "highlighted"
|
||
|
|
} = options;
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:meta-highlight",
|
||
|
|
line(node, line) {
|
||
|
|
if (!this.options.meta?.__raw) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const meta = this.meta;
|
||
|
|
meta[symbol] ??= parseMetaHighlightString(this.options.meta.__raw);
|
||
|
|
const lines = meta[symbol] ?? [];
|
||
|
|
if (lines.includes(line))
|
||
|
|
this.addClassToHast(node, className);
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function parseMetaHighlightWords(meta) {
|
||
|
|
if (!meta)
|
||
|
|
return [];
|
||
|
|
const match = Array.from(meta.matchAll(/\/((?:\\.|[^/])+)\//g));
|
||
|
|
return match.map((v) => v[1].replace(/\\(.)/g, "$1"));
|
||
|
|
}
|
||
|
|
function transformerMetaWordHighlight(options = {}) {
|
||
|
|
const {
|
||
|
|
className = "highlighted-word"
|
||
|
|
} = options;
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:meta-word-highlight",
|
||
|
|
preprocess(code, options2) {
|
||
|
|
if (!this.options.meta?.__raw)
|
||
|
|
return;
|
||
|
|
const words = parseMetaHighlightWords(this.options.meta.__raw);
|
||
|
|
options2.decorations ||= [];
|
||
|
|
for (const word of words) {
|
||
|
|
const indexes = findAllSubstringIndexes(code, word);
|
||
|
|
for (const index of indexes) {
|
||
|
|
options2.decorations.push({
|
||
|
|
start: index,
|
||
|
|
end: index + word.length,
|
||
|
|
properties: {
|
||
|
|
class: className
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function findAllSubstringIndexes(str, substr) {
|
||
|
|
const indexes = [];
|
||
|
|
let cursor = 0;
|
||
|
|
while (true) {
|
||
|
|
const index = str.indexOf(substr, cursor);
|
||
|
|
if (index === -1 || index >= str.length)
|
||
|
|
break;
|
||
|
|
if (index < cursor)
|
||
|
|
break;
|
||
|
|
indexes.push(index);
|
||
|
|
cursor = index + substr.length;
|
||
|
|
}
|
||
|
|
return indexes;
|
||
|
|
}
|
||
|
|
|
||
|
|
function escapeRegExp(str) {
|
||
|
|
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||
|
|
}
|
||
|
|
function transformerNotationMap(options = {}, name = "@shikijs/transformers:notation-map") {
|
||
|
|
const {
|
||
|
|
classMap = {},
|
||
|
|
classActivePre = void 0
|
||
|
|
} = options;
|
||
|
|
return createCommentNotationTransformer(
|
||
|
|
name,
|
||
|
|
new RegExp(`#?\\s*\\[!code (${Object.keys(classMap).map(escapeRegExp).join("|")})(:\\d+)?\\]`, "gi"),
|
||
|
|
function([_, match, range = ":1"], _line, _comment, lines, index) {
|
||
|
|
const lineNum = Number.parseInt(range.slice(1), 10);
|
||
|
|
for (let i = index; i < Math.min(index + lineNum, lines.length); i++) {
|
||
|
|
this.addClassToHast(lines[i], classMap[match]);
|
||
|
|
}
|
||
|
|
if (classActivePre)
|
||
|
|
this.addClassToHast(this.pre, classActivePre);
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
options.matchAlgorithm
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerNotationDiff(options = {}) {
|
||
|
|
const {
|
||
|
|
classLineAdd = "diff add",
|
||
|
|
classLineRemove = "diff remove",
|
||
|
|
classActivePre = "has-diff"
|
||
|
|
} = options;
|
||
|
|
return transformerNotationMap(
|
||
|
|
{
|
||
|
|
classMap: {
|
||
|
|
"++": classLineAdd,
|
||
|
|
"--": classLineRemove
|
||
|
|
},
|
||
|
|
classActivePre,
|
||
|
|
matchAlgorithm: options.matchAlgorithm
|
||
|
|
},
|
||
|
|
"@shikijs/transformers:notation-diff"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerNotationErrorLevel(options = {}) {
|
||
|
|
const {
|
||
|
|
classMap = {
|
||
|
|
error: ["highlighted", "error"],
|
||
|
|
warning: ["highlighted", "warning"]
|
||
|
|
},
|
||
|
|
classActivePre = "has-highlighted"
|
||
|
|
} = options;
|
||
|
|
return transformerNotationMap(
|
||
|
|
{
|
||
|
|
classMap,
|
||
|
|
classActivePre,
|
||
|
|
matchAlgorithm: options.matchAlgorithm
|
||
|
|
},
|
||
|
|
"@shikijs/transformers:notation-error-level"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerNotationFocus(options = {}) {
|
||
|
|
const {
|
||
|
|
classActiveLine = "focused",
|
||
|
|
classActivePre = "has-focused"
|
||
|
|
} = options;
|
||
|
|
return transformerNotationMap(
|
||
|
|
{
|
||
|
|
classMap: {
|
||
|
|
focus: classActiveLine
|
||
|
|
},
|
||
|
|
classActivePre,
|
||
|
|
matchAlgorithm: options.matchAlgorithm
|
||
|
|
},
|
||
|
|
"@shikijs/transformers:notation-focus"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerNotationHighlight(options = {}) {
|
||
|
|
const {
|
||
|
|
classActiveLine = "highlighted",
|
||
|
|
classActivePre = "has-highlighted"
|
||
|
|
} = options;
|
||
|
|
return transformerNotationMap(
|
||
|
|
{
|
||
|
|
classMap: {
|
||
|
|
highlight: classActiveLine,
|
||
|
|
hl: classActiveLine
|
||
|
|
},
|
||
|
|
classActivePre,
|
||
|
|
matchAlgorithm: options.matchAlgorithm
|
||
|
|
},
|
||
|
|
"@shikijs/transformers:notation-highlight"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function highlightWordInLine(line, ignoredElement, word, className) {
|
||
|
|
const content = getTextContent(line);
|
||
|
|
let index = content.indexOf(word);
|
||
|
|
while (index !== -1) {
|
||
|
|
highlightRange.call(this, line.children, ignoredElement, index, word.length, className);
|
||
|
|
index = content.indexOf(word, index + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function getTextContent(element) {
|
||
|
|
if (element.type === "text")
|
||
|
|
return element.value;
|
||
|
|
if (element.type === "element" && element.tagName === "span")
|
||
|
|
return element.children.map(getTextContent).join("");
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
function highlightRange(elements, ignoredElement, index, len, className) {
|
||
|
|
let currentIdx = 0;
|
||
|
|
for (let i = 0; i < elements.length; i++) {
|
||
|
|
const element = elements[i];
|
||
|
|
if (element.type !== "element" || element.tagName !== "span" || element === ignoredElement)
|
||
|
|
continue;
|
||
|
|
const textNode = element.children[0];
|
||
|
|
if (textNode.type !== "text")
|
||
|
|
continue;
|
||
|
|
if (hasOverlap([currentIdx, currentIdx + textNode.value.length - 1], [index, index + len])) {
|
||
|
|
const start = Math.max(0, index - currentIdx);
|
||
|
|
const length = len - Math.max(0, currentIdx - index);
|
||
|
|
if (length === 0)
|
||
|
|
continue;
|
||
|
|
const separated = separateToken(element, textNode, start, length);
|
||
|
|
this.addClassToHast(separated[1], className);
|
||
|
|
const output = separated.filter(Boolean);
|
||
|
|
elements.splice(i, 1, ...output);
|
||
|
|
i += output.length - 1;
|
||
|
|
}
|
||
|
|
currentIdx += textNode.value.length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function hasOverlap(range1, range2) {
|
||
|
|
return range1[0] <= range2[1] && range1[1] >= range2[0];
|
||
|
|
}
|
||
|
|
function separateToken(span, textNode, index, len) {
|
||
|
|
const text = textNode.value;
|
||
|
|
const createNode = (value) => inheritElement(span, {
|
||
|
|
children: [
|
||
|
|
{
|
||
|
|
type: "text",
|
||
|
|
value
|
||
|
|
}
|
||
|
|
]
|
||
|
|
});
|
||
|
|
return [
|
||
|
|
index > 0 ? createNode(text.slice(0, index)) : void 0,
|
||
|
|
createNode(text.slice(index, index + len)),
|
||
|
|
index + len < text.length ? createNode(text.slice(index + len)) : void 0
|
||
|
|
];
|
||
|
|
}
|
||
|
|
function inheritElement(original, overrides) {
|
||
|
|
return {
|
||
|
|
...original,
|
||
|
|
properties: {
|
||
|
|
...original.properties
|
||
|
|
},
|
||
|
|
...overrides
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerNotationWordHighlight(options = {}) {
|
||
|
|
const {
|
||
|
|
classActiveWord = "highlighted-word",
|
||
|
|
classActivePre = void 0
|
||
|
|
} = options;
|
||
|
|
return createCommentNotationTransformer(
|
||
|
|
"@shikijs/transformers:notation-highlight-word",
|
||
|
|
/\s*\[!code word:((?:\\.|[^:\]])+)(:\d+)?\]/,
|
||
|
|
function([_, word, range], _line, comment, lines, index) {
|
||
|
|
const lineNum = range ? Number.parseInt(range.slice(1), 10) : lines.length;
|
||
|
|
word = word.replace(/\\(.)/g, "$1");
|
||
|
|
for (let i = index; i < Math.min(index + lineNum, lines.length); i++) {
|
||
|
|
highlightWordInLine.call(this, lines[i], comment, word, classActiveWord);
|
||
|
|
}
|
||
|
|
if (classActivePre)
|
||
|
|
this.addClassToHast(this.pre, classActivePre);
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
options.matchAlgorithm
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerRemoveLineBreak() {
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:remove-line-break",
|
||
|
|
code(code) {
|
||
|
|
code.children = code.children.filter((line) => !(line.type === "text" && line.value === "\n"));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerRemoveNotationEscape() {
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:remove-notation-escape",
|
||
|
|
code(hast) {
|
||
|
|
function replace(node) {
|
||
|
|
if (node.type === "text") {
|
||
|
|
node.value = node.value.replace("[\\!code", "[!code");
|
||
|
|
} else if ("children" in node) {
|
||
|
|
for (const child of node.children) {
|
||
|
|
replace(child);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
replace(hast);
|
||
|
|
return hast;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerRenderIndentGuides(options = {}) {
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:render-indent-guides",
|
||
|
|
code(hast) {
|
||
|
|
const indent = Number(
|
||
|
|
this.options.meta?.indent ?? this.options.meta?.__raw?.match(/\{indent:(\d+|false)\}/)?.[1] ?? options.indent ?? 2
|
||
|
|
);
|
||
|
|
if (Number.isNaN(indent) || indent <= 0) {
|
||
|
|
return hast;
|
||
|
|
}
|
||
|
|
const indentRegex = new RegExp(` {${indent}}| {0,${indent - 1}} | {1,}$`, "g");
|
||
|
|
const emptyLines = [];
|
||
|
|
let level = 0;
|
||
|
|
for (const line of hast.children) {
|
||
|
|
if (line.type !== "element") {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
const first = line.children[0];
|
||
|
|
if (first?.type !== "element" || first?.children[0]?.type !== "text") {
|
||
|
|
emptyLines.push([line, level]);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
const text = first.children[0];
|
||
|
|
const blanks = text.value.split(/[^ \t]/, 1)[0];
|
||
|
|
const ranges = [];
|
||
|
|
for (const match of blanks.matchAll(indentRegex)) {
|
||
|
|
const start = match.index;
|
||
|
|
const end = start + match[0].length;
|
||
|
|
ranges.push([start, end]);
|
||
|
|
}
|
||
|
|
for (const [line2, level2] of emptyLines) {
|
||
|
|
line2.children.unshift(...Array.from({ length: Math.min(ranges.length, level2 + 1) }, (_, i) => ({
|
||
|
|
type: "element",
|
||
|
|
tagName: "span",
|
||
|
|
properties: {
|
||
|
|
class: "indent",
|
||
|
|
style: `--indent-offset: ${i * indent}ch;`
|
||
|
|
},
|
||
|
|
children: []
|
||
|
|
})));
|
||
|
|
}
|
||
|
|
emptyLines.length = 0;
|
||
|
|
level = ranges.length;
|
||
|
|
if (ranges.length) {
|
||
|
|
line.children.unshift(
|
||
|
|
...ranges.map(([start, end]) => ({
|
||
|
|
type: "element",
|
||
|
|
tagName: "span",
|
||
|
|
properties: {
|
||
|
|
class: "indent"
|
||
|
|
},
|
||
|
|
children: [{
|
||
|
|
type: "text",
|
||
|
|
value: text.value.slice(start, end)
|
||
|
|
}]
|
||
|
|
}))
|
||
|
|
);
|
||
|
|
text.value = text.value.slice(ranges.at(-1)[1]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hast;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function isTab(part) {
|
||
|
|
return part === " ";
|
||
|
|
}
|
||
|
|
function isSpace(part) {
|
||
|
|
return part === " " || part === " ";
|
||
|
|
}
|
||
|
|
function separateContinuousSpaces(inputs) {
|
||
|
|
const result = [];
|
||
|
|
let current = "";
|
||
|
|
function bump() {
|
||
|
|
if (current.length)
|
||
|
|
result.push(current);
|
||
|
|
current = "";
|
||
|
|
}
|
||
|
|
inputs.forEach((part, idx) => {
|
||
|
|
if (isTab(part)) {
|
||
|
|
bump();
|
||
|
|
result.push(part);
|
||
|
|
} else if (isSpace(part) && (isSpace(inputs[idx - 1]) || isSpace(inputs[idx + 1]))) {
|
||
|
|
bump();
|
||
|
|
result.push(part);
|
||
|
|
} else {
|
||
|
|
current += part;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
bump();
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function splitSpaces(parts, type, renderContinuousSpaces = true) {
|
||
|
|
if (type === "all")
|
||
|
|
return parts;
|
||
|
|
let leftCount = 0;
|
||
|
|
let rightCount = 0;
|
||
|
|
if (type === "boundary") {
|
||
|
|
for (let i = 0; i < parts.length; i++) {
|
||
|
|
if (isSpace(parts[i]))
|
||
|
|
leftCount++;
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (type === "boundary" || type === "trailing") {
|
||
|
|
for (let i = parts.length - 1; i >= 0; i--) {
|
||
|
|
if (isSpace(parts[i]))
|
||
|
|
rightCount++;
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const middle = parts.slice(leftCount, parts.length - rightCount);
|
||
|
|
return [
|
||
|
|
...parts.slice(0, leftCount),
|
||
|
|
...renderContinuousSpaces ? separateContinuousSpaces(middle) : [middle.join("")],
|
||
|
|
...parts.slice(parts.length - rightCount)
|
||
|
|
];
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerRenderWhitespace(options = {}) {
|
||
|
|
const classMap = {
|
||
|
|
" ": options.classSpace ?? "space",
|
||
|
|
" ": options.classTab ?? "tab"
|
||
|
|
};
|
||
|
|
const position = options.position ?? "all";
|
||
|
|
const keys = Object.keys(classMap);
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:render-whitespace",
|
||
|
|
// We use `root` hook here to ensure it runs after all other transformers
|
||
|
|
root(root) {
|
||
|
|
const pre = root.children[0];
|
||
|
|
const code = pre.tagName === "pre" ? pre.children[0] : { children: [root] };
|
||
|
|
code.children.forEach(
|
||
|
|
(line) => {
|
||
|
|
if (line.type !== "element" && line.type !== "root")
|
||
|
|
return;
|
||
|
|
const elements = line.children.filter((token) => token.type === "element");
|
||
|
|
const last = elements.length - 1;
|
||
|
|
line.children = line.children.flatMap((token) => {
|
||
|
|
if (token.type !== "element")
|
||
|
|
return token;
|
||
|
|
const index = elements.indexOf(token);
|
||
|
|
if (position === "boundary" && index !== 0 && index !== last)
|
||
|
|
return token;
|
||
|
|
if (position === "trailing" && index !== last)
|
||
|
|
return token;
|
||
|
|
const node = token.children[0];
|
||
|
|
if (node.type !== "text" || !node.value)
|
||
|
|
return token;
|
||
|
|
const parts = splitSpaces(
|
||
|
|
node.value.split(/([ \t])/).filter((i) => i.length),
|
||
|
|
position === "boundary" && index === last && last !== 0 ? "trailing" : position,
|
||
|
|
position !== "trailing"
|
||
|
|
);
|
||
|
|
if (parts.length <= 1)
|
||
|
|
return token;
|
||
|
|
return parts.map((part) => {
|
||
|
|
const clone = {
|
||
|
|
...token,
|
||
|
|
properties: { ...token.properties }
|
||
|
|
};
|
||
|
|
clone.children = [{ type: "text", value: part }];
|
||
|
|
if (keys.includes(part)) {
|
||
|
|
this.addClassToHast(clone, classMap[part]);
|
||
|
|
delete clone.properties.style;
|
||
|
|
}
|
||
|
|
return clone;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function transformerStyleToClass(options = {}) {
|
||
|
|
const {
|
||
|
|
classPrefix = "__shiki_",
|
||
|
|
classSuffix = "",
|
||
|
|
classReplacer = (className) => className
|
||
|
|
} = options;
|
||
|
|
const classToStyle = /* @__PURE__ */ new Map();
|
||
|
|
function stringifyStyle(style) {
|
||
|
|
return Object.entries(style).map(([key, value]) => `${key}:${value}`).join(";");
|
||
|
|
}
|
||
|
|
function registerStyle(style) {
|
||
|
|
const str = typeof style === "string" ? style : stringifyStyle(style);
|
||
|
|
let className = classPrefix + cyrb53(str) + classSuffix;
|
||
|
|
className = classReplacer(className);
|
||
|
|
if (!classToStyle.has(className)) {
|
||
|
|
classToStyle.set(
|
||
|
|
className,
|
||
|
|
typeof style === "string" ? style : { ...style }
|
||
|
|
);
|
||
|
|
}
|
||
|
|
return className;
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
name: "@shikijs/transformers:style-to-class",
|
||
|
|
pre(t) {
|
||
|
|
if (!t.properties.style)
|
||
|
|
return;
|
||
|
|
const className = registerStyle(t.properties.style);
|
||
|
|
delete t.properties.style;
|
||
|
|
this.addClassToHast(t, className);
|
||
|
|
},
|
||
|
|
tokens(lines) {
|
||
|
|
for (const line of lines) {
|
||
|
|
for (const token of line) {
|
||
|
|
if (!token.htmlStyle)
|
||
|
|
continue;
|
||
|
|
const className = registerStyle(token.htmlStyle);
|
||
|
|
token.htmlStyle = {};
|
||
|
|
token.htmlAttrs ||= {};
|
||
|
|
if (!token.htmlAttrs.class)
|
||
|
|
token.htmlAttrs.class = className;
|
||
|
|
else
|
||
|
|
token.htmlAttrs.class += ` ${className}`;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
getClassRegistry() {
|
||
|
|
return classToStyle;
|
||
|
|
},
|
||
|
|
getCSS() {
|
||
|
|
let css = "";
|
||
|
|
for (const [className, style] of classToStyle.entries()) {
|
||
|
|
css += `.${className}{${typeof style === "string" ? style : stringifyStyle(style)}}`;
|
||
|
|
}
|
||
|
|
return css;
|
||
|
|
},
|
||
|
|
clearRegistry() {
|
||
|
|
classToStyle.clear();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function cyrb53(str, seed = 0) {
|
||
|
|
let h1 = 3735928559 ^ seed;
|
||
|
|
let h2 = 1103547991 ^ seed;
|
||
|
|
for (let i = 0, ch; i < str.length; i++) {
|
||
|
|
ch = str.charCodeAt(i);
|
||
|
|
h1 = Math.imul(h1 ^ ch, 2654435761);
|
||
|
|
h2 = Math.imul(h2 ^ ch, 1597334677);
|
||
|
|
}
|
||
|
|
h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
|
||
|
|
h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
|
||
|
|
h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
|
||
|
|
h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
|
||
|
|
return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).slice(0, 6);
|
||
|
|
}
|
||
|
|
|
||
|
|
export { createCommentNotationTransformer, findAllSubstringIndexes, parseMetaHighlightString, parseMetaHighlightWords, transformerCompactLineOptions, transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationMap, transformerNotationWordHighlight, transformerRemoveLineBreak, transformerRemoveNotationEscape, transformerRenderIndentGuides, transformerRenderWhitespace, transformerStyleToClass };
|