4950 lines
147 KiB
JavaScript
4950 lines
147 KiB
JavaScript
import {
|
||
decodeHTML
|
||
} from "./chunk-QK75OLN6.js";
|
||
import {
|
||
__export
|
||
} from "./chunk-GFT2G5UO.js";
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/common/utils.mjs
|
||
var utils_exports = {};
|
||
__export(utils_exports, {
|
||
arrayReplaceAt: () => arrayReplaceAt,
|
||
assign: () => assign,
|
||
escapeHtml: () => escapeHtml,
|
||
escapeRE: () => escapeRE,
|
||
fromCodePoint: () => fromCodePoint,
|
||
has: () => has,
|
||
isMdAsciiPunct: () => isMdAsciiPunct,
|
||
isPunctChar: () => isPunctChar,
|
||
isSpace: () => isSpace,
|
||
isString: () => isString,
|
||
isValidEntityCode: () => isValidEntityCode,
|
||
isWhiteSpace: () => isWhiteSpace,
|
||
lib: () => lib,
|
||
normalizeReference: () => normalizeReference,
|
||
unescapeAll: () => unescapeAll,
|
||
unescapeMd: () => unescapeMd
|
||
});
|
||
|
||
// node_modules/.pnpm/mdurl@2.0.0/node_modules/mdurl/index.mjs
|
||
var mdurl_exports = {};
|
||
__export(mdurl_exports, {
|
||
decode: () => decode_default,
|
||
encode: () => encode_default,
|
||
format: () => format,
|
||
parse: () => parse_default
|
||
});
|
||
|
||
// node_modules/.pnpm/mdurl@2.0.0/node_modules/mdurl/lib/decode.mjs
|
||
var decodeCache = {};
|
||
function getDecodeCache(exclude) {
|
||
let cache = decodeCache[exclude];
|
||
if (cache) {
|
||
return cache;
|
||
}
|
||
cache = decodeCache[exclude] = [];
|
||
for (let i = 0; i < 128; i++) {
|
||
const ch = String.fromCharCode(i);
|
||
cache.push(ch);
|
||
}
|
||
for (let i = 0; i < exclude.length; i++) {
|
||
const ch = exclude.charCodeAt(i);
|
||
cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
|
||
}
|
||
return cache;
|
||
}
|
||
function decode(string, exclude) {
|
||
if (typeof exclude !== "string") {
|
||
exclude = decode.defaultChars;
|
||
}
|
||
const cache = getDecodeCache(exclude);
|
||
return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
|
||
let result = "";
|
||
for (let i = 0, l = seq.length; i < l; i += 3) {
|
||
const b1 = parseInt(seq.slice(i + 1, i + 3), 16);
|
||
if (b1 < 128) {
|
||
result += cache[b1];
|
||
continue;
|
||
}
|
||
if ((b1 & 224) === 192 && i + 3 < l) {
|
||
const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
|
||
if ((b2 & 192) === 128) {
|
||
const chr = b1 << 6 & 1984 | b2 & 63;
|
||
if (chr < 128) {
|
||
result += "<22><>";
|
||
} else {
|
||
result += String.fromCharCode(chr);
|
||
}
|
||
i += 3;
|
||
continue;
|
||
}
|
||
}
|
||
if ((b1 & 240) === 224 && i + 6 < l) {
|
||
const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
|
||
const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
|
||
if ((b2 & 192) === 128 && (b3 & 192) === 128) {
|
||
const chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
|
||
if (chr < 2048 || chr >= 55296 && chr <= 57343) {
|
||
result += "<22><><EFBFBD>";
|
||
} else {
|
||
result += String.fromCharCode(chr);
|
||
}
|
||
i += 6;
|
||
continue;
|
||
}
|
||
}
|
||
if ((b1 & 248) === 240 && i + 9 < l) {
|
||
const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
|
||
const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
|
||
const b4 = parseInt(seq.slice(i + 10, i + 12), 16);
|
||
if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
|
||
let chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
|
||
if (chr < 65536 || chr > 1114111) {
|
||
result += "<22><><EFBFBD><EFBFBD>";
|
||
} else {
|
||
chr -= 65536;
|
||
result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
|
||
}
|
||
i += 9;
|
||
continue;
|
||
}
|
||
}
|
||
result += "<22>";
|
||
}
|
||
return result;
|
||
});
|
||
}
|
||
decode.defaultChars = ";/?:@&=+$,#";
|
||
decode.componentChars = "";
|
||
var decode_default = decode;
|
||
|
||
// node_modules/.pnpm/mdurl@2.0.0/node_modules/mdurl/lib/encode.mjs
|
||
var encodeCache = {};
|
||
function getEncodeCache(exclude) {
|
||
let cache = encodeCache[exclude];
|
||
if (cache) {
|
||
return cache;
|
||
}
|
||
cache = encodeCache[exclude] = [];
|
||
for (let i = 0; i < 128; i++) {
|
||
const ch = String.fromCharCode(i);
|
||
if (/^[0-9a-z]$/i.test(ch)) {
|
||
cache.push(ch);
|
||
} else {
|
||
cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
|
||
}
|
||
}
|
||
for (let i = 0; i < exclude.length; i++) {
|
||
cache[exclude.charCodeAt(i)] = exclude[i];
|
||
}
|
||
return cache;
|
||
}
|
||
function encode(string, exclude, keepEscaped) {
|
||
if (typeof exclude !== "string") {
|
||
keepEscaped = exclude;
|
||
exclude = encode.defaultChars;
|
||
}
|
||
if (typeof keepEscaped === "undefined") {
|
||
keepEscaped = true;
|
||
}
|
||
const cache = getEncodeCache(exclude);
|
||
let result = "";
|
||
for (let i = 0, l = string.length; i < l; i++) {
|
||
const code2 = string.charCodeAt(i);
|
||
if (keepEscaped && code2 === 37 && i + 2 < l) {
|
||
if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
|
||
result += string.slice(i, i + 3);
|
||
i += 2;
|
||
continue;
|
||
}
|
||
}
|
||
if (code2 < 128) {
|
||
result += cache[code2];
|
||
continue;
|
||
}
|
||
if (code2 >= 55296 && code2 <= 57343) {
|
||
if (code2 >= 55296 && code2 <= 56319 && i + 1 < l) {
|
||
const nextCode = string.charCodeAt(i + 1);
|
||
if (nextCode >= 56320 && nextCode <= 57343) {
|
||
result += encodeURIComponent(string[i] + string[i + 1]);
|
||
i++;
|
||
continue;
|
||
}
|
||
}
|
||
result += "%EF%BF%BD";
|
||
continue;
|
||
}
|
||
result += encodeURIComponent(string[i]);
|
||
}
|
||
return result;
|
||
}
|
||
encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
|
||
encode.componentChars = "-_.!~*'()";
|
||
var encode_default = encode;
|
||
|
||
// node_modules/.pnpm/mdurl@2.0.0/node_modules/mdurl/lib/format.mjs
|
||
function format(url) {
|
||
let result = "";
|
||
result += url.protocol || "";
|
||
result += url.slashes ? "//" : "";
|
||
result += url.auth ? url.auth + "@" : "";
|
||
if (url.hostname && url.hostname.indexOf(":") !== -1) {
|
||
result += "[" + url.hostname + "]";
|
||
} else {
|
||
result += url.hostname || "";
|
||
}
|
||
result += url.port ? ":" + url.port : "";
|
||
result += url.pathname || "";
|
||
result += url.search || "";
|
||
result += url.hash || "";
|
||
return result;
|
||
}
|
||
|
||
// node_modules/.pnpm/mdurl@2.0.0/node_modules/mdurl/lib/parse.mjs
|
||
function Url() {
|
||
this.protocol = null;
|
||
this.slashes = null;
|
||
this.auth = null;
|
||
this.port = null;
|
||
this.hostname = null;
|
||
this.hash = null;
|
||
this.search = null;
|
||
this.pathname = null;
|
||
}
|
||
var protocolPattern = /^([a-z0-9.+-]+:)/i;
|
||
var portPattern = /:[0-9]*$/;
|
||
var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
|
||
var delims = ["<", ">", '"', "`", " ", "\r", "\n", " "];
|
||
var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
|
||
var autoEscape = ["'"].concat(unwise);
|
||
var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
|
||
var hostEndingChars = ["/", "?", "#"];
|
||
var hostnameMaxLen = 255;
|
||
var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
|
||
var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
|
||
var hostlessProtocol = {
|
||
javascript: true,
|
||
"javascript:": true
|
||
};
|
||
var slashedProtocol = {
|
||
http: true,
|
||
https: true,
|
||
ftp: true,
|
||
gopher: true,
|
||
file: true,
|
||
"http:": true,
|
||
"https:": true,
|
||
"ftp:": true,
|
||
"gopher:": true,
|
||
"file:": true
|
||
};
|
||
function urlParse(url, slashesDenoteHost) {
|
||
if (url && url instanceof Url)
|
||
return url;
|
||
const u = new Url();
|
||
u.parse(url, slashesDenoteHost);
|
||
return u;
|
||
}
|
||
Url.prototype.parse = function(url, slashesDenoteHost) {
|
||
let lowerProto, hec, slashes;
|
||
let rest = url;
|
||
rest = rest.trim();
|
||
if (!slashesDenoteHost && url.split("#").length === 1) {
|
||
const simplePath = simplePathPattern.exec(rest);
|
||
if (simplePath) {
|
||
this.pathname = simplePath[1];
|
||
if (simplePath[2]) {
|
||
this.search = simplePath[2];
|
||
}
|
||
return this;
|
||
}
|
||
}
|
||
let proto = protocolPattern.exec(rest);
|
||
if (proto) {
|
||
proto = proto[0];
|
||
lowerProto = proto.toLowerCase();
|
||
this.protocol = proto;
|
||
rest = rest.substr(proto.length);
|
||
}
|
||
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
|
||
slashes = rest.substr(0, 2) === "//";
|
||
if (slashes && !(proto && hostlessProtocol[proto])) {
|
||
rest = rest.substr(2);
|
||
this.slashes = true;
|
||
}
|
||
}
|
||
if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
|
||
let hostEnd = -1;
|
||
for (let i = 0; i < hostEndingChars.length; i++) {
|
||
hec = rest.indexOf(hostEndingChars[i]);
|
||
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
|
||
hostEnd = hec;
|
||
}
|
||
}
|
||
let auth, atSign;
|
||
if (hostEnd === -1) {
|
||
atSign = rest.lastIndexOf("@");
|
||
} else {
|
||
atSign = rest.lastIndexOf("@", hostEnd);
|
||
}
|
||
if (atSign !== -1) {
|
||
auth = rest.slice(0, atSign);
|
||
rest = rest.slice(atSign + 1);
|
||
this.auth = auth;
|
||
}
|
||
hostEnd = -1;
|
||
for (let i = 0; i < nonHostChars.length; i++) {
|
||
hec = rest.indexOf(nonHostChars[i]);
|
||
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
|
||
hostEnd = hec;
|
||
}
|
||
}
|
||
if (hostEnd === -1) {
|
||
hostEnd = rest.length;
|
||
}
|
||
if (rest[hostEnd - 1] === ":") {
|
||
hostEnd--;
|
||
}
|
||
const host = rest.slice(0, hostEnd);
|
||
rest = rest.slice(hostEnd);
|
||
this.parseHost(host);
|
||
this.hostname = this.hostname || "";
|
||
const ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
|
||
if (!ipv6Hostname) {
|
||
const hostparts = this.hostname.split(/\./);
|
||
for (let i = 0, l = hostparts.length; i < l; i++) {
|
||
const part = hostparts[i];
|
||
if (!part) {
|
||
continue;
|
||
}
|
||
if (!part.match(hostnamePartPattern)) {
|
||
let newpart = "";
|
||
for (let j = 0, k = part.length; j < k; j++) {
|
||
if (part.charCodeAt(j) > 127) {
|
||
newpart += "x";
|
||
} else {
|
||
newpart += part[j];
|
||
}
|
||
}
|
||
if (!newpart.match(hostnamePartPattern)) {
|
||
const validParts = hostparts.slice(0, i);
|
||
const notHost = hostparts.slice(i + 1);
|
||
const bit = part.match(hostnamePartStart);
|
||
if (bit) {
|
||
validParts.push(bit[1]);
|
||
notHost.unshift(bit[2]);
|
||
}
|
||
if (notHost.length) {
|
||
rest = notHost.join(".") + rest;
|
||
}
|
||
this.hostname = validParts.join(".");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (this.hostname.length > hostnameMaxLen) {
|
||
this.hostname = "";
|
||
}
|
||
if (ipv6Hostname) {
|
||
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
|
||
}
|
||
}
|
||
const hash = rest.indexOf("#");
|
||
if (hash !== -1) {
|
||
this.hash = rest.substr(hash);
|
||
rest = rest.slice(0, hash);
|
||
}
|
||
const qm = rest.indexOf("?");
|
||
if (qm !== -1) {
|
||
this.search = rest.substr(qm);
|
||
rest = rest.slice(0, qm);
|
||
}
|
||
if (rest) {
|
||
this.pathname = rest;
|
||
}
|
||
if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
|
||
this.pathname = "";
|
||
}
|
||
return this;
|
||
};
|
||
Url.prototype.parseHost = function(host) {
|
||
let port = portPattern.exec(host);
|
||
if (port) {
|
||
port = port[0];
|
||
if (port !== ":") {
|
||
this.port = port.substr(1);
|
||
}
|
||
host = host.substr(0, host.length - port.length);
|
||
}
|
||
if (host) {
|
||
this.hostname = host;
|
||
}
|
||
};
|
||
var parse_default = urlParse;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/index.mjs
|
||
var uc_exports = {};
|
||
__export(uc_exports, {
|
||
Any: () => regex_default,
|
||
Cc: () => regex_default2,
|
||
Cf: () => regex_default3,
|
||
P: () => regex_default4,
|
||
S: () => regex_default5,
|
||
Z: () => regex_default6
|
||
});
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/properties/Any/regex.mjs
|
||
var regex_default = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/categories/Cc/regex.mjs
|
||
var regex_default2 = /[\0-\x1F\x7F-\x9F]/;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/categories/Cf/regex.mjs
|
||
var regex_default3 = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u0890\u0891\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC3F]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/categories/P/regex.mjs
|
||
var regex_default4 = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59\uDF86-\uDF89]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDEB9\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2\uDF00-\uDF09]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDF43-\uDF4F\uDFFF]|\uD809[\uDC70-\uDC74]|\uD80B[\uDFF1\uDFF2]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/categories/S/regex.mjs
|
||
var regex_default5 = /[\$\+<->\^`\|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u0888\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20C0\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u31EF\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC2\uFD40-\uFD4F\uFDCF\uFDFC-\uFDFF\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD833[\uDF50-\uDFC3]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDEA\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEDC-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF76\uDF7B-\uDFD9\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDE53\uDE60-\uDE6D\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC5\uDECE-\uDEDB\uDEE0-\uDEE8\uDEF0-\uDEF8\uDF00-\uDF92\uDF94-\uDFCA]/;
|
||
|
||
// node_modules/.pnpm/uc.micro@2.1.0/node_modules/uc.micro/categories/Z/regex.mjs
|
||
var regex_default6 = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/common/utils.mjs
|
||
function _class(obj) {
|
||
return Object.prototype.toString.call(obj);
|
||
}
|
||
function isString(obj) {
|
||
return _class(obj) === "[object String]";
|
||
}
|
||
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
function has(object, key) {
|
||
return _hasOwnProperty.call(object, key);
|
||
}
|
||
function assign(obj) {
|
||
const sources = Array.prototype.slice.call(arguments, 1);
|
||
sources.forEach(function(source) {
|
||
if (!source) {
|
||
return;
|
||
}
|
||
if (typeof source !== "object") {
|
||
throw new TypeError(source + "must be object");
|
||
}
|
||
Object.keys(source).forEach(function(key) {
|
||
obj[key] = source[key];
|
||
});
|
||
});
|
||
return obj;
|
||
}
|
||
function arrayReplaceAt(src, pos, newElements) {
|
||
return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
|
||
}
|
||
function isValidEntityCode(c) {
|
||
if (c >= 55296 && c <= 57343) {
|
||
return false;
|
||
}
|
||
if (c >= 64976 && c <= 65007) {
|
||
return false;
|
||
}
|
||
if ((c & 65535) === 65535 || (c & 65535) === 65534) {
|
||
return false;
|
||
}
|
||
if (c >= 0 && c <= 8) {
|
||
return false;
|
||
}
|
||
if (c === 11) {
|
||
return false;
|
||
}
|
||
if (c >= 14 && c <= 31) {
|
||
return false;
|
||
}
|
||
if (c >= 127 && c <= 159) {
|
||
return false;
|
||
}
|
||
if (c > 1114111) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function fromCodePoint(c) {
|
||
if (c > 65535) {
|
||
c -= 65536;
|
||
const surrogate1 = 55296 + (c >> 10);
|
||
const surrogate2 = 56320 + (c & 1023);
|
||
return String.fromCharCode(surrogate1, surrogate2);
|
||
}
|
||
return String.fromCharCode(c);
|
||
}
|
||
var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
|
||
var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
|
||
var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
|
||
var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
|
||
function replaceEntityPattern(match2, name) {
|
||
if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
|
||
const code2 = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
|
||
if (isValidEntityCode(code2)) {
|
||
return fromCodePoint(code2);
|
||
}
|
||
return match2;
|
||
}
|
||
const decoded = decodeHTML(match2);
|
||
if (decoded !== match2) {
|
||
return decoded;
|
||
}
|
||
return match2;
|
||
}
|
||
function unescapeMd(str) {
|
||
if (str.indexOf("\\") < 0) {
|
||
return str;
|
||
}
|
||
return str.replace(UNESCAPE_MD_RE, "$1");
|
||
}
|
||
function unescapeAll(str) {
|
||
if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) {
|
||
return str;
|
||
}
|
||
return str.replace(UNESCAPE_ALL_RE, function(match2, escaped, entity2) {
|
||
if (escaped) {
|
||
return escaped;
|
||
}
|
||
return replaceEntityPattern(match2, entity2);
|
||
});
|
||
}
|
||
var HTML_ESCAPE_TEST_RE = /[&<>"]/;
|
||
var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
|
||
var HTML_REPLACEMENTS = {
|
||
"&": "&",
|
||
"<": "<",
|
||
">": ">",
|
||
'"': """
|
||
};
|
||
function replaceUnsafeChar(ch) {
|
||
return HTML_REPLACEMENTS[ch];
|
||
}
|
||
function escapeHtml(str) {
|
||
if (HTML_ESCAPE_TEST_RE.test(str)) {
|
||
return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
|
||
}
|
||
return str;
|
||
}
|
||
var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
|
||
function escapeRE(str) {
|
||
return str.replace(REGEXP_ESCAPE_RE, "\\$&");
|
||
}
|
||
function isSpace(code2) {
|
||
switch (code2) {
|
||
case 9:
|
||
case 32:
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
function isWhiteSpace(code2) {
|
||
if (code2 >= 8192 && code2 <= 8202) {
|
||
return true;
|
||
}
|
||
switch (code2) {
|
||
case 9:
|
||
case 10:
|
||
case 11:
|
||
case 12:
|
||
case 13:
|
||
case 32:
|
||
case 160:
|
||
case 5760:
|
||
case 8239:
|
||
case 8287:
|
||
case 12288:
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
function isPunctChar(ch) {
|
||
return regex_default4.test(ch) || regex_default5.test(ch);
|
||
}
|
||
function isMdAsciiPunct(ch) {
|
||
switch (ch) {
|
||
case 33:
|
||
case 34:
|
||
case 35:
|
||
case 36:
|
||
case 37:
|
||
case 38:
|
||
case 39:
|
||
case 40:
|
||
case 41:
|
||
case 42:
|
||
case 43:
|
||
case 44:
|
||
case 45:
|
||
case 46:
|
||
case 47:
|
||
case 58:
|
||
case 59:
|
||
case 60:
|
||
case 61:
|
||
case 62:
|
||
case 63:
|
||
case 64:
|
||
case 91:
|
||
case 92:
|
||
case 93:
|
||
case 94:
|
||
case 95:
|
||
case 96:
|
||
case 123:
|
||
case 124:
|
||
case 125:
|
||
case 126:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
function normalizeReference(str) {
|
||
str = str.trim().replace(/\s+/g, " ");
|
||
if ("ẞ".toLowerCase() === "Ṿ") {
|
||
str = str.replace(/ẞ/g, "ß");
|
||
}
|
||
return str.toLowerCase().toUpperCase();
|
||
}
|
||
var lib = { mdurl: mdurl_exports, ucmicro: uc_exports };
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/helpers/index.mjs
|
||
var helpers_exports = {};
|
||
__export(helpers_exports, {
|
||
parseLinkDestination: () => parseLinkDestination,
|
||
parseLinkLabel: () => parseLinkLabel,
|
||
parseLinkTitle: () => parseLinkTitle
|
||
});
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/helpers/parse_link_label.mjs
|
||
function parseLinkLabel(state, start, disableNested) {
|
||
let level, found, marker, prevPos;
|
||
const max = state.posMax;
|
||
const oldPos = state.pos;
|
||
state.pos = start + 1;
|
||
level = 1;
|
||
while (state.pos < max) {
|
||
marker = state.src.charCodeAt(state.pos);
|
||
if (marker === 93) {
|
||
level--;
|
||
if (level === 0) {
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
prevPos = state.pos;
|
||
state.md.inline.skipToken(state);
|
||
if (marker === 91) {
|
||
if (prevPos === state.pos - 1) {
|
||
level++;
|
||
} else if (disableNested) {
|
||
state.pos = oldPos;
|
||
return -1;
|
||
}
|
||
}
|
||
}
|
||
let labelEnd = -1;
|
||
if (found) {
|
||
labelEnd = state.pos;
|
||
}
|
||
state.pos = oldPos;
|
||
return labelEnd;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/helpers/parse_link_destination.mjs
|
||
function parseLinkDestination(str, start, max) {
|
||
let code2;
|
||
let pos = start;
|
||
const result = {
|
||
ok: false,
|
||
pos: 0,
|
||
str: ""
|
||
};
|
||
if (str.charCodeAt(pos) === 60) {
|
||
pos++;
|
||
while (pos < max) {
|
||
code2 = str.charCodeAt(pos);
|
||
if (code2 === 10) {
|
||
return result;
|
||
}
|
||
if (code2 === 60) {
|
||
return result;
|
||
}
|
||
if (code2 === 62) {
|
||
result.pos = pos + 1;
|
||
result.str = unescapeAll(str.slice(start + 1, pos));
|
||
result.ok = true;
|
||
return result;
|
||
}
|
||
if (code2 === 92 && pos + 1 < max) {
|
||
pos += 2;
|
||
continue;
|
||
}
|
||
pos++;
|
||
}
|
||
return result;
|
||
}
|
||
let level = 0;
|
||
while (pos < max) {
|
||
code2 = str.charCodeAt(pos);
|
||
if (code2 === 32) {
|
||
break;
|
||
}
|
||
if (code2 < 32 || code2 === 127) {
|
||
break;
|
||
}
|
||
if (code2 === 92 && pos + 1 < max) {
|
||
if (str.charCodeAt(pos + 1) === 32) {
|
||
break;
|
||
}
|
||
pos += 2;
|
||
continue;
|
||
}
|
||
if (code2 === 40) {
|
||
level++;
|
||
if (level > 32) {
|
||
return result;
|
||
}
|
||
}
|
||
if (code2 === 41) {
|
||
if (level === 0) {
|
||
break;
|
||
}
|
||
level--;
|
||
}
|
||
pos++;
|
||
}
|
||
if (start === pos) {
|
||
return result;
|
||
}
|
||
if (level !== 0) {
|
||
return result;
|
||
}
|
||
result.str = unescapeAll(str.slice(start, pos));
|
||
result.pos = pos;
|
||
result.ok = true;
|
||
return result;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/helpers/parse_link_title.mjs
|
||
function parseLinkTitle(str, start, max, prev_state) {
|
||
let code2;
|
||
let pos = start;
|
||
const state = {
|
||
// if `true`, this is a valid link title
|
||
ok: false,
|
||
// if `true`, this link can be continued on the next line
|
||
can_continue: false,
|
||
// if `ok`, it's the position of the first character after the closing marker
|
||
pos: 0,
|
||
// if `ok`, it's the unescaped title
|
||
str: "",
|
||
// expected closing marker character code
|
||
marker: 0
|
||
};
|
||
if (prev_state) {
|
||
state.str = prev_state.str;
|
||
state.marker = prev_state.marker;
|
||
} else {
|
||
if (pos >= max) {
|
||
return state;
|
||
}
|
||
let marker = str.charCodeAt(pos);
|
||
if (marker !== 34 && marker !== 39 && marker !== 40) {
|
||
return state;
|
||
}
|
||
start++;
|
||
pos++;
|
||
if (marker === 40) {
|
||
marker = 41;
|
||
}
|
||
state.marker = marker;
|
||
}
|
||
while (pos < max) {
|
||
code2 = str.charCodeAt(pos);
|
||
if (code2 === state.marker) {
|
||
state.pos = pos + 1;
|
||
state.str += unescapeAll(str.slice(start, pos));
|
||
state.ok = true;
|
||
return state;
|
||
} else if (code2 === 40 && state.marker === 41) {
|
||
return state;
|
||
} else if (code2 === 92 && pos + 1 < max) {
|
||
pos++;
|
||
}
|
||
pos++;
|
||
}
|
||
state.can_continue = true;
|
||
state.str += unescapeAll(str.slice(start, pos));
|
||
return state;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/renderer.mjs
|
||
var default_rules = {};
|
||
default_rules.code_inline = function(tokens, idx, options, env, slf) {
|
||
const token = tokens[idx];
|
||
return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(token.content) + "</code>";
|
||
};
|
||
default_rules.code_block = function(tokens, idx, options, env, slf) {
|
||
const token = tokens[idx];
|
||
return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
|
||
};
|
||
default_rules.fence = function(tokens, idx, options, env, slf) {
|
||
const token = tokens[idx];
|
||
const info = token.info ? unescapeAll(token.info).trim() : "";
|
||
let langName = "";
|
||
let langAttrs = "";
|
||
if (info) {
|
||
const arr = info.split(/(\s+)/g);
|
||
langName = arr[0];
|
||
langAttrs = arr.slice(2).join("");
|
||
}
|
||
let highlighted;
|
||
if (options.highlight) {
|
||
highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
|
||
} else {
|
||
highlighted = escapeHtml(token.content);
|
||
}
|
||
if (highlighted.indexOf("<pre") === 0) {
|
||
return highlighted + "\n";
|
||
}
|
||
if (info) {
|
||
const i = token.attrIndex("class");
|
||
const tmpAttrs = token.attrs ? token.attrs.slice() : [];
|
||
if (i < 0) {
|
||
tmpAttrs.push(["class", options.langPrefix + langName]);
|
||
} else {
|
||
tmpAttrs[i] = tmpAttrs[i].slice();
|
||
tmpAttrs[i][1] += " " + options.langPrefix + langName;
|
||
}
|
||
const tmpToken = {
|
||
attrs: tmpAttrs
|
||
};
|
||
return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>
|
||
`;
|
||
}
|
||
return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>
|
||
`;
|
||
};
|
||
default_rules.image = function(tokens, idx, options, env, slf) {
|
||
const token = tokens[idx];
|
||
token.attrs[token.attrIndex("alt")][1] = slf.renderInlineAsText(token.children, options, env);
|
||
return slf.renderToken(tokens, idx, options);
|
||
};
|
||
default_rules.hardbreak = function(tokens, idx, options) {
|
||
return options.xhtmlOut ? "<br />\n" : "<br>\n";
|
||
};
|
||
default_rules.softbreak = function(tokens, idx, options) {
|
||
return options.breaks ? options.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
|
||
};
|
||
default_rules.text = function(tokens, idx) {
|
||
return escapeHtml(tokens[idx].content);
|
||
};
|
||
default_rules.html_block = function(tokens, idx) {
|
||
return tokens[idx].content;
|
||
};
|
||
default_rules.html_inline = function(tokens, idx) {
|
||
return tokens[idx].content;
|
||
};
|
||
function Renderer() {
|
||
this.rules = assign({}, default_rules);
|
||
}
|
||
Renderer.prototype.renderAttrs = function renderAttrs(token) {
|
||
let i, l, result;
|
||
if (!token.attrs) {
|
||
return "";
|
||
}
|
||
result = "";
|
||
for (i = 0, l = token.attrs.length; i < l; i++) {
|
||
result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
|
||
}
|
||
return result;
|
||
};
|
||
Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
|
||
const token = tokens[idx];
|
||
let result = "";
|
||
if (token.hidden) {
|
||
return "";
|
||
}
|
||
if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
|
||
result += "\n";
|
||
}
|
||
result += (token.nesting === -1 ? "</" : "<") + token.tag;
|
||
result += this.renderAttrs(token);
|
||
if (token.nesting === 0 && options.xhtmlOut) {
|
||
result += " /";
|
||
}
|
||
let needLf = false;
|
||
if (token.block) {
|
||
needLf = true;
|
||
if (token.nesting === 1) {
|
||
if (idx + 1 < tokens.length) {
|
||
const nextToken = tokens[idx + 1];
|
||
if (nextToken.type === "inline" || nextToken.hidden) {
|
||
needLf = false;
|
||
} else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
|
||
needLf = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
result += needLf ? ">\n" : ">";
|
||
return result;
|
||
};
|
||
Renderer.prototype.renderInline = function(tokens, options, env) {
|
||
let result = "";
|
||
const rules = this.rules;
|
||
for (let i = 0, len = tokens.length; i < len; i++) {
|
||
const type = tokens[i].type;
|
||
if (typeof rules[type] !== "undefined") {
|
||
result += rules[type](tokens, i, options, env, this);
|
||
} else {
|
||
result += this.renderToken(tokens, i, options);
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
Renderer.prototype.renderInlineAsText = function(tokens, options, env) {
|
||
let result = "";
|
||
for (let i = 0, len = tokens.length; i < len; i++) {
|
||
switch (tokens[i].type) {
|
||
case "text":
|
||
result += tokens[i].content;
|
||
break;
|
||
case "image":
|
||
result += this.renderInlineAsText(tokens[i].children, options, env);
|
||
break;
|
||
case "html_inline":
|
||
case "html_block":
|
||
result += tokens[i].content;
|
||
break;
|
||
case "softbreak":
|
||
case "hardbreak":
|
||
result += "\n";
|
||
break;
|
||
default:
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
Renderer.prototype.render = function(tokens, options, env) {
|
||
let result = "";
|
||
const rules = this.rules;
|
||
for (let i = 0, len = tokens.length; i < len; i++) {
|
||
const type = tokens[i].type;
|
||
if (type === "inline") {
|
||
result += this.renderInline(tokens[i].children, options, env);
|
||
} else if (typeof rules[type] !== "undefined") {
|
||
result += rules[type](tokens, i, options, env, this);
|
||
} else {
|
||
result += this.renderToken(tokens, i, options, env);
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
var renderer_default = Renderer;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/ruler.mjs
|
||
function Ruler() {
|
||
this.__rules__ = [];
|
||
this.__cache__ = null;
|
||
}
|
||
Ruler.prototype.__find__ = function(name) {
|
||
for (let i = 0; i < this.__rules__.length; i++) {
|
||
if (this.__rules__[i].name === name) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
};
|
||
Ruler.prototype.__compile__ = function() {
|
||
const self = this;
|
||
const chains = [""];
|
||
self.__rules__.forEach(function(rule) {
|
||
if (!rule.enabled) {
|
||
return;
|
||
}
|
||
rule.alt.forEach(function(altName) {
|
||
if (chains.indexOf(altName) < 0) {
|
||
chains.push(altName);
|
||
}
|
||
});
|
||
});
|
||
self.__cache__ = {};
|
||
chains.forEach(function(chain) {
|
||
self.__cache__[chain] = [];
|
||
self.__rules__.forEach(function(rule) {
|
||
if (!rule.enabled) {
|
||
return;
|
||
}
|
||
if (chain && rule.alt.indexOf(chain) < 0) {
|
||
return;
|
||
}
|
||
self.__cache__[chain].push(rule.fn);
|
||
});
|
||
});
|
||
};
|
||
Ruler.prototype.at = function(name, fn, options) {
|
||
const index = this.__find__(name);
|
||
const opt = options || {};
|
||
if (index === -1) {
|
||
throw new Error("Parser rule not found: " + name);
|
||
}
|
||
this.__rules__[index].fn = fn;
|
||
this.__rules__[index].alt = opt.alt || [];
|
||
this.__cache__ = null;
|
||
};
|
||
Ruler.prototype.before = function(beforeName, ruleName, fn, options) {
|
||
const index = this.__find__(beforeName);
|
||
const opt = options || {};
|
||
if (index === -1) {
|
||
throw new Error("Parser rule not found: " + beforeName);
|
||
}
|
||
this.__rules__.splice(index, 0, {
|
||
name: ruleName,
|
||
enabled: true,
|
||
fn,
|
||
alt: opt.alt || []
|
||
});
|
||
this.__cache__ = null;
|
||
};
|
||
Ruler.prototype.after = function(afterName, ruleName, fn, options) {
|
||
const index = this.__find__(afterName);
|
||
const opt = options || {};
|
||
if (index === -1) {
|
||
throw new Error("Parser rule not found: " + afterName);
|
||
}
|
||
this.__rules__.splice(index + 1, 0, {
|
||
name: ruleName,
|
||
enabled: true,
|
||
fn,
|
||
alt: opt.alt || []
|
||
});
|
||
this.__cache__ = null;
|
||
};
|
||
Ruler.prototype.push = function(ruleName, fn, options) {
|
||
const opt = options || {};
|
||
this.__rules__.push({
|
||
name: ruleName,
|
||
enabled: true,
|
||
fn,
|
||
alt: opt.alt || []
|
||
});
|
||
this.__cache__ = null;
|
||
};
|
||
Ruler.prototype.enable = function(list2, ignoreInvalid) {
|
||
if (!Array.isArray(list2)) {
|
||
list2 = [list2];
|
||
}
|
||
const result = [];
|
||
list2.forEach(function(name) {
|
||
const idx = this.__find__(name);
|
||
if (idx < 0) {
|
||
if (ignoreInvalid) {
|
||
return;
|
||
}
|
||
throw new Error("Rules manager: invalid rule name " + name);
|
||
}
|
||
this.__rules__[idx].enabled = true;
|
||
result.push(name);
|
||
}, this);
|
||
this.__cache__ = null;
|
||
return result;
|
||
};
|
||
Ruler.prototype.enableOnly = function(list2, ignoreInvalid) {
|
||
if (!Array.isArray(list2)) {
|
||
list2 = [list2];
|
||
}
|
||
this.__rules__.forEach(function(rule) {
|
||
rule.enabled = false;
|
||
});
|
||
this.enable(list2, ignoreInvalid);
|
||
};
|
||
Ruler.prototype.disable = function(list2, ignoreInvalid) {
|
||
if (!Array.isArray(list2)) {
|
||
list2 = [list2];
|
||
}
|
||
const result = [];
|
||
list2.forEach(function(name) {
|
||
const idx = this.__find__(name);
|
||
if (idx < 0) {
|
||
if (ignoreInvalid) {
|
||
return;
|
||
}
|
||
throw new Error("Rules manager: invalid rule name " + name);
|
||
}
|
||
this.__rules__[idx].enabled = false;
|
||
result.push(name);
|
||
}, this);
|
||
this.__cache__ = null;
|
||
return result;
|
||
};
|
||
Ruler.prototype.getRules = function(chainName) {
|
||
if (this.__cache__ === null) {
|
||
this.__compile__();
|
||
}
|
||
return this.__cache__[chainName] || [];
|
||
};
|
||
var ruler_default = Ruler;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/token.mjs
|
||
function Token(type, tag, nesting) {
|
||
this.type = type;
|
||
this.tag = tag;
|
||
this.attrs = null;
|
||
this.map = null;
|
||
this.nesting = nesting;
|
||
this.level = 0;
|
||
this.children = null;
|
||
this.content = "";
|
||
this.markup = "";
|
||
this.info = "";
|
||
this.meta = null;
|
||
this.block = false;
|
||
this.hidden = false;
|
||
}
|
||
Token.prototype.attrIndex = function attrIndex(name) {
|
||
if (!this.attrs) {
|
||
return -1;
|
||
}
|
||
const attrs = this.attrs;
|
||
for (let i = 0, len = attrs.length; i < len; i++) {
|
||
if (attrs[i][0] === name) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
};
|
||
Token.prototype.attrPush = function attrPush(attrData) {
|
||
if (this.attrs) {
|
||
this.attrs.push(attrData);
|
||
} else {
|
||
this.attrs = [attrData];
|
||
}
|
||
};
|
||
Token.prototype.attrSet = function attrSet(name, value) {
|
||
const idx = this.attrIndex(name);
|
||
const attrData = [name, value];
|
||
if (idx < 0) {
|
||
this.attrPush(attrData);
|
||
} else {
|
||
this.attrs[idx] = attrData;
|
||
}
|
||
};
|
||
Token.prototype.attrGet = function attrGet(name) {
|
||
const idx = this.attrIndex(name);
|
||
let value = null;
|
||
if (idx >= 0) {
|
||
value = this.attrs[idx][1];
|
||
}
|
||
return value;
|
||
};
|
||
Token.prototype.attrJoin = function attrJoin(name, value) {
|
||
const idx = this.attrIndex(name);
|
||
if (idx < 0) {
|
||
this.attrPush([name, value]);
|
||
} else {
|
||
this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
|
||
}
|
||
};
|
||
var token_default = Token;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/state_core.mjs
|
||
function StateCore(src, md, env) {
|
||
this.src = src;
|
||
this.env = env;
|
||
this.tokens = [];
|
||
this.inlineMode = false;
|
||
this.md = md;
|
||
}
|
||
StateCore.prototype.Token = token_default;
|
||
var state_core_default = StateCore;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/normalize.mjs
|
||
var NEWLINES_RE = /\r\n?|\n/g;
|
||
var NULL_RE = /\0/g;
|
||
function normalize(state) {
|
||
let str;
|
||
str = state.src.replace(NEWLINES_RE, "\n");
|
||
str = str.replace(NULL_RE, "<22>");
|
||
state.src = str;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/block.mjs
|
||
function block(state) {
|
||
let token;
|
||
if (state.inlineMode) {
|
||
token = new state.Token("inline", "", 0);
|
||
token.content = state.src;
|
||
token.map = [0, 1];
|
||
token.children = [];
|
||
state.tokens.push(token);
|
||
} else {
|
||
state.md.block.parse(state.src, state.md, state.env, state.tokens);
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/inline.mjs
|
||
function inline(state) {
|
||
const tokens = state.tokens;
|
||
for (let i = 0, l = tokens.length; i < l; i++) {
|
||
const tok = tokens[i];
|
||
if (tok.type === "inline") {
|
||
state.md.inline.parse(tok.content, state.md, state.env, tok.children);
|
||
}
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/linkify.mjs
|
||
function isLinkOpen(str) {
|
||
return /^<a[>\s]/i.test(str);
|
||
}
|
||
function isLinkClose(str) {
|
||
return /^<\/a\s*>/i.test(str);
|
||
}
|
||
function linkify(state) {
|
||
const blockTokens = state.tokens;
|
||
if (!state.md.options.linkify) {
|
||
return;
|
||
}
|
||
for (let j = 0, l = blockTokens.length; j < l; j++) {
|
||
if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) {
|
||
continue;
|
||
}
|
||
let tokens = blockTokens[j].children;
|
||
let htmlLinkLevel = 0;
|
||
for (let i = tokens.length - 1; i >= 0; i--) {
|
||
const currentToken = tokens[i];
|
||
if (currentToken.type === "link_close") {
|
||
i--;
|
||
while (tokens[i].level !== currentToken.level && tokens[i].type !== "link_open") {
|
||
i--;
|
||
}
|
||
continue;
|
||
}
|
||
if (currentToken.type === "html_inline") {
|
||
if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
|
||
htmlLinkLevel--;
|
||
}
|
||
if (isLinkClose(currentToken.content)) {
|
||
htmlLinkLevel++;
|
||
}
|
||
}
|
||
if (htmlLinkLevel > 0) {
|
||
continue;
|
||
}
|
||
if (currentToken.type === "text" && state.md.linkify.test(currentToken.content)) {
|
||
const text2 = currentToken.content;
|
||
let links = state.md.linkify.match(text2);
|
||
const nodes = [];
|
||
let level = currentToken.level;
|
||
let lastPos = 0;
|
||
if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special") {
|
||
links = links.slice(1);
|
||
}
|
||
for (let ln = 0; ln < links.length; ln++) {
|
||
const url = links[ln].url;
|
||
const fullUrl = state.md.normalizeLink(url);
|
||
if (!state.md.validateLink(fullUrl)) {
|
||
continue;
|
||
}
|
||
let urlText = links[ln].text;
|
||
if (!links[ln].schema) {
|
||
urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
|
||
} else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) {
|
||
urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
|
||
} else {
|
||
urlText = state.md.normalizeLinkText(urlText);
|
||
}
|
||
const pos = links[ln].index;
|
||
if (pos > lastPos) {
|
||
const token = new state.Token("text", "", 0);
|
||
token.content = text2.slice(lastPos, pos);
|
||
token.level = level;
|
||
nodes.push(token);
|
||
}
|
||
const token_o = new state.Token("link_open", "a", 1);
|
||
token_o.attrs = [["href", fullUrl]];
|
||
token_o.level = level++;
|
||
token_o.markup = "linkify";
|
||
token_o.info = "auto";
|
||
nodes.push(token_o);
|
||
const token_t = new state.Token("text", "", 0);
|
||
token_t.content = urlText;
|
||
token_t.level = level;
|
||
nodes.push(token_t);
|
||
const token_c = new state.Token("link_close", "a", -1);
|
||
token_c.level = --level;
|
||
token_c.markup = "linkify";
|
||
token_c.info = "auto";
|
||
nodes.push(token_c);
|
||
lastPos = links[ln].lastIndex;
|
||
}
|
||
if (lastPos < text2.length) {
|
||
const token = new state.Token("text", "", 0);
|
||
token.content = text2.slice(lastPos);
|
||
token.level = level;
|
||
nodes.push(token);
|
||
}
|
||
blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/replacements.mjs
|
||
var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
|
||
var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
|
||
var SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
|
||
var SCOPED_ABBR = {
|
||
c: "©",
|
||
r: "®",
|
||
tm: "™"
|
||
};
|
||
function replaceFn(match2, name) {
|
||
return SCOPED_ABBR[name.toLowerCase()];
|
||
}
|
||
function replace_scoped(inlineTokens) {
|
||
let inside_autolink = 0;
|
||
for (let i = inlineTokens.length - 1; i >= 0; i--) {
|
||
const token = inlineTokens[i];
|
||
if (token.type === "text" && !inside_autolink) {
|
||
token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
|
||
}
|
||
if (token.type === "link_open" && token.info === "auto") {
|
||
inside_autolink--;
|
||
}
|
||
if (token.type === "link_close" && token.info === "auto") {
|
||
inside_autolink++;
|
||
}
|
||
}
|
||
}
|
||
function replace_rare(inlineTokens) {
|
||
let inside_autolink = 0;
|
||
for (let i = inlineTokens.length - 1; i >= 0; i--) {
|
||
const token = inlineTokens[i];
|
||
if (token.type === "text" && !inside_autolink) {
|
||
if (RARE_RE.test(token.content)) {
|
||
token.content = token.content.replace(/\+-/g, "±").replace(/\.{2,}/g, "…").replace(/([?!])…/g, "$1..").replace(/([?!]){4,}/g, "$1$1$1").replace(/,{2,}/g, ",").replace(/(^|[^-])---(?=[^-]|$)/mg, "$1—").replace(/(^|\s)--(?=\s|$)/mg, "$1–").replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, "$1–");
|
||
}
|
||
}
|
||
if (token.type === "link_open" && token.info === "auto") {
|
||
inside_autolink--;
|
||
}
|
||
if (token.type === "link_close" && token.info === "auto") {
|
||
inside_autolink++;
|
||
}
|
||
}
|
||
}
|
||
function replace(state) {
|
||
let blkIdx;
|
||
if (!state.md.options.typographer) {
|
||
return;
|
||
}
|
||
for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
|
||
if (state.tokens[blkIdx].type !== "inline") {
|
||
continue;
|
||
}
|
||
if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
|
||
replace_scoped(state.tokens[blkIdx].children);
|
||
}
|
||
if (RARE_RE.test(state.tokens[blkIdx].content)) {
|
||
replace_rare(state.tokens[blkIdx].children);
|
||
}
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/smartquotes.mjs
|
||
var QUOTE_TEST_RE = /['"]/;
|
||
var QUOTE_RE = /['"]/g;
|
||
var APOSTROPHE = "’";
|
||
function replaceAt(str, index, ch) {
|
||
return str.slice(0, index) + ch + str.slice(index + 1);
|
||
}
|
||
function process_inlines(tokens, state) {
|
||
let j;
|
||
const stack = [];
|
||
for (let i = 0; i < tokens.length; i++) {
|
||
const token = tokens[i];
|
||
const thisLevel = tokens[i].level;
|
||
for (j = stack.length - 1; j >= 0; j--) {
|
||
if (stack[j].level <= thisLevel) {
|
||
break;
|
||
}
|
||
}
|
||
stack.length = j + 1;
|
||
if (token.type !== "text") {
|
||
continue;
|
||
}
|
||
let text2 = token.content;
|
||
let pos = 0;
|
||
let max = text2.length;
|
||
OUTER:
|
||
while (pos < max) {
|
||
QUOTE_RE.lastIndex = pos;
|
||
const t = QUOTE_RE.exec(text2);
|
||
if (!t) {
|
||
break;
|
||
}
|
||
let canOpen = true;
|
||
let canClose = true;
|
||
pos = t.index + 1;
|
||
const isSingle = t[0] === "'";
|
||
let lastChar = 32;
|
||
if (t.index - 1 >= 0) {
|
||
lastChar = text2.charCodeAt(t.index - 1);
|
||
} else {
|
||
for (j = i - 1; j >= 0; j--) {
|
||
if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
|
||
break;
|
||
if (!tokens[j].content)
|
||
continue;
|
||
lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
|
||
break;
|
||
}
|
||
}
|
||
let nextChar = 32;
|
||
if (pos < max) {
|
||
nextChar = text2.charCodeAt(pos);
|
||
} else {
|
||
for (j = i + 1; j < tokens.length; j++) {
|
||
if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak")
|
||
break;
|
||
if (!tokens[j].content)
|
||
continue;
|
||
nextChar = tokens[j].content.charCodeAt(0);
|
||
break;
|
||
}
|
||
}
|
||
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
|
||
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
|
||
const isLastWhiteSpace = isWhiteSpace(lastChar);
|
||
const isNextWhiteSpace = isWhiteSpace(nextChar);
|
||
if (isNextWhiteSpace) {
|
||
canOpen = false;
|
||
} else if (isNextPunctChar) {
|
||
if (!(isLastWhiteSpace || isLastPunctChar)) {
|
||
canOpen = false;
|
||
}
|
||
}
|
||
if (isLastWhiteSpace) {
|
||
canClose = false;
|
||
} else if (isLastPunctChar) {
|
||
if (!(isNextWhiteSpace || isNextPunctChar)) {
|
||
canClose = false;
|
||
}
|
||
}
|
||
if (nextChar === 34 && t[0] === '"') {
|
||
if (lastChar >= 48 && lastChar <= 57) {
|
||
canClose = canOpen = false;
|
||
}
|
||
}
|
||
if (canOpen && canClose) {
|
||
canOpen = isLastPunctChar;
|
||
canClose = isNextPunctChar;
|
||
}
|
||
if (!canOpen && !canClose) {
|
||
if (isSingle) {
|
||
token.content = replaceAt(token.content, t.index, APOSTROPHE);
|
||
}
|
||
continue;
|
||
}
|
||
if (canClose) {
|
||
for (j = stack.length - 1; j >= 0; j--) {
|
||
let item = stack[j];
|
||
if (stack[j].level < thisLevel) {
|
||
break;
|
||
}
|
||
if (item.single === isSingle && stack[j].level === thisLevel) {
|
||
item = stack[j];
|
||
let openQuote;
|
||
let closeQuote;
|
||
if (isSingle) {
|
||
openQuote = state.md.options.quotes[2];
|
||
closeQuote = state.md.options.quotes[3];
|
||
} else {
|
||
openQuote = state.md.options.quotes[0];
|
||
closeQuote = state.md.options.quotes[1];
|
||
}
|
||
token.content = replaceAt(token.content, t.index, closeQuote);
|
||
tokens[item.token].content = replaceAt(
|
||
tokens[item.token].content,
|
||
item.pos,
|
||
openQuote
|
||
);
|
||
pos += closeQuote.length - 1;
|
||
if (item.token === i) {
|
||
pos += openQuote.length - 1;
|
||
}
|
||
text2 = token.content;
|
||
max = text2.length;
|
||
stack.length = j;
|
||
continue OUTER;
|
||
}
|
||
}
|
||
}
|
||
if (canOpen) {
|
||
stack.push({
|
||
token: i,
|
||
pos: t.index,
|
||
single: isSingle,
|
||
level: thisLevel
|
||
});
|
||
} else if (canClose && isSingle) {
|
||
token.content = replaceAt(token.content, t.index, APOSTROPHE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function smartquotes(state) {
|
||
if (!state.md.options.typographer) {
|
||
return;
|
||
}
|
||
for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
|
||
if (state.tokens[blkIdx].type !== "inline" || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
|
||
continue;
|
||
}
|
||
process_inlines(state.tokens[blkIdx].children, state);
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_core/text_join.mjs
|
||
function text_join(state) {
|
||
let curr, last;
|
||
const blockTokens = state.tokens;
|
||
const l = blockTokens.length;
|
||
for (let j = 0; j < l; j++) {
|
||
if (blockTokens[j].type !== "inline")
|
||
continue;
|
||
const tokens = blockTokens[j].children;
|
||
const max = tokens.length;
|
||
for (curr = 0; curr < max; curr++) {
|
||
if (tokens[curr].type === "text_special") {
|
||
tokens[curr].type = "text";
|
||
}
|
||
}
|
||
for (curr = last = 0; curr < max; curr++) {
|
||
if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
|
||
tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
|
||
} else {
|
||
if (curr !== last) {
|
||
tokens[last] = tokens[curr];
|
||
}
|
||
last++;
|
||
}
|
||
}
|
||
if (curr !== last) {
|
||
tokens.length = last;
|
||
}
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/parser_core.mjs
|
||
var _rules = [
|
||
["normalize", normalize],
|
||
["block", block],
|
||
["inline", inline],
|
||
["linkify", linkify],
|
||
["replacements", replace],
|
||
["smartquotes", smartquotes],
|
||
// `text_join` finds `text_special` tokens (for escape sequences)
|
||
// and joins them with the rest of the text
|
||
["text_join", text_join]
|
||
];
|
||
function Core() {
|
||
this.ruler = new ruler_default();
|
||
for (let i = 0; i < _rules.length; i++) {
|
||
this.ruler.push(_rules[i][0], _rules[i][1]);
|
||
}
|
||
}
|
||
Core.prototype.process = function(state) {
|
||
const rules = this.ruler.getRules("");
|
||
for (let i = 0, l = rules.length; i < l; i++) {
|
||
rules[i](state);
|
||
}
|
||
};
|
||
Core.prototype.State = state_core_default;
|
||
var parser_core_default = Core;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/state_block.mjs
|
||
function StateBlock(src, md, env, tokens) {
|
||
this.src = src;
|
||
this.md = md;
|
||
this.env = env;
|
||
this.tokens = tokens;
|
||
this.bMarks = [];
|
||
this.eMarks = [];
|
||
this.tShift = [];
|
||
this.sCount = [];
|
||
this.bsCount = [];
|
||
this.blkIndent = 0;
|
||
this.line = 0;
|
||
this.lineMax = 0;
|
||
this.tight = false;
|
||
this.ddIndent = -1;
|
||
this.listIndent = -1;
|
||
this.parentType = "root";
|
||
this.level = 0;
|
||
const s = this.src;
|
||
for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
|
||
const ch = s.charCodeAt(pos);
|
||
if (!indent_found) {
|
||
if (isSpace(ch)) {
|
||
indent++;
|
||
if (ch === 9) {
|
||
offset += 4 - offset % 4;
|
||
} else {
|
||
offset++;
|
||
}
|
||
continue;
|
||
} else {
|
||
indent_found = true;
|
||
}
|
||
}
|
||
if (ch === 10 || pos === len - 1) {
|
||
if (ch !== 10) {
|
||
pos++;
|
||
}
|
||
this.bMarks.push(start);
|
||
this.eMarks.push(pos);
|
||
this.tShift.push(indent);
|
||
this.sCount.push(offset);
|
||
this.bsCount.push(0);
|
||
indent_found = false;
|
||
indent = 0;
|
||
offset = 0;
|
||
start = pos + 1;
|
||
}
|
||
}
|
||
this.bMarks.push(s.length);
|
||
this.eMarks.push(s.length);
|
||
this.tShift.push(0);
|
||
this.sCount.push(0);
|
||
this.bsCount.push(0);
|
||
this.lineMax = this.bMarks.length - 1;
|
||
}
|
||
StateBlock.prototype.push = function(type, tag, nesting) {
|
||
const token = new token_default(type, tag, nesting);
|
||
token.block = true;
|
||
if (nesting < 0)
|
||
this.level--;
|
||
token.level = this.level;
|
||
if (nesting > 0)
|
||
this.level++;
|
||
this.tokens.push(token);
|
||
return token;
|
||
};
|
||
StateBlock.prototype.isEmpty = function isEmpty(line) {
|
||
return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
|
||
};
|
||
StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
|
||
for (let max = this.lineMax; from < max; from++) {
|
||
if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
|
||
break;
|
||
}
|
||
}
|
||
return from;
|
||
};
|
||
StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
|
||
for (let max = this.src.length; pos < max; pos++) {
|
||
const ch = this.src.charCodeAt(pos);
|
||
if (!isSpace(ch)) {
|
||
break;
|
||
}
|
||
}
|
||
return pos;
|
||
};
|
||
StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
|
||
if (pos <= min) {
|
||
return pos;
|
||
}
|
||
while (pos > min) {
|
||
if (!isSpace(this.src.charCodeAt(--pos))) {
|
||
return pos + 1;
|
||
}
|
||
}
|
||
return pos;
|
||
};
|
||
StateBlock.prototype.skipChars = function skipChars(pos, code2) {
|
||
for (let max = this.src.length; pos < max; pos++) {
|
||
if (this.src.charCodeAt(pos) !== code2) {
|
||
break;
|
||
}
|
||
}
|
||
return pos;
|
||
};
|
||
StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code2, min) {
|
||
if (pos <= min) {
|
||
return pos;
|
||
}
|
||
while (pos > min) {
|
||
if (code2 !== this.src.charCodeAt(--pos)) {
|
||
return pos + 1;
|
||
}
|
||
}
|
||
return pos;
|
||
};
|
||
StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
|
||
if (begin >= end) {
|
||
return "";
|
||
}
|
||
const queue = new Array(end - begin);
|
||
for (let i = 0, line = begin; line < end; line++, i++) {
|
||
let lineIndent = 0;
|
||
const lineStart = this.bMarks[line];
|
||
let first = lineStart;
|
||
let last;
|
||
if (line + 1 < end || keepLastLF) {
|
||
last = this.eMarks[line] + 1;
|
||
} else {
|
||
last = this.eMarks[line];
|
||
}
|
||
while (first < last && lineIndent < indent) {
|
||
const ch = this.src.charCodeAt(first);
|
||
if (isSpace(ch)) {
|
||
if (ch === 9) {
|
||
lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
|
||
} else {
|
||
lineIndent++;
|
||
}
|
||
} else if (first - lineStart < this.tShift[line]) {
|
||
lineIndent++;
|
||
} else {
|
||
break;
|
||
}
|
||
first++;
|
||
}
|
||
if (lineIndent > indent) {
|
||
queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
|
||
} else {
|
||
queue[i] = this.src.slice(first, last);
|
||
}
|
||
}
|
||
return queue.join("");
|
||
};
|
||
StateBlock.prototype.Token = token_default;
|
||
var state_block_default = StateBlock;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/table.mjs
|
||
var MAX_AUTOCOMPLETED_CELLS = 65536;
|
||
function getLine(state, line) {
|
||
const pos = state.bMarks[line] + state.tShift[line];
|
||
const max = state.eMarks[line];
|
||
return state.src.slice(pos, max);
|
||
}
|
||
function escapedSplit(str) {
|
||
const result = [];
|
||
const max = str.length;
|
||
let pos = 0;
|
||
let ch = str.charCodeAt(pos);
|
||
let isEscaped = false;
|
||
let lastPos = 0;
|
||
let current = "";
|
||
while (pos < max) {
|
||
if (ch === 124) {
|
||
if (!isEscaped) {
|
||
result.push(current + str.substring(lastPos, pos));
|
||
current = "";
|
||
lastPos = pos + 1;
|
||
} else {
|
||
current += str.substring(lastPos, pos - 1);
|
||
lastPos = pos;
|
||
}
|
||
}
|
||
isEscaped = ch === 92;
|
||
pos++;
|
||
ch = str.charCodeAt(pos);
|
||
}
|
||
result.push(current + str.substring(lastPos));
|
||
return result;
|
||
}
|
||
function table(state, startLine, endLine, silent) {
|
||
if (startLine + 2 > endLine) {
|
||
return false;
|
||
}
|
||
let nextLine = startLine + 1;
|
||
if (state.sCount[nextLine] < state.blkIndent) {
|
||
return false;
|
||
}
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
let pos = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
if (pos >= state.eMarks[nextLine]) {
|
||
return false;
|
||
}
|
||
const firstCh = state.src.charCodeAt(pos++);
|
||
if (firstCh !== 124 && firstCh !== 45 && firstCh !== 58) {
|
||
return false;
|
||
}
|
||
if (pos >= state.eMarks[nextLine]) {
|
||
return false;
|
||
}
|
||
const secondCh = state.src.charCodeAt(pos++);
|
||
if (secondCh !== 124 && secondCh !== 45 && secondCh !== 58 && !isSpace(secondCh)) {
|
||
return false;
|
||
}
|
||
if (firstCh === 45 && isSpace(secondCh)) {
|
||
return false;
|
||
}
|
||
while (pos < state.eMarks[nextLine]) {
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
|
||
return false;
|
||
}
|
||
pos++;
|
||
}
|
||
let lineText = getLine(state, startLine + 1);
|
||
let columns = lineText.split("|");
|
||
const aligns = [];
|
||
for (let i = 0; i < columns.length; i++) {
|
||
const t = columns[i].trim();
|
||
if (!t) {
|
||
if (i === 0 || i === columns.length - 1) {
|
||
continue;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
if (!/^:?-+:?$/.test(t)) {
|
||
return false;
|
||
}
|
||
if (t.charCodeAt(t.length - 1) === 58) {
|
||
aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
|
||
} else if (t.charCodeAt(0) === 58) {
|
||
aligns.push("left");
|
||
} else {
|
||
aligns.push("");
|
||
}
|
||
}
|
||
lineText = getLine(state, startLine).trim();
|
||
if (lineText.indexOf("|") === -1) {
|
||
return false;
|
||
}
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
columns = escapedSplit(lineText);
|
||
if (columns.length && columns[0] === "")
|
||
columns.shift();
|
||
if (columns.length && columns[columns.length - 1] === "")
|
||
columns.pop();
|
||
const columnCount = columns.length;
|
||
if (columnCount === 0 || columnCount !== aligns.length) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
const oldParentType = state.parentType;
|
||
state.parentType = "table";
|
||
const terminatorRules = state.md.block.ruler.getRules("blockquote");
|
||
const token_to = state.push("table_open", "table", 1);
|
||
const tableLines = [startLine, 0];
|
||
token_to.map = tableLines;
|
||
const token_tho = state.push("thead_open", "thead", 1);
|
||
token_tho.map = [startLine, startLine + 1];
|
||
const token_htro = state.push("tr_open", "tr", 1);
|
||
token_htro.map = [startLine, startLine + 1];
|
||
for (let i = 0; i < columns.length; i++) {
|
||
const token_ho = state.push("th_open", "th", 1);
|
||
if (aligns[i]) {
|
||
token_ho.attrs = [["style", "text-align:" + aligns[i]]];
|
||
}
|
||
const token_il = state.push("inline", "", 0);
|
||
token_il.content = columns[i].trim();
|
||
token_il.children = [];
|
||
state.push("th_close", "th", -1);
|
||
}
|
||
state.push("tr_close", "tr", -1);
|
||
state.push("thead_close", "thead", -1);
|
||
let tbodyLines;
|
||
let autocompletedCells = 0;
|
||
for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
|
||
if (state.sCount[nextLine] < state.blkIndent) {
|
||
break;
|
||
}
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
if (terminate) {
|
||
break;
|
||
}
|
||
lineText = getLine(state, nextLine).trim();
|
||
if (!lineText) {
|
||
break;
|
||
}
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
break;
|
||
}
|
||
columns = escapedSplit(lineText);
|
||
if (columns.length && columns[0] === "")
|
||
columns.shift();
|
||
if (columns.length && columns[columns.length - 1] === "")
|
||
columns.pop();
|
||
autocompletedCells += columnCount - columns.length;
|
||
if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) {
|
||
break;
|
||
}
|
||
if (nextLine === startLine + 2) {
|
||
const token_tbo = state.push("tbody_open", "tbody", 1);
|
||
token_tbo.map = tbodyLines = [startLine + 2, 0];
|
||
}
|
||
const token_tro = state.push("tr_open", "tr", 1);
|
||
token_tro.map = [nextLine, nextLine + 1];
|
||
for (let i = 0; i < columnCount; i++) {
|
||
const token_tdo = state.push("td_open", "td", 1);
|
||
if (aligns[i]) {
|
||
token_tdo.attrs = [["style", "text-align:" + aligns[i]]];
|
||
}
|
||
const token_il = state.push("inline", "", 0);
|
||
token_il.content = columns[i] ? columns[i].trim() : "";
|
||
token_il.children = [];
|
||
state.push("td_close", "td", -1);
|
||
}
|
||
state.push("tr_close", "tr", -1);
|
||
}
|
||
if (tbodyLines) {
|
||
state.push("tbody_close", "tbody", -1);
|
||
tbodyLines[1] = nextLine;
|
||
}
|
||
state.push("table_close", "table", -1);
|
||
tableLines[1] = nextLine;
|
||
state.parentType = oldParentType;
|
||
state.line = nextLine;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/code.mjs
|
||
function code(state, startLine, endLine) {
|
||
if (state.sCount[startLine] - state.blkIndent < 4) {
|
||
return false;
|
||
}
|
||
let nextLine = startLine + 1;
|
||
let last = nextLine;
|
||
while (nextLine < endLine) {
|
||
if (state.isEmpty(nextLine)) {
|
||
nextLine++;
|
||
continue;
|
||
}
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
nextLine++;
|
||
last = nextLine;
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
state.line = last;
|
||
const token = state.push("code_block", "code", 0);
|
||
token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + "\n";
|
||
token.map = [startLine, state.line];
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/fence.mjs
|
||
function fence(state, startLine, endLine, silent) {
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
let max = state.eMarks[startLine];
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
if (pos + 3 > max) {
|
||
return false;
|
||
}
|
||
const marker = state.src.charCodeAt(pos);
|
||
if (marker !== 126 && marker !== 96) {
|
||
return false;
|
||
}
|
||
let mem = pos;
|
||
pos = state.skipChars(pos, marker);
|
||
let len = pos - mem;
|
||
if (len < 3) {
|
||
return false;
|
||
}
|
||
const markup = state.src.slice(mem, pos);
|
||
const params = state.src.slice(pos, max);
|
||
if (marker === 96) {
|
||
if (params.indexOf(String.fromCharCode(marker)) >= 0) {
|
||
return false;
|
||
}
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
let nextLine = startLine;
|
||
let haveEndMarker = false;
|
||
for (; ; ) {
|
||
nextLine++;
|
||
if (nextLine >= endLine) {
|
||
break;
|
||
}
|
||
pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
max = state.eMarks[nextLine];
|
||
if (pos < max && state.sCount[nextLine] < state.blkIndent) {
|
||
break;
|
||
}
|
||
if (state.src.charCodeAt(pos) !== marker) {
|
||
continue;
|
||
}
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
continue;
|
||
}
|
||
pos = state.skipChars(pos, marker);
|
||
if (pos - mem < len) {
|
||
continue;
|
||
}
|
||
pos = state.skipSpaces(pos);
|
||
if (pos < max) {
|
||
continue;
|
||
}
|
||
haveEndMarker = true;
|
||
break;
|
||
}
|
||
len = state.sCount[startLine];
|
||
state.line = nextLine + (haveEndMarker ? 1 : 0);
|
||
const token = state.push("fence", "code", 0);
|
||
token.info = params;
|
||
token.content = state.getLines(startLine + 1, nextLine, len, true);
|
||
token.markup = markup;
|
||
token.map = [startLine, state.line];
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/blockquote.mjs
|
||
function blockquote(state, startLine, endLine, silent) {
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
let max = state.eMarks[startLine];
|
||
const oldLineMax = state.lineMax;
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
if (state.src.charCodeAt(pos) !== 62) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
const oldBMarks = [];
|
||
const oldBSCount = [];
|
||
const oldSCount = [];
|
||
const oldTShift = [];
|
||
const terminatorRules = state.md.block.ruler.getRules("blockquote");
|
||
const oldParentType = state.parentType;
|
||
state.parentType = "blockquote";
|
||
let lastLineEmpty = false;
|
||
let nextLine;
|
||
for (nextLine = startLine; nextLine < endLine; nextLine++) {
|
||
const isOutdented = state.sCount[nextLine] < state.blkIndent;
|
||
pos = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
max = state.eMarks[nextLine];
|
||
if (pos >= max) {
|
||
break;
|
||
}
|
||
if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
|
||
let initial = state.sCount[nextLine] + 1;
|
||
let spaceAfterMarker;
|
||
let adjustTab;
|
||
if (state.src.charCodeAt(pos) === 32) {
|
||
pos++;
|
||
initial++;
|
||
adjustTab = false;
|
||
spaceAfterMarker = true;
|
||
} else if (state.src.charCodeAt(pos) === 9) {
|
||
spaceAfterMarker = true;
|
||
if ((state.bsCount[nextLine] + initial) % 4 === 3) {
|
||
pos++;
|
||
initial++;
|
||
adjustTab = false;
|
||
} else {
|
||
adjustTab = true;
|
||
}
|
||
} else {
|
||
spaceAfterMarker = false;
|
||
}
|
||
let offset = initial;
|
||
oldBMarks.push(state.bMarks[nextLine]);
|
||
state.bMarks[nextLine] = pos;
|
||
while (pos < max) {
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (isSpace(ch)) {
|
||
if (ch === 9) {
|
||
offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
|
||
} else {
|
||
offset++;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
pos++;
|
||
}
|
||
lastLineEmpty = pos >= max;
|
||
oldBSCount.push(state.bsCount[nextLine]);
|
||
state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
|
||
oldSCount.push(state.sCount[nextLine]);
|
||
state.sCount[nextLine] = offset - initial;
|
||
oldTShift.push(state.tShift[nextLine]);
|
||
state.tShift[nextLine] = pos - state.bMarks[nextLine];
|
||
continue;
|
||
}
|
||
if (lastLineEmpty) {
|
||
break;
|
||
}
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
if (terminate) {
|
||
state.lineMax = nextLine;
|
||
if (state.blkIndent !== 0) {
|
||
oldBMarks.push(state.bMarks[nextLine]);
|
||
oldBSCount.push(state.bsCount[nextLine]);
|
||
oldTShift.push(state.tShift[nextLine]);
|
||
oldSCount.push(state.sCount[nextLine]);
|
||
state.sCount[nextLine] -= state.blkIndent;
|
||
}
|
||
break;
|
||
}
|
||
oldBMarks.push(state.bMarks[nextLine]);
|
||
oldBSCount.push(state.bsCount[nextLine]);
|
||
oldTShift.push(state.tShift[nextLine]);
|
||
oldSCount.push(state.sCount[nextLine]);
|
||
state.sCount[nextLine] = -1;
|
||
}
|
||
const oldIndent = state.blkIndent;
|
||
state.blkIndent = 0;
|
||
const token_o = state.push("blockquote_open", "blockquote", 1);
|
||
token_o.markup = ">";
|
||
const lines = [startLine, 0];
|
||
token_o.map = lines;
|
||
state.md.block.tokenize(state, startLine, nextLine);
|
||
const token_c = state.push("blockquote_close", "blockquote", -1);
|
||
token_c.markup = ">";
|
||
state.lineMax = oldLineMax;
|
||
state.parentType = oldParentType;
|
||
lines[1] = state.line;
|
||
for (let i = 0; i < oldTShift.length; i++) {
|
||
state.bMarks[i + startLine] = oldBMarks[i];
|
||
state.tShift[i + startLine] = oldTShift[i];
|
||
state.sCount[i + startLine] = oldSCount[i];
|
||
state.bsCount[i + startLine] = oldBSCount[i];
|
||
}
|
||
state.blkIndent = oldIndent;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/hr.mjs
|
||
function hr(state, startLine, endLine, silent) {
|
||
const max = state.eMarks[startLine];
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
const marker = state.src.charCodeAt(pos++);
|
||
if (marker !== 42 && marker !== 45 && marker !== 95) {
|
||
return false;
|
||
}
|
||
let cnt = 1;
|
||
while (pos < max) {
|
||
const ch = state.src.charCodeAt(pos++);
|
||
if (ch !== marker && !isSpace(ch)) {
|
||
return false;
|
||
}
|
||
if (ch === marker) {
|
||
cnt++;
|
||
}
|
||
}
|
||
if (cnt < 3) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
state.line = startLine + 1;
|
||
const token = state.push("hr", "hr", 0);
|
||
token.map = [startLine, state.line];
|
||
token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/list.mjs
|
||
function skipBulletListMarker(state, startLine) {
|
||
const max = state.eMarks[startLine];
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
const marker = state.src.charCodeAt(pos++);
|
||
if (marker !== 42 && marker !== 45 && marker !== 43) {
|
||
return -1;
|
||
}
|
||
if (pos < max) {
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (!isSpace(ch)) {
|
||
return -1;
|
||
}
|
||
}
|
||
return pos;
|
||
}
|
||
function skipOrderedListMarker(state, startLine) {
|
||
const start = state.bMarks[startLine] + state.tShift[startLine];
|
||
const max = state.eMarks[startLine];
|
||
let pos = start;
|
||
if (pos + 1 >= max) {
|
||
return -1;
|
||
}
|
||
let ch = state.src.charCodeAt(pos++);
|
||
if (ch < 48 || ch > 57) {
|
||
return -1;
|
||
}
|
||
for (; ; ) {
|
||
if (pos >= max) {
|
||
return -1;
|
||
}
|
||
ch = state.src.charCodeAt(pos++);
|
||
if (ch >= 48 && ch <= 57) {
|
||
if (pos - start >= 10) {
|
||
return -1;
|
||
}
|
||
continue;
|
||
}
|
||
if (ch === 41 || ch === 46) {
|
||
break;
|
||
}
|
||
return -1;
|
||
}
|
||
if (pos < max) {
|
||
ch = state.src.charCodeAt(pos);
|
||
if (!isSpace(ch)) {
|
||
return -1;
|
||
}
|
||
}
|
||
return pos;
|
||
}
|
||
function markTightParagraphs(state, idx) {
|
||
const level = state.level + 2;
|
||
for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
|
||
if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
|
||
state.tokens[i + 2].hidden = true;
|
||
state.tokens[i].hidden = true;
|
||
i += 2;
|
||
}
|
||
}
|
||
}
|
||
function list(state, startLine, endLine, silent) {
|
||
let max, pos, start, token;
|
||
let nextLine = startLine;
|
||
let tight = true;
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
if (state.listIndent >= 0 && state.sCount[nextLine] - state.listIndent >= 4 && state.sCount[nextLine] < state.blkIndent) {
|
||
return false;
|
||
}
|
||
let isTerminatingParagraph = false;
|
||
if (silent && state.parentType === "paragraph") {
|
||
if (state.sCount[nextLine] >= state.blkIndent) {
|
||
isTerminatingParagraph = true;
|
||
}
|
||
}
|
||
let isOrdered;
|
||
let markerValue;
|
||
let posAfterMarker;
|
||
if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
|
||
isOrdered = true;
|
||
start = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
markerValue = Number(state.src.slice(start, posAfterMarker - 1));
|
||
if (isTerminatingParagraph && markerValue !== 1)
|
||
return false;
|
||
} else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
|
||
isOrdered = false;
|
||
} else {
|
||
return false;
|
||
}
|
||
if (isTerminatingParagraph) {
|
||
if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine])
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
const markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
|
||
const listTokIdx = state.tokens.length;
|
||
if (isOrdered) {
|
||
token = state.push("ordered_list_open", "ol", 1);
|
||
if (markerValue !== 1) {
|
||
token.attrs = [["start", markerValue]];
|
||
}
|
||
} else {
|
||
token = state.push("bullet_list_open", "ul", 1);
|
||
}
|
||
const listLines = [nextLine, 0];
|
||
token.map = listLines;
|
||
token.markup = String.fromCharCode(markerCharCode);
|
||
let prevEmptyEnd = false;
|
||
const terminatorRules = state.md.block.ruler.getRules("list");
|
||
const oldParentType = state.parentType;
|
||
state.parentType = "list";
|
||
while (nextLine < endLine) {
|
||
pos = posAfterMarker;
|
||
max = state.eMarks[nextLine];
|
||
const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);
|
||
let offset = initial;
|
||
while (pos < max) {
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (ch === 9) {
|
||
offset += 4 - (offset + state.bsCount[nextLine]) % 4;
|
||
} else if (ch === 32) {
|
||
offset++;
|
||
} else {
|
||
break;
|
||
}
|
||
pos++;
|
||
}
|
||
const contentStart = pos;
|
||
let indentAfterMarker;
|
||
if (contentStart >= max) {
|
||
indentAfterMarker = 1;
|
||
} else {
|
||
indentAfterMarker = offset - initial;
|
||
}
|
||
if (indentAfterMarker > 4) {
|
||
indentAfterMarker = 1;
|
||
}
|
||
const indent = initial + indentAfterMarker;
|
||
token = state.push("list_item_open", "li", 1);
|
||
token.markup = String.fromCharCode(markerCharCode);
|
||
const itemLines = [nextLine, 0];
|
||
token.map = itemLines;
|
||
if (isOrdered) {
|
||
token.info = state.src.slice(start, posAfterMarker - 1);
|
||
}
|
||
const oldTight = state.tight;
|
||
const oldTShift = state.tShift[nextLine];
|
||
const oldSCount = state.sCount[nextLine];
|
||
const oldListIndent = state.listIndent;
|
||
state.listIndent = state.blkIndent;
|
||
state.blkIndent = indent;
|
||
state.tight = true;
|
||
state.tShift[nextLine] = contentStart - state.bMarks[nextLine];
|
||
state.sCount[nextLine] = offset;
|
||
if (contentStart >= max && state.isEmpty(nextLine + 1)) {
|
||
state.line = Math.min(state.line + 2, endLine);
|
||
} else {
|
||
state.md.block.tokenize(state, nextLine, endLine, true);
|
||
}
|
||
if (!state.tight || prevEmptyEnd) {
|
||
tight = false;
|
||
}
|
||
prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);
|
||
state.blkIndent = state.listIndent;
|
||
state.listIndent = oldListIndent;
|
||
state.tShift[nextLine] = oldTShift;
|
||
state.sCount[nextLine] = oldSCount;
|
||
state.tight = oldTight;
|
||
token = state.push("list_item_close", "li", -1);
|
||
token.markup = String.fromCharCode(markerCharCode);
|
||
nextLine = state.line;
|
||
itemLines[1] = nextLine;
|
||
if (nextLine >= endLine) {
|
||
break;
|
||
}
|
||
if (state.sCount[nextLine] < state.blkIndent) {
|
||
break;
|
||
}
|
||
if (state.sCount[nextLine] - state.blkIndent >= 4) {
|
||
break;
|
||
}
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
if (terminate) {
|
||
break;
|
||
}
|
||
if (isOrdered) {
|
||
posAfterMarker = skipOrderedListMarker(state, nextLine);
|
||
if (posAfterMarker < 0) {
|
||
break;
|
||
}
|
||
start = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
} else {
|
||
posAfterMarker = skipBulletListMarker(state, nextLine);
|
||
if (posAfterMarker < 0) {
|
||
break;
|
||
}
|
||
}
|
||
if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
|
||
break;
|
||
}
|
||
}
|
||
if (isOrdered) {
|
||
token = state.push("ordered_list_close", "ol", -1);
|
||
} else {
|
||
token = state.push("bullet_list_close", "ul", -1);
|
||
}
|
||
token.markup = String.fromCharCode(markerCharCode);
|
||
listLines[1] = nextLine;
|
||
state.line = nextLine;
|
||
state.parentType = oldParentType;
|
||
if (tight) {
|
||
markTightParagraphs(state, listTokIdx);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/reference.mjs
|
||
function reference(state, startLine, _endLine, silent) {
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
let max = state.eMarks[startLine];
|
||
let nextLine = startLine + 1;
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
if (state.src.charCodeAt(pos) !== 91) {
|
||
return false;
|
||
}
|
||
function getNextLine(nextLine2) {
|
||
const endLine = state.lineMax;
|
||
if (nextLine2 >= endLine || state.isEmpty(nextLine2)) {
|
||
return null;
|
||
}
|
||
let isContinuation = false;
|
||
if (state.sCount[nextLine2] - state.blkIndent > 3) {
|
||
isContinuation = true;
|
||
}
|
||
if (state.sCount[nextLine2] < 0) {
|
||
isContinuation = true;
|
||
}
|
||
if (!isContinuation) {
|
||
const terminatorRules = state.md.block.ruler.getRules("reference");
|
||
const oldParentType = state.parentType;
|
||
state.parentType = "reference";
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine2, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
state.parentType = oldParentType;
|
||
if (terminate) {
|
||
return null;
|
||
}
|
||
}
|
||
const pos2 = state.bMarks[nextLine2] + state.tShift[nextLine2];
|
||
const max2 = state.eMarks[nextLine2];
|
||
return state.src.slice(pos2, max2 + 1);
|
||
}
|
||
let str = state.src.slice(pos, max + 1);
|
||
max = str.length;
|
||
let labelEnd = -1;
|
||
for (pos = 1; pos < max; pos++) {
|
||
const ch = str.charCodeAt(pos);
|
||
if (ch === 91) {
|
||
return false;
|
||
} else if (ch === 93) {
|
||
labelEnd = pos;
|
||
break;
|
||
} else if (ch === 10) {
|
||
const lineContent = getNextLine(nextLine);
|
||
if (lineContent !== null) {
|
||
str += lineContent;
|
||
max = str.length;
|
||
nextLine++;
|
||
}
|
||
} else if (ch === 92) {
|
||
pos++;
|
||
if (pos < max && str.charCodeAt(pos) === 10) {
|
||
const lineContent = getNextLine(nextLine);
|
||
if (lineContent !== null) {
|
||
str += lineContent;
|
||
max = str.length;
|
||
nextLine++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) {
|
||
return false;
|
||
}
|
||
for (pos = labelEnd + 2; pos < max; pos++) {
|
||
const ch = str.charCodeAt(pos);
|
||
if (ch === 10) {
|
||
const lineContent = getNextLine(nextLine);
|
||
if (lineContent !== null) {
|
||
str += lineContent;
|
||
max = str.length;
|
||
nextLine++;
|
||
}
|
||
} else if (isSpace(ch)) {
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
const destRes = state.md.helpers.parseLinkDestination(str, pos, max);
|
||
if (!destRes.ok) {
|
||
return false;
|
||
}
|
||
const href = state.md.normalizeLink(destRes.str);
|
||
if (!state.md.validateLink(href)) {
|
||
return false;
|
||
}
|
||
pos = destRes.pos;
|
||
const destEndPos = pos;
|
||
const destEndLineNo = nextLine;
|
||
const start = pos;
|
||
for (; pos < max; pos++) {
|
||
const ch = str.charCodeAt(pos);
|
||
if (ch === 10) {
|
||
const lineContent = getNextLine(nextLine);
|
||
if (lineContent !== null) {
|
||
str += lineContent;
|
||
max = str.length;
|
||
nextLine++;
|
||
}
|
||
} else if (isSpace(ch)) {
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
|
||
while (titleRes.can_continue) {
|
||
const lineContent = getNextLine(nextLine);
|
||
if (lineContent === null)
|
||
break;
|
||
str += lineContent;
|
||
pos = max;
|
||
max = str.length;
|
||
nextLine++;
|
||
titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
|
||
}
|
||
let title;
|
||
if (pos < max && start !== pos && titleRes.ok) {
|
||
title = titleRes.str;
|
||
pos = titleRes.pos;
|
||
} else {
|
||
title = "";
|
||
pos = destEndPos;
|
||
nextLine = destEndLineNo;
|
||
}
|
||
while (pos < max) {
|
||
const ch = str.charCodeAt(pos);
|
||
if (!isSpace(ch)) {
|
||
break;
|
||
}
|
||
pos++;
|
||
}
|
||
if (pos < max && str.charCodeAt(pos) !== 10) {
|
||
if (title) {
|
||
title = "";
|
||
pos = destEndPos;
|
||
nextLine = destEndLineNo;
|
||
while (pos < max) {
|
||
const ch = str.charCodeAt(pos);
|
||
if (!isSpace(ch)) {
|
||
break;
|
||
}
|
||
pos++;
|
||
}
|
||
}
|
||
}
|
||
if (pos < max && str.charCodeAt(pos) !== 10) {
|
||
return false;
|
||
}
|
||
const label = normalizeReference(str.slice(1, labelEnd));
|
||
if (!label) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
if (typeof state.env.references === "undefined") {
|
||
state.env.references = {};
|
||
}
|
||
if (typeof state.env.references[label] === "undefined") {
|
||
state.env.references[label] = { title, href };
|
||
}
|
||
state.line = nextLine;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/common/html_blocks.mjs
|
||
var html_blocks_default = [
|
||
"address",
|
||
"article",
|
||
"aside",
|
||
"base",
|
||
"basefont",
|
||
"blockquote",
|
||
"body",
|
||
"caption",
|
||
"center",
|
||
"col",
|
||
"colgroup",
|
||
"dd",
|
||
"details",
|
||
"dialog",
|
||
"dir",
|
||
"div",
|
||
"dl",
|
||
"dt",
|
||
"fieldset",
|
||
"figcaption",
|
||
"figure",
|
||
"footer",
|
||
"form",
|
||
"frame",
|
||
"frameset",
|
||
"h1",
|
||
"h2",
|
||
"h3",
|
||
"h4",
|
||
"h5",
|
||
"h6",
|
||
"head",
|
||
"header",
|
||
"hr",
|
||
"html",
|
||
"iframe",
|
||
"legend",
|
||
"li",
|
||
"link",
|
||
"main",
|
||
"menu",
|
||
"menuitem",
|
||
"nav",
|
||
"noframes",
|
||
"ol",
|
||
"optgroup",
|
||
"option",
|
||
"p",
|
||
"param",
|
||
"search",
|
||
"section",
|
||
"summary",
|
||
"table",
|
||
"tbody",
|
||
"td",
|
||
"tfoot",
|
||
"th",
|
||
"thead",
|
||
"title",
|
||
"tr",
|
||
"track",
|
||
"ul"
|
||
];
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/common/html_re.mjs
|
||
var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
|
||
var unquoted = "[^\"'=<>`\\x00-\\x20]+";
|
||
var single_quoted = "'[^']*'";
|
||
var double_quoted = '"[^"]*"';
|
||
var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
|
||
var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
|
||
var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
|
||
var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
|
||
var comment = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->";
|
||
var processing = "<[?][\\s\\S]*?[?]>";
|
||
var declaration = "<![A-Za-z][^>]*>";
|
||
var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
|
||
var HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
|
||
var HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/html_block.mjs
|
||
var HTML_SEQUENCES = [
|
||
[/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
|
||
[/^<!--/, /-->/, true],
|
||
[/^<\?/, /\?>/, true],
|
||
[/^<![A-Z]/, />/, true],
|
||
[/^<!\[CDATA\[/, /\]\]>/, true],
|
||
[new RegExp("^</?(" + html_blocks_default.join("|") + ")(?=(\\s|/?>|$))", "i"), /^$/, true],
|
||
[new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false]
|
||
];
|
||
function html_block(state, startLine, endLine, silent) {
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
let max = state.eMarks[startLine];
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
if (!state.md.options.html) {
|
||
return false;
|
||
}
|
||
if (state.src.charCodeAt(pos) !== 60) {
|
||
return false;
|
||
}
|
||
let lineText = state.src.slice(pos, max);
|
||
let i = 0;
|
||
for (; i < HTML_SEQUENCES.length; i++) {
|
||
if (HTML_SEQUENCES[i][0].test(lineText)) {
|
||
break;
|
||
}
|
||
}
|
||
if (i === HTML_SEQUENCES.length) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return HTML_SEQUENCES[i][2];
|
||
}
|
||
let nextLine = startLine + 1;
|
||
if (!HTML_SEQUENCES[i][1].test(lineText)) {
|
||
for (; nextLine < endLine; nextLine++) {
|
||
if (state.sCount[nextLine] < state.blkIndent) {
|
||
break;
|
||
}
|
||
pos = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
max = state.eMarks[nextLine];
|
||
lineText = state.src.slice(pos, max);
|
||
if (HTML_SEQUENCES[i][1].test(lineText)) {
|
||
if (lineText.length !== 0) {
|
||
nextLine++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
state.line = nextLine;
|
||
const token = state.push("html_block", "", 0);
|
||
token.map = [startLine, nextLine];
|
||
token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/heading.mjs
|
||
function heading(state, startLine, endLine, silent) {
|
||
let pos = state.bMarks[startLine] + state.tShift[startLine];
|
||
let max = state.eMarks[startLine];
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
let ch = state.src.charCodeAt(pos);
|
||
if (ch !== 35 || pos >= max) {
|
||
return false;
|
||
}
|
||
let level = 1;
|
||
ch = state.src.charCodeAt(++pos);
|
||
while (ch === 35 && pos < max && level <= 6) {
|
||
level++;
|
||
ch = state.src.charCodeAt(++pos);
|
||
}
|
||
if (level > 6 || pos < max && !isSpace(ch)) {
|
||
return false;
|
||
}
|
||
if (silent) {
|
||
return true;
|
||
}
|
||
max = state.skipSpacesBack(max, pos);
|
||
const tmp = state.skipCharsBack(max, 35, pos);
|
||
if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
|
||
max = tmp;
|
||
}
|
||
state.line = startLine + 1;
|
||
const token_o = state.push("heading_open", "h" + String(level), 1);
|
||
token_o.markup = "########".slice(0, level);
|
||
token_o.map = [startLine, state.line];
|
||
const token_i = state.push("inline", "", 0);
|
||
token_i.content = state.src.slice(pos, max).trim();
|
||
token_i.map = [startLine, state.line];
|
||
token_i.children = [];
|
||
const token_c = state.push("heading_close", "h" + String(level), -1);
|
||
token_c.markup = "########".slice(0, level);
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/lheading.mjs
|
||
function lheading(state, startLine, endLine) {
|
||
const terminatorRules = state.md.block.ruler.getRules("paragraph");
|
||
if (state.sCount[startLine] - state.blkIndent >= 4) {
|
||
return false;
|
||
}
|
||
const oldParentType = state.parentType;
|
||
state.parentType = "paragraph";
|
||
let level = 0;
|
||
let marker;
|
||
let nextLine = startLine + 1;
|
||
for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
|
||
if (state.sCount[nextLine] - state.blkIndent > 3) {
|
||
continue;
|
||
}
|
||
if (state.sCount[nextLine] >= state.blkIndent) {
|
||
let pos = state.bMarks[nextLine] + state.tShift[nextLine];
|
||
const max = state.eMarks[nextLine];
|
||
if (pos < max) {
|
||
marker = state.src.charCodeAt(pos);
|
||
if (marker === 45 || marker === 61) {
|
||
pos = state.skipChars(pos, marker);
|
||
pos = state.skipSpaces(pos);
|
||
if (pos >= max) {
|
||
level = marker === 61 ? 1 : 2;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (state.sCount[nextLine] < 0) {
|
||
continue;
|
||
}
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
if (terminate) {
|
||
break;
|
||
}
|
||
}
|
||
if (!level) {
|
||
return false;
|
||
}
|
||
const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
|
||
state.line = nextLine + 1;
|
||
const token_o = state.push("heading_open", "h" + String(level), 1);
|
||
token_o.markup = String.fromCharCode(marker);
|
||
token_o.map = [startLine, state.line];
|
||
const token_i = state.push("inline", "", 0);
|
||
token_i.content = content;
|
||
token_i.map = [startLine, state.line - 1];
|
||
token_i.children = [];
|
||
const token_c = state.push("heading_close", "h" + String(level), -1);
|
||
token_c.markup = String.fromCharCode(marker);
|
||
state.parentType = oldParentType;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_block/paragraph.mjs
|
||
function paragraph(state, startLine, endLine) {
|
||
const terminatorRules = state.md.block.ruler.getRules("paragraph");
|
||
const oldParentType = state.parentType;
|
||
let nextLine = startLine + 1;
|
||
state.parentType = "paragraph";
|
||
for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
|
||
if (state.sCount[nextLine] - state.blkIndent > 3) {
|
||
continue;
|
||
}
|
||
if (state.sCount[nextLine] < 0) {
|
||
continue;
|
||
}
|
||
let terminate = false;
|
||
for (let i = 0, l = terminatorRules.length; i < l; i++) {
|
||
if (terminatorRules[i](state, nextLine, endLine, true)) {
|
||
terminate = true;
|
||
break;
|
||
}
|
||
}
|
||
if (terminate) {
|
||
break;
|
||
}
|
||
}
|
||
const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
|
||
state.line = nextLine;
|
||
const token_o = state.push("paragraph_open", "p", 1);
|
||
token_o.map = [startLine, state.line];
|
||
const token_i = state.push("inline", "", 0);
|
||
token_i.content = content;
|
||
token_i.map = [startLine, state.line];
|
||
token_i.children = [];
|
||
state.push("paragraph_close", "p", -1);
|
||
state.parentType = oldParentType;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/parser_block.mjs
|
||
var _rules2 = [
|
||
// First 2 params - rule name & source. Secondary array - list of rules,
|
||
// which can be terminated by this one.
|
||
["table", table, ["paragraph", "reference"]],
|
||
["code", code],
|
||
["fence", fence, ["paragraph", "reference", "blockquote", "list"]],
|
||
["blockquote", blockquote, ["paragraph", "reference", "blockquote", "list"]],
|
||
["hr", hr, ["paragraph", "reference", "blockquote", "list"]],
|
||
["list", list, ["paragraph", "reference", "blockquote"]],
|
||
["reference", reference],
|
||
["html_block", html_block, ["paragraph", "reference", "blockquote"]],
|
||
["heading", heading, ["paragraph", "reference", "blockquote"]],
|
||
["lheading", lheading],
|
||
["paragraph", paragraph]
|
||
];
|
||
function ParserBlock() {
|
||
this.ruler = new ruler_default();
|
||
for (let i = 0; i < _rules2.length; i++) {
|
||
this.ruler.push(_rules2[i][0], _rules2[i][1], { alt: (_rules2[i][2] || []).slice() });
|
||
}
|
||
}
|
||
ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
|
||
const rules = this.ruler.getRules("");
|
||
const len = rules.length;
|
||
const maxNesting = state.md.options.maxNesting;
|
||
let line = startLine;
|
||
let hasEmptyLines = false;
|
||
while (line < endLine) {
|
||
state.line = line = state.skipEmptyLines(line);
|
||
if (line >= endLine) {
|
||
break;
|
||
}
|
||
if (state.sCount[line] < state.blkIndent) {
|
||
break;
|
||
}
|
||
if (state.level >= maxNesting) {
|
||
state.line = endLine;
|
||
break;
|
||
}
|
||
const prevLine = state.line;
|
||
let ok = false;
|
||
for (let i = 0; i < len; i++) {
|
||
ok = rules[i](state, line, endLine, false);
|
||
if (ok) {
|
||
if (prevLine >= state.line) {
|
||
throw new Error("block rule didn't increment state.line");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (!ok)
|
||
throw new Error("none of the block rules matched");
|
||
state.tight = !hasEmptyLines;
|
||
if (state.isEmpty(state.line - 1)) {
|
||
hasEmptyLines = true;
|
||
}
|
||
line = state.line;
|
||
if (line < endLine && state.isEmpty(line)) {
|
||
hasEmptyLines = true;
|
||
line++;
|
||
state.line = line;
|
||
}
|
||
}
|
||
};
|
||
ParserBlock.prototype.parse = function(src, md, env, outTokens) {
|
||
if (!src) {
|
||
return;
|
||
}
|
||
const state = new this.State(src, md, env, outTokens);
|
||
this.tokenize(state, state.line, state.lineMax);
|
||
};
|
||
ParserBlock.prototype.State = state_block_default;
|
||
var parser_block_default = ParserBlock;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/state_inline.mjs
|
||
function StateInline(src, md, env, outTokens) {
|
||
this.src = src;
|
||
this.env = env;
|
||
this.md = md;
|
||
this.tokens = outTokens;
|
||
this.tokens_meta = Array(outTokens.length);
|
||
this.pos = 0;
|
||
this.posMax = this.src.length;
|
||
this.level = 0;
|
||
this.pending = "";
|
||
this.pendingLevel = 0;
|
||
this.cache = {};
|
||
this.delimiters = [];
|
||
this._prev_delimiters = [];
|
||
this.backticks = {};
|
||
this.backticksScanned = false;
|
||
this.linkLevel = 0;
|
||
}
|
||
StateInline.prototype.pushPending = function() {
|
||
const token = new token_default("text", "", 0);
|
||
token.content = this.pending;
|
||
token.level = this.pendingLevel;
|
||
this.tokens.push(token);
|
||
this.pending = "";
|
||
return token;
|
||
};
|
||
StateInline.prototype.push = function(type, tag, nesting) {
|
||
if (this.pending) {
|
||
this.pushPending();
|
||
}
|
||
const token = new token_default(type, tag, nesting);
|
||
let token_meta = null;
|
||
if (nesting < 0) {
|
||
this.level--;
|
||
this.delimiters = this._prev_delimiters.pop();
|
||
}
|
||
token.level = this.level;
|
||
if (nesting > 0) {
|
||
this.level++;
|
||
this._prev_delimiters.push(this.delimiters);
|
||
this.delimiters = [];
|
||
token_meta = { delimiters: this.delimiters };
|
||
}
|
||
this.pendingLevel = this.level;
|
||
this.tokens.push(token);
|
||
this.tokens_meta.push(token_meta);
|
||
return token;
|
||
};
|
||
StateInline.prototype.scanDelims = function(start, canSplitWord) {
|
||
const max = this.posMax;
|
||
const marker = this.src.charCodeAt(start);
|
||
const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
|
||
let pos = start;
|
||
while (pos < max && this.src.charCodeAt(pos) === marker) {
|
||
pos++;
|
||
}
|
||
const count = pos - start;
|
||
const nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
|
||
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
|
||
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
|
||
const isLastWhiteSpace = isWhiteSpace(lastChar);
|
||
const isNextWhiteSpace = isWhiteSpace(nextChar);
|
||
const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
|
||
const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
|
||
const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar);
|
||
const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar);
|
||
return { can_open, can_close, length: count };
|
||
};
|
||
StateInline.prototype.Token = token_default;
|
||
var state_inline_default = StateInline;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/text.mjs
|
||
function isTerminatorChar(ch) {
|
||
switch (ch) {
|
||
case 10:
|
||
case 33:
|
||
case 35:
|
||
case 36:
|
||
case 37:
|
||
case 38:
|
||
case 42:
|
||
case 43:
|
||
case 45:
|
||
case 58:
|
||
case 60:
|
||
case 61:
|
||
case 62:
|
||
case 64:
|
||
case 91:
|
||
case 92:
|
||
case 93:
|
||
case 94:
|
||
case 95:
|
||
case 96:
|
||
case 123:
|
||
case 125:
|
||
case 126:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
function text(state, silent) {
|
||
let pos = state.pos;
|
||
while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
|
||
pos++;
|
||
}
|
||
if (pos === state.pos) {
|
||
return false;
|
||
}
|
||
if (!silent) {
|
||
state.pending += state.src.slice(state.pos, pos);
|
||
}
|
||
state.pos = pos;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/linkify.mjs
|
||
var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
|
||
function linkify2(state, silent) {
|
||
if (!state.md.options.linkify)
|
||
return false;
|
||
if (state.linkLevel > 0)
|
||
return false;
|
||
const pos = state.pos;
|
||
const max = state.posMax;
|
||
if (pos + 3 > max)
|
||
return false;
|
||
if (state.src.charCodeAt(pos) !== 58)
|
||
return false;
|
||
if (state.src.charCodeAt(pos + 1) !== 47)
|
||
return false;
|
||
if (state.src.charCodeAt(pos + 2) !== 47)
|
||
return false;
|
||
const match2 = state.pending.match(SCHEME_RE);
|
||
if (!match2)
|
||
return false;
|
||
const proto = match2[1];
|
||
const link2 = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
|
||
if (!link2)
|
||
return false;
|
||
let url = link2.url;
|
||
if (url.length <= proto.length)
|
||
return false;
|
||
url = url.replace(/\*+$/, "");
|
||
const fullUrl = state.md.normalizeLink(url);
|
||
if (!state.md.validateLink(fullUrl))
|
||
return false;
|
||
if (!silent) {
|
||
state.pending = state.pending.slice(0, -proto.length);
|
||
const token_o = state.push("link_open", "a", 1);
|
||
token_o.attrs = [["href", fullUrl]];
|
||
token_o.markup = "linkify";
|
||
token_o.info = "auto";
|
||
const token_t = state.push("text", "", 0);
|
||
token_t.content = state.md.normalizeLinkText(url);
|
||
const token_c = state.push("link_close", "a", -1);
|
||
token_c.markup = "linkify";
|
||
token_c.info = "auto";
|
||
}
|
||
state.pos += url.length - proto.length;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/newline.mjs
|
||
function newline(state, silent) {
|
||
let pos = state.pos;
|
||
if (state.src.charCodeAt(pos) !== 10) {
|
||
return false;
|
||
}
|
||
const pmax = state.pending.length - 1;
|
||
const max = state.posMax;
|
||
if (!silent) {
|
||
if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
|
||
if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
|
||
let ws = pmax - 1;
|
||
while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32)
|
||
ws--;
|
||
state.pending = state.pending.slice(0, ws);
|
||
state.push("hardbreak", "br", 0);
|
||
} else {
|
||
state.pending = state.pending.slice(0, -1);
|
||
state.push("softbreak", "br", 0);
|
||
}
|
||
} else {
|
||
state.push("softbreak", "br", 0);
|
||
}
|
||
}
|
||
pos++;
|
||
while (pos < max && isSpace(state.src.charCodeAt(pos))) {
|
||
pos++;
|
||
}
|
||
state.pos = pos;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/escape.mjs
|
||
var ESCAPED = [];
|
||
for (let i = 0; i < 256; i++) {
|
||
ESCAPED.push(0);
|
||
}
|
||
"\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
|
||
ESCAPED[ch.charCodeAt(0)] = 1;
|
||
});
|
||
function escape(state, silent) {
|
||
let pos = state.pos;
|
||
const max = state.posMax;
|
||
if (state.src.charCodeAt(pos) !== 92)
|
||
return false;
|
||
pos++;
|
||
if (pos >= max)
|
||
return false;
|
||
let ch1 = state.src.charCodeAt(pos);
|
||
if (ch1 === 10) {
|
||
if (!silent) {
|
||
state.push("hardbreak", "br", 0);
|
||
}
|
||
pos++;
|
||
while (pos < max) {
|
||
ch1 = state.src.charCodeAt(pos);
|
||
if (!isSpace(ch1))
|
||
break;
|
||
pos++;
|
||
}
|
||
state.pos = pos;
|
||
return true;
|
||
}
|
||
let escapedStr = state.src[pos];
|
||
if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
|
||
const ch2 = state.src.charCodeAt(pos + 1);
|
||
if (ch2 >= 56320 && ch2 <= 57343) {
|
||
escapedStr += state.src[pos + 1];
|
||
pos++;
|
||
}
|
||
}
|
||
const origStr = "\\" + escapedStr;
|
||
if (!silent) {
|
||
const token = state.push("text_special", "", 0);
|
||
if (ch1 < 256 && ESCAPED[ch1] !== 0) {
|
||
token.content = escapedStr;
|
||
} else {
|
||
token.content = origStr;
|
||
}
|
||
token.markup = origStr;
|
||
token.info = "escape";
|
||
}
|
||
state.pos = pos + 1;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/backticks.mjs
|
||
function backtick(state, silent) {
|
||
let pos = state.pos;
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (ch !== 96) {
|
||
return false;
|
||
}
|
||
const start = pos;
|
||
pos++;
|
||
const max = state.posMax;
|
||
while (pos < max && state.src.charCodeAt(pos) === 96) {
|
||
pos++;
|
||
}
|
||
const marker = state.src.slice(start, pos);
|
||
const openerLength = marker.length;
|
||
if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
|
||
if (!silent)
|
||
state.pending += marker;
|
||
state.pos += openerLength;
|
||
return true;
|
||
}
|
||
let matchEnd = pos;
|
||
let matchStart;
|
||
while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
|
||
matchEnd = matchStart + 1;
|
||
while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
|
||
matchEnd++;
|
||
}
|
||
const closerLength = matchEnd - matchStart;
|
||
if (closerLength === openerLength) {
|
||
if (!silent) {
|
||
const token = state.push("code_inline", "code", 0);
|
||
token.markup = marker;
|
||
token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
|
||
}
|
||
state.pos = matchEnd;
|
||
return true;
|
||
}
|
||
state.backticks[closerLength] = matchStart;
|
||
}
|
||
state.backticksScanned = true;
|
||
if (!silent)
|
||
state.pending += marker;
|
||
state.pos += openerLength;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/strikethrough.mjs
|
||
function strikethrough_tokenize(state, silent) {
|
||
const start = state.pos;
|
||
const marker = state.src.charCodeAt(start);
|
||
if (silent) {
|
||
return false;
|
||
}
|
||
if (marker !== 126) {
|
||
return false;
|
||
}
|
||
const scanned = state.scanDelims(state.pos, true);
|
||
let len = scanned.length;
|
||
const ch = String.fromCharCode(marker);
|
||
if (len < 2) {
|
||
return false;
|
||
}
|
||
let token;
|
||
if (len % 2) {
|
||
token = state.push("text", "", 0);
|
||
token.content = ch;
|
||
len--;
|
||
}
|
||
for (let i = 0; i < len; i += 2) {
|
||
token = state.push("text", "", 0);
|
||
token.content = ch + ch;
|
||
state.delimiters.push({
|
||
marker,
|
||
length: 0,
|
||
// disable "rule of 3" length checks meant for emphasis
|
||
token: state.tokens.length - 1,
|
||
end: -1,
|
||
open: scanned.can_open,
|
||
close: scanned.can_close
|
||
});
|
||
}
|
||
state.pos += scanned.length;
|
||
return true;
|
||
}
|
||
function postProcess(state, delimiters) {
|
||
let token;
|
||
const loneMarkers = [];
|
||
const max = delimiters.length;
|
||
for (let i = 0; i < max; i++) {
|
||
const startDelim = delimiters[i];
|
||
if (startDelim.marker !== 126) {
|
||
continue;
|
||
}
|
||
if (startDelim.end === -1) {
|
||
continue;
|
||
}
|
||
const endDelim = delimiters[startDelim.end];
|
||
token = state.tokens[startDelim.token];
|
||
token.type = "s_open";
|
||
token.tag = "s";
|
||
token.nesting = 1;
|
||
token.markup = "~~";
|
||
token.content = "";
|
||
token = state.tokens[endDelim.token];
|
||
token.type = "s_close";
|
||
token.tag = "s";
|
||
token.nesting = -1;
|
||
token.markup = "~~";
|
||
token.content = "";
|
||
if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "~") {
|
||
loneMarkers.push(endDelim.token - 1);
|
||
}
|
||
}
|
||
while (loneMarkers.length) {
|
||
const i = loneMarkers.pop();
|
||
let j = i + 1;
|
||
while (j < state.tokens.length && state.tokens[j].type === "s_close") {
|
||
j++;
|
||
}
|
||
j--;
|
||
if (i !== j) {
|
||
token = state.tokens[j];
|
||
state.tokens[j] = state.tokens[i];
|
||
state.tokens[i] = token;
|
||
}
|
||
}
|
||
}
|
||
function strikethrough_postProcess(state) {
|
||
const tokens_meta = state.tokens_meta;
|
||
const max = state.tokens_meta.length;
|
||
postProcess(state, state.delimiters);
|
||
for (let curr = 0; curr < max; curr++) {
|
||
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
|
||
postProcess(state, tokens_meta[curr].delimiters);
|
||
}
|
||
}
|
||
}
|
||
var strikethrough_default = {
|
||
tokenize: strikethrough_tokenize,
|
||
postProcess: strikethrough_postProcess
|
||
};
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/emphasis.mjs
|
||
function emphasis_tokenize(state, silent) {
|
||
const start = state.pos;
|
||
const marker = state.src.charCodeAt(start);
|
||
if (silent) {
|
||
return false;
|
||
}
|
||
if (marker !== 95 && marker !== 42) {
|
||
return false;
|
||
}
|
||
const scanned = state.scanDelims(state.pos, marker === 42);
|
||
for (let i = 0; i < scanned.length; i++) {
|
||
const token = state.push("text", "", 0);
|
||
token.content = String.fromCharCode(marker);
|
||
state.delimiters.push({
|
||
// Char code of the starting marker (number).
|
||
//
|
||
marker,
|
||
// Total length of these series of delimiters.
|
||
//
|
||
length: scanned.length,
|
||
// A position of the token this delimiter corresponds to.
|
||
//
|
||
token: state.tokens.length - 1,
|
||
// If this delimiter is matched as a valid opener, `end` will be
|
||
// equal to its position, otherwise it's `-1`.
|
||
//
|
||
end: -1,
|
||
// Boolean flags that determine if this delimiter could open or close
|
||
// an emphasis.
|
||
//
|
||
open: scanned.can_open,
|
||
close: scanned.can_close
|
||
});
|
||
}
|
||
state.pos += scanned.length;
|
||
return true;
|
||
}
|
||
function postProcess2(state, delimiters) {
|
||
const max = delimiters.length;
|
||
for (let i = max - 1; i >= 0; i--) {
|
||
const startDelim = delimiters[i];
|
||
if (startDelim.marker !== 95 && startDelim.marker !== 42) {
|
||
continue;
|
||
}
|
||
if (startDelim.end === -1) {
|
||
continue;
|
||
}
|
||
const endDelim = delimiters[startDelim.end];
|
||
const isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && // check that first two markers match and adjacent
|
||
delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 && // check that last two markers are adjacent (we can safely assume they match)
|
||
delimiters[startDelim.end + 1].token === endDelim.token + 1;
|
||
const ch = String.fromCharCode(startDelim.marker);
|
||
const token_o = state.tokens[startDelim.token];
|
||
token_o.type = isStrong ? "strong_open" : "em_open";
|
||
token_o.tag = isStrong ? "strong" : "em";
|
||
token_o.nesting = 1;
|
||
token_o.markup = isStrong ? ch + ch : ch;
|
||
token_o.content = "";
|
||
const token_c = state.tokens[endDelim.token];
|
||
token_c.type = isStrong ? "strong_close" : "em_close";
|
||
token_c.tag = isStrong ? "strong" : "em";
|
||
token_c.nesting = -1;
|
||
token_c.markup = isStrong ? ch + ch : ch;
|
||
token_c.content = "";
|
||
if (isStrong) {
|
||
state.tokens[delimiters[i - 1].token].content = "";
|
||
state.tokens[delimiters[startDelim.end + 1].token].content = "";
|
||
i--;
|
||
}
|
||
}
|
||
}
|
||
function emphasis_post_process(state) {
|
||
const tokens_meta = state.tokens_meta;
|
||
const max = state.tokens_meta.length;
|
||
postProcess2(state, state.delimiters);
|
||
for (let curr = 0; curr < max; curr++) {
|
||
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
|
||
postProcess2(state, tokens_meta[curr].delimiters);
|
||
}
|
||
}
|
||
}
|
||
var emphasis_default = {
|
||
tokenize: emphasis_tokenize,
|
||
postProcess: emphasis_post_process
|
||
};
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/link.mjs
|
||
function link(state, silent) {
|
||
let code2, label, res, ref;
|
||
let href = "";
|
||
let title = "";
|
||
let start = state.pos;
|
||
let parseReference = true;
|
||
if (state.src.charCodeAt(state.pos) !== 91) {
|
||
return false;
|
||
}
|
||
const oldPos = state.pos;
|
||
const max = state.posMax;
|
||
const labelStart = state.pos + 1;
|
||
const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
|
||
if (labelEnd < 0) {
|
||
return false;
|
||
}
|
||
let pos = labelEnd + 1;
|
||
if (pos < max && state.src.charCodeAt(pos) === 40) {
|
||
parseReference = false;
|
||
pos++;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
if (pos >= max) {
|
||
return false;
|
||
}
|
||
start = pos;
|
||
res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
|
||
if (res.ok) {
|
||
href = state.md.normalizeLink(res.str);
|
||
if (state.md.validateLink(href)) {
|
||
pos = res.pos;
|
||
} else {
|
||
href = "";
|
||
}
|
||
start = pos;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
|
||
if (pos < max && start !== pos && res.ok) {
|
||
title = res.str;
|
||
pos = res.pos;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (pos >= max || state.src.charCodeAt(pos) !== 41) {
|
||
parseReference = true;
|
||
}
|
||
pos++;
|
||
}
|
||
if (parseReference) {
|
||
if (typeof state.env.references === "undefined") {
|
||
return false;
|
||
}
|
||
if (pos < max && state.src.charCodeAt(pos) === 91) {
|
||
start = pos + 1;
|
||
pos = state.md.helpers.parseLinkLabel(state, pos);
|
||
if (pos >= 0) {
|
||
label = state.src.slice(start, pos++);
|
||
} else {
|
||
pos = labelEnd + 1;
|
||
}
|
||
} else {
|
||
pos = labelEnd + 1;
|
||
}
|
||
if (!label) {
|
||
label = state.src.slice(labelStart, labelEnd);
|
||
}
|
||
ref = state.env.references[normalizeReference(label)];
|
||
if (!ref) {
|
||
state.pos = oldPos;
|
||
return false;
|
||
}
|
||
href = ref.href;
|
||
title = ref.title;
|
||
}
|
||
if (!silent) {
|
||
state.pos = labelStart;
|
||
state.posMax = labelEnd;
|
||
const token_o = state.push("link_open", "a", 1);
|
||
const attrs = [["href", href]];
|
||
token_o.attrs = attrs;
|
||
if (title) {
|
||
attrs.push(["title", title]);
|
||
}
|
||
state.linkLevel++;
|
||
state.md.inline.tokenize(state);
|
||
state.linkLevel--;
|
||
state.push("link_close", "a", -1);
|
||
}
|
||
state.pos = pos;
|
||
state.posMax = max;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/image.mjs
|
||
function image(state, silent) {
|
||
let code2, content, label, pos, ref, res, title, start;
|
||
let href = "";
|
||
const oldPos = state.pos;
|
||
const max = state.posMax;
|
||
if (state.src.charCodeAt(state.pos) !== 33) {
|
||
return false;
|
||
}
|
||
if (state.src.charCodeAt(state.pos + 1) !== 91) {
|
||
return false;
|
||
}
|
||
const labelStart = state.pos + 2;
|
||
const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
|
||
if (labelEnd < 0) {
|
||
return false;
|
||
}
|
||
pos = labelEnd + 1;
|
||
if (pos < max && state.src.charCodeAt(pos) === 40) {
|
||
pos++;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
if (pos >= max) {
|
||
return false;
|
||
}
|
||
start = pos;
|
||
res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
|
||
if (res.ok) {
|
||
href = state.md.normalizeLink(res.str);
|
||
if (state.md.validateLink(href)) {
|
||
pos = res.pos;
|
||
} else {
|
||
href = "";
|
||
}
|
||
}
|
||
start = pos;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
|
||
if (pos < max && start !== pos && res.ok) {
|
||
title = res.str;
|
||
pos = res.pos;
|
||
for (; pos < max; pos++) {
|
||
code2 = state.src.charCodeAt(pos);
|
||
if (!isSpace(code2) && code2 !== 10) {
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
title = "";
|
||
}
|
||
if (pos >= max || state.src.charCodeAt(pos) !== 41) {
|
||
state.pos = oldPos;
|
||
return false;
|
||
}
|
||
pos++;
|
||
} else {
|
||
if (typeof state.env.references === "undefined") {
|
||
return false;
|
||
}
|
||
if (pos < max && state.src.charCodeAt(pos) === 91) {
|
||
start = pos + 1;
|
||
pos = state.md.helpers.parseLinkLabel(state, pos);
|
||
if (pos >= 0) {
|
||
label = state.src.slice(start, pos++);
|
||
} else {
|
||
pos = labelEnd + 1;
|
||
}
|
||
} else {
|
||
pos = labelEnd + 1;
|
||
}
|
||
if (!label) {
|
||
label = state.src.slice(labelStart, labelEnd);
|
||
}
|
||
ref = state.env.references[normalizeReference(label)];
|
||
if (!ref) {
|
||
state.pos = oldPos;
|
||
return false;
|
||
}
|
||
href = ref.href;
|
||
title = ref.title;
|
||
}
|
||
if (!silent) {
|
||
content = state.src.slice(labelStart, labelEnd);
|
||
const tokens = [];
|
||
state.md.inline.parse(
|
||
content,
|
||
state.md,
|
||
state.env,
|
||
tokens
|
||
);
|
||
const token = state.push("image", "img", 0);
|
||
const attrs = [["src", href], ["alt", ""]];
|
||
token.attrs = attrs;
|
||
token.children = tokens;
|
||
token.content = content;
|
||
if (title) {
|
||
attrs.push(["title", title]);
|
||
}
|
||
}
|
||
state.pos = pos;
|
||
state.posMax = max;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/autolink.mjs
|
||
var EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
|
||
var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
|
||
function autolink(state, silent) {
|
||
let pos = state.pos;
|
||
if (state.src.charCodeAt(pos) !== 60) {
|
||
return false;
|
||
}
|
||
const start = state.pos;
|
||
const max = state.posMax;
|
||
for (; ; ) {
|
||
if (++pos >= max)
|
||
return false;
|
||
const ch = state.src.charCodeAt(pos);
|
||
if (ch === 60)
|
||
return false;
|
||
if (ch === 62)
|
||
break;
|
||
}
|
||
const url = state.src.slice(start + 1, pos);
|
||
if (AUTOLINK_RE.test(url)) {
|
||
const fullUrl = state.md.normalizeLink(url);
|
||
if (!state.md.validateLink(fullUrl)) {
|
||
return false;
|
||
}
|
||
if (!silent) {
|
||
const token_o = state.push("link_open", "a", 1);
|
||
token_o.attrs = [["href", fullUrl]];
|
||
token_o.markup = "autolink";
|
||
token_o.info = "auto";
|
||
const token_t = state.push("text", "", 0);
|
||
token_t.content = state.md.normalizeLinkText(url);
|
||
const token_c = state.push("link_close", "a", -1);
|
||
token_c.markup = "autolink";
|
||
token_c.info = "auto";
|
||
}
|
||
state.pos += url.length + 2;
|
||
return true;
|
||
}
|
||
if (EMAIL_RE.test(url)) {
|
||
const fullUrl = state.md.normalizeLink("mailto:" + url);
|
||
if (!state.md.validateLink(fullUrl)) {
|
||
return false;
|
||
}
|
||
if (!silent) {
|
||
const token_o = state.push("link_open", "a", 1);
|
||
token_o.attrs = [["href", fullUrl]];
|
||
token_o.markup = "autolink";
|
||
token_o.info = "auto";
|
||
const token_t = state.push("text", "", 0);
|
||
token_t.content = state.md.normalizeLinkText(url);
|
||
const token_c = state.push("link_close", "a", -1);
|
||
token_c.markup = "autolink";
|
||
token_c.info = "auto";
|
||
}
|
||
state.pos += url.length + 2;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/html_inline.mjs
|
||
function isLinkOpen2(str) {
|
||
return /^<a[>\s]/i.test(str);
|
||
}
|
||
function isLinkClose2(str) {
|
||
return /^<\/a\s*>/i.test(str);
|
||
}
|
||
function isLetter(ch) {
|
||
const lc = ch | 32;
|
||
return lc >= 97 && lc <= 122;
|
||
}
|
||
function html_inline(state, silent) {
|
||
if (!state.md.options.html) {
|
||
return false;
|
||
}
|
||
const max = state.posMax;
|
||
const pos = state.pos;
|
||
if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
|
||
return false;
|
||
}
|
||
const ch = state.src.charCodeAt(pos + 1);
|
||
if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) {
|
||
return false;
|
||
}
|
||
const match2 = state.src.slice(pos).match(HTML_TAG_RE);
|
||
if (!match2) {
|
||
return false;
|
||
}
|
||
if (!silent) {
|
||
const token = state.push("html_inline", "", 0);
|
||
token.content = match2[0];
|
||
if (isLinkOpen2(token.content))
|
||
state.linkLevel++;
|
||
if (isLinkClose2(token.content))
|
||
state.linkLevel--;
|
||
}
|
||
state.pos += match2[0].length;
|
||
return true;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/entity.mjs
|
||
var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
|
||
var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
|
||
function entity(state, silent) {
|
||
const pos = state.pos;
|
||
const max = state.posMax;
|
||
if (state.src.charCodeAt(pos) !== 38)
|
||
return false;
|
||
if (pos + 1 >= max)
|
||
return false;
|
||
const ch = state.src.charCodeAt(pos + 1);
|
||
if (ch === 35) {
|
||
const match2 = state.src.slice(pos).match(DIGITAL_RE);
|
||
if (match2) {
|
||
if (!silent) {
|
||
const code2 = match2[1][0].toLowerCase() === "x" ? parseInt(match2[1].slice(1), 16) : parseInt(match2[1], 10);
|
||
const token = state.push("text_special", "", 0);
|
||
token.content = isValidEntityCode(code2) ? fromCodePoint(code2) : fromCodePoint(65533);
|
||
token.markup = match2[0];
|
||
token.info = "entity";
|
||
}
|
||
state.pos += match2[0].length;
|
||
return true;
|
||
}
|
||
} else {
|
||
const match2 = state.src.slice(pos).match(NAMED_RE);
|
||
if (match2) {
|
||
const decoded = decodeHTML(match2[0]);
|
||
if (decoded !== match2[0]) {
|
||
if (!silent) {
|
||
const token = state.push("text_special", "", 0);
|
||
token.content = decoded;
|
||
token.markup = match2[0];
|
||
token.info = "entity";
|
||
}
|
||
state.pos += match2[0].length;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/balance_pairs.mjs
|
||
function processDelimiters(delimiters) {
|
||
const openersBottom = {};
|
||
const max = delimiters.length;
|
||
if (!max)
|
||
return;
|
||
let headerIdx = 0;
|
||
let lastTokenIdx = -2;
|
||
const jumps = [];
|
||
for (let closerIdx = 0; closerIdx < max; closerIdx++) {
|
||
const closer = delimiters[closerIdx];
|
||
jumps.push(0);
|
||
if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
|
||
headerIdx = closerIdx;
|
||
}
|
||
lastTokenIdx = closer.token;
|
||
closer.length = closer.length || 0;
|
||
if (!closer.close)
|
||
continue;
|
||
if (!openersBottom.hasOwnProperty(closer.marker)) {
|
||
openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
|
||
}
|
||
const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];
|
||
let openerIdx = headerIdx - jumps[headerIdx] - 1;
|
||
let newMinOpenerIdx = openerIdx;
|
||
for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
|
||
const opener = delimiters[openerIdx];
|
||
if (opener.marker !== closer.marker)
|
||
continue;
|
||
if (opener.open && opener.end < 0) {
|
||
let isOddMatch = false;
|
||
if (opener.close || closer.open) {
|
||
if ((opener.length + closer.length) % 3 === 0) {
|
||
if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
|
||
isOddMatch = true;
|
||
}
|
||
}
|
||
}
|
||
if (!isOddMatch) {
|
||
const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;
|
||
jumps[closerIdx] = closerIdx - openerIdx + lastJump;
|
||
jumps[openerIdx] = lastJump;
|
||
closer.open = false;
|
||
opener.end = closerIdx;
|
||
opener.close = false;
|
||
newMinOpenerIdx = -1;
|
||
lastTokenIdx = -2;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (newMinOpenerIdx !== -1) {
|
||
openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;
|
||
}
|
||
}
|
||
}
|
||
function link_pairs(state) {
|
||
const tokens_meta = state.tokens_meta;
|
||
const max = state.tokens_meta.length;
|
||
processDelimiters(state.delimiters);
|
||
for (let curr = 0; curr < max; curr++) {
|
||
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
|
||
processDelimiters(tokens_meta[curr].delimiters);
|
||
}
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/rules_inline/fragments_join.mjs
|
||
function fragments_join(state) {
|
||
let curr, last;
|
||
let level = 0;
|
||
const tokens = state.tokens;
|
||
const max = state.tokens.length;
|
||
for (curr = last = 0; curr < max; curr++) {
|
||
if (tokens[curr].nesting < 0)
|
||
level--;
|
||
tokens[curr].level = level;
|
||
if (tokens[curr].nesting > 0)
|
||
level++;
|
||
if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
|
||
tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
|
||
} else {
|
||
if (curr !== last) {
|
||
tokens[last] = tokens[curr];
|
||
}
|
||
last++;
|
||
}
|
||
}
|
||
if (curr !== last) {
|
||
tokens.length = last;
|
||
}
|
||
}
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/parser_inline.mjs
|
||
var _rules3 = [
|
||
["text", text],
|
||
["linkify", linkify2],
|
||
["newline", newline],
|
||
["escape", escape],
|
||
["backticks", backtick],
|
||
["strikethrough", strikethrough_default.tokenize],
|
||
["emphasis", emphasis_default.tokenize],
|
||
["link", link],
|
||
["image", image],
|
||
["autolink", autolink],
|
||
["html_inline", html_inline],
|
||
["entity", entity]
|
||
];
|
||
var _rules22 = [
|
||
["balance_pairs", link_pairs],
|
||
["strikethrough", strikethrough_default.postProcess],
|
||
["emphasis", emphasis_default.postProcess],
|
||
// rules for pairs separate '**' into its own text tokens, which may be left unused,
|
||
// rule below merges unused segments back with the rest of the text
|
||
["fragments_join", fragments_join]
|
||
];
|
||
function ParserInline() {
|
||
this.ruler = new ruler_default();
|
||
for (let i = 0; i < _rules3.length; i++) {
|
||
this.ruler.push(_rules3[i][0], _rules3[i][1]);
|
||
}
|
||
this.ruler2 = new ruler_default();
|
||
for (let i = 0; i < _rules22.length; i++) {
|
||
this.ruler2.push(_rules22[i][0], _rules22[i][1]);
|
||
}
|
||
}
|
||
ParserInline.prototype.skipToken = function(state) {
|
||
const pos = state.pos;
|
||
const rules = this.ruler.getRules("");
|
||
const len = rules.length;
|
||
const maxNesting = state.md.options.maxNesting;
|
||
const cache = state.cache;
|
||
if (typeof cache[pos] !== "undefined") {
|
||
state.pos = cache[pos];
|
||
return;
|
||
}
|
||
let ok = false;
|
||
if (state.level < maxNesting) {
|
||
for (let i = 0; i < len; i++) {
|
||
state.level++;
|
||
ok = rules[i](state, true);
|
||
state.level--;
|
||
if (ok) {
|
||
if (pos >= state.pos) {
|
||
throw new Error("inline rule didn't increment state.pos");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
state.pos = state.posMax;
|
||
}
|
||
if (!ok) {
|
||
state.pos++;
|
||
}
|
||
cache[pos] = state.pos;
|
||
};
|
||
ParserInline.prototype.tokenize = function(state) {
|
||
const rules = this.ruler.getRules("");
|
||
const len = rules.length;
|
||
const end = state.posMax;
|
||
const maxNesting = state.md.options.maxNesting;
|
||
while (state.pos < end) {
|
||
const prevPos = state.pos;
|
||
let ok = false;
|
||
if (state.level < maxNesting) {
|
||
for (let i = 0; i < len; i++) {
|
||
ok = rules[i](state, false);
|
||
if (ok) {
|
||
if (prevPos >= state.pos) {
|
||
throw new Error("inline rule didn't increment state.pos");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (ok) {
|
||
if (state.pos >= end) {
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
state.pending += state.src[state.pos++];
|
||
}
|
||
if (state.pending) {
|
||
state.pushPending();
|
||
}
|
||
};
|
||
ParserInline.prototype.parse = function(str, md, env, outTokens) {
|
||
const state = new this.State(str, md, env, outTokens);
|
||
this.tokenize(state);
|
||
const rules = this.ruler2.getRules("");
|
||
const len = rules.length;
|
||
for (let i = 0; i < len; i++) {
|
||
rules[i](state);
|
||
}
|
||
};
|
||
ParserInline.prototype.State = state_inline_default;
|
||
var parser_inline_default = ParserInline;
|
||
|
||
// node_modules/.pnpm/linkify-it@5.0.0/node_modules/linkify-it/lib/re.mjs
|
||
function re_default(opts) {
|
||
const re = {};
|
||
opts = opts || {};
|
||
re.src_Any = regex_default.source;
|
||
re.src_Cc = regex_default2.source;
|
||
re.src_Z = regex_default6.source;
|
||
re.src_P = regex_default4.source;
|
||
re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
|
||
re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
|
||
const text_separators = "[><｜]";
|
||
re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
|
||
re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
|
||
re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
|
||
re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
|
||
re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
|
||
re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]|$)|" + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
|
||
",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
|
||
re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
|
||
re.src_xn = "xn--[a-z0-9\\-]{1,59}";
|
||
re.src_domain_root = // Allow letters & digits (http://test1)
|
||
"(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
|
||
re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
|
||
re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
|
||
re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
|
||
re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
|
||
re.src_host_strict = re.src_host + re.src_host_terminator;
|
||
re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
|
||
re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
|
||
re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
|
||
re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
|
||
re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
|
||
re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
|
||
re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
|
||
// but can start with > (markdown blockquote)
|
||
"(^|(?![.:/\\-_@])(?:[$+<=>^`|｜]|" + re.src_ZPCc + "))((?![$+<=>^`|｜])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
|
||
re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
|
||
// but can start with > (markdown blockquote)
|
||
"(^|(?![.:/\\-_@])(?:[$+<=>^`|｜]|" + re.src_ZPCc + "))((?![$+<=>^`|｜])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
|
||
return re;
|
||
}
|
||
|
||
// node_modules/.pnpm/linkify-it@5.0.0/node_modules/linkify-it/index.mjs
|
||
function assign2(obj) {
|
||
const sources = Array.prototype.slice.call(arguments, 1);
|
||
sources.forEach(function(source) {
|
||
if (!source) {
|
||
return;
|
||
}
|
||
Object.keys(source).forEach(function(key) {
|
||
obj[key] = source[key];
|
||
});
|
||
});
|
||
return obj;
|
||
}
|
||
function _class2(obj) {
|
||
return Object.prototype.toString.call(obj);
|
||
}
|
||
function isString2(obj) {
|
||
return _class2(obj) === "[object String]";
|
||
}
|
||
function isObject(obj) {
|
||
return _class2(obj) === "[object Object]";
|
||
}
|
||
function isRegExp(obj) {
|
||
return _class2(obj) === "[object RegExp]";
|
||
}
|
||
function isFunction(obj) {
|
||
return _class2(obj) === "[object Function]";
|
||
}
|
||
function escapeRE2(str) {
|
||
return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
|
||
}
|
||
var defaultOptions = {
|
||
fuzzyLink: true,
|
||
fuzzyEmail: true,
|
||
fuzzyIP: false
|
||
};
|
||
function isOptionsObj(obj) {
|
||
return Object.keys(obj || {}).reduce(function(acc, k) {
|
||
return acc || defaultOptions.hasOwnProperty(k);
|
||
}, false);
|
||
}
|
||
var defaultSchemas = {
|
||
"http:": {
|
||
validate: function(text2, pos, self) {
|
||
const tail = text2.slice(pos);
|
||
if (!self.re.http) {
|
||
self.re.http = new RegExp(
|
||
"^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
|
||
"i"
|
||
);
|
||
}
|
||
if (self.re.http.test(tail)) {
|
||
return tail.match(self.re.http)[0].length;
|
||
}
|
||
return 0;
|
||
}
|
||
},
|
||
"https:": "http:",
|
||
"ftp:": "http:",
|
||
"//": {
|
||
validate: function(text2, pos, self) {
|
||
const tail = text2.slice(pos);
|
||
if (!self.re.no_http) {
|
||
self.re.no_http = new RegExp(
|
||
"^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
|
||
// with code comments
|
||
"(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
|
||
"i"
|
||
);
|
||
}
|
||
if (self.re.no_http.test(tail)) {
|
||
if (pos >= 3 && text2[pos - 3] === ":") {
|
||
return 0;
|
||
}
|
||
if (pos >= 3 && text2[pos - 3] === "/") {
|
||
return 0;
|
||
}
|
||
return tail.match(self.re.no_http)[0].length;
|
||
}
|
||
return 0;
|
||
}
|
||
},
|
||
"mailto:": {
|
||
validate: function(text2, pos, self) {
|
||
const tail = text2.slice(pos);
|
||
if (!self.re.mailto) {
|
||
self.re.mailto = new RegExp(
|
||
"^" + self.re.src_email_name + "@" + self.re.src_host_strict,
|
||
"i"
|
||
);
|
||
}
|
||
if (self.re.mailto.test(tail)) {
|
||
return tail.match(self.re.mailto)[0].length;
|
||
}
|
||
return 0;
|
||
}
|
||
}
|
||
};
|
||
var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
|
||
var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф".split("|");
|
||
function resetScanCache(self) {
|
||
self.__index__ = -1;
|
||
self.__text_cache__ = "";
|
||
}
|
||
function createValidator(re) {
|
||
return function(text2, pos) {
|
||
const tail = text2.slice(pos);
|
||
if (re.test(tail)) {
|
||
return tail.match(re)[0].length;
|
||
}
|
||
return 0;
|
||
};
|
||
}
|
||
function createNormalizer() {
|
||
return function(match2, self) {
|
||
self.normalize(match2);
|
||
};
|
||
}
|
||
function compile(self) {
|
||
const re = self.re = re_default(self.__opts__);
|
||
const tlds2 = self.__tlds__.slice();
|
||
self.onCompile();
|
||
if (!self.__tlds_replaced__) {
|
||
tlds2.push(tlds_2ch_src_re);
|
||
}
|
||
tlds2.push(re.src_xn);
|
||
re.src_tlds = tlds2.join("|");
|
||
function untpl(tpl) {
|
||
return tpl.replace("%TLDS%", re.src_tlds);
|
||
}
|
||
re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
|
||
re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
|
||
re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
|
||
re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
|
||
const aliases = [];
|
||
self.__compiled__ = {};
|
||
function schemaError(name, val) {
|
||
throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
|
||
}
|
||
Object.keys(self.__schemas__).forEach(function(name) {
|
||
const val = self.__schemas__[name];
|
||
if (val === null) {
|
||
return;
|
||
}
|
||
const compiled = { validate: null, link: null };
|
||
self.__compiled__[name] = compiled;
|
||
if (isObject(val)) {
|
||
if (isRegExp(val.validate)) {
|
||
compiled.validate = createValidator(val.validate);
|
||
} else if (isFunction(val.validate)) {
|
||
compiled.validate = val.validate;
|
||
} else {
|
||
schemaError(name, val);
|
||
}
|
||
if (isFunction(val.normalize)) {
|
||
compiled.normalize = val.normalize;
|
||
} else if (!val.normalize) {
|
||
compiled.normalize = createNormalizer();
|
||
} else {
|
||
schemaError(name, val);
|
||
}
|
||
return;
|
||
}
|
||
if (isString2(val)) {
|
||
aliases.push(name);
|
||
return;
|
||
}
|
||
schemaError(name, val);
|
||
});
|
||
aliases.forEach(function(alias) {
|
||
if (!self.__compiled__[self.__schemas__[alias]]) {
|
||
return;
|
||
}
|
||
self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
|
||
self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
|
||
});
|
||
self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
|
||
const slist = Object.keys(self.__compiled__).filter(function(name) {
|
||
return name.length > 0 && self.__compiled__[name];
|
||
}).map(escapeRE2).join("|");
|
||
self.re.schema_test = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "i");
|
||
self.re.schema_search = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
|
||
self.re.schema_at_start = RegExp("^" + self.re.schema_search.source, "i");
|
||
self.re.pretest = RegExp(
|
||
"(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
|
||
"i"
|
||
);
|
||
resetScanCache(self);
|
||
}
|
||
function Match(self, shift) {
|
||
const start = self.__index__;
|
||
const end = self.__last_index__;
|
||
const text2 = self.__text_cache__.slice(start, end);
|
||
this.schema = self.__schema__.toLowerCase();
|
||
this.index = start + shift;
|
||
this.lastIndex = end + shift;
|
||
this.raw = text2;
|
||
this.text = text2;
|
||
this.url = text2;
|
||
}
|
||
function createMatch(self, shift) {
|
||
const match2 = new Match(self, shift);
|
||
self.__compiled__[match2.schema].normalize(match2, self);
|
||
return match2;
|
||
}
|
||
function LinkifyIt(schemas, options) {
|
||
if (!(this instanceof LinkifyIt)) {
|
||
return new LinkifyIt(schemas, options);
|
||
}
|
||
if (!options) {
|
||
if (isOptionsObj(schemas)) {
|
||
options = schemas;
|
||
schemas = {};
|
||
}
|
||
}
|
||
this.__opts__ = assign2({}, defaultOptions, options);
|
||
this.__index__ = -1;
|
||
this.__last_index__ = -1;
|
||
this.__schema__ = "";
|
||
this.__text_cache__ = "";
|
||
this.__schemas__ = assign2({}, defaultSchemas, schemas);
|
||
this.__compiled__ = {};
|
||
this.__tlds__ = tlds_default;
|
||
this.__tlds_replaced__ = false;
|
||
this.re = {};
|
||
compile(this);
|
||
}
|
||
LinkifyIt.prototype.add = function add(schema, definition) {
|
||
this.__schemas__[schema] = definition;
|
||
compile(this);
|
||
return this;
|
||
};
|
||
LinkifyIt.prototype.set = function set(options) {
|
||
this.__opts__ = assign2(this.__opts__, options);
|
||
return this;
|
||
};
|
||
LinkifyIt.prototype.test = function test(text2) {
|
||
this.__text_cache__ = text2;
|
||
this.__index__ = -1;
|
||
if (!text2.length) {
|
||
return false;
|
||
}
|
||
let m, ml, me, len, shift, next, re, tld_pos, at_pos;
|
||
if (this.re.schema_test.test(text2)) {
|
||
re = this.re.schema_search;
|
||
re.lastIndex = 0;
|
||
while ((m = re.exec(text2)) !== null) {
|
||
len = this.testSchemaAt(text2, m[2], re.lastIndex);
|
||
if (len) {
|
||
this.__schema__ = m[2];
|
||
this.__index__ = m.index + m[1].length;
|
||
this.__last_index__ = m.index + m[0].length + len;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
|
||
tld_pos = text2.search(this.re.host_fuzzy_test);
|
||
if (tld_pos >= 0) {
|
||
if (this.__index__ < 0 || tld_pos < this.__index__) {
|
||
if ((ml = text2.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
|
||
shift = ml.index + ml[1].length;
|
||
if (this.__index__ < 0 || shift < this.__index__) {
|
||
this.__schema__ = "";
|
||
this.__index__ = shift;
|
||
this.__last_index__ = ml.index + ml[0].length;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
|
||
at_pos = text2.indexOf("@");
|
||
if (at_pos >= 0) {
|
||
if ((me = text2.match(this.re.email_fuzzy)) !== null) {
|
||
shift = me.index + me[1].length;
|
||
next = me.index + me[0].length;
|
||
if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
|
||
this.__schema__ = "mailto:";
|
||
this.__index__ = shift;
|
||
this.__last_index__ = next;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this.__index__ >= 0;
|
||
};
|
||
LinkifyIt.prototype.pretest = function pretest(text2) {
|
||
return this.re.pretest.test(text2);
|
||
};
|
||
LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text2, schema, pos) {
|
||
if (!this.__compiled__[schema.toLowerCase()]) {
|
||
return 0;
|
||
}
|
||
return this.__compiled__[schema.toLowerCase()].validate(text2, pos, this);
|
||
};
|
||
LinkifyIt.prototype.match = function match(text2) {
|
||
const result = [];
|
||
let shift = 0;
|
||
if (this.__index__ >= 0 && this.__text_cache__ === text2) {
|
||
result.push(createMatch(this, shift));
|
||
shift = this.__last_index__;
|
||
}
|
||
let tail = shift ? text2.slice(shift) : text2;
|
||
while (this.test(tail)) {
|
||
result.push(createMatch(this, shift));
|
||
tail = tail.slice(this.__last_index__);
|
||
shift += this.__last_index__;
|
||
}
|
||
if (result.length) {
|
||
return result;
|
||
}
|
||
return null;
|
||
};
|
||
LinkifyIt.prototype.matchAtStart = function matchAtStart(text2) {
|
||
this.__text_cache__ = text2;
|
||
this.__index__ = -1;
|
||
if (!text2.length)
|
||
return null;
|
||
const m = this.re.schema_at_start.exec(text2);
|
||
if (!m)
|
||
return null;
|
||
const len = this.testSchemaAt(text2, m[2], m[0].length);
|
||
if (!len)
|
||
return null;
|
||
this.__schema__ = m[2];
|
||
this.__index__ = m.index + m[1].length;
|
||
this.__last_index__ = m.index + m[0].length + len;
|
||
return createMatch(this, 0);
|
||
};
|
||
LinkifyIt.prototype.tlds = function tlds(list2, keepOld) {
|
||
list2 = Array.isArray(list2) ? list2 : [list2];
|
||
if (!keepOld) {
|
||
this.__tlds__ = list2.slice();
|
||
this.__tlds_replaced__ = true;
|
||
compile(this);
|
||
return this;
|
||
}
|
||
this.__tlds__ = this.__tlds__.concat(list2).sort().filter(function(el, idx, arr) {
|
||
return el !== arr[idx - 1];
|
||
}).reverse();
|
||
compile(this);
|
||
return this;
|
||
};
|
||
LinkifyIt.prototype.normalize = function normalize2(match2) {
|
||
if (!match2.schema) {
|
||
match2.url = "http://" + match2.url;
|
||
}
|
||
if (match2.schema === "mailto:" && !/^mailto:/i.test(match2.url)) {
|
||
match2.url = "mailto:" + match2.url;
|
||
}
|
||
};
|
||
LinkifyIt.prototype.onCompile = function onCompile() {
|
||
};
|
||
var linkify_it_default = LinkifyIt;
|
||
|
||
// node_modules/.pnpm/punycode.js@2.3.1/node_modules/punycode.js/punycode.es6.js
|
||
var maxInt = 2147483647;
|
||
var base = 36;
|
||
var tMin = 1;
|
||
var tMax = 26;
|
||
var skew = 38;
|
||
var damp = 700;
|
||
var initialBias = 72;
|
||
var initialN = 128;
|
||
var delimiter = "-";
|
||
var regexPunycode = /^xn--/;
|
||
var regexNonASCII = /[^\0-\x7F]/;
|
||
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
|
||
var errors = {
|
||
"overflow": "Overflow: input needs wider integers to process",
|
||
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
|
||
"invalid-input": "Invalid input"
|
||
};
|
||
var baseMinusTMin = base - tMin;
|
||
var floor = Math.floor;
|
||
var stringFromCharCode = String.fromCharCode;
|
||
function error(type) {
|
||
throw new RangeError(errors[type]);
|
||
}
|
||
function map(array, callback) {
|
||
const result = [];
|
||
let length = array.length;
|
||
while (length--) {
|
||
result[length] = callback(array[length]);
|
||
}
|
||
return result;
|
||
}
|
||
function mapDomain(domain, callback) {
|
||
const parts = domain.split("@");
|
||
let result = "";
|
||
if (parts.length > 1) {
|
||
result = parts[0] + "@";
|
||
domain = parts[1];
|
||
}
|
||
domain = domain.replace(regexSeparators, ".");
|
||
const labels = domain.split(".");
|
||
const encoded = map(labels, callback).join(".");
|
||
return result + encoded;
|
||
}
|
||
function ucs2decode(string) {
|
||
const output = [];
|
||
let counter = 0;
|
||
const length = string.length;
|
||
while (counter < length) {
|
||
const value = string.charCodeAt(counter++);
|
||
if (value >= 55296 && value <= 56319 && counter < length) {
|
||
const extra = string.charCodeAt(counter++);
|
||
if ((extra & 64512) == 56320) {
|
||
output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
|
||
} else {
|
||
output.push(value);
|
||
counter--;
|
||
}
|
||
} else {
|
||
output.push(value);
|
||
}
|
||
}
|
||
return output;
|
||
}
|
||
var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
|
||
var basicToDigit = function(codePoint) {
|
||
if (codePoint >= 48 && codePoint < 58) {
|
||
return 26 + (codePoint - 48);
|
||
}
|
||
if (codePoint >= 65 && codePoint < 91) {
|
||
return codePoint - 65;
|
||
}
|
||
if (codePoint >= 97 && codePoint < 123) {
|
||
return codePoint - 97;
|
||
}
|
||
return base;
|
||
};
|
||
var digitToBasic = function(digit, flag) {
|
||
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
||
};
|
||
var adapt = function(delta, numPoints, firstTime) {
|
||
let k = 0;
|
||
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
||
delta += floor(delta / numPoints);
|
||
for (; delta > baseMinusTMin * tMax >> 1; k += base) {
|
||
delta = floor(delta / baseMinusTMin);
|
||
}
|
||
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
||
};
|
||
var decode2 = function(input) {
|
||
const output = [];
|
||
const inputLength = input.length;
|
||
let i = 0;
|
||
let n = initialN;
|
||
let bias = initialBias;
|
||
let basic = input.lastIndexOf(delimiter);
|
||
if (basic < 0) {
|
||
basic = 0;
|
||
}
|
||
for (let j = 0; j < basic; ++j) {
|
||
if (input.charCodeAt(j) >= 128) {
|
||
error("not-basic");
|
||
}
|
||
output.push(input.charCodeAt(j));
|
||
}
|
||
for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
|
||
const oldi = i;
|
||
for (let w = 1, k = base; ; k += base) {
|
||
if (index >= inputLength) {
|
||
error("invalid-input");
|
||
}
|
||
const digit = basicToDigit(input.charCodeAt(index++));
|
||
if (digit >= base) {
|
||
error("invalid-input");
|
||
}
|
||
if (digit > floor((maxInt - i) / w)) {
|
||
error("overflow");
|
||
}
|
||
i += digit * w;
|
||
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
||
if (digit < t) {
|
||
break;
|
||
}
|
||
const baseMinusT = base - t;
|
||
if (w > floor(maxInt / baseMinusT)) {
|
||
error("overflow");
|
||
}
|
||
w *= baseMinusT;
|
||
}
|
||
const out = output.length + 1;
|
||
bias = adapt(i - oldi, out, oldi == 0);
|
||
if (floor(i / out) > maxInt - n) {
|
||
error("overflow");
|
||
}
|
||
n += floor(i / out);
|
||
i %= out;
|
||
output.splice(i++, 0, n);
|
||
}
|
||
return String.fromCodePoint(...output);
|
||
};
|
||
var encode2 = function(input) {
|
||
const output = [];
|
||
input = ucs2decode(input);
|
||
const inputLength = input.length;
|
||
let n = initialN;
|
||
let delta = 0;
|
||
let bias = initialBias;
|
||
for (const currentValue of input) {
|
||
if (currentValue < 128) {
|
||
output.push(stringFromCharCode(currentValue));
|
||
}
|
||
}
|
||
const basicLength = output.length;
|
||
let handledCPCount = basicLength;
|
||
if (basicLength) {
|
||
output.push(delimiter);
|
||
}
|
||
while (handledCPCount < inputLength) {
|
||
let m = maxInt;
|
||
for (const currentValue of input) {
|
||
if (currentValue >= n && currentValue < m) {
|
||
m = currentValue;
|
||
}
|
||
}
|
||
const handledCPCountPlusOne = handledCPCount + 1;
|
||
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
||
error("overflow");
|
||
}
|
||
delta += (m - n) * handledCPCountPlusOne;
|
||
n = m;
|
||
for (const currentValue of input) {
|
||
if (currentValue < n && ++delta > maxInt) {
|
||
error("overflow");
|
||
}
|
||
if (currentValue === n) {
|
||
let q = delta;
|
||
for (let k = base; ; k += base) {
|
||
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
|
||
if (q < t) {
|
||
break;
|
||
}
|
||
const qMinusT = q - t;
|
||
const baseMinusT = base - t;
|
||
output.push(
|
||
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
||
);
|
||
q = floor(qMinusT / baseMinusT);
|
||
}
|
||
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
||
bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
|
||
delta = 0;
|
||
++handledCPCount;
|
||
}
|
||
}
|
||
++delta;
|
||
++n;
|
||
}
|
||
return output.join("");
|
||
};
|
||
var toUnicode = function(input) {
|
||
return mapDomain(input, function(string) {
|
||
return regexPunycode.test(string) ? decode2(string.slice(4).toLowerCase()) : string;
|
||
});
|
||
};
|
||
var toASCII = function(input) {
|
||
return mapDomain(input, function(string) {
|
||
return regexNonASCII.test(string) ? "xn--" + encode2(string) : string;
|
||
});
|
||
};
|
||
var punycode = {
|
||
/**
|
||
* A string representing the current Punycode.js version number.
|
||
* @memberOf punycode
|
||
* @type String
|
||
*/
|
||
"version": "2.3.1",
|
||
/**
|
||
* An object of methods to convert from JavaScript's internal character
|
||
* representation (UCS-2) to Unicode code points, and back.
|
||
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
||
* @memberOf punycode
|
||
* @type Object
|
||
*/
|
||
"ucs2": {
|
||
"decode": ucs2decode,
|
||
"encode": ucs2encode
|
||
},
|
||
"decode": decode2,
|
||
"encode": encode2,
|
||
"toASCII": toASCII,
|
||
"toUnicode": toUnicode
|
||
};
|
||
var punycode_es6_default = punycode;
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/presets/default.mjs
|
||
var default_default = {
|
||
options: {
|
||
// Enable HTML tags in source
|
||
html: false,
|
||
// Use '/' to close single tags (<br />)
|
||
xhtmlOut: false,
|
||
// Convert '\n' in paragraphs into <br>
|
||
breaks: false,
|
||
// CSS language prefix for fenced blocks
|
||
langPrefix: "language-",
|
||
// autoconvert URL-like texts to links
|
||
linkify: false,
|
||
// Enable some language-neutral replacements + quotes beautification
|
||
typographer: false,
|
||
// Double + single quotes replacement pairs, when typographer enabled,
|
||
// and smartquotes on. Could be either a String or an Array.
|
||
//
|
||
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
|
||
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
|
||
quotes: "“”‘’",
|
||
/* “”‘’ */
|
||
// Highlighter function. Should return escaped HTML,
|
||
// or '' if the source string is not changed and should be escaped externaly.
|
||
// If result starts with <pre... internal wrapper is skipped.
|
||
//
|
||
// function (/*str, lang*/) { return ''; }
|
||
//
|
||
highlight: null,
|
||
// Internal protection, recursion limit
|
||
maxNesting: 100
|
||
},
|
||
components: {
|
||
core: {},
|
||
block: {},
|
||
inline: {}
|
||
}
|
||
};
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/presets/zero.mjs
|
||
var zero_default = {
|
||
options: {
|
||
// Enable HTML tags in source
|
||
html: false,
|
||
// Use '/' to close single tags (<br />)
|
||
xhtmlOut: false,
|
||
// Convert '\n' in paragraphs into <br>
|
||
breaks: false,
|
||
// CSS language prefix for fenced blocks
|
||
langPrefix: "language-",
|
||
// autoconvert URL-like texts to links
|
||
linkify: false,
|
||
// Enable some language-neutral replacements + quotes beautification
|
||
typographer: false,
|
||
// Double + single quotes replacement pairs, when typographer enabled,
|
||
// and smartquotes on. Could be either a String or an Array.
|
||
//
|
||
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
|
||
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
|
||
quotes: "“”‘’",
|
||
/* “”‘’ */
|
||
// Highlighter function. Should return escaped HTML,
|
||
// or '' if the source string is not changed and should be escaped externaly.
|
||
// If result starts with <pre... internal wrapper is skipped.
|
||
//
|
||
// function (/*str, lang*/) { return ''; }
|
||
//
|
||
highlight: null,
|
||
// Internal protection, recursion limit
|
||
maxNesting: 20
|
||
},
|
||
components: {
|
||
core: {
|
||
rules: [
|
||
"normalize",
|
||
"block",
|
||
"inline",
|
||
"text_join"
|
||
]
|
||
},
|
||
block: {
|
||
rules: [
|
||
"paragraph"
|
||
]
|
||
},
|
||
inline: {
|
||
rules: [
|
||
"text"
|
||
],
|
||
rules2: [
|
||
"balance_pairs",
|
||
"fragments_join"
|
||
]
|
||
}
|
||
}
|
||
};
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/presets/commonmark.mjs
|
||
var commonmark_default = {
|
||
options: {
|
||
// Enable HTML tags in source
|
||
html: true,
|
||
// Use '/' to close single tags (<br />)
|
||
xhtmlOut: true,
|
||
// Convert '\n' in paragraphs into <br>
|
||
breaks: false,
|
||
// CSS language prefix for fenced blocks
|
||
langPrefix: "language-",
|
||
// autoconvert URL-like texts to links
|
||
linkify: false,
|
||
// Enable some language-neutral replacements + quotes beautification
|
||
typographer: false,
|
||
// Double + single quotes replacement pairs, when typographer enabled,
|
||
// and smartquotes on. Could be either a String or an Array.
|
||
//
|
||
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
|
||
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
|
||
quotes: "“”‘’",
|
||
/* “”‘’ */
|
||
// Highlighter function. Should return escaped HTML,
|
||
// or '' if the source string is not changed and should be escaped externaly.
|
||
// If result starts with <pre... internal wrapper is skipped.
|
||
//
|
||
// function (/*str, lang*/) { return ''; }
|
||
//
|
||
highlight: null,
|
||
// Internal protection, recursion limit
|
||
maxNesting: 20
|
||
},
|
||
components: {
|
||
core: {
|
||
rules: [
|
||
"normalize",
|
||
"block",
|
||
"inline",
|
||
"text_join"
|
||
]
|
||
},
|
||
block: {
|
||
rules: [
|
||
"blockquote",
|
||
"code",
|
||
"fence",
|
||
"heading",
|
||
"hr",
|
||
"html_block",
|
||
"lheading",
|
||
"list",
|
||
"reference",
|
||
"paragraph"
|
||
]
|
||
},
|
||
inline: {
|
||
rules: [
|
||
"autolink",
|
||
"backticks",
|
||
"emphasis",
|
||
"entity",
|
||
"escape",
|
||
"html_inline",
|
||
"image",
|
||
"link",
|
||
"newline",
|
||
"text"
|
||
],
|
||
rules2: [
|
||
"balance_pairs",
|
||
"emphasis",
|
||
"fragments_join"
|
||
]
|
||
}
|
||
}
|
||
};
|
||
|
||
// node_modules/.pnpm/markdown-it@14.1.0/node_modules/markdown-it/lib/index.mjs
|
||
var config = {
|
||
default: default_default,
|
||
zero: zero_default,
|
||
commonmark: commonmark_default
|
||
};
|
||
var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
|
||
var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
|
||
function validateLink(url) {
|
||
const str = url.trim().toLowerCase();
|
||
return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;
|
||
}
|
||
var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
|
||
function normalizeLink(url) {
|
||
const parsed = parse_default(url, true);
|
||
if (parsed.hostname) {
|
||
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
|
||
try {
|
||
parsed.hostname = punycode_es6_default.toASCII(parsed.hostname);
|
||
} catch (er) {
|
||
}
|
||
}
|
||
}
|
||
return encode_default(format(parsed));
|
||
}
|
||
function normalizeLinkText(url) {
|
||
const parsed = parse_default(url, true);
|
||
if (parsed.hostname) {
|
||
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
|
||
try {
|
||
parsed.hostname = punycode_es6_default.toUnicode(parsed.hostname);
|
||
} catch (er) {
|
||
}
|
||
}
|
||
}
|
||
return decode_default(format(parsed), decode_default.defaultChars + "%");
|
||
}
|
||
function MarkdownIt(presetName, options) {
|
||
if (!(this instanceof MarkdownIt)) {
|
||
return new MarkdownIt(presetName, options);
|
||
}
|
||
if (!options) {
|
||
if (!isString(presetName)) {
|
||
options = presetName || {};
|
||
presetName = "default";
|
||
}
|
||
}
|
||
this.inline = new parser_inline_default();
|
||
this.block = new parser_block_default();
|
||
this.core = new parser_core_default();
|
||
this.renderer = new renderer_default();
|
||
this.linkify = new linkify_it_default();
|
||
this.validateLink = validateLink;
|
||
this.normalizeLink = normalizeLink;
|
||
this.normalizeLinkText = normalizeLinkText;
|
||
this.utils = utils_exports;
|
||
this.helpers = assign({}, helpers_exports);
|
||
this.options = {};
|
||
this.configure(presetName);
|
||
if (options) {
|
||
this.set(options);
|
||
}
|
||
}
|
||
MarkdownIt.prototype.set = function(options) {
|
||
assign(this.options, options);
|
||
return this;
|
||
};
|
||
MarkdownIt.prototype.configure = function(presets) {
|
||
const self = this;
|
||
if (isString(presets)) {
|
||
const presetName = presets;
|
||
presets = config[presetName];
|
||
if (!presets) {
|
||
throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
|
||
}
|
||
}
|
||
if (!presets) {
|
||
throw new Error("Wrong `markdown-it` preset, can't be empty");
|
||
}
|
||
if (presets.options) {
|
||
self.set(presets.options);
|
||
}
|
||
if (presets.components) {
|
||
Object.keys(presets.components).forEach(function(name) {
|
||
if (presets.components[name].rules) {
|
||
self[name].ruler.enableOnly(presets.components[name].rules);
|
||
}
|
||
if (presets.components[name].rules2) {
|
||
self[name].ruler2.enableOnly(presets.components[name].rules2);
|
||
}
|
||
});
|
||
}
|
||
return this;
|
||
};
|
||
MarkdownIt.prototype.enable = function(list2, ignoreInvalid) {
|
||
let result = [];
|
||
if (!Array.isArray(list2)) {
|
||
list2 = [list2];
|
||
}
|
||
["core", "block", "inline"].forEach(function(chain) {
|
||
result = result.concat(this[chain].ruler.enable(list2, true));
|
||
}, this);
|
||
result = result.concat(this.inline.ruler2.enable(list2, true));
|
||
const missed = list2.filter(function(name) {
|
||
return result.indexOf(name) < 0;
|
||
});
|
||
if (missed.length && !ignoreInvalid) {
|
||
throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
|
||
}
|
||
return this;
|
||
};
|
||
MarkdownIt.prototype.disable = function(list2, ignoreInvalid) {
|
||
let result = [];
|
||
if (!Array.isArray(list2)) {
|
||
list2 = [list2];
|
||
}
|
||
["core", "block", "inline"].forEach(function(chain) {
|
||
result = result.concat(this[chain].ruler.disable(list2, true));
|
||
}, this);
|
||
result = result.concat(this.inline.ruler2.disable(list2, true));
|
||
const missed = list2.filter(function(name) {
|
||
return result.indexOf(name) < 0;
|
||
});
|
||
if (missed.length && !ignoreInvalid) {
|
||
throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
|
||
}
|
||
return this;
|
||
};
|
||
MarkdownIt.prototype.use = function(plugin) {
|
||
const args = [this].concat(Array.prototype.slice.call(arguments, 1));
|
||
plugin.apply(plugin, args);
|
||
return this;
|
||
};
|
||
MarkdownIt.prototype.parse = function(src, env) {
|
||
if (typeof src !== "string") {
|
||
throw new Error("Input data should be a String");
|
||
}
|
||
const state = new this.core.State(src, this, env);
|
||
this.core.process(state);
|
||
return state.tokens;
|
||
};
|
||
MarkdownIt.prototype.render = function(src, env) {
|
||
env = env || {};
|
||
return this.renderer.render(this.parse(src, env), this.options, env);
|
||
};
|
||
MarkdownIt.prototype.parseInline = function(src, env) {
|
||
const state = new this.core.State(src, this, env);
|
||
state.inlineMode = true;
|
||
this.core.process(state);
|
||
return state.tokens;
|
||
};
|
||
MarkdownIt.prototype.renderInline = function(src, env) {
|
||
env = env || {};
|
||
return this.renderer.render(this.parseInline(src, env), this.options, env);
|
||
};
|
||
var lib_default = MarkdownIt;
|
||
export {
|
||
lib_default as default
|
||
};
|
||
//# sourceMappingURL=markdown-it.js.map
|