1841 lines
51 KiB
JavaScript
1841 lines
51 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => mod[key],
|
|
enumerable: true
|
|
});
|
|
return to;
|
|
};
|
|
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
|
|
// node_modules/highlight.js/lib/core.js
|
|
var require_core = __commonJS((exports, module) => {
|
|
var deepFreeze = function(obj) {
|
|
if (obj instanceof Map) {
|
|
obj.clear = obj.delete = obj.set = function() {
|
|
throw new Error("map is read-only");
|
|
};
|
|
} else if (obj instanceof Set) {
|
|
obj.add = obj.clear = obj.delete = function() {
|
|
throw new Error("set is read-only");
|
|
};
|
|
}
|
|
Object.freeze(obj);
|
|
Object.getOwnPropertyNames(obj).forEach((name) => {
|
|
const prop = obj[name];
|
|
const type = typeof prop;
|
|
if ((type === "object" || type === "function") && !Object.isFrozen(prop)) {
|
|
deepFreeze(prop);
|
|
}
|
|
});
|
|
return obj;
|
|
};
|
|
var escapeHTML = function(value) {
|
|
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'");
|
|
};
|
|
var inherit$1 = function(original, ...objects) {
|
|
const result = Object.create(null);
|
|
for (const key in original) {
|
|
result[key] = original[key];
|
|
}
|
|
objects.forEach(function(obj) {
|
|
for (const key in obj) {
|
|
result[key] = obj[key];
|
|
}
|
|
});
|
|
return result;
|
|
};
|
|
var source = function(re) {
|
|
if (!re)
|
|
return null;
|
|
if (typeof re === "string")
|
|
return re;
|
|
return re.source;
|
|
};
|
|
var lookahead = function(re) {
|
|
return concat("(?=", re, ")");
|
|
};
|
|
var anyNumberOfTimes = function(re) {
|
|
return concat("(?:", re, ")*");
|
|
};
|
|
var optional = function(re) {
|
|
return concat("(?:", re, ")?");
|
|
};
|
|
var concat = function(...args) {
|
|
const joined = args.map((x) => source(x)).join("");
|
|
return joined;
|
|
};
|
|
var stripOptionsFromArgs = function(args) {
|
|
const opts = args[args.length - 1];
|
|
if (typeof opts === "object" && opts.constructor === Object) {
|
|
args.splice(args.length - 1, 1);
|
|
return opts;
|
|
} else {
|
|
return {};
|
|
}
|
|
};
|
|
var either = function(...args) {
|
|
const opts = stripOptionsFromArgs(args);
|
|
const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
|
|
return joined;
|
|
};
|
|
var countMatchGroups = function(re) {
|
|
return new RegExp(re.toString() + "|").exec("").length - 1;
|
|
};
|
|
var startsWith = function(re, lexeme) {
|
|
const match = re && re.exec(lexeme);
|
|
return match && match.index === 0;
|
|
};
|
|
var _rewriteBackreferences = function(regexps, { joinWith }) {
|
|
let numCaptures = 0;
|
|
return regexps.map((regex) => {
|
|
numCaptures += 1;
|
|
const offset = numCaptures;
|
|
let re = source(regex);
|
|
let out = "";
|
|
while (re.length > 0) {
|
|
const match = BACKREF_RE.exec(re);
|
|
if (!match) {
|
|
out += re;
|
|
break;
|
|
}
|
|
out += re.substring(0, match.index);
|
|
re = re.substring(match.index + match[0].length);
|
|
if (match[0][0] === "\\" && match[1]) {
|
|
out += "\\" + String(Number(match[1]) + offset);
|
|
} else {
|
|
out += match[0];
|
|
if (match[0] === "(") {
|
|
numCaptures++;
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}).map((re) => `(${re})`).join(joinWith);
|
|
};
|
|
var skipIfHasPrecedingDot = function(match, response) {
|
|
const before = match.input[match.index - 1];
|
|
if (before === ".") {
|
|
response.ignoreMatch();
|
|
}
|
|
};
|
|
var scopeClassName = function(mode, _parent) {
|
|
if (mode.className !== undefined) {
|
|
mode.scope = mode.className;
|
|
delete mode.className;
|
|
}
|
|
};
|
|
var beginKeywords = function(mode, parent) {
|
|
if (!parent)
|
|
return;
|
|
if (!mode.beginKeywords)
|
|
return;
|
|
mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)";
|
|
mode.__beforeBegin = skipIfHasPrecedingDot;
|
|
mode.keywords = mode.keywords || mode.beginKeywords;
|
|
delete mode.beginKeywords;
|
|
if (mode.relevance === undefined)
|
|
mode.relevance = 0;
|
|
};
|
|
var compileIllegal = function(mode, _parent) {
|
|
if (!Array.isArray(mode.illegal))
|
|
return;
|
|
mode.illegal = either(...mode.illegal);
|
|
};
|
|
var compileMatch = function(mode, _parent) {
|
|
if (!mode.match)
|
|
return;
|
|
if (mode.begin || mode.end)
|
|
throw new Error("begin & end are not supported with match");
|
|
mode.begin = mode.match;
|
|
delete mode.match;
|
|
};
|
|
var compileRelevance = function(mode, _parent) {
|
|
if (mode.relevance === undefined)
|
|
mode.relevance = 1;
|
|
};
|
|
var compileKeywords = function(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
|
|
const compiledKeywords = Object.create(null);
|
|
if (typeof rawKeywords === "string") {
|
|
compileList(scopeName, rawKeywords.split(" "));
|
|
} else if (Array.isArray(rawKeywords)) {
|
|
compileList(scopeName, rawKeywords);
|
|
} else {
|
|
Object.keys(rawKeywords).forEach(function(scopeName2) {
|
|
Object.assign(compiledKeywords, compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2));
|
|
});
|
|
}
|
|
return compiledKeywords;
|
|
function compileList(scopeName2, keywordList) {
|
|
if (caseInsensitive) {
|
|
keywordList = keywordList.map((x) => x.toLowerCase());
|
|
}
|
|
keywordList.forEach(function(keyword) {
|
|
const pair = keyword.split("|");
|
|
compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])];
|
|
});
|
|
}
|
|
};
|
|
var scoreForKeyword = function(keyword, providedScore) {
|
|
if (providedScore) {
|
|
return Number(providedScore);
|
|
}
|
|
return commonKeyword(keyword) ? 0 : 1;
|
|
};
|
|
var commonKeyword = function(keyword) {
|
|
return COMMON_KEYWORDS.includes(keyword.toLowerCase());
|
|
};
|
|
var remapScopeNames = function(mode, regexes, { key }) {
|
|
let offset = 0;
|
|
const scopeNames = mode[key];
|
|
const emit = {};
|
|
const positions = {};
|
|
for (let i = 1;i <= regexes.length; i++) {
|
|
positions[i + offset] = scopeNames[i];
|
|
emit[i + offset] = true;
|
|
offset += countMatchGroups(regexes[i - 1]);
|
|
}
|
|
mode[key] = positions;
|
|
mode[key]._emit = emit;
|
|
mode[key]._multi = true;
|
|
};
|
|
var beginMultiClass = function(mode) {
|
|
if (!Array.isArray(mode.begin))
|
|
return;
|
|
if (mode.skip || mode.excludeBegin || mode.returnBegin) {
|
|
error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
|
|
throw MultiClassError;
|
|
}
|
|
if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
|
|
error("beginScope must be object");
|
|
throw MultiClassError;
|
|
}
|
|
remapScopeNames(mode, mode.begin, { key: "beginScope" });
|
|
mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
|
|
};
|
|
var endMultiClass = function(mode) {
|
|
if (!Array.isArray(mode.end))
|
|
return;
|
|
if (mode.skip || mode.excludeEnd || mode.returnEnd) {
|
|
error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
|
|
throw MultiClassError;
|
|
}
|
|
if (typeof mode.endScope !== "object" || mode.endScope === null) {
|
|
error("endScope must be object");
|
|
throw MultiClassError;
|
|
}
|
|
remapScopeNames(mode, mode.end, { key: "endScope" });
|
|
mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
|
|
};
|
|
var scopeSugar = function(mode) {
|
|
if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
|
|
mode.beginScope = mode.scope;
|
|
delete mode.scope;
|
|
}
|
|
};
|
|
var MultiClass = function(mode) {
|
|
scopeSugar(mode);
|
|
if (typeof mode.beginScope === "string") {
|
|
mode.beginScope = { _wrap: mode.beginScope };
|
|
}
|
|
if (typeof mode.endScope === "string") {
|
|
mode.endScope = { _wrap: mode.endScope };
|
|
}
|
|
beginMultiClass(mode);
|
|
endMultiClass(mode);
|
|
};
|
|
var compileLanguage = function(language) {
|
|
function langRe(value, global) {
|
|
return new RegExp(source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : ""));
|
|
}
|
|
|
|
class MultiRegex {
|
|
constructor() {
|
|
this.matchIndexes = {};
|
|
this.regexes = [];
|
|
this.matchAt = 1;
|
|
this.position = 0;
|
|
}
|
|
addRule(re, opts) {
|
|
opts.position = this.position++;
|
|
this.matchIndexes[this.matchAt] = opts;
|
|
this.regexes.push([opts, re]);
|
|
this.matchAt += countMatchGroups(re) + 1;
|
|
}
|
|
compile() {
|
|
if (this.regexes.length === 0) {
|
|
this.exec = () => null;
|
|
}
|
|
const terminators = this.regexes.map((el) => el[1]);
|
|
this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true);
|
|
this.lastIndex = 0;
|
|
}
|
|
exec(s) {
|
|
this.matcherRe.lastIndex = this.lastIndex;
|
|
const match = this.matcherRe.exec(s);
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
const i = match.findIndex((el, i2) => i2 > 0 && el !== undefined);
|
|
const matchData = this.matchIndexes[i];
|
|
match.splice(0, i);
|
|
return Object.assign(match, matchData);
|
|
}
|
|
}
|
|
|
|
class ResumableMultiRegex {
|
|
constructor() {
|
|
this.rules = [];
|
|
this.multiRegexes = [];
|
|
this.count = 0;
|
|
this.lastIndex = 0;
|
|
this.regexIndex = 0;
|
|
}
|
|
getMatcher(index) {
|
|
if (this.multiRegexes[index])
|
|
return this.multiRegexes[index];
|
|
const matcher = new MultiRegex;
|
|
this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
|
|
matcher.compile();
|
|
this.multiRegexes[index] = matcher;
|
|
return matcher;
|
|
}
|
|
resumingScanAtSamePosition() {
|
|
return this.regexIndex !== 0;
|
|
}
|
|
considerAll() {
|
|
this.regexIndex = 0;
|
|
}
|
|
addRule(re, opts) {
|
|
this.rules.push([re, opts]);
|
|
if (opts.type === "begin")
|
|
this.count++;
|
|
}
|
|
exec(s) {
|
|
const m = this.getMatcher(this.regexIndex);
|
|
m.lastIndex = this.lastIndex;
|
|
let result = m.exec(s);
|
|
if (this.resumingScanAtSamePosition()) {
|
|
if (result && result.index === this.lastIndex)
|
|
;
|
|
else {
|
|
const m2 = this.getMatcher(0);
|
|
m2.lastIndex = this.lastIndex + 1;
|
|
result = m2.exec(s);
|
|
}
|
|
}
|
|
if (result) {
|
|
this.regexIndex += result.position + 1;
|
|
if (this.regexIndex === this.count) {
|
|
this.considerAll();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function buildModeRegex(mode) {
|
|
const mm = new ResumableMultiRegex;
|
|
mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" }));
|
|
if (mode.terminatorEnd) {
|
|
mm.addRule(mode.terminatorEnd, { type: "end" });
|
|
}
|
|
if (mode.illegal) {
|
|
mm.addRule(mode.illegal, { type: "illegal" });
|
|
}
|
|
return mm;
|
|
}
|
|
function compileMode(mode, parent) {
|
|
const cmode = mode;
|
|
if (mode.isCompiled)
|
|
return cmode;
|
|
[
|
|
scopeClassName,
|
|
compileMatch,
|
|
MultiClass,
|
|
beforeMatchExt
|
|
].forEach((ext) => ext(mode, parent));
|
|
language.compilerExtensions.forEach((ext) => ext(mode, parent));
|
|
mode.__beforeBegin = null;
|
|
[
|
|
beginKeywords,
|
|
compileIllegal,
|
|
compileRelevance
|
|
].forEach((ext) => ext(mode, parent));
|
|
mode.isCompiled = true;
|
|
let keywordPattern = null;
|
|
if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
|
|
mode.keywords = Object.assign({}, mode.keywords);
|
|
keywordPattern = mode.keywords.$pattern;
|
|
delete mode.keywords.$pattern;
|
|
}
|
|
keywordPattern = keywordPattern || /\w+/;
|
|
if (mode.keywords) {
|
|
mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
|
|
}
|
|
cmode.keywordPatternRe = langRe(keywordPattern, true);
|
|
if (parent) {
|
|
if (!mode.begin)
|
|
mode.begin = /\B|\b/;
|
|
cmode.beginRe = langRe(cmode.begin);
|
|
if (!mode.end && !mode.endsWithParent)
|
|
mode.end = /\B|\b/;
|
|
if (mode.end)
|
|
cmode.endRe = langRe(cmode.end);
|
|
cmode.terminatorEnd = source(cmode.end) || "";
|
|
if (mode.endsWithParent && parent.terminatorEnd) {
|
|
cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
|
|
}
|
|
}
|
|
if (mode.illegal)
|
|
cmode.illegalRe = langRe(mode.illegal);
|
|
if (!mode.contains)
|
|
mode.contains = [];
|
|
mode.contains = [].concat(...mode.contains.map(function(c) {
|
|
return expandOrCloneMode(c === "self" ? mode : c);
|
|
}));
|
|
mode.contains.forEach(function(c) {
|
|
compileMode(c, cmode);
|
|
});
|
|
if (mode.starts) {
|
|
compileMode(mode.starts, parent);
|
|
}
|
|
cmode.matcher = buildModeRegex(cmode);
|
|
return cmode;
|
|
}
|
|
if (!language.compilerExtensions)
|
|
language.compilerExtensions = [];
|
|
if (language.contains && language.contains.includes("self")) {
|
|
throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");
|
|
}
|
|
language.classNameAliases = inherit$1(language.classNameAliases || {});
|
|
return compileMode(language);
|
|
};
|
|
var dependencyOnParent = function(mode) {
|
|
if (!mode)
|
|
return false;
|
|
return mode.endsWithParent || dependencyOnParent(mode.starts);
|
|
};
|
|
var expandOrCloneMode = function(mode) {
|
|
if (mode.variants && !mode.cachedVariants) {
|
|
mode.cachedVariants = mode.variants.map(function(variant) {
|
|
return inherit$1(mode, { variants: null }, variant);
|
|
});
|
|
}
|
|
if (mode.cachedVariants) {
|
|
return mode.cachedVariants;
|
|
}
|
|
if (dependencyOnParent(mode)) {
|
|
return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
|
|
}
|
|
if (Object.isFrozen(mode)) {
|
|
return inherit$1(mode);
|
|
}
|
|
return mode;
|
|
};
|
|
|
|
class Response {
|
|
constructor(mode) {
|
|
if (mode.data === undefined)
|
|
mode.data = {};
|
|
this.data = mode.data;
|
|
this.isMatchIgnored = false;
|
|
}
|
|
ignoreMatch() {
|
|
this.isMatchIgnored = true;
|
|
}
|
|
}
|
|
var SPAN_CLOSE = "</span>";
|
|
var emitsWrappingTags = (node) => {
|
|
return !!node.scope;
|
|
};
|
|
var scopeToCSSClass = (name, { prefix }) => {
|
|
if (name.startsWith("language:")) {
|
|
return name.replace("language:", "language-");
|
|
}
|
|
if (name.includes(".")) {
|
|
const pieces = name.split(".");
|
|
return [
|
|
`${prefix}${pieces.shift()}`,
|
|
...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
|
|
].join(" ");
|
|
}
|
|
return `${prefix}${name}`;
|
|
};
|
|
|
|
class HTMLRenderer {
|
|
constructor(parseTree, options) {
|
|
this.buffer = "";
|
|
this.classPrefix = options.classPrefix;
|
|
parseTree.walk(this);
|
|
}
|
|
addText(text) {
|
|
this.buffer += escapeHTML(text);
|
|
}
|
|
openNode(node) {
|
|
if (!emitsWrappingTags(node))
|
|
return;
|
|
const className = scopeToCSSClass(node.scope, { prefix: this.classPrefix });
|
|
this.span(className);
|
|
}
|
|
closeNode(node) {
|
|
if (!emitsWrappingTags(node))
|
|
return;
|
|
this.buffer += SPAN_CLOSE;
|
|
}
|
|
value() {
|
|
return this.buffer;
|
|
}
|
|
span(className) {
|
|
this.buffer += `<span class="${className}">`;
|
|
}
|
|
}
|
|
var newNode = (opts = {}) => {
|
|
const result = { children: [] };
|
|
Object.assign(result, opts);
|
|
return result;
|
|
};
|
|
|
|
class TokenTree {
|
|
constructor() {
|
|
this.rootNode = newNode();
|
|
this.stack = [this.rootNode];
|
|
}
|
|
get top() {
|
|
return this.stack[this.stack.length - 1];
|
|
}
|
|
get root() {
|
|
return this.rootNode;
|
|
}
|
|
add(node) {
|
|
this.top.children.push(node);
|
|
}
|
|
openNode(scope) {
|
|
const node = newNode({ scope });
|
|
this.add(node);
|
|
this.stack.push(node);
|
|
}
|
|
closeNode() {
|
|
if (this.stack.length > 1) {
|
|
return this.stack.pop();
|
|
}
|
|
return;
|
|
}
|
|
closeAllNodes() {
|
|
while (this.closeNode())
|
|
;
|
|
}
|
|
toJSON() {
|
|
return JSON.stringify(this.rootNode, null, 4);
|
|
}
|
|
walk(builder) {
|
|
return this.constructor._walk(builder, this.rootNode);
|
|
}
|
|
static _walk(builder, node) {
|
|
if (typeof node === "string") {
|
|
builder.addText(node);
|
|
} else if (node.children) {
|
|
builder.openNode(node);
|
|
node.children.forEach((child) => this._walk(builder, child));
|
|
builder.closeNode(node);
|
|
}
|
|
return builder;
|
|
}
|
|
static _collapse(node) {
|
|
if (typeof node === "string")
|
|
return;
|
|
if (!node.children)
|
|
return;
|
|
if (node.children.every((el) => typeof el === "string")) {
|
|
node.children = [node.children.join("")];
|
|
} else {
|
|
node.children.forEach((child) => {
|
|
TokenTree._collapse(child);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
class TokenTreeEmitter extends TokenTree {
|
|
constructor(options) {
|
|
super();
|
|
this.options = options;
|
|
}
|
|
addText(text) {
|
|
if (text === "") {
|
|
return;
|
|
}
|
|
this.add(text);
|
|
}
|
|
startScope(scope) {
|
|
this.openNode(scope);
|
|
}
|
|
endScope() {
|
|
this.closeNode();
|
|
}
|
|
__addSublanguage(emitter, name) {
|
|
const node = emitter.root;
|
|
if (name)
|
|
node.scope = `language:${name}`;
|
|
this.add(node);
|
|
}
|
|
toHTML() {
|
|
const renderer = new HTMLRenderer(this, this.options);
|
|
return renderer.value();
|
|
}
|
|
finalize() {
|
|
this.closeAllNodes();
|
|
return true;
|
|
}
|
|
}
|
|
var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
|
|
var MATCH_NOTHING_RE = /\b\B/;
|
|
var IDENT_RE = "[a-zA-Z]\\w*";
|
|
var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*";
|
|
var NUMBER_RE = "\\b\\d+(\\.\\d+)?";
|
|
var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";
|
|
var BINARY_NUMBER_RE = "\\b(0b[01]+)";
|
|
var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";
|
|
var SHEBANG = (opts = {}) => {
|
|
const beginShebang = /^#![ ]*\//;
|
|
if (opts.binary) {
|
|
opts.begin = concat(beginShebang, /.*\b/, opts.binary, /\b.*/);
|
|
}
|
|
return inherit$1({
|
|
scope: "meta",
|
|
begin: beginShebang,
|
|
end: /$/,
|
|
relevance: 0,
|
|
"on:begin": (m, resp) => {
|
|
if (m.index !== 0)
|
|
resp.ignoreMatch();
|
|
}
|
|
}, opts);
|
|
};
|
|
var BACKSLASH_ESCAPE = {
|
|
begin: "\\\\[\\s\\S]",
|
|
relevance: 0
|
|
};
|
|
var APOS_STRING_MODE = {
|
|
scope: "string",
|
|
begin: "\'",
|
|
end: "\'",
|
|
illegal: "\\n",
|
|
contains: [BACKSLASH_ESCAPE]
|
|
};
|
|
var QUOTE_STRING_MODE = {
|
|
scope: "string",
|
|
begin: '"',
|
|
end: '"',
|
|
illegal: "\\n",
|
|
contains: [BACKSLASH_ESCAPE]
|
|
};
|
|
var PHRASAL_WORDS_MODE = {
|
|
begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
|
|
};
|
|
var COMMENT = function(begin, end, modeOptions = {}) {
|
|
const mode = inherit$1({
|
|
scope: "comment",
|
|
begin,
|
|
end,
|
|
contains: []
|
|
}, modeOptions);
|
|
mode.contains.push({
|
|
scope: "doctag",
|
|
begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
|
|
end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
|
|
excludeBegin: true,
|
|
relevance: 0
|
|
});
|
|
const ENGLISH_WORD = either("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/);
|
|
mode.contains.push({
|
|
begin: concat(/[ ]+/, "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}")
|
|
});
|
|
return mode;
|
|
};
|
|
var C_LINE_COMMENT_MODE = COMMENT("//", "$");
|
|
var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/");
|
|
var HASH_COMMENT_MODE = COMMENT("#", "$");
|
|
var NUMBER_MODE = {
|
|
scope: "number",
|
|
begin: NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
var C_NUMBER_MODE = {
|
|
scope: "number",
|
|
begin: C_NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
var BINARY_NUMBER_MODE = {
|
|
scope: "number",
|
|
begin: BINARY_NUMBER_RE,
|
|
relevance: 0
|
|
};
|
|
var REGEXP_MODE = {
|
|
scope: "regexp",
|
|
begin: /\/(?=[^/\n]*\/)/,
|
|
end: /\/[gimuy]*/,
|
|
contains: [
|
|
BACKSLASH_ESCAPE,
|
|
{
|
|
begin: /\[/,
|
|
end: /\]/,
|
|
relevance: 0,
|
|
contains: [BACKSLASH_ESCAPE]
|
|
}
|
|
]
|
|
};
|
|
var TITLE_MODE = {
|
|
scope: "title",
|
|
begin: IDENT_RE,
|
|
relevance: 0
|
|
};
|
|
var UNDERSCORE_TITLE_MODE = {
|
|
scope: "title",
|
|
begin: UNDERSCORE_IDENT_RE,
|
|
relevance: 0
|
|
};
|
|
var METHOD_GUARD = {
|
|
begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
|
|
relevance: 0
|
|
};
|
|
var END_SAME_AS_BEGIN = function(mode) {
|
|
return Object.assign(mode, {
|
|
"on:begin": (m, resp) => {
|
|
resp.data._beginMatch = m[1];
|
|
},
|
|
"on:end": (m, resp) => {
|
|
if (resp.data._beginMatch !== m[1])
|
|
resp.ignoreMatch();
|
|
}
|
|
});
|
|
};
|
|
var MODES = Object.freeze({
|
|
__proto__: null,
|
|
APOS_STRING_MODE,
|
|
BACKSLASH_ESCAPE,
|
|
BINARY_NUMBER_MODE,
|
|
BINARY_NUMBER_RE,
|
|
COMMENT,
|
|
C_BLOCK_COMMENT_MODE,
|
|
C_LINE_COMMENT_MODE,
|
|
C_NUMBER_MODE,
|
|
C_NUMBER_RE,
|
|
END_SAME_AS_BEGIN,
|
|
HASH_COMMENT_MODE,
|
|
IDENT_RE,
|
|
MATCH_NOTHING_RE,
|
|
METHOD_GUARD,
|
|
NUMBER_MODE,
|
|
NUMBER_RE,
|
|
PHRASAL_WORDS_MODE,
|
|
QUOTE_STRING_MODE,
|
|
REGEXP_MODE,
|
|
RE_STARTERS_RE,
|
|
SHEBANG,
|
|
TITLE_MODE,
|
|
UNDERSCORE_IDENT_RE,
|
|
UNDERSCORE_TITLE_MODE
|
|
});
|
|
var beforeMatchExt = (mode, parent) => {
|
|
if (!mode.beforeMatch)
|
|
return;
|
|
if (mode.starts)
|
|
throw new Error("beforeMatch cannot be used with starts");
|
|
const originalMode = Object.assign({}, mode);
|
|
Object.keys(mode).forEach((key) => {
|
|
delete mode[key];
|
|
});
|
|
mode.keywords = originalMode.keywords;
|
|
mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
|
|
mode.starts = {
|
|
relevance: 0,
|
|
contains: [
|
|
Object.assign(originalMode, { endsParent: true })
|
|
]
|
|
};
|
|
mode.relevance = 0;
|
|
delete originalMode.beforeMatch;
|
|
};
|
|
var COMMON_KEYWORDS = [
|
|
"of",
|
|
"and",
|
|
"for",
|
|
"in",
|
|
"not",
|
|
"or",
|
|
"if",
|
|
"then",
|
|
"parent",
|
|
"list",
|
|
"value"
|
|
];
|
|
var DEFAULT_KEYWORD_SCOPE = "keyword";
|
|
var seenDeprecations = {};
|
|
var error = (message) => {
|
|
console.error(message);
|
|
};
|
|
var warn = (message, ...args) => {
|
|
console.log(`WARN: ${message}`, ...args);
|
|
};
|
|
var deprecated = (version2, message) => {
|
|
if (seenDeprecations[`${version2}/${message}`])
|
|
return;
|
|
console.log(`Deprecated as of ${version2}. ${message}`);
|
|
seenDeprecations[`${version2}/${message}`] = true;
|
|
};
|
|
var MultiClassError = new Error;
|
|
var version = "11.9.0";
|
|
|
|
class HTMLInjectionError extends Error {
|
|
constructor(reason, html) {
|
|
super(reason);
|
|
this.name = "HTMLInjectionError";
|
|
this.html = html;
|
|
}
|
|
}
|
|
var escape = escapeHTML;
|
|
var inherit = inherit$1;
|
|
var NO_MATCH = Symbol("nomatch");
|
|
var MAX_KEYWORD_HITS = 7;
|
|
var HLJS = function(hljs) {
|
|
const languages = Object.create(null);
|
|
const aliases = Object.create(null);
|
|
const plugins = [];
|
|
let SAFE_MODE = true;
|
|
const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
|
|
const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] };
|
|
let options = {
|
|
ignoreUnescapedHTML: false,
|
|
throwUnescapedHTML: false,
|
|
noHighlightRe: /^(no-?highlight)$/i,
|
|
languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
|
|
classPrefix: "hljs-",
|
|
cssSelector: "pre code",
|
|
languages: null,
|
|
__emitter: TokenTreeEmitter
|
|
};
|
|
function shouldNotHighlight(languageName) {
|
|
return options.noHighlightRe.test(languageName);
|
|
}
|
|
function blockLanguage(block) {
|
|
let classes = block.className + " ";
|
|
classes += block.parentNode ? block.parentNode.className : "";
|
|
const match = options.languageDetectRe.exec(classes);
|
|
if (match) {
|
|
const language = getLanguage(match[1]);
|
|
if (!language) {
|
|
warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
|
|
warn("Falling back to no-highlight mode for this block.", block);
|
|
}
|
|
return language ? match[1] : "no-highlight";
|
|
}
|
|
return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
|
|
}
|
|
function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
|
|
let code = "";
|
|
let languageName = "";
|
|
if (typeof optionsOrCode === "object") {
|
|
code = codeOrLanguageName;
|
|
ignoreIllegals = optionsOrCode.ignoreIllegals;
|
|
languageName = optionsOrCode.language;
|
|
} else {
|
|
deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
|
|
deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
|
|
languageName = codeOrLanguageName;
|
|
code = optionsOrCode;
|
|
}
|
|
if (ignoreIllegals === undefined) {
|
|
ignoreIllegals = true;
|
|
}
|
|
const context = {
|
|
code,
|
|
language: languageName
|
|
};
|
|
fire("before:highlight", context);
|
|
const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
|
|
result.code = context.code;
|
|
fire("after:highlight", result);
|
|
return result;
|
|
}
|
|
function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
|
|
const keywordHits = Object.create(null);
|
|
function keywordData(mode, matchText) {
|
|
return mode.keywords[matchText];
|
|
}
|
|
function processKeywords() {
|
|
if (!top.keywords) {
|
|
emitter.addText(modeBuffer);
|
|
return;
|
|
}
|
|
let lastIndex = 0;
|
|
top.keywordPatternRe.lastIndex = 0;
|
|
let match = top.keywordPatternRe.exec(modeBuffer);
|
|
let buf = "";
|
|
while (match) {
|
|
buf += modeBuffer.substring(lastIndex, match.index);
|
|
const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
|
|
const data = keywordData(top, word);
|
|
if (data) {
|
|
const [kind, keywordRelevance] = data;
|
|
emitter.addText(buf);
|
|
buf = "";
|
|
keywordHits[word] = (keywordHits[word] || 0) + 1;
|
|
if (keywordHits[word] <= MAX_KEYWORD_HITS)
|
|
relevance += keywordRelevance;
|
|
if (kind.startsWith("_")) {
|
|
buf += match[0];
|
|
} else {
|
|
const cssClass = language.classNameAliases[kind] || kind;
|
|
emitKeyword(match[0], cssClass);
|
|
}
|
|
} else {
|
|
buf += match[0];
|
|
}
|
|
lastIndex = top.keywordPatternRe.lastIndex;
|
|
match = top.keywordPatternRe.exec(modeBuffer);
|
|
}
|
|
buf += modeBuffer.substring(lastIndex);
|
|
emitter.addText(buf);
|
|
}
|
|
function processSubLanguage() {
|
|
if (modeBuffer === "")
|
|
return;
|
|
let result2 = null;
|
|
if (typeof top.subLanguage === "string") {
|
|
if (!languages[top.subLanguage]) {
|
|
emitter.addText(modeBuffer);
|
|
return;
|
|
}
|
|
result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
|
|
continuations[top.subLanguage] = result2._top;
|
|
} else {
|
|
result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
|
|
}
|
|
if (top.relevance > 0) {
|
|
relevance += result2.relevance;
|
|
}
|
|
emitter.__addSublanguage(result2._emitter, result2.language);
|
|
}
|
|
function processBuffer() {
|
|
if (top.subLanguage != null) {
|
|
processSubLanguage();
|
|
} else {
|
|
processKeywords();
|
|
}
|
|
modeBuffer = "";
|
|
}
|
|
function emitKeyword(keyword, scope) {
|
|
if (keyword === "")
|
|
return;
|
|
emitter.startScope(scope);
|
|
emitter.addText(keyword);
|
|
emitter.endScope();
|
|
}
|
|
function emitMultiClass(scope, match) {
|
|
let i = 1;
|
|
const max = match.length - 1;
|
|
while (i <= max) {
|
|
if (!scope._emit[i]) {
|
|
i++;
|
|
continue;
|
|
}
|
|
const klass = language.classNameAliases[scope[i]] || scope[i];
|
|
const text = match[i];
|
|
if (klass) {
|
|
emitKeyword(text, klass);
|
|
} else {
|
|
modeBuffer = text;
|
|
processKeywords();
|
|
modeBuffer = "";
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
function startNewMode(mode, match) {
|
|
if (mode.scope && typeof mode.scope === "string") {
|
|
emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
|
|
}
|
|
if (mode.beginScope) {
|
|
if (mode.beginScope._wrap) {
|
|
emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
|
|
modeBuffer = "";
|
|
} else if (mode.beginScope._multi) {
|
|
emitMultiClass(mode.beginScope, match);
|
|
modeBuffer = "";
|
|
}
|
|
}
|
|
top = Object.create(mode, { parent: { value: top } });
|
|
return top;
|
|
}
|
|
function endOfMode(mode, match, matchPlusRemainder) {
|
|
let matched = startsWith(mode.endRe, matchPlusRemainder);
|
|
if (matched) {
|
|
if (mode["on:end"]) {
|
|
const resp = new Response(mode);
|
|
mode["on:end"](match, resp);
|
|
if (resp.isMatchIgnored)
|
|
matched = false;
|
|
}
|
|
if (matched) {
|
|
while (mode.endsParent && mode.parent) {
|
|
mode = mode.parent;
|
|
}
|
|
return mode;
|
|
}
|
|
}
|
|
if (mode.endsWithParent) {
|
|
return endOfMode(mode.parent, match, matchPlusRemainder);
|
|
}
|
|
}
|
|
function doIgnore(lexeme) {
|
|
if (top.matcher.regexIndex === 0) {
|
|
modeBuffer += lexeme[0];
|
|
return 1;
|
|
} else {
|
|
resumeScanAtSamePosition = true;
|
|
return 0;
|
|
}
|
|
}
|
|
function doBeginMatch(match) {
|
|
const lexeme = match[0];
|
|
const newMode = match.rule;
|
|
const resp = new Response(newMode);
|
|
const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
|
|
for (const cb of beforeCallbacks) {
|
|
if (!cb)
|
|
continue;
|
|
cb(match, resp);
|
|
if (resp.isMatchIgnored)
|
|
return doIgnore(lexeme);
|
|
}
|
|
if (newMode.skip) {
|
|
modeBuffer += lexeme;
|
|
} else {
|
|
if (newMode.excludeBegin) {
|
|
modeBuffer += lexeme;
|
|
}
|
|
processBuffer();
|
|
if (!newMode.returnBegin && !newMode.excludeBegin) {
|
|
modeBuffer = lexeme;
|
|
}
|
|
}
|
|
startNewMode(newMode, match);
|
|
return newMode.returnBegin ? 0 : lexeme.length;
|
|
}
|
|
function doEndMatch(match) {
|
|
const lexeme = match[0];
|
|
const matchPlusRemainder = codeToHighlight.substring(match.index);
|
|
const endMode = endOfMode(top, match, matchPlusRemainder);
|
|
if (!endMode) {
|
|
return NO_MATCH;
|
|
}
|
|
const origin = top;
|
|
if (top.endScope && top.endScope._wrap) {
|
|
processBuffer();
|
|
emitKeyword(lexeme, top.endScope._wrap);
|
|
} else if (top.endScope && top.endScope._multi) {
|
|
processBuffer();
|
|
emitMultiClass(top.endScope, match);
|
|
} else if (origin.skip) {
|
|
modeBuffer += lexeme;
|
|
} else {
|
|
if (!(origin.returnEnd || origin.excludeEnd)) {
|
|
modeBuffer += lexeme;
|
|
}
|
|
processBuffer();
|
|
if (origin.excludeEnd) {
|
|
modeBuffer = lexeme;
|
|
}
|
|
}
|
|
do {
|
|
if (top.scope) {
|
|
emitter.closeNode();
|
|
}
|
|
if (!top.skip && !top.subLanguage) {
|
|
relevance += top.relevance;
|
|
}
|
|
top = top.parent;
|
|
} while (top !== endMode.parent);
|
|
if (endMode.starts) {
|
|
startNewMode(endMode.starts, match);
|
|
}
|
|
return origin.returnEnd ? 0 : lexeme.length;
|
|
}
|
|
function processContinuations() {
|
|
const list = [];
|
|
for (let current = top;current !== language; current = current.parent) {
|
|
if (current.scope) {
|
|
list.unshift(current.scope);
|
|
}
|
|
}
|
|
list.forEach((item) => emitter.openNode(item));
|
|
}
|
|
let lastMatch = {};
|
|
function processLexeme(textBeforeMatch, match) {
|
|
const lexeme = match && match[0];
|
|
modeBuffer += textBeforeMatch;
|
|
if (lexeme == null) {
|
|
processBuffer();
|
|
return 0;
|
|
}
|
|
if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
|
|
modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
|
|
if (!SAFE_MODE) {
|
|
const err = new Error(`0 width match regex (${languageName})`);
|
|
err.languageName = languageName;
|
|
err.badRule = lastMatch.rule;
|
|
throw err;
|
|
}
|
|
return 1;
|
|
}
|
|
lastMatch = match;
|
|
if (match.type === "begin") {
|
|
return doBeginMatch(match);
|
|
} else if (match.type === "illegal" && !ignoreIllegals) {
|
|
const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "<unnamed>") + '"');
|
|
err.mode = top;
|
|
throw err;
|
|
} else if (match.type === "end") {
|
|
const processed = doEndMatch(match);
|
|
if (processed !== NO_MATCH) {
|
|
return processed;
|
|
}
|
|
}
|
|
if (match.type === "illegal" && lexeme === "") {
|
|
return 1;
|
|
}
|
|
if (iterations > 1e5 && iterations > match.index * 3) {
|
|
const err = new Error("potential infinite loop, way more iterations than matches");
|
|
throw err;
|
|
}
|
|
modeBuffer += lexeme;
|
|
return lexeme.length;
|
|
}
|
|
const language = getLanguage(languageName);
|
|
if (!language) {
|
|
error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
|
|
throw new Error('Unknown language: "' + languageName + '"');
|
|
}
|
|
const md = compileLanguage(language);
|
|
let result = "";
|
|
let top = continuation || md;
|
|
const continuations = {};
|
|
const emitter = new options.__emitter(options);
|
|
processContinuations();
|
|
let modeBuffer = "";
|
|
let relevance = 0;
|
|
let index = 0;
|
|
let iterations = 0;
|
|
let resumeScanAtSamePosition = false;
|
|
try {
|
|
if (!language.__emitTokens) {
|
|
top.matcher.considerAll();
|
|
for (;; ) {
|
|
iterations++;
|
|
if (resumeScanAtSamePosition) {
|
|
resumeScanAtSamePosition = false;
|
|
} else {
|
|
top.matcher.considerAll();
|
|
}
|
|
top.matcher.lastIndex = index;
|
|
const match = top.matcher.exec(codeToHighlight);
|
|
if (!match)
|
|
break;
|
|
const beforeMatch = codeToHighlight.substring(index, match.index);
|
|
const processedCount = processLexeme(beforeMatch, match);
|
|
index = match.index + processedCount;
|
|
}
|
|
processLexeme(codeToHighlight.substring(index));
|
|
} else {
|
|
language.__emitTokens(codeToHighlight, emitter);
|
|
}
|
|
emitter.finalize();
|
|
result = emitter.toHTML();
|
|
return {
|
|
language: languageName,
|
|
value: result,
|
|
relevance,
|
|
illegal: false,
|
|
_emitter: emitter,
|
|
_top: top
|
|
};
|
|
} catch (err) {
|
|
if (err.message && err.message.includes("Illegal")) {
|
|
return {
|
|
language: languageName,
|
|
value: escape(codeToHighlight),
|
|
illegal: true,
|
|
relevance: 0,
|
|
_illegalBy: {
|
|
message: err.message,
|
|
index,
|
|
context: codeToHighlight.slice(index - 100, index + 100),
|
|
mode: err.mode,
|
|
resultSoFar: result
|
|
},
|
|
_emitter: emitter
|
|
};
|
|
} else if (SAFE_MODE) {
|
|
return {
|
|
language: languageName,
|
|
value: escape(codeToHighlight),
|
|
illegal: false,
|
|
relevance: 0,
|
|
errorRaised: err,
|
|
_emitter: emitter,
|
|
_top: top
|
|
};
|
|
} else {
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
function justTextHighlightResult(code) {
|
|
const result = {
|
|
value: escape(code),
|
|
illegal: false,
|
|
relevance: 0,
|
|
_top: PLAINTEXT_LANGUAGE,
|
|
_emitter: new options.__emitter(options)
|
|
};
|
|
result._emitter.addText(code);
|
|
return result;
|
|
}
|
|
function highlightAuto(code, languageSubset) {
|
|
languageSubset = languageSubset || options.languages || Object.keys(languages);
|
|
const plaintext = justTextHighlightResult(code);
|
|
const results = languageSubset.filter(getLanguage).filter(autoDetection).map((name) => _highlight(name, code, false));
|
|
results.unshift(plaintext);
|
|
const sorted = results.sort((a, b) => {
|
|
if (a.relevance !== b.relevance)
|
|
return b.relevance - a.relevance;
|
|
if (a.language && b.language) {
|
|
if (getLanguage(a.language).supersetOf === b.language) {
|
|
return 1;
|
|
} else if (getLanguage(b.language).supersetOf === a.language) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
});
|
|
const [best, secondBest] = sorted;
|
|
const result = best;
|
|
result.secondBest = secondBest;
|
|
return result;
|
|
}
|
|
function updateClassName(element, currentLang, resultLang) {
|
|
const language = currentLang && aliases[currentLang] || resultLang;
|
|
element.classList.add("hljs");
|
|
element.classList.add(`language-${language}`);
|
|
}
|
|
function highlightElement(element) {
|
|
let node = null;
|
|
const language = blockLanguage(element);
|
|
if (shouldNotHighlight(language))
|
|
return;
|
|
fire("before:highlightElement", { el: element, language });
|
|
if (element.dataset.highlighted) {
|
|
console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
|
|
return;
|
|
}
|
|
if (element.children.length > 0) {
|
|
if (!options.ignoreUnescapedHTML) {
|
|
console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
|
|
console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
|
|
console.warn("The element with unescaped HTML:");
|
|
console.warn(element);
|
|
}
|
|
if (options.throwUnescapedHTML) {
|
|
const err = new HTMLInjectionError("One of your code blocks includes unescaped HTML.", element.innerHTML);
|
|
throw err;
|
|
}
|
|
}
|
|
node = element;
|
|
const text = node.textContent;
|
|
const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
|
|
element.innerHTML = result.value;
|
|
element.dataset.highlighted = "yes";
|
|
updateClassName(element, language, result.language);
|
|
element.result = {
|
|
language: result.language,
|
|
re: result.relevance,
|
|
relevance: result.relevance
|
|
};
|
|
if (result.secondBest) {
|
|
element.secondBest = {
|
|
language: result.secondBest.language,
|
|
relevance: result.secondBest.relevance
|
|
};
|
|
}
|
|
fire("after:highlightElement", { el: element, result, text });
|
|
}
|
|
function configure(userOptions) {
|
|
options = inherit(options, userOptions);
|
|
}
|
|
const initHighlighting = () => {
|
|
highlightAll();
|
|
deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now.");
|
|
};
|
|
function initHighlightingOnLoad() {
|
|
highlightAll();
|
|
deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now.");
|
|
}
|
|
let wantsHighlight = false;
|
|
function highlightAll() {
|
|
if (document.readyState === "loading") {
|
|
wantsHighlight = true;
|
|
return;
|
|
}
|
|
const blocks = document.querySelectorAll(options.cssSelector);
|
|
blocks.forEach(highlightElement);
|
|
}
|
|
function boot() {
|
|
if (wantsHighlight)
|
|
highlightAll();
|
|
}
|
|
if (typeof window !== "undefined" && window.addEventListener) {
|
|
window.addEventListener("DOMContentLoaded", boot, false);
|
|
}
|
|
function registerLanguage(languageName, languageDefinition) {
|
|
let lang = null;
|
|
try {
|
|
lang = languageDefinition(hljs);
|
|
} catch (error$1) {
|
|
error("Language definition for '{}' could not be registered.".replace("{}", languageName));
|
|
if (!SAFE_MODE) {
|
|
throw error$1;
|
|
} else {
|
|
error(error$1);
|
|
}
|
|
lang = PLAINTEXT_LANGUAGE;
|
|
}
|
|
if (!lang.name)
|
|
lang.name = languageName;
|
|
languages[languageName] = lang;
|
|
lang.rawDefinition = languageDefinition.bind(null, hljs);
|
|
if (lang.aliases) {
|
|
registerAliases(lang.aliases, { languageName });
|
|
}
|
|
}
|
|
function unregisterLanguage(languageName) {
|
|
delete languages[languageName];
|
|
for (const alias of Object.keys(aliases)) {
|
|
if (aliases[alias] === languageName) {
|
|
delete aliases[alias];
|
|
}
|
|
}
|
|
}
|
|
function listLanguages() {
|
|
return Object.keys(languages);
|
|
}
|
|
function getLanguage(name) {
|
|
name = (name || "").toLowerCase();
|
|
return languages[name] || languages[aliases[name]];
|
|
}
|
|
function registerAliases(aliasList, { languageName }) {
|
|
if (typeof aliasList === "string") {
|
|
aliasList = [aliasList];
|
|
}
|
|
aliasList.forEach((alias) => {
|
|
aliases[alias.toLowerCase()] = languageName;
|
|
});
|
|
}
|
|
function autoDetection(name) {
|
|
const lang = getLanguage(name);
|
|
return lang && !lang.disableAutodetect;
|
|
}
|
|
function upgradePluginAPI(plugin) {
|
|
if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
|
|
plugin["before:highlightElement"] = (data) => {
|
|
plugin["before:highlightBlock"](Object.assign({ block: data.el }, data));
|
|
};
|
|
}
|
|
if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
|
|
plugin["after:highlightElement"] = (data) => {
|
|
plugin["after:highlightBlock"](Object.assign({ block: data.el }, data));
|
|
};
|
|
}
|
|
}
|
|
function addPlugin(plugin) {
|
|
upgradePluginAPI(plugin);
|
|
plugins.push(plugin);
|
|
}
|
|
function removePlugin(plugin) {
|
|
const index = plugins.indexOf(plugin);
|
|
if (index !== -1) {
|
|
plugins.splice(index, 1);
|
|
}
|
|
}
|
|
function fire(event, args) {
|
|
const cb = event;
|
|
plugins.forEach(function(plugin) {
|
|
if (plugin[cb]) {
|
|
plugin[cb](args);
|
|
}
|
|
});
|
|
}
|
|
function deprecateHighlightBlock(el) {
|
|
deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
|
|
deprecated("10.7.0", "Please use highlightElement now.");
|
|
return highlightElement(el);
|
|
}
|
|
Object.assign(hljs, {
|
|
highlight: highlight2,
|
|
highlightAuto,
|
|
highlightAll,
|
|
highlightElement,
|
|
highlightBlock: deprecateHighlightBlock,
|
|
configure,
|
|
initHighlighting,
|
|
initHighlightingOnLoad,
|
|
registerLanguage,
|
|
unregisterLanguage,
|
|
listLanguages,
|
|
getLanguage,
|
|
registerAliases,
|
|
autoDetection,
|
|
inherit,
|
|
addPlugin,
|
|
removePlugin
|
|
});
|
|
hljs.debugMode = function() {
|
|
SAFE_MODE = false;
|
|
};
|
|
hljs.safeMode = function() {
|
|
SAFE_MODE = true;
|
|
};
|
|
hljs.versionString = version;
|
|
hljs.regex = {
|
|
concat,
|
|
lookahead,
|
|
either,
|
|
optional,
|
|
anyNumberOfTimes
|
|
};
|
|
for (const key in MODES) {
|
|
if (typeof MODES[key] === "object") {
|
|
deepFreeze(MODES[key]);
|
|
}
|
|
}
|
|
Object.assign(hljs, MODES);
|
|
return hljs;
|
|
};
|
|
var highlight = HLJS({});
|
|
highlight.newInstance = () => HLJS({});
|
|
module.exports = highlight;
|
|
highlight.HighlightJS = highlight;
|
|
highlight.default = highlight;
|
|
});
|
|
|
|
// node_modules/highlight.js/es/core.js
|
|
var core = __toESM(require_core(), 1);
|
|
var core_default = core.default;
|
|
|
|
// node_modules/highlight.js/es/languages/bash.js
|
|
var bash = function(hljs) {
|
|
const regex = hljs.regex;
|
|
const VAR = {};
|
|
const BRACED_VAR = {
|
|
begin: /\$\{/,
|
|
end: /\}/,
|
|
contains: [
|
|
"self",
|
|
{
|
|
begin: /:-/,
|
|
contains: [VAR]
|
|
}
|
|
]
|
|
};
|
|
Object.assign(VAR, {
|
|
className: "variable",
|
|
variants: [
|
|
{ begin: regex.concat(/\$[\w\d#@][\w\d_]*/, `(?![\\w\\d])(?![\$])`) },
|
|
BRACED_VAR
|
|
]
|
|
});
|
|
const SUBST = {
|
|
className: "subst",
|
|
begin: /\$\(/,
|
|
end: /\)/,
|
|
contains: [hljs.BACKSLASH_ESCAPE]
|
|
};
|
|
const HERE_DOC = {
|
|
begin: /<<-?\s*(?=\w+)/,
|
|
starts: { contains: [
|
|
hljs.END_SAME_AS_BEGIN({
|
|
begin: /(\w+)/,
|
|
end: /(\w+)/,
|
|
className: "string"
|
|
})
|
|
] }
|
|
};
|
|
const QUOTE_STRING = {
|
|
className: "string",
|
|
begin: /"/,
|
|
end: /"/,
|
|
contains: [
|
|
hljs.BACKSLASH_ESCAPE,
|
|
VAR,
|
|
SUBST
|
|
]
|
|
};
|
|
SUBST.contains.push(QUOTE_STRING);
|
|
const ESCAPED_QUOTE = {
|
|
match: /\\"/
|
|
};
|
|
const APOS_STRING = {
|
|
className: "string",
|
|
begin: /'/,
|
|
end: /'/
|
|
};
|
|
const ESCAPED_APOS = {
|
|
match: /\\'/
|
|
};
|
|
const ARITHMETIC = {
|
|
begin: /\$?\(\(/,
|
|
end: /\)\)/,
|
|
contains: [
|
|
{
|
|
begin: /\d+#[0-9a-f]+/,
|
|
className: "number"
|
|
},
|
|
hljs.NUMBER_MODE,
|
|
VAR
|
|
]
|
|
};
|
|
const SH_LIKE_SHELLS = [
|
|
"fish",
|
|
"bash",
|
|
"zsh",
|
|
"sh",
|
|
"csh",
|
|
"ksh",
|
|
"tcsh",
|
|
"dash",
|
|
"scsh"
|
|
];
|
|
const KNOWN_SHEBANG = hljs.SHEBANG({
|
|
binary: `(${SH_LIKE_SHELLS.join("|")})`,
|
|
relevance: 10
|
|
});
|
|
const FUNCTION = {
|
|
className: "function",
|
|
begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/,
|
|
returnBegin: true,
|
|
contains: [hljs.inherit(hljs.TITLE_MODE, { begin: /\w[\w\d_]*/ })],
|
|
relevance: 0
|
|
};
|
|
const KEYWORDS = [
|
|
"if",
|
|
"then",
|
|
"else",
|
|
"elif",
|
|
"fi",
|
|
"for",
|
|
"while",
|
|
"until",
|
|
"in",
|
|
"do",
|
|
"done",
|
|
"case",
|
|
"esac",
|
|
"function",
|
|
"select"
|
|
];
|
|
const LITERALS = [
|
|
"true",
|
|
"false"
|
|
];
|
|
const PATH_MODE = { match: /(\/[a-z._-]+)+/ };
|
|
const SHELL_BUILT_INS = [
|
|
"break",
|
|
"cd",
|
|
"continue",
|
|
"eval",
|
|
"exec",
|
|
"exit",
|
|
"export",
|
|
"getopts",
|
|
"hash",
|
|
"pwd",
|
|
"readonly",
|
|
"return",
|
|
"shift",
|
|
"test",
|
|
"times",
|
|
"trap",
|
|
"umask",
|
|
"unset"
|
|
];
|
|
const BASH_BUILT_INS = [
|
|
"alias",
|
|
"bind",
|
|
"builtin",
|
|
"caller",
|
|
"command",
|
|
"declare",
|
|
"echo",
|
|
"enable",
|
|
"help",
|
|
"let",
|
|
"local",
|
|
"logout",
|
|
"mapfile",
|
|
"printf",
|
|
"read",
|
|
"readarray",
|
|
"source",
|
|
"type",
|
|
"typeset",
|
|
"ulimit",
|
|
"unalias"
|
|
];
|
|
const ZSH_BUILT_INS = [
|
|
"autoload",
|
|
"bg",
|
|
"bindkey",
|
|
"bye",
|
|
"cap",
|
|
"chdir",
|
|
"clone",
|
|
"comparguments",
|
|
"compcall",
|
|
"compctl",
|
|
"compdescribe",
|
|
"compfiles",
|
|
"compgroups",
|
|
"compquote",
|
|
"comptags",
|
|
"comptry",
|
|
"compvalues",
|
|
"dirs",
|
|
"disable",
|
|
"disown",
|
|
"echotc",
|
|
"echoti",
|
|
"emulate",
|
|
"fc",
|
|
"fg",
|
|
"float",
|
|
"functions",
|
|
"getcap",
|
|
"getln",
|
|
"history",
|
|
"integer",
|
|
"jobs",
|
|
"kill",
|
|
"limit",
|
|
"log",
|
|
"noglob",
|
|
"popd",
|
|
"print",
|
|
"pushd",
|
|
"pushln",
|
|
"rehash",
|
|
"sched",
|
|
"setcap",
|
|
"setopt",
|
|
"stat",
|
|
"suspend",
|
|
"ttyctl",
|
|
"unfunction",
|
|
"unhash",
|
|
"unlimit",
|
|
"unsetopt",
|
|
"vared",
|
|
"wait",
|
|
"whence",
|
|
"where",
|
|
"which",
|
|
"zcompile",
|
|
"zformat",
|
|
"zftp",
|
|
"zle",
|
|
"zmodload",
|
|
"zparseopts",
|
|
"zprof",
|
|
"zpty",
|
|
"zregexparse",
|
|
"zsocket",
|
|
"zstyle",
|
|
"ztcp"
|
|
];
|
|
const GNU_CORE_UTILS = [
|
|
"chcon",
|
|
"chgrp",
|
|
"chown",
|
|
"chmod",
|
|
"cp",
|
|
"dd",
|
|
"df",
|
|
"dir",
|
|
"dircolors",
|
|
"ln",
|
|
"ls",
|
|
"mkdir",
|
|
"mkfifo",
|
|
"mknod",
|
|
"mktemp",
|
|
"mv",
|
|
"realpath",
|
|
"rm",
|
|
"rmdir",
|
|
"shred",
|
|
"sync",
|
|
"touch",
|
|
"truncate",
|
|
"vdir",
|
|
"b2sum",
|
|
"base32",
|
|
"base64",
|
|
"cat",
|
|
"cksum",
|
|
"comm",
|
|
"csplit",
|
|
"cut",
|
|
"expand",
|
|
"fmt",
|
|
"fold",
|
|
"head",
|
|
"join",
|
|
"md5sum",
|
|
"nl",
|
|
"numfmt",
|
|
"od",
|
|
"paste",
|
|
"ptx",
|
|
"pr",
|
|
"sha1sum",
|
|
"sha224sum",
|
|
"sha256sum",
|
|
"sha384sum",
|
|
"sha512sum",
|
|
"shuf",
|
|
"sort",
|
|
"split",
|
|
"sum",
|
|
"tac",
|
|
"tail",
|
|
"tr",
|
|
"tsort",
|
|
"unexpand",
|
|
"uniq",
|
|
"wc",
|
|
"arch",
|
|
"basename",
|
|
"chroot",
|
|
"date",
|
|
"dirname",
|
|
"du",
|
|
"echo",
|
|
"env",
|
|
"expr",
|
|
"factor",
|
|
"groups",
|
|
"hostid",
|
|
"id",
|
|
"link",
|
|
"logname",
|
|
"nice",
|
|
"nohup",
|
|
"nproc",
|
|
"pathchk",
|
|
"pinky",
|
|
"printenv",
|
|
"printf",
|
|
"pwd",
|
|
"readlink",
|
|
"runcon",
|
|
"seq",
|
|
"sleep",
|
|
"stat",
|
|
"stdbuf",
|
|
"stty",
|
|
"tee",
|
|
"test",
|
|
"timeout",
|
|
"tty",
|
|
"uname",
|
|
"unlink",
|
|
"uptime",
|
|
"users",
|
|
"who",
|
|
"whoami",
|
|
"yes"
|
|
];
|
|
return {
|
|
name: "Bash",
|
|
aliases: ["sh"],
|
|
keywords: {
|
|
$pattern: /\b[a-z][a-z0-9._-]+\b/,
|
|
keyword: KEYWORDS,
|
|
literal: LITERALS,
|
|
built_in: [
|
|
...SHELL_BUILT_INS,
|
|
...BASH_BUILT_INS,
|
|
"set",
|
|
"shopt",
|
|
...ZSH_BUILT_INS,
|
|
...GNU_CORE_UTILS
|
|
]
|
|
},
|
|
contains: [
|
|
KNOWN_SHEBANG,
|
|
hljs.SHEBANG(),
|
|
FUNCTION,
|
|
ARITHMETIC,
|
|
hljs.HASH_COMMENT_MODE,
|
|
HERE_DOC,
|
|
PATH_MODE,
|
|
QUOTE_STRING,
|
|
ESCAPED_QUOTE,
|
|
APOS_STRING,
|
|
ESCAPED_APOS,
|
|
VAR
|
|
]
|
|
};
|
|
};
|
|
|
|
// assets/js/highlight.ts
|
|
core_default.registerLanguage("bash", bash);
|
|
var addStylesheet = function(url) {
|
|
const link = document.createElement("link");
|
|
link.rel = "stylesheet";
|
|
link.href = url;
|
|
document.head.appendChild(link);
|
|
};
|
|
var wrapAsCode = function(container, language) {
|
|
const code = container.innerHTML.split("\n");
|
|
code.pop();
|
|
const codeElement = document.createElement("code");
|
|
codeElement.className = `language-${language}`;
|
|
codeElement.innerHTML = code.join("\n");
|
|
const pre = document.createElement("pre");
|
|
pre.appendChild(codeElement);
|
|
container.replaceChildren(pre);
|
|
return codeElement;
|
|
};
|
|
var addReadmeLink = function(codeblock) {
|
|
const span = document.createElement("span");
|
|
span.className = "hljs-comment";
|
|
const readme = document.createElement("a");
|
|
readme.innerText = "WHAT IS THIS";
|
|
readme.href = "https://dots.00dani.me/README";
|
|
span.append("# ", readme);
|
|
codeblock.querySelector("span.hljs-meta + span.hljs-comment")?.replaceWith(span);
|
|
};
|
|
addStylesheet("/assets/css/style.css");
|
|
addStylesheet("/assets/css/code.css");
|
|
addStylesheet("/assets/css/monokai.min.css");
|
|
var codeblock = wrapAsCode(document.body, "bash");
|
|
core_default.highlightElement(codeblock);
|
|
addReadmeLink(codeblock);
|