devstar插件
This commit is contained in:
670
node_modules/@shikijs/transformers/dist/index.mjs
generated
vendored
Normal file
670
node_modules/@shikijs/transformers/dist/index.mjs
generated
vendored
Normal file
@@ -0,0 +1,670 @@
|
||||
import { warnDeprecated } from '@shikijs/core';
|
||||
|
||||
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;
|
||||
const match = matchToken(head.value, isLast);
|
||||
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
|
||||
});
|
||||
} else {
|
||||
out.push({
|
||||
info: match,
|
||||
line,
|
||||
token,
|
||||
isLineCommentOnly: elements.length === 1 && token.children.length === 1,
|
||||
isJsxStyle: false
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
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 = "v1";
|
||||
warnDeprecated('The default `matchAlgorithm: "v1"` is deprecated and will be removed in the future. Please explicitly set `matchAlgorithm: "v3"` in the transformer options.', 3);
|
||||
}
|
||||
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) {
|
||||
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("");
|
||||
}
|
||||
}
|
||||
}
|
||||
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+)?\\]`),
|
||||
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",
|
||||
postprocess(code) {
|
||||
return code.replace(/\[\\!code/g, "[!code");
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
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.children[0];
|
||||
code.children.forEach(
|
||||
(line) => {
|
||||
if (line.type !== "element")
|
||||
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, transformerRenderWhitespace, transformerStyleToClass };
|
||||
Reference in New Issue
Block a user