mirror of
https://github.com/Funkoala14/knowledgebase_law.git
synced 2025-06-09 02:08:16 +08:00
1814 lines
58 KiB
JavaScript
1814 lines
58 KiB
JavaScript
|
import {
|
||
|
|
__commonJS
|
||
|
|
} from "./chunk-2TUXWMP5.js";
|
||
|
|
|
||
|
|
// node_modules/highlight.js/lib/core.js
|
||
|
|
var require_core = __commonJS({
|
||
|
|
"node_modules/highlight.js/lib/core.js"(exports, module) {
|
||
|
|
function deepFreeze(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(function(name) {
|
||
|
|
var prop = obj[name];
|
||
|
|
if (typeof prop == "object" && !Object.isFrozen(prop)) {
|
||
|
|
deepFreeze(prop);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
var deepFreezeEs6 = deepFreeze;
|
||
|
|
var _default = deepFreeze;
|
||
|
|
deepFreezeEs6.default = _default;
|
||
|
|
var Response = class {
|
||
|
|
/**
|
||
|
|
* @param {CompiledMode} mode
|
||
|
|
*/
|
||
|
|
constructor(mode) {
|
||
|
|
if (mode.data === void 0) mode.data = {};
|
||
|
|
this.data = mode.data;
|
||
|
|
this.isMatchIgnored = false;
|
||
|
|
}
|
||
|
|
ignoreMatch() {
|
||
|
|
this.isMatchIgnored = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function escapeHTML(value) {
|
||
|
|
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'");
|
||
|
|
}
|
||
|
|
function inherit(original, ...objects) {
|
||
|
|
const result = /* @__PURE__ */ 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 (
|
||
|
|
/** @type {T} */
|
||
|
|
result
|
||
|
|
);
|
||
|
|
}
|
||
|
|
var SPAN_CLOSE = "</span>";
|
||
|
|
var emitsWrappingTags = (node) => {
|
||
|
|
return !!node.kind;
|
||
|
|
};
|
||
|
|
var HTMLRenderer = class {
|
||
|
|
/**
|
||
|
|
* Creates a new HTMLRenderer
|
||
|
|
*
|
||
|
|
* @param {Tree} parseTree - the parse tree (must support `walk` API)
|
||
|
|
* @param {{classPrefix: string}} options
|
||
|
|
*/
|
||
|
|
constructor(parseTree, options) {
|
||
|
|
this.buffer = "";
|
||
|
|
this.classPrefix = options.classPrefix;
|
||
|
|
parseTree.walk(this);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Adds texts to the output stream
|
||
|
|
*
|
||
|
|
* @param {string} text */
|
||
|
|
addText(text) {
|
||
|
|
this.buffer += escapeHTML(text);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Adds a node open to the output stream (if needed)
|
||
|
|
*
|
||
|
|
* @param {Node} node */
|
||
|
|
openNode(node) {
|
||
|
|
if (!emitsWrappingTags(node)) return;
|
||
|
|
let className = node.kind;
|
||
|
|
if (!node.sublanguage) {
|
||
|
|
className = `${this.classPrefix}${className}`;
|
||
|
|
}
|
||
|
|
this.span(className);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Adds a node close to the output stream (if needed)
|
||
|
|
*
|
||
|
|
* @param {Node} node */
|
||
|
|
closeNode(node) {
|
||
|
|
if (!emitsWrappingTags(node)) return;
|
||
|
|
this.buffer += SPAN_CLOSE;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* returns the accumulated buffer
|
||
|
|
*/
|
||
|
|
value() {
|
||
|
|
return this.buffer;
|
||
|
|
}
|
||
|
|
// helpers
|
||
|
|
/**
|
||
|
|
* Builds a span element
|
||
|
|
*
|
||
|
|
* @param {string} className */
|
||
|
|
span(className) {
|
||
|
|
this.buffer += `<span class="${className}">`;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var TokenTree = class _TokenTree {
|
||
|
|
constructor() {
|
||
|
|
this.rootNode = { children: [] };
|
||
|
|
this.stack = [this.rootNode];
|
||
|
|
}
|
||
|
|
get top() {
|
||
|
|
return this.stack[this.stack.length - 1];
|
||
|
|
}
|
||
|
|
get root() {
|
||
|
|
return this.rootNode;
|
||
|
|
}
|
||
|
|
/** @param {Node} node */
|
||
|
|
add(node) {
|
||
|
|
this.top.children.push(node);
|
||
|
|
}
|
||
|
|
/** @param {string} kind */
|
||
|
|
openNode(kind) {
|
||
|
|
const node = { kind, children: [] };
|
||
|
|
this.add(node);
|
||
|
|
this.stack.push(node);
|
||
|
|
}
|
||
|
|
closeNode() {
|
||
|
|
if (this.stack.length > 1) {
|
||
|
|
return this.stack.pop();
|
||
|
|
}
|
||
|
|
return void 0;
|
||
|
|
}
|
||
|
|
closeAllNodes() {
|
||
|
|
while (this.closeNode()) ;
|
||
|
|
}
|
||
|
|
toJSON() {
|
||
|
|
return JSON.stringify(this.rootNode, null, 4);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @typedef { import("./html_renderer").Renderer } Renderer
|
||
|
|
* @param {Renderer} builder
|
||
|
|
*/
|
||
|
|
walk(builder) {
|
||
|
|
return this.constructor._walk(builder, this.rootNode);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {Renderer} builder
|
||
|
|
* @param {Node} node
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {Node} node
|
||
|
|
*/
|
||
|
|
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);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var TokenTreeEmitter = class extends TokenTree {
|
||
|
|
/**
|
||
|
|
* @param {*} options
|
||
|
|
*/
|
||
|
|
constructor(options) {
|
||
|
|
super();
|
||
|
|
this.options = options;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {string} text
|
||
|
|
* @param {string} kind
|
||
|
|
*/
|
||
|
|
addKeyword(text, kind) {
|
||
|
|
if (text === "") {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this.openNode(kind);
|
||
|
|
this.addText(text);
|
||
|
|
this.closeNode();
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {string} text
|
||
|
|
*/
|
||
|
|
addText(text) {
|
||
|
|
if (text === "") {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this.add(text);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {Emitter & {root: DataNode}} emitter
|
||
|
|
* @param {string} name
|
||
|
|
*/
|
||
|
|
addSublanguage(emitter, name) {
|
||
|
|
const node = emitter.root;
|
||
|
|
node.kind = name;
|
||
|
|
node.sublanguage = true;
|
||
|
|
this.add(node);
|
||
|
|
}
|
||
|
|
toHTML() {
|
||
|
|
const renderer = new HTMLRenderer(this, this.options);
|
||
|
|
return renderer.value();
|
||
|
|
}
|
||
|
|
finalize() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function escape(value) {
|
||
|
|
return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"), "m");
|
||
|
|
}
|
||
|
|
function source(re) {
|
||
|
|
if (!re) return null;
|
||
|
|
if (typeof re === "string") return re;
|
||
|
|
return re.source;
|
||
|
|
}
|
||
|
|
function concat(...args) {
|
||
|
|
const joined = args.map((x) => source(x)).join("");
|
||
|
|
return joined;
|
||
|
|
}
|
||
|
|
function either(...args) {
|
||
|
|
const joined = "(" + args.map((x) => source(x)).join("|") + ")";
|
||
|
|
return joined;
|
||
|
|
}
|
||
|
|
function countMatchGroups(re) {
|
||
|
|
return new RegExp(re.toString() + "|").exec("").length - 1;
|
||
|
|
}
|
||
|
|
function startsWith(re, lexeme) {
|
||
|
|
const match = re && re.exec(lexeme);
|
||
|
|
return match && match.index === 0;
|
||
|
|
}
|
||
|
|
var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
|
||
|
|
function join(regexps, separator = "|") {
|
||
|
|
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(separator);
|
||
|
|
}
|
||
|
|
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({
|
||
|
|
className: "meta",
|
||
|
|
begin: beginShebang,
|
||
|
|
end: /$/,
|
||
|
|
relevance: 0,
|
||
|
|
/** @type {ModeCallback} */
|
||
|
|
"on:begin": (m, resp) => {
|
||
|
|
if (m.index !== 0) resp.ignoreMatch();
|
||
|
|
}
|
||
|
|
}, opts);
|
||
|
|
};
|
||
|
|
var BACKSLASH_ESCAPE = {
|
||
|
|
begin: "\\\\[\\s\\S]",
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var APOS_STRING_MODE = {
|
||
|
|
className: "string",
|
||
|
|
begin: "'",
|
||
|
|
end: "'",
|
||
|
|
illegal: "\\n",
|
||
|
|
contains: [BACKSLASH_ESCAPE]
|
||
|
|
};
|
||
|
|
var QUOTE_STRING_MODE = {
|
||
|
|
className: "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(
|
||
|
|
{
|
||
|
|
className: "comment",
|
||
|
|
begin,
|
||
|
|
end,
|
||
|
|
contains: []
|
||
|
|
},
|
||
|
|
modeOptions
|
||
|
|
);
|
||
|
|
mode.contains.push(PHRASAL_WORDS_MODE);
|
||
|
|
mode.contains.push({
|
||
|
|
className: "doctag",
|
||
|
|
begin: "(?:TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):",
|
||
|
|
relevance: 0
|
||
|
|
});
|
||
|
|
return mode;
|
||
|
|
};
|
||
|
|
var C_LINE_COMMENT_MODE = COMMENT("//", "$");
|
||
|
|
var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/");
|
||
|
|
var HASH_COMMENT_MODE = COMMENT("#", "$");
|
||
|
|
var NUMBER_MODE = {
|
||
|
|
className: "number",
|
||
|
|
begin: NUMBER_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var C_NUMBER_MODE = {
|
||
|
|
className: "number",
|
||
|
|
begin: C_NUMBER_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var BINARY_NUMBER_MODE = {
|
||
|
|
className: "number",
|
||
|
|
begin: BINARY_NUMBER_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var CSS_NUMBER_MODE = {
|
||
|
|
className: "number",
|
||
|
|
begin: NUMBER_RE + "(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var REGEXP_MODE = {
|
||
|
|
// this outer rule makes sure we actually have a WHOLE regex and not simply
|
||
|
|
// an expression such as:
|
||
|
|
//
|
||
|
|
// 3 / something
|
||
|
|
//
|
||
|
|
// (which will then blow up when regex's `illegal` sees the newline)
|
||
|
|
begin: /(?=\/[^/\n]*\/)/,
|
||
|
|
contains: [{
|
||
|
|
className: "regexp",
|
||
|
|
begin: /\//,
|
||
|
|
end: /\/[gimuy]*/,
|
||
|
|
illegal: /\n/,
|
||
|
|
contains: [
|
||
|
|
BACKSLASH_ESCAPE,
|
||
|
|
{
|
||
|
|
begin: /\[/,
|
||
|
|
end: /\]/,
|
||
|
|
relevance: 0,
|
||
|
|
contains: [BACKSLASH_ESCAPE]
|
||
|
|
}
|
||
|
|
]
|
||
|
|
}]
|
||
|
|
};
|
||
|
|
var TITLE_MODE = {
|
||
|
|
className: "title",
|
||
|
|
begin: IDENT_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var UNDERSCORE_TITLE_MODE = {
|
||
|
|
className: "title",
|
||
|
|
begin: UNDERSCORE_IDENT_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var METHOD_GUARD = {
|
||
|
|
// excludes method names from keyword processing
|
||
|
|
begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
|
||
|
|
relevance: 0
|
||
|
|
};
|
||
|
|
var END_SAME_AS_BEGIN = function(mode) {
|
||
|
|
return Object.assign(
|
||
|
|
mode,
|
||
|
|
{
|
||
|
|
/** @type {ModeCallback} */
|
||
|
|
"on:begin": (m, resp) => {
|
||
|
|
resp.data._beginMatch = m[1];
|
||
|
|
},
|
||
|
|
/** @type {ModeCallback} */
|
||
|
|
"on:end": (m, resp) => {
|
||
|
|
if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
);
|
||
|
|
};
|
||
|
|
var MODES = Object.freeze({
|
||
|
|
__proto__: null,
|
||
|
|
MATCH_NOTHING_RE,
|
||
|
|
IDENT_RE,
|
||
|
|
UNDERSCORE_IDENT_RE,
|
||
|
|
NUMBER_RE,
|
||
|
|
C_NUMBER_RE,
|
||
|
|
BINARY_NUMBER_RE,
|
||
|
|
RE_STARTERS_RE,
|
||
|
|
SHEBANG,
|
||
|
|
BACKSLASH_ESCAPE,
|
||
|
|
APOS_STRING_MODE,
|
||
|
|
QUOTE_STRING_MODE,
|
||
|
|
PHRASAL_WORDS_MODE,
|
||
|
|
COMMENT,
|
||
|
|
C_LINE_COMMENT_MODE,
|
||
|
|
C_BLOCK_COMMENT_MODE,
|
||
|
|
HASH_COMMENT_MODE,
|
||
|
|
NUMBER_MODE,
|
||
|
|
C_NUMBER_MODE,
|
||
|
|
BINARY_NUMBER_MODE,
|
||
|
|
CSS_NUMBER_MODE,
|
||
|
|
REGEXP_MODE,
|
||
|
|
TITLE_MODE,
|
||
|
|
UNDERSCORE_TITLE_MODE,
|
||
|
|
METHOD_GUARD,
|
||
|
|
END_SAME_AS_BEGIN
|
||
|
|
});
|
||
|
|
function skipIfhasPrecedingDot(match, response) {
|
||
|
|
const before = match.input[match.index - 1];
|
||
|
|
if (before === ".") {
|
||
|
|
response.ignoreMatch();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function beginKeywords(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 === void 0) mode.relevance = 0;
|
||
|
|
}
|
||
|
|
function compileIllegal(mode, _parent) {
|
||
|
|
if (!Array.isArray(mode.illegal)) return;
|
||
|
|
mode.illegal = either(...mode.illegal);
|
||
|
|
}
|
||
|
|
function compileMatch(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;
|
||
|
|
}
|
||
|
|
function compileRelevance(mode, _parent) {
|
||
|
|
if (mode.relevance === void 0) mode.relevance = 1;
|
||
|
|
}
|
||
|
|
var COMMON_KEYWORDS = [
|
||
|
|
"of",
|
||
|
|
"and",
|
||
|
|
"for",
|
||
|
|
"in",
|
||
|
|
"not",
|
||
|
|
"or",
|
||
|
|
"if",
|
||
|
|
"then",
|
||
|
|
"parent",
|
||
|
|
// common variable name
|
||
|
|
"list",
|
||
|
|
// common variable name
|
||
|
|
"value"
|
||
|
|
// common variable name
|
||
|
|
];
|
||
|
|
var DEFAULT_KEYWORD_CLASSNAME = "keyword";
|
||
|
|
function compileKeywords(rawKeywords, caseInsensitive, className = DEFAULT_KEYWORD_CLASSNAME) {
|
||
|
|
const compiledKeywords = {};
|
||
|
|
if (typeof rawKeywords === "string") {
|
||
|
|
compileList(className, rawKeywords.split(" "));
|
||
|
|
} else if (Array.isArray(rawKeywords)) {
|
||
|
|
compileList(className, rawKeywords);
|
||
|
|
} else {
|
||
|
|
Object.keys(rawKeywords).forEach(function(className2) {
|
||
|
|
Object.assign(
|
||
|
|
compiledKeywords,
|
||
|
|
compileKeywords(rawKeywords[className2], caseInsensitive, className2)
|
||
|
|
);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return compiledKeywords;
|
||
|
|
function compileList(className2, keywordList) {
|
||
|
|
if (caseInsensitive) {
|
||
|
|
keywordList = keywordList.map((x) => x.toLowerCase());
|
||
|
|
}
|
||
|
|
keywordList.forEach(function(keyword) {
|
||
|
|
const pair = keyword.split("|");
|
||
|
|
compiledKeywords[pair[0]] = [className2, scoreForKeyword(pair[0], pair[1])];
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function scoreForKeyword(keyword, providedScore) {
|
||
|
|
if (providedScore) {
|
||
|
|
return Number(providedScore);
|
||
|
|
}
|
||
|
|
return commonKeyword(keyword) ? 0 : 1;
|
||
|
|
}
|
||
|
|
function commonKeyword(keyword) {
|
||
|
|
return COMMON_KEYWORDS.includes(keyword.toLowerCase());
|
||
|
|
}
|
||
|
|
function compileLanguage(language, { plugins }) {
|
||
|
|
function langRe(value, global) {
|
||
|
|
return new RegExp(
|
||
|
|
source(value),
|
||
|
|
"m" + (language.case_insensitive ? "i" : "") + (global ? "g" : "")
|
||
|
|
);
|
||
|
|
}
|
||
|
|
class MultiRegex {
|
||
|
|
constructor() {
|
||
|
|
this.matchIndexes = {};
|
||
|
|
this.regexes = [];
|
||
|
|
this.matchAt = 1;
|
||
|
|
this.position = 0;
|
||
|
|
}
|
||
|
|
// @ts-ignore
|
||
|
|
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(join(terminators), true);
|
||
|
|
this.lastIndex = 0;
|
||
|
|
}
|
||
|
|
/** @param {string} s */
|
||
|
|
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 !== void 0);
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
// @ts-ignore
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
// @ts-ignore
|
||
|
|
addRule(re, opts) {
|
||
|
|
this.rules.push([re, opts]);
|
||
|
|
if (opts.type === "begin") this.count++;
|
||
|
|
}
|
||
|
|
/** @param {string} s */
|
||
|
|
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 = (
|
||
|
|
/** @type CompiledMode */
|
||
|
|
mode
|
||
|
|
);
|
||
|
|
if (mode.isCompiled) return cmode;
|
||
|
|
[
|
||
|
|
// do this early so compiler extensions generally don't have to worry about
|
||
|
|
// the distinction between match/begin
|
||
|
|
compileMatch
|
||
|
|
].forEach((ext) => ext(mode, parent));
|
||
|
|
language.compilerExtensions.forEach((ext) => ext(mode, parent));
|
||
|
|
mode.__beforeBegin = null;
|
||
|
|
[
|
||
|
|
beginKeywords,
|
||
|
|
// do this later so compiler extensions that come earlier have access to the
|
||
|
|
// raw array if they wanted to perhaps manipulate it, etc.
|
||
|
|
compileIllegal,
|
||
|
|
// default to 1 relevance if not specified
|
||
|
|
compileRelevance
|
||
|
|
].forEach((ext) => ext(mode, parent));
|
||
|
|
mode.isCompiled = true;
|
||
|
|
let keywordPattern = null;
|
||
|
|
if (typeof mode.keywords === "object") {
|
||
|
|
keywordPattern = mode.keywords.$pattern;
|
||
|
|
delete mode.keywords.$pattern;
|
||
|
|
}
|
||
|
|
if (mode.keywords) {
|
||
|
|
mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
|
||
|
|
}
|
||
|
|
if (mode.lexemes && keywordPattern) {
|
||
|
|
throw new Error("ERR: Prefer `keywords.$pattern` to `mode.lexemes`, BOTH are not allowed. (see mode reference) ");
|
||
|
|
}
|
||
|
|
keywordPattern = keywordPattern || mode.lexemes || /\w+/;
|
||
|
|
cmode.keywordPatternRe = langRe(keywordPattern, true);
|
||
|
|
if (parent) {
|
||
|
|
if (!mode.begin) mode.begin = /\B|\b/;
|
||
|
|
cmode.beginRe = langRe(mode.begin);
|
||
|
|
if (mode.endSameAsBegin) mode.end = mode.begin;
|
||
|
|
if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
|
||
|
|
if (mode.end) cmode.endRe = langRe(mode.end);
|
||
|
|
cmode.terminatorEnd = source(mode.end) || "";
|
||
|
|
if (mode.endsWithParent && parent.terminatorEnd) {
|
||
|
|
cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (mode.illegal) cmode.illegalRe = langRe(
|
||
|
|
/** @type {RegExp | string} */
|
||
|
|
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(
|
||
|
|
/** @type Mode */
|
||
|
|
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(language.classNameAliases || {});
|
||
|
|
return compileMode(
|
||
|
|
/** @type Mode */
|
||
|
|
language
|
||
|
|
);
|
||
|
|
}
|
||
|
|
function dependencyOnParent(mode) {
|
||
|
|
if (!mode) return false;
|
||
|
|
return mode.endsWithParent || dependencyOnParent(mode.starts);
|
||
|
|
}
|
||
|
|
function expandOrCloneMode(mode) {
|
||
|
|
if (mode.variants && !mode.cachedVariants) {
|
||
|
|
mode.cachedVariants = mode.variants.map(function(variant) {
|
||
|
|
return inherit(mode, { variants: null }, variant);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (mode.cachedVariants) {
|
||
|
|
return mode.cachedVariants;
|
||
|
|
}
|
||
|
|
if (dependencyOnParent(mode)) {
|
||
|
|
return inherit(mode, { starts: mode.starts ? inherit(mode.starts) : null });
|
||
|
|
}
|
||
|
|
if (Object.isFrozen(mode)) {
|
||
|
|
return inherit(mode);
|
||
|
|
}
|
||
|
|
return mode;
|
||
|
|
}
|
||
|
|
var version = "10.7.3";
|
||
|
|
function hasValueOrEmptyAttribute(value) {
|
||
|
|
return Boolean(value || value === "");
|
||
|
|
}
|
||
|
|
function BuildVuePlugin(hljs) {
|
||
|
|
const Component = {
|
||
|
|
props: ["language", "code", "autodetect"],
|
||
|
|
data: function() {
|
||
|
|
return {
|
||
|
|
detectedLanguage: "",
|
||
|
|
unknownLanguage: false
|
||
|
|
};
|
||
|
|
},
|
||
|
|
computed: {
|
||
|
|
className() {
|
||
|
|
if (this.unknownLanguage) return "";
|
||
|
|
return "hljs " + this.detectedLanguage;
|
||
|
|
},
|
||
|
|
highlighted() {
|
||
|
|
if (!this.autoDetect && !hljs.getLanguage(this.language)) {
|
||
|
|
console.warn(`The language "${this.language}" you specified could not be found.`);
|
||
|
|
this.unknownLanguage = true;
|
||
|
|
return escapeHTML(this.code);
|
||
|
|
}
|
||
|
|
let result = {};
|
||
|
|
if (this.autoDetect) {
|
||
|
|
result = hljs.highlightAuto(this.code);
|
||
|
|
this.detectedLanguage = result.language;
|
||
|
|
} else {
|
||
|
|
result = hljs.highlight(this.language, this.code, this.ignoreIllegals);
|
||
|
|
this.detectedLanguage = this.language;
|
||
|
|
}
|
||
|
|
return result.value;
|
||
|
|
},
|
||
|
|
autoDetect() {
|
||
|
|
return !this.language || hasValueOrEmptyAttribute(this.autodetect);
|
||
|
|
},
|
||
|
|
ignoreIllegals() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
// this avoids needing to use a whole Vue compilation pipeline just
|
||
|
|
// to build Highlight.js
|
||
|
|
render(createElement) {
|
||
|
|
return createElement("pre", {}, [
|
||
|
|
createElement("code", {
|
||
|
|
class: this.className,
|
||
|
|
domProps: { innerHTML: this.highlighted }
|
||
|
|
})
|
||
|
|
]);
|
||
|
|
}
|
||
|
|
// template: `<pre><code :class="className" v-html="highlighted"></code></pre>`
|
||
|
|
};
|
||
|
|
const VuePlugin = {
|
||
|
|
install(Vue) {
|
||
|
|
Vue.component("highlightjs", Component);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return { Component, VuePlugin };
|
||
|
|
}
|
||
|
|
var mergeHTMLPlugin = {
|
||
|
|
"after:highlightElement": ({ el, result, text }) => {
|
||
|
|
const originalStream = nodeStream(el);
|
||
|
|
if (!originalStream.length) return;
|
||
|
|
const resultNode = document.createElement("div");
|
||
|
|
resultNode.innerHTML = result.value;
|
||
|
|
result.value = mergeStreams(originalStream, nodeStream(resultNode), text);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function tag(node) {
|
||
|
|
return node.nodeName.toLowerCase();
|
||
|
|
}
|
||
|
|
function nodeStream(node) {
|
||
|
|
const result = [];
|
||
|
|
(function _nodeStream(node2, offset) {
|
||
|
|
for (let child = node2.firstChild; child; child = child.nextSibling) {
|
||
|
|
if (child.nodeType === 3) {
|
||
|
|
offset += child.nodeValue.length;
|
||
|
|
} else if (child.nodeType === 1) {
|
||
|
|
result.push({
|
||
|
|
event: "start",
|
||
|
|
offset,
|
||
|
|
node: child
|
||
|
|
});
|
||
|
|
offset = _nodeStream(child, offset);
|
||
|
|
if (!tag(child).match(/br|hr|img|input/)) {
|
||
|
|
result.push({
|
||
|
|
event: "stop",
|
||
|
|
offset,
|
||
|
|
node: child
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return offset;
|
||
|
|
})(node, 0);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function mergeStreams(original, highlighted, value) {
|
||
|
|
let processed = 0;
|
||
|
|
let result = "";
|
||
|
|
const nodeStack = [];
|
||
|
|
function selectStream() {
|
||
|
|
if (!original.length || !highlighted.length) {
|
||
|
|
return original.length ? original : highlighted;
|
||
|
|
}
|
||
|
|
if (original[0].offset !== highlighted[0].offset) {
|
||
|
|
return original[0].offset < highlighted[0].offset ? original : highlighted;
|
||
|
|
}
|
||
|
|
return highlighted[0].event === "start" ? original : highlighted;
|
||
|
|
}
|
||
|
|
function open(node) {
|
||
|
|
function attributeString(attr) {
|
||
|
|
return " " + attr.nodeName + '="' + escapeHTML(attr.value) + '"';
|
||
|
|
}
|
||
|
|
result += "<" + tag(node) + [].map.call(node.attributes, attributeString).join("") + ">";
|
||
|
|
}
|
||
|
|
function close(node) {
|
||
|
|
result += "</" + tag(node) + ">";
|
||
|
|
}
|
||
|
|
function render(event) {
|
||
|
|
(event.event === "start" ? open : close)(event.node);
|
||
|
|
}
|
||
|
|
while (original.length || highlighted.length) {
|
||
|
|
let stream = selectStream();
|
||
|
|
result += escapeHTML(value.substring(processed, stream[0].offset));
|
||
|
|
processed = stream[0].offset;
|
||
|
|
if (stream === original) {
|
||
|
|
nodeStack.reverse().forEach(close);
|
||
|
|
do {
|
||
|
|
render(stream.splice(0, 1)[0]);
|
||
|
|
stream = selectStream();
|
||
|
|
} while (stream === original && stream.length && stream[0].offset === processed);
|
||
|
|
nodeStack.reverse().forEach(open);
|
||
|
|
} else {
|
||
|
|
if (stream[0].event === "start") {
|
||
|
|
nodeStack.push(stream[0].node);
|
||
|
|
} else {
|
||
|
|
nodeStack.pop();
|
||
|
|
}
|
||
|
|
render(stream.splice(0, 1)[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result + escapeHTML(value.substr(processed));
|
||
|
|
}
|
||
|
|
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 escape$1 = escapeHTML;
|
||
|
|
var inherit$1 = inherit;
|
||
|
|
var NO_MATCH = Symbol("nomatch");
|
||
|
|
var HLJS = function(hljs) {
|
||
|
|
const languages = /* @__PURE__ */ Object.create(null);
|
||
|
|
const aliases = /* @__PURE__ */ Object.create(null);
|
||
|
|
const plugins = [];
|
||
|
|
let SAFE_MODE = true;
|
||
|
|
const fixMarkupRe = /(^(<[^>]+>|\t|)+|\n)/gm;
|
||
|
|
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 = {
|
||
|
|
noHighlightRe: /^(no-?highlight)$/i,
|
||
|
|
languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
|
||
|
|
classPrefix: "hljs-",
|
||
|
|
tabReplace: null,
|
||
|
|
useBR: false,
|
||
|
|
languages: null,
|
||
|
|
// beta configuration options, subject to change, welcome to discuss
|
||
|
|
// https://github.com/highlightjs/highlight.js/issues/1086
|
||
|
|
__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, continuation) {
|
||
|
|
let code = "";
|
||
|
|
let languageName = "";
|
||
|
|
if (typeof optionsOrCode === "object") {
|
||
|
|
code = codeOrlanguageName;
|
||
|
|
ignoreIllegals = optionsOrCode.ignoreIllegals;
|
||
|
|
languageName = optionsOrCode.language;
|
||
|
|
continuation = void 0;
|
||
|
|
} 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;
|
||
|
|
}
|
||
|
|
const context = {
|
||
|
|
code,
|
||
|
|
language: languageName
|
||
|
|
};
|
||
|
|
fire("before:highlight", context);
|
||
|
|
const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals, continuation);
|
||
|
|
result.code = context.code;
|
||
|
|
fire("after:highlight", result);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
|
||
|
|
function keywordData(mode, match) {
|
||
|
|
const matchText = language.case_insensitive ? match[0].toLowerCase() : match[0];
|
||
|
|
return Object.prototype.hasOwnProperty.call(mode.keywords, matchText) && 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 data = keywordData(top, match);
|
||
|
|
if (data) {
|
||
|
|
const [kind, keywordRelevance] = data;
|
||
|
|
emitter.addText(buf);
|
||
|
|
buf = "";
|
||
|
|
relevance += keywordRelevance;
|
||
|
|
if (kind.startsWith("_")) {
|
||
|
|
buf += match[0];
|
||
|
|
} else {
|
||
|
|
const cssClass = language.classNameAliases[kind] || kind;
|
||
|
|
emitter.addKeyword(match[0], cssClass);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
buf += match[0];
|
||
|
|
}
|
||
|
|
lastIndex = top.keywordPatternRe.lastIndex;
|
||
|
|
match = top.keywordPatternRe.exec(modeBuffer);
|
||
|
|
}
|
||
|
|
buf += modeBuffer.substr(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] = /** @type {CompiledMode} */
|
||
|
|
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 startNewMode(mode) {
|
||
|
|
if (mode.className) {
|
||
|
|
emitter.openNode(language.classNameAliases[mode.className] || mode.className);
|
||
|
|
}
|
||
|
|
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 && newMode.endSameAsBegin) {
|
||
|
|
newMode.endRe = escape(lexeme);
|
||
|
|
}
|
||
|
|
if (newMode.skip) {
|
||
|
|
modeBuffer += lexeme;
|
||
|
|
} else {
|
||
|
|
if (newMode.excludeBegin) {
|
||
|
|
modeBuffer += lexeme;
|
||
|
|
}
|
||
|
|
processBuffer();
|
||
|
|
if (!newMode.returnBegin && !newMode.excludeBegin) {
|
||
|
|
modeBuffer = lexeme;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
startNewMode(newMode);
|
||
|
|
return newMode.returnBegin ? 0 : lexeme.length;
|
||
|
|
}
|
||
|
|
function doEndMatch(match) {
|
||
|
|
const lexeme = match[0];
|
||
|
|
const matchPlusRemainder = codeToHighlight.substr(match.index);
|
||
|
|
const endMode = endOfMode(top, match, matchPlusRemainder);
|
||
|
|
if (!endMode) {
|
||
|
|
return NO_MATCH;
|
||
|
|
}
|
||
|
|
const origin = top;
|
||
|
|
if (origin.skip) {
|
||
|
|
modeBuffer += lexeme;
|
||
|
|
} else {
|
||
|
|
if (!(origin.returnEnd || origin.excludeEnd)) {
|
||
|
|
modeBuffer += lexeme;
|
||
|
|
}
|
||
|
|
processBuffer();
|
||
|
|
if (origin.excludeEnd) {
|
||
|
|
modeBuffer = lexeme;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
do {
|
||
|
|
if (top.className) {
|
||
|
|
emitter.closeNode();
|
||
|
|
}
|
||
|
|
if (!top.skip && !top.subLanguage) {
|
||
|
|
relevance += top.relevance;
|
||
|
|
}
|
||
|
|
top = top.parent;
|
||
|
|
} while (top !== endMode.parent);
|
||
|
|
if (endMode.starts) {
|
||
|
|
if (endMode.endSameAsBegin) {
|
||
|
|
endMode.starts.endRe = endMode.endRe;
|
||
|
|
}
|
||
|
|
startNewMode(endMode.starts);
|
||
|
|
}
|
||
|
|
return origin.returnEnd ? 0 : lexeme.length;
|
||
|
|
}
|
||
|
|
function processContinuations() {
|
||
|
|
const list = [];
|
||
|
|
for (let current = top; current !== language; current = current.parent) {
|
||
|
|
if (current.className) {
|
||
|
|
list.unshift(current.className);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
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");
|
||
|
|
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.className || "<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, { plugins });
|
||
|
|
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 {
|
||
|
|
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.substr(index));
|
||
|
|
emitter.closeAllNodes();
|
||
|
|
emitter.finalize();
|
||
|
|
result = emitter.toHTML();
|
||
|
|
return {
|
||
|
|
// avoid possible breakage with v10 clients expecting
|
||
|
|
// this to always be an integer
|
||
|
|
relevance: Math.floor(relevance),
|
||
|
|
value: result,
|
||
|
|
language: languageName,
|
||
|
|
illegal: false,
|
||
|
|
emitter,
|
||
|
|
top
|
||
|
|
};
|
||
|
|
} catch (err) {
|
||
|
|
if (err.message && err.message.includes("Illegal")) {
|
||
|
|
return {
|
||
|
|
illegal: true,
|
||
|
|
illegalBy: {
|
||
|
|
msg: err.message,
|
||
|
|
context: codeToHighlight.slice(index - 100, index + 100),
|
||
|
|
mode: err.mode
|
||
|
|
},
|
||
|
|
sofar: result,
|
||
|
|
relevance: 0,
|
||
|
|
value: escape$1(codeToHighlight),
|
||
|
|
emitter
|
||
|
|
};
|
||
|
|
} else if (SAFE_MODE) {
|
||
|
|
return {
|
||
|
|
illegal: false,
|
||
|
|
relevance: 0,
|
||
|
|
value: escape$1(codeToHighlight),
|
||
|
|
emitter,
|
||
|
|
language: languageName,
|
||
|
|
top,
|
||
|
|
errorRaised: err
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function justTextHighlightResult(code) {
|
||
|
|
const result = {
|
||
|
|
relevance: 0,
|
||
|
|
emitter: new options.__emitter(options),
|
||
|
|
value: escape$1(code),
|
||
|
|
illegal: false,
|
||
|
|
top: PLAINTEXT_LANGUAGE
|
||
|
|
};
|
||
|
|
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.second_best = secondBest;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function fixMarkup(html) {
|
||
|
|
if (!(options.tabReplace || options.useBR)) {
|
||
|
|
return html;
|
||
|
|
}
|
||
|
|
return html.replace(fixMarkupRe, (match) => {
|
||
|
|
if (match === "\n") {
|
||
|
|
return options.useBR ? "<br>" : match;
|
||
|
|
} else if (options.tabReplace) {
|
||
|
|
return match.replace(/\t/g, options.tabReplace);
|
||
|
|
}
|
||
|
|
return match;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function updateClassName(element, currentLang, resultLang) {
|
||
|
|
const language = currentLang ? aliases[currentLang] : resultLang;
|
||
|
|
element.classList.add("hljs");
|
||
|
|
if (language) element.classList.add(language);
|
||
|
|
}
|
||
|
|
const brPlugin = {
|
||
|
|
"before:highlightElement": ({ el }) => {
|
||
|
|
if (options.useBR) {
|
||
|
|
el.innerHTML = el.innerHTML.replace(/\n/g, "").replace(/<br[ /]*>/g, "\n");
|
||
|
|
}
|
||
|
|
},
|
||
|
|
"after:highlightElement": ({ result }) => {
|
||
|
|
if (options.useBR) {
|
||
|
|
result.value = result.value.replace(/\n/g, "<br>");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
const TAB_REPLACE_RE = /^(<[^>]+>|\t)+/gm;
|
||
|
|
const tabReplacePlugin = {
|
||
|
|
"after:highlightElement": ({ result }) => {
|
||
|
|
if (options.tabReplace) {
|
||
|
|
result.value = result.value.replace(
|
||
|
|
TAB_REPLACE_RE,
|
||
|
|
(m) => m.replace(/\t/g, options.tabReplace)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function highlightElement(element) {
|
||
|
|
let node = null;
|
||
|
|
const language = blockLanguage(element);
|
||
|
|
if (shouldNotHighlight(language)) return;
|
||
|
|
fire(
|
||
|
|
"before:highlightElement",
|
||
|
|
{ el: element, language }
|
||
|
|
);
|
||
|
|
node = element;
|
||
|
|
const text = node.textContent;
|
||
|
|
const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
|
||
|
|
fire("after:highlightElement", { el: element, result, text });
|
||
|
|
element.innerHTML = result.value;
|
||
|
|
updateClassName(element, language, result.language);
|
||
|
|
element.result = {
|
||
|
|
language: result.language,
|
||
|
|
// TODO: remove with version 11.0
|
||
|
|
re: result.relevance,
|
||
|
|
relavance: result.relevance
|
||
|
|
};
|
||
|
|
if (result.second_best) {
|
||
|
|
element.second_best = {
|
||
|
|
language: result.second_best.language,
|
||
|
|
// TODO: remove with version 11.0
|
||
|
|
re: result.second_best.relevance,
|
||
|
|
relavance: result.second_best.relevance
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function configure(userOptions) {
|
||
|
|
if (userOptions.useBR) {
|
||
|
|
deprecated("10.3.0", "'useBR' will be removed entirely in v11.0");
|
||
|
|
deprecated("10.3.0", "Please see https://github.com/highlightjs/highlight.js/issues/2559");
|
||
|
|
}
|
||
|
|
options = inherit$1(options, userOptions);
|
||
|
|
}
|
||
|
|
const initHighlighting = () => {
|
||
|
|
if (initHighlighting.called) return;
|
||
|
|
initHighlighting.called = true;
|
||
|
|
deprecated("10.6.0", "initHighlighting() is deprecated. Use highlightAll() instead.");
|
||
|
|
const blocks = document.querySelectorAll("pre code");
|
||
|
|
blocks.forEach(highlightElement);
|
||
|
|
};
|
||
|
|
function initHighlightingOnLoad() {
|
||
|
|
deprecated("10.6.0", "initHighlightingOnLoad() is deprecated. Use highlightAll() instead.");
|
||
|
|
wantsHighlight = true;
|
||
|
|
}
|
||
|
|
let wantsHighlight = false;
|
||
|
|
function highlightAll() {
|
||
|
|
if (document.readyState === "loading") {
|
||
|
|
wantsHighlight = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const blocks = document.querySelectorAll("pre code");
|
||
|
|
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 requireLanguage(name) {
|
||
|
|
deprecated("10.4.0", "requireLanguage will be removed entirely in v11.");
|
||
|
|
deprecated("10.4.0", "Please see https://github.com/highlightjs/highlight.js/pull/2844");
|
||
|
|
const lang = getLanguage(name);
|
||
|
|
if (lang) {
|
||
|
|
return lang;
|
||
|
|
}
|
||
|
|
const err = new Error("The '{}' language is required, but not loaded.".replace("{}", name));
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
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 fire(event, args) {
|
||
|
|
const cb = event;
|
||
|
|
plugins.forEach(function(plugin) {
|
||
|
|
if (plugin[cb]) {
|
||
|
|
plugin[cb](args);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function deprecateFixMarkup(arg) {
|
||
|
|
deprecated("10.2.0", "fixMarkup will be removed entirely in v11.0");
|
||
|
|
deprecated("10.2.0", "Please see https://github.com/highlightjs/highlight.js/issues/2534");
|
||
|
|
return fixMarkup(arg);
|
||
|
|
}
|
||
|
|
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,
|
||
|
|
fixMarkup: deprecateFixMarkup,
|
||
|
|
highlightElement,
|
||
|
|
// TODO: Remove with v12 API
|
||
|
|
highlightBlock: deprecateHighlightBlock,
|
||
|
|
configure,
|
||
|
|
initHighlighting,
|
||
|
|
initHighlightingOnLoad,
|
||
|
|
registerLanguage,
|
||
|
|
unregisterLanguage,
|
||
|
|
listLanguages,
|
||
|
|
getLanguage,
|
||
|
|
registerAliases,
|
||
|
|
requireLanguage,
|
||
|
|
autoDetection,
|
||
|
|
inherit: inherit$1,
|
||
|
|
addPlugin,
|
||
|
|
// plugins for frameworks
|
||
|
|
vuePlugin: BuildVuePlugin(hljs).VuePlugin
|
||
|
|
});
|
||
|
|
hljs.debugMode = function() {
|
||
|
|
SAFE_MODE = false;
|
||
|
|
};
|
||
|
|
hljs.safeMode = function() {
|
||
|
|
SAFE_MODE = true;
|
||
|
|
};
|
||
|
|
hljs.versionString = version;
|
||
|
|
for (const key in MODES) {
|
||
|
|
if (typeof MODES[key] === "object") {
|
||
|
|
deepFreezeEs6(MODES[key]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Object.assign(hljs, MODES);
|
||
|
|
hljs.addPlugin(brPlugin);
|
||
|
|
hljs.addPlugin(mergeHTMLPlugin);
|
||
|
|
hljs.addPlugin(tabReplacePlugin);
|
||
|
|
return hljs;
|
||
|
|
};
|
||
|
|
var highlight = HLJS({});
|
||
|
|
module.exports = highlight;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/format/format.js
|
||
|
|
var require_format = __commonJS({
|
||
|
|
"node_modules/format/format.js"(exports, module) {
|
||
|
|
(function() {
|
||
|
|
var namespace;
|
||
|
|
if (typeof module !== "undefined") {
|
||
|
|
namespace = module.exports = format;
|
||
|
|
} else {
|
||
|
|
namespace = function() {
|
||
|
|
return this || (1, eval)("this");
|
||
|
|
}();
|
||
|
|
}
|
||
|
|
namespace.format = format;
|
||
|
|
namespace.vsprintf = vsprintf;
|
||
|
|
if (typeof console !== "undefined" && typeof console.log === "function") {
|
||
|
|
namespace.printf = printf;
|
||
|
|
}
|
||
|
|
function printf() {
|
||
|
|
console.log(format.apply(null, arguments));
|
||
|
|
}
|
||
|
|
function vsprintf(fmt, replacements) {
|
||
|
|
return format.apply(null, [fmt].concat(replacements));
|
||
|
|
}
|
||
|
|
function format(fmt) {
|
||
|
|
var argIndex = 1, args = [].slice.call(arguments), i = 0, n = fmt.length, result = "", c, escaped = false, arg, tmp, leadingZero = false, precision, nextArg = function() {
|
||
|
|
return args[argIndex++];
|
||
|
|
}, slurpNumber = function() {
|
||
|
|
var digits = "";
|
||
|
|
while (/\d/.test(fmt[i])) {
|
||
|
|
digits += fmt[i++];
|
||
|
|
c = fmt[i];
|
||
|
|
}
|
||
|
|
return digits.length > 0 ? parseInt(digits) : null;
|
||
|
|
};
|
||
|
|
for (; i < n; ++i) {
|
||
|
|
c = fmt[i];
|
||
|
|
if (escaped) {
|
||
|
|
escaped = false;
|
||
|
|
if (c == ".") {
|
||
|
|
leadingZero = false;
|
||
|
|
c = fmt[++i];
|
||
|
|
} else if (c == "0" && fmt[i + 1] == ".") {
|
||
|
|
leadingZero = true;
|
||
|
|
i += 2;
|
||
|
|
c = fmt[i];
|
||
|
|
} else {
|
||
|
|
leadingZero = true;
|
||
|
|
}
|
||
|
|
precision = slurpNumber();
|
||
|
|
switch (c) {
|
||
|
|
case "b":
|
||
|
|
result += parseInt(nextArg(), 10).toString(2);
|
||
|
|
break;
|
||
|
|
case "c":
|
||
|
|
arg = nextArg();
|
||
|
|
if (typeof arg === "string" || arg instanceof String)
|
||
|
|
result += arg;
|
||
|
|
else
|
||
|
|
result += String.fromCharCode(parseInt(arg, 10));
|
||
|
|
break;
|
||
|
|
case "d":
|
||
|
|
result += parseInt(nextArg(), 10);
|
||
|
|
break;
|
||
|
|
case "f":
|
||
|
|
tmp = String(parseFloat(nextArg()).toFixed(precision || 6));
|
||
|
|
result += leadingZero ? tmp : tmp.replace(/^0/, "");
|
||
|
|
break;
|
||
|
|
case "j":
|
||
|
|
result += JSON.stringify(nextArg());
|
||
|
|
break;
|
||
|
|
case "o":
|
||
|
|
result += "0" + parseInt(nextArg(), 10).toString(8);
|
||
|
|
break;
|
||
|
|
case "s":
|
||
|
|
result += nextArg();
|
||
|
|
break;
|
||
|
|
case "x":
|
||
|
|
result += "0x" + parseInt(nextArg(), 10).toString(16);
|
||
|
|
break;
|
||
|
|
case "X":
|
||
|
|
result += "0x" + parseInt(nextArg(), 10).toString(16).toUpperCase();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
result += c;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else if (c === "%") {
|
||
|
|
escaped = true;
|
||
|
|
} else {
|
||
|
|
result += c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
})();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/fault/index.js
|
||
|
|
var require_fault = __commonJS({
|
||
|
|
"node_modules/fault/index.js"(exports, module) {
|
||
|
|
"use strict";
|
||
|
|
var formatter = require_format();
|
||
|
|
var fault = create(Error);
|
||
|
|
module.exports = fault;
|
||
|
|
fault.eval = create(EvalError);
|
||
|
|
fault.range = create(RangeError);
|
||
|
|
fault.reference = create(ReferenceError);
|
||
|
|
fault.syntax = create(SyntaxError);
|
||
|
|
fault.type = create(TypeError);
|
||
|
|
fault.uri = create(URIError);
|
||
|
|
fault.create = create;
|
||
|
|
function create(EConstructor) {
|
||
|
|
FormattedError.displayName = EConstructor.displayName || EConstructor.name;
|
||
|
|
return FormattedError;
|
||
|
|
function FormattedError(format) {
|
||
|
|
if (format) {
|
||
|
|
format = formatter.apply(null, arguments);
|
||
|
|
}
|
||
|
|
return new EConstructor(format);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// node_modules/lowlight/lib/core.js
|
||
|
|
var require_core2 = __commonJS({
|
||
|
|
"node_modules/lowlight/lib/core.js"(exports) {
|
||
|
|
var high = require_core();
|
||
|
|
var fault = require_fault();
|
||
|
|
exports.highlight = highlight;
|
||
|
|
exports.highlightAuto = highlightAuto;
|
||
|
|
exports.registerLanguage = registerLanguage;
|
||
|
|
exports.listLanguages = listLanguages;
|
||
|
|
exports.registerAlias = registerAlias;
|
||
|
|
Emitter.prototype.addText = text;
|
||
|
|
Emitter.prototype.addKeyword = addKeyword;
|
||
|
|
Emitter.prototype.addSublanguage = addSublanguage;
|
||
|
|
Emitter.prototype.openNode = open;
|
||
|
|
Emitter.prototype.closeNode = close;
|
||
|
|
Emitter.prototype.closeAllNodes = noop;
|
||
|
|
Emitter.prototype.finalize = noop;
|
||
|
|
Emitter.prototype.toHTML = toHtmlNoop;
|
||
|
|
var defaultPrefix = "hljs-";
|
||
|
|
function highlight(name, value, options) {
|
||
|
|
var before = high.configure({});
|
||
|
|
var settings = options || {};
|
||
|
|
var prefix = settings.prefix;
|
||
|
|
var result;
|
||
|
|
if (typeof name !== "string") {
|
||
|
|
throw fault("Expected `string` for name, got `%s`", name);
|
||
|
|
}
|
||
|
|
if (!high.getLanguage(name)) {
|
||
|
|
throw fault("Unknown language: `%s` is not registered", name);
|
||
|
|
}
|
||
|
|
if (typeof value !== "string") {
|
||
|
|
throw fault("Expected `string` for value, got `%s`", value);
|
||
|
|
}
|
||
|
|
if (prefix === null || prefix === void 0) {
|
||
|
|
prefix = defaultPrefix;
|
||
|
|
}
|
||
|
|
high.configure({ __emitter: Emitter, classPrefix: prefix });
|
||
|
|
result = high.highlight(value, { language: name, ignoreIllegals: true });
|
||
|
|
high.configure(before || {});
|
||
|
|
if (result.errorRaised) {
|
||
|
|
throw result.errorRaised;
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
relevance: result.relevance,
|
||
|
|
language: result.language,
|
||
|
|
value: result.emitter.rootNode.children
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function highlightAuto(value, options) {
|
||
|
|
var settings = options || {};
|
||
|
|
var subset = settings.subset || high.listLanguages();
|
||
|
|
var prefix = settings.prefix;
|
||
|
|
var length = subset.length;
|
||
|
|
var index = -1;
|
||
|
|
var result;
|
||
|
|
var secondBest;
|
||
|
|
var current;
|
||
|
|
var name;
|
||
|
|
if (prefix === null || prefix === void 0) {
|
||
|
|
prefix = defaultPrefix;
|
||
|
|
}
|
||
|
|
if (typeof value !== "string") {
|
||
|
|
throw fault("Expected `string` for value, got `%s`", value);
|
||
|
|
}
|
||
|
|
secondBest = { relevance: 0, language: null, value: [] };
|
||
|
|
result = { relevance: 0, language: null, value: [] };
|
||
|
|
while (++index < length) {
|
||
|
|
name = subset[index];
|
||
|
|
if (!high.getLanguage(name)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
current = highlight(name, value, options);
|
||
|
|
current.language = name;
|
||
|
|
if (current.relevance > secondBest.relevance) {
|
||
|
|
secondBest = current;
|
||
|
|
}
|
||
|
|
if (current.relevance > result.relevance) {
|
||
|
|
secondBest = result;
|
||
|
|
result = current;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (secondBest.language) {
|
||
|
|
result.secondBest = secondBest;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function registerLanguage(name, syntax) {
|
||
|
|
high.registerLanguage(name, syntax);
|
||
|
|
}
|
||
|
|
function listLanguages() {
|
||
|
|
return high.listLanguages();
|
||
|
|
}
|
||
|
|
function registerAlias(name, alias) {
|
||
|
|
var map = name;
|
||
|
|
var key;
|
||
|
|
if (alias) {
|
||
|
|
map = {};
|
||
|
|
map[name] = alias;
|
||
|
|
}
|
||
|
|
for (key in map) {
|
||
|
|
high.registerAliases(map[key], { languageName: key });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function Emitter(options) {
|
||
|
|
this.options = options;
|
||
|
|
this.rootNode = { children: [] };
|
||
|
|
this.stack = [this.rootNode];
|
||
|
|
}
|
||
|
|
function addKeyword(value, name) {
|
||
|
|
this.openNode(name);
|
||
|
|
this.addText(value);
|
||
|
|
this.closeNode();
|
||
|
|
}
|
||
|
|
function addSublanguage(other, name) {
|
||
|
|
var stack = this.stack;
|
||
|
|
var current = stack[stack.length - 1];
|
||
|
|
var results = other.rootNode.children;
|
||
|
|
var node = name ? {
|
||
|
|
type: "element",
|
||
|
|
tagName: "span",
|
||
|
|
properties: { className: [name] },
|
||
|
|
children: results
|
||
|
|
} : results;
|
||
|
|
current.children = current.children.concat(node);
|
||
|
|
}
|
||
|
|
function text(value) {
|
||
|
|
var stack = this.stack;
|
||
|
|
var current;
|
||
|
|
var tail;
|
||
|
|
if (value === "") return;
|
||
|
|
current = stack[stack.length - 1];
|
||
|
|
tail = current.children[current.children.length - 1];
|
||
|
|
if (tail && tail.type === "text") {
|
||
|
|
tail.value += value;
|
||
|
|
} else {
|
||
|
|
current.children.push({ type: "text", value });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function open(name) {
|
||
|
|
var stack = this.stack;
|
||
|
|
var className = this.options.classPrefix + name;
|
||
|
|
var current = stack[stack.length - 1];
|
||
|
|
var child = {
|
||
|
|
type: "element",
|
||
|
|
tagName: "span",
|
||
|
|
properties: { className: [className] },
|
||
|
|
children: []
|
||
|
|
};
|
||
|
|
current.children.push(child);
|
||
|
|
stack.push(child);
|
||
|
|
}
|
||
|
|
function close() {
|
||
|
|
this.stack.pop();
|
||
|
|
}
|
||
|
|
function toHtmlNoop() {
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
function noop() {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
export {
|
||
|
|
require_core2 as require_core
|
||
|
|
};
|
||
|
|
//# sourceMappingURL=chunk-Q2MKGQKV.js.map
|