mirror of
https://github.com/facebook/docusaurus.git
synced 2025-04-28 09:47:48 +02:00
4907 lines
123 KiB
JavaScript
Vendored
4907 lines
123 KiB
JavaScript
Vendored
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// node_modules/remark-gfm/index.js
|
|
var remark_gfm_exports = {};
|
|
__export(remark_gfm_exports, {
|
|
default: () => remarkGfm
|
|
});
|
|
module.exports = __toCommonJS(remark_gfm_exports);
|
|
|
|
// node_modules/micromark-util-chunked/index.js
|
|
function splice(list, start, remove, items) {
|
|
const end = list.length;
|
|
let chunkStart = 0;
|
|
let parameters;
|
|
if (start < 0) {
|
|
start = -start > end ? 0 : end + start;
|
|
} else {
|
|
start = start > end ? end : start;
|
|
}
|
|
remove = remove > 0 ? remove : 0;
|
|
if (items.length < 1e4) {
|
|
parameters = Array.from(items);
|
|
parameters.unshift(start, remove);
|
|
[].splice.apply(list, parameters);
|
|
} else {
|
|
if (remove)
|
|
[].splice.apply(list, [start, remove]);
|
|
while (chunkStart < items.length) {
|
|
parameters = items.slice(chunkStart, chunkStart + 1e4);
|
|
parameters.unshift(start, 0);
|
|
[].splice.apply(list, parameters);
|
|
chunkStart += 1e4;
|
|
start += 1e4;
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-util-combine-extensions/index.js
|
|
var hasOwnProperty = {}.hasOwnProperty;
|
|
function combineExtensions(extensions) {
|
|
const all = {};
|
|
let index = -1;
|
|
while (++index < extensions.length) {
|
|
syntaxExtension(all, extensions[index]);
|
|
}
|
|
return all;
|
|
}
|
|
function syntaxExtension(all, extension) {
|
|
let hook;
|
|
for (hook in extension) {
|
|
const maybe = hasOwnProperty.call(all, hook) ? all[hook] : void 0;
|
|
const left = maybe || (all[hook] = {});
|
|
const right = extension[hook];
|
|
let code2;
|
|
for (code2 in right) {
|
|
if (!hasOwnProperty.call(left, code2))
|
|
left[code2] = [];
|
|
const value = right[code2];
|
|
constructs(
|
|
left[code2],
|
|
Array.isArray(value) ? value : value ? [value] : []
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function constructs(existing, list) {
|
|
let index = -1;
|
|
const before = [];
|
|
while (++index < list.length) {
|
|
;
|
|
(list[index].add === "after" ? existing : before).push(list[index]);
|
|
}
|
|
splice(existing, 0, 0, before);
|
|
}
|
|
|
|
// node_modules/micromark-util-character/lib/unicode-punctuation-regex.js
|
|
var unicodePunctuationRegex = /[!-/:-@[-`{-~\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\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\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\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]/;
|
|
|
|
// node_modules/micromark-util-character/index.js
|
|
var asciiAlpha = regexCheck(/[A-Za-z]/);
|
|
var asciiDigit = regexCheck(/\d/);
|
|
var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
|
|
var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
|
|
var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
|
|
var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
|
|
function asciiControl(code2) {
|
|
return code2 !== null && (code2 < 32 || code2 === 127);
|
|
}
|
|
function markdownLineEndingOrSpace(code2) {
|
|
return code2 !== null && (code2 < 0 || code2 === 32);
|
|
}
|
|
function markdownLineEnding(code2) {
|
|
return code2 !== null && code2 < -2;
|
|
}
|
|
function markdownSpace(code2) {
|
|
return code2 === -2 || code2 === -1 || code2 === 32;
|
|
}
|
|
var unicodeWhitespace = regexCheck(/\s/);
|
|
var unicodePunctuation = regexCheck(unicodePunctuationRegex);
|
|
function regexCheck(regex) {
|
|
return check;
|
|
function check(code2) {
|
|
return code2 !== null && regex.test(String.fromCharCode(code2));
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
|
|
var www = {
|
|
tokenize: tokenizeWww,
|
|
partial: true
|
|
};
|
|
var domain = {
|
|
tokenize: tokenizeDomain,
|
|
partial: true
|
|
};
|
|
var path = {
|
|
tokenize: tokenizePath,
|
|
partial: true
|
|
};
|
|
var punctuation = {
|
|
tokenize: tokenizePunctuation,
|
|
partial: true
|
|
};
|
|
var namedCharacterReference = {
|
|
tokenize: tokenizeNamedCharacterReference,
|
|
partial: true
|
|
};
|
|
var wwwAutolink = {
|
|
tokenize: tokenizeWwwAutolink,
|
|
previous: previousWww
|
|
};
|
|
var httpAutolink = {
|
|
tokenize: tokenizeHttpAutolink,
|
|
previous: previousHttp
|
|
};
|
|
var emailAutolink = {
|
|
tokenize: tokenizeEmailAutolink,
|
|
previous: previousEmail
|
|
};
|
|
var text = {};
|
|
var gfmAutolinkLiteral = {
|
|
text
|
|
};
|
|
var code = 48;
|
|
while (code < 123) {
|
|
text[code] = emailAutolink;
|
|
code++;
|
|
if (code === 58)
|
|
code = 65;
|
|
else if (code === 91)
|
|
code = 97;
|
|
}
|
|
text[43] = emailAutolink;
|
|
text[45] = emailAutolink;
|
|
text[46] = emailAutolink;
|
|
text[95] = emailAutolink;
|
|
text[72] = [emailAutolink, httpAutolink];
|
|
text[104] = [emailAutolink, httpAutolink];
|
|
text[87] = [emailAutolink, wwwAutolink];
|
|
text[119] = [emailAutolink, wwwAutolink];
|
|
function tokenizeEmailAutolink(effects, ok2, nok) {
|
|
const self = this;
|
|
let hasDot;
|
|
let hasDigitInLastSegment;
|
|
return start;
|
|
function start(code2) {
|
|
if (!gfmAtext(code2) || !previousEmail(self.previous) || previousUnbalanced(self.events)) {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("literalAutolink");
|
|
effects.enter("literalAutolinkEmail");
|
|
return atext(code2);
|
|
}
|
|
function atext(code2) {
|
|
if (gfmAtext(code2)) {
|
|
effects.consume(code2);
|
|
return atext;
|
|
}
|
|
if (code2 === 64) {
|
|
effects.consume(code2);
|
|
return label;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function label(code2) {
|
|
if (code2 === 46) {
|
|
return effects.check(punctuation, done, dotContinuation)(code2);
|
|
}
|
|
if (code2 === 45 || code2 === 95) {
|
|
return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code2);
|
|
}
|
|
if (asciiAlphanumeric(code2)) {
|
|
if (!hasDigitInLastSegment && asciiDigit(code2)) {
|
|
hasDigitInLastSegment = true;
|
|
}
|
|
effects.consume(code2);
|
|
return label;
|
|
}
|
|
return done(code2);
|
|
}
|
|
function dotContinuation(code2) {
|
|
effects.consume(code2);
|
|
hasDot = true;
|
|
hasDigitInLastSegment = void 0;
|
|
return label;
|
|
}
|
|
function dashOrUnderscoreContinuation(code2) {
|
|
effects.consume(code2);
|
|
return afterDashOrUnderscore;
|
|
}
|
|
function afterDashOrUnderscore(code2) {
|
|
if (code2 === 46) {
|
|
return effects.check(punctuation, nok, dotContinuation)(code2);
|
|
}
|
|
return label(code2);
|
|
}
|
|
function done(code2) {
|
|
if (hasDot && !hasDigitInLastSegment) {
|
|
effects.exit("literalAutolinkEmail");
|
|
effects.exit("literalAutolink");
|
|
return ok2(code2);
|
|
}
|
|
return nok(code2);
|
|
}
|
|
}
|
|
function tokenizeWwwAutolink(effects, ok2, nok) {
|
|
const self = this;
|
|
return start;
|
|
function start(code2) {
|
|
if (code2 !== 87 && code2 !== 119 || !previousWww(self.previous) || previousUnbalanced(self.events)) {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("literalAutolink");
|
|
effects.enter("literalAutolinkWww");
|
|
return effects.check(
|
|
www,
|
|
effects.attempt(domain, effects.attempt(path, done), nok),
|
|
nok
|
|
)(code2);
|
|
}
|
|
function done(code2) {
|
|
effects.exit("literalAutolinkWww");
|
|
effects.exit("literalAutolink");
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
function tokenizeHttpAutolink(effects, ok2, nok) {
|
|
const self = this;
|
|
return start;
|
|
function start(code2) {
|
|
if (code2 !== 72 && code2 !== 104 || !previousHttp(self.previous) || previousUnbalanced(self.events)) {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("literalAutolink");
|
|
effects.enter("literalAutolinkHttp");
|
|
effects.consume(code2);
|
|
return t1;
|
|
}
|
|
function t1(code2) {
|
|
if (code2 === 84 || code2 === 116) {
|
|
effects.consume(code2);
|
|
return t2;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function t2(code2) {
|
|
if (code2 === 84 || code2 === 116) {
|
|
effects.consume(code2);
|
|
return p;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function p(code2) {
|
|
if (code2 === 80 || code2 === 112) {
|
|
effects.consume(code2);
|
|
return s;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function s(code2) {
|
|
if (code2 === 83 || code2 === 115) {
|
|
effects.consume(code2);
|
|
return colon;
|
|
}
|
|
return colon(code2);
|
|
}
|
|
function colon(code2) {
|
|
if (code2 === 58) {
|
|
effects.consume(code2);
|
|
return slash1;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function slash1(code2) {
|
|
if (code2 === 47) {
|
|
effects.consume(code2);
|
|
return slash2;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function slash2(code2) {
|
|
if (code2 === 47) {
|
|
effects.consume(code2);
|
|
return after;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function after(code2) {
|
|
return code2 === null || asciiControl(code2) || unicodeWhitespace(code2) || unicodePunctuation(code2) ? nok(code2) : effects.attempt(domain, effects.attempt(path, done), nok)(code2);
|
|
}
|
|
function done(code2) {
|
|
effects.exit("literalAutolinkHttp");
|
|
effects.exit("literalAutolink");
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
function tokenizeWww(effects, ok2, nok) {
|
|
return start;
|
|
function start(code2) {
|
|
effects.consume(code2);
|
|
return w2;
|
|
}
|
|
function w2(code2) {
|
|
if (code2 === 87 || code2 === 119) {
|
|
effects.consume(code2);
|
|
return w3;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function w3(code2) {
|
|
if (code2 === 87 || code2 === 119) {
|
|
effects.consume(code2);
|
|
return dot;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function dot(code2) {
|
|
if (code2 === 46) {
|
|
effects.consume(code2);
|
|
return after;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function after(code2) {
|
|
return code2 === null || markdownLineEnding(code2) ? nok(code2) : ok2(code2);
|
|
}
|
|
}
|
|
function tokenizeDomain(effects, ok2, nok) {
|
|
let hasUnderscoreInLastSegment;
|
|
let hasUnderscoreInLastLastSegment;
|
|
return domain2;
|
|
function domain2(code2) {
|
|
if (code2 === 38) {
|
|
return effects.check(
|
|
namedCharacterReference,
|
|
done,
|
|
punctuationContinuation
|
|
)(code2);
|
|
}
|
|
if (code2 === 46 || code2 === 95) {
|
|
return effects.check(punctuation, done, punctuationContinuation)(code2);
|
|
}
|
|
if (code2 === null || asciiControl(code2) || unicodeWhitespace(code2) || code2 !== 45 && unicodePunctuation(code2)) {
|
|
return done(code2);
|
|
}
|
|
effects.consume(code2);
|
|
return domain2;
|
|
}
|
|
function punctuationContinuation(code2) {
|
|
if (code2 === 46) {
|
|
hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment;
|
|
hasUnderscoreInLastSegment = void 0;
|
|
effects.consume(code2);
|
|
return domain2;
|
|
}
|
|
if (code2 === 95)
|
|
hasUnderscoreInLastSegment = true;
|
|
effects.consume(code2);
|
|
return domain2;
|
|
}
|
|
function done(code2) {
|
|
if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {
|
|
return ok2(code2);
|
|
}
|
|
return nok(code2);
|
|
}
|
|
}
|
|
function tokenizePath(effects, ok2) {
|
|
let balance = 0;
|
|
return inPath;
|
|
function inPath(code2) {
|
|
if (code2 === 38) {
|
|
return effects.check(
|
|
namedCharacterReference,
|
|
ok2,
|
|
continuedPunctuation
|
|
)(code2);
|
|
}
|
|
if (code2 === 40) {
|
|
balance++;
|
|
}
|
|
if (code2 === 41) {
|
|
return effects.check(
|
|
punctuation,
|
|
parenAtPathEnd,
|
|
continuedPunctuation
|
|
)(code2);
|
|
}
|
|
if (pathEnd(code2)) {
|
|
return ok2(code2);
|
|
}
|
|
if (trailingPunctuation(code2)) {
|
|
return effects.check(punctuation, ok2, continuedPunctuation)(code2);
|
|
}
|
|
effects.consume(code2);
|
|
return inPath;
|
|
}
|
|
function continuedPunctuation(code2) {
|
|
effects.consume(code2);
|
|
return inPath;
|
|
}
|
|
function parenAtPathEnd(code2) {
|
|
balance--;
|
|
return balance < 0 ? ok2(code2) : continuedPunctuation(code2);
|
|
}
|
|
}
|
|
function tokenizeNamedCharacterReference(effects, ok2, nok) {
|
|
return start;
|
|
function start(code2) {
|
|
effects.consume(code2);
|
|
return inside;
|
|
}
|
|
function inside(code2) {
|
|
if (asciiAlpha(code2)) {
|
|
effects.consume(code2);
|
|
return inside;
|
|
}
|
|
if (code2 === 59) {
|
|
effects.consume(code2);
|
|
return after;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function after(code2) {
|
|
return pathEnd(code2) ? ok2(code2) : nok(code2);
|
|
}
|
|
}
|
|
function tokenizePunctuation(effects, ok2, nok) {
|
|
return start;
|
|
function start(code2) {
|
|
effects.consume(code2);
|
|
return after;
|
|
}
|
|
function after(code2) {
|
|
if (trailingPunctuation(code2)) {
|
|
effects.consume(code2);
|
|
return after;
|
|
}
|
|
return pathEnd(code2) ? ok2(code2) : nok(code2);
|
|
}
|
|
}
|
|
function trailingPunctuation(code2) {
|
|
return code2 === 33 || code2 === 34 || code2 === 39 || code2 === 41 || code2 === 42 || code2 === 44 || code2 === 46 || code2 === 58 || code2 === 59 || code2 === 60 || code2 === 63 || code2 === 95 || code2 === 126;
|
|
}
|
|
function pathEnd(code2) {
|
|
return code2 === null || code2 === 60 || markdownLineEndingOrSpace(code2);
|
|
}
|
|
function gfmAtext(code2) {
|
|
return code2 === 43 || code2 === 45 || code2 === 46 || code2 === 95 || asciiAlphanumeric(code2);
|
|
}
|
|
function previousWww(code2) {
|
|
return code2 === null || code2 === 40 || code2 === 42 || code2 === 95 || code2 === 126 || markdownLineEndingOrSpace(code2);
|
|
}
|
|
function previousHttp(code2) {
|
|
return code2 === null || !asciiAlpha(code2);
|
|
}
|
|
function previousEmail(code2) {
|
|
return code2 !== 47 && previousHttp(code2);
|
|
}
|
|
function previousUnbalanced(events) {
|
|
let index = events.length;
|
|
let result = false;
|
|
while (index--) {
|
|
const token = events[index][1];
|
|
if ((token.type === "labelLink" || token.type === "labelImage") && !token._balanced) {
|
|
result = true;
|
|
break;
|
|
}
|
|
if (token._gfmAutolinkLiteralWalkedInto) {
|
|
result = false;
|
|
break;
|
|
}
|
|
}
|
|
if (events.length > 0 && !result) {
|
|
events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// node_modules/micromark-util-classify-character/index.js
|
|
function classifyCharacter(code2) {
|
|
if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
|
|
return 1;
|
|
}
|
|
if (unicodePunctuation(code2)) {
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-util-resolve-all/index.js
|
|
function resolveAll(constructs2, events, context) {
|
|
const called = [];
|
|
let index = -1;
|
|
while (++index < constructs2.length) {
|
|
const resolve = constructs2[index].resolveAll;
|
|
if (resolve && !called.includes(resolve)) {
|
|
events = resolve(events, context);
|
|
called.push(resolve);
|
|
}
|
|
}
|
|
return events;
|
|
}
|
|
|
|
// node_modules/micromark-factory-space/index.js
|
|
function factorySpace(effects, ok2, type, max) {
|
|
const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
|
|
let size = 0;
|
|
return start;
|
|
function start(code2) {
|
|
if (markdownSpace(code2)) {
|
|
effects.enter(type);
|
|
return prefix(code2);
|
|
}
|
|
return ok2(code2);
|
|
}
|
|
function prefix(code2) {
|
|
if (markdownSpace(code2) && size++ < limit) {
|
|
effects.consume(code2);
|
|
return prefix;
|
|
}
|
|
effects.exit(type);
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-core-commonmark/lib/blank-line.js
|
|
var blankLine = {
|
|
tokenize: tokenizeBlankLine,
|
|
partial: true
|
|
};
|
|
function tokenizeBlankLine(effects, ok2, nok) {
|
|
return factorySpace(effects, afterWhitespace, "linePrefix");
|
|
function afterWhitespace(code2) {
|
|
return code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
|
|
}
|
|
}
|
|
|
|
// node_modules/character-entities/index.js
|
|
var characterEntities = {
|
|
AElig: "\xC6",
|
|
AMP: "&",
|
|
Aacute: "\xC1",
|
|
Abreve: "\u0102",
|
|
Acirc: "\xC2",
|
|
Acy: "\u0410",
|
|
Afr: "\u{1D504}",
|
|
Agrave: "\xC0",
|
|
Alpha: "\u0391",
|
|
Amacr: "\u0100",
|
|
And: "\u2A53",
|
|
Aogon: "\u0104",
|
|
Aopf: "\u{1D538}",
|
|
ApplyFunction: "\u2061",
|
|
Aring: "\xC5",
|
|
Ascr: "\u{1D49C}",
|
|
Assign: "\u2254",
|
|
Atilde: "\xC3",
|
|
Auml: "\xC4",
|
|
Backslash: "\u2216",
|
|
Barv: "\u2AE7",
|
|
Barwed: "\u2306",
|
|
Bcy: "\u0411",
|
|
Because: "\u2235",
|
|
Bernoullis: "\u212C",
|
|
Beta: "\u0392",
|
|
Bfr: "\u{1D505}",
|
|
Bopf: "\u{1D539}",
|
|
Breve: "\u02D8",
|
|
Bscr: "\u212C",
|
|
Bumpeq: "\u224E",
|
|
CHcy: "\u0427",
|
|
COPY: "\xA9",
|
|
Cacute: "\u0106",
|
|
Cap: "\u22D2",
|
|
CapitalDifferentialD: "\u2145",
|
|
Cayleys: "\u212D",
|
|
Ccaron: "\u010C",
|
|
Ccedil: "\xC7",
|
|
Ccirc: "\u0108",
|
|
Cconint: "\u2230",
|
|
Cdot: "\u010A",
|
|
Cedilla: "\xB8",
|
|
CenterDot: "\xB7",
|
|
Cfr: "\u212D",
|
|
Chi: "\u03A7",
|
|
CircleDot: "\u2299",
|
|
CircleMinus: "\u2296",
|
|
CirclePlus: "\u2295",
|
|
CircleTimes: "\u2297",
|
|
ClockwiseContourIntegral: "\u2232",
|
|
CloseCurlyDoubleQuote: "\u201D",
|
|
CloseCurlyQuote: "\u2019",
|
|
Colon: "\u2237",
|
|
Colone: "\u2A74",
|
|
Congruent: "\u2261",
|
|
Conint: "\u222F",
|
|
ContourIntegral: "\u222E",
|
|
Copf: "\u2102",
|
|
Coproduct: "\u2210",
|
|
CounterClockwiseContourIntegral: "\u2233",
|
|
Cross: "\u2A2F",
|
|
Cscr: "\u{1D49E}",
|
|
Cup: "\u22D3",
|
|
CupCap: "\u224D",
|
|
DD: "\u2145",
|
|
DDotrahd: "\u2911",
|
|
DJcy: "\u0402",
|
|
DScy: "\u0405",
|
|
DZcy: "\u040F",
|
|
Dagger: "\u2021",
|
|
Darr: "\u21A1",
|
|
Dashv: "\u2AE4",
|
|
Dcaron: "\u010E",
|
|
Dcy: "\u0414",
|
|
Del: "\u2207",
|
|
Delta: "\u0394",
|
|
Dfr: "\u{1D507}",
|
|
DiacriticalAcute: "\xB4",
|
|
DiacriticalDot: "\u02D9",
|
|
DiacriticalDoubleAcute: "\u02DD",
|
|
DiacriticalGrave: "`",
|
|
DiacriticalTilde: "\u02DC",
|
|
Diamond: "\u22C4",
|
|
DifferentialD: "\u2146",
|
|
Dopf: "\u{1D53B}",
|
|
Dot: "\xA8",
|
|
DotDot: "\u20DC",
|
|
DotEqual: "\u2250",
|
|
DoubleContourIntegral: "\u222F",
|
|
DoubleDot: "\xA8",
|
|
DoubleDownArrow: "\u21D3",
|
|
DoubleLeftArrow: "\u21D0",
|
|
DoubleLeftRightArrow: "\u21D4",
|
|
DoubleLeftTee: "\u2AE4",
|
|
DoubleLongLeftArrow: "\u27F8",
|
|
DoubleLongLeftRightArrow: "\u27FA",
|
|
DoubleLongRightArrow: "\u27F9",
|
|
DoubleRightArrow: "\u21D2",
|
|
DoubleRightTee: "\u22A8",
|
|
DoubleUpArrow: "\u21D1",
|
|
DoubleUpDownArrow: "\u21D5",
|
|
DoubleVerticalBar: "\u2225",
|
|
DownArrow: "\u2193",
|
|
DownArrowBar: "\u2913",
|
|
DownArrowUpArrow: "\u21F5",
|
|
DownBreve: "\u0311",
|
|
DownLeftRightVector: "\u2950",
|
|
DownLeftTeeVector: "\u295E",
|
|
DownLeftVector: "\u21BD",
|
|
DownLeftVectorBar: "\u2956",
|
|
DownRightTeeVector: "\u295F",
|
|
DownRightVector: "\u21C1",
|
|
DownRightVectorBar: "\u2957",
|
|
DownTee: "\u22A4",
|
|
DownTeeArrow: "\u21A7",
|
|
Downarrow: "\u21D3",
|
|
Dscr: "\u{1D49F}",
|
|
Dstrok: "\u0110",
|
|
ENG: "\u014A",
|
|
ETH: "\xD0",
|
|
Eacute: "\xC9",
|
|
Ecaron: "\u011A",
|
|
Ecirc: "\xCA",
|
|
Ecy: "\u042D",
|
|
Edot: "\u0116",
|
|
Efr: "\u{1D508}",
|
|
Egrave: "\xC8",
|
|
Element: "\u2208",
|
|
Emacr: "\u0112",
|
|
EmptySmallSquare: "\u25FB",
|
|
EmptyVerySmallSquare: "\u25AB",
|
|
Eogon: "\u0118",
|
|
Eopf: "\u{1D53C}",
|
|
Epsilon: "\u0395",
|
|
Equal: "\u2A75",
|
|
EqualTilde: "\u2242",
|
|
Equilibrium: "\u21CC",
|
|
Escr: "\u2130",
|
|
Esim: "\u2A73",
|
|
Eta: "\u0397",
|
|
Euml: "\xCB",
|
|
Exists: "\u2203",
|
|
ExponentialE: "\u2147",
|
|
Fcy: "\u0424",
|
|
Ffr: "\u{1D509}",
|
|
FilledSmallSquare: "\u25FC",
|
|
FilledVerySmallSquare: "\u25AA",
|
|
Fopf: "\u{1D53D}",
|
|
ForAll: "\u2200",
|
|
Fouriertrf: "\u2131",
|
|
Fscr: "\u2131",
|
|
GJcy: "\u0403",
|
|
GT: ">",
|
|
Gamma: "\u0393",
|
|
Gammad: "\u03DC",
|
|
Gbreve: "\u011E",
|
|
Gcedil: "\u0122",
|
|
Gcirc: "\u011C",
|
|
Gcy: "\u0413",
|
|
Gdot: "\u0120",
|
|
Gfr: "\u{1D50A}",
|
|
Gg: "\u22D9",
|
|
Gopf: "\u{1D53E}",
|
|
GreaterEqual: "\u2265",
|
|
GreaterEqualLess: "\u22DB",
|
|
GreaterFullEqual: "\u2267",
|
|
GreaterGreater: "\u2AA2",
|
|
GreaterLess: "\u2277",
|
|
GreaterSlantEqual: "\u2A7E",
|
|
GreaterTilde: "\u2273",
|
|
Gscr: "\u{1D4A2}",
|
|
Gt: "\u226B",
|
|
HARDcy: "\u042A",
|
|
Hacek: "\u02C7",
|
|
Hat: "^",
|
|
Hcirc: "\u0124",
|
|
Hfr: "\u210C",
|
|
HilbertSpace: "\u210B",
|
|
Hopf: "\u210D",
|
|
HorizontalLine: "\u2500",
|
|
Hscr: "\u210B",
|
|
Hstrok: "\u0126",
|
|
HumpDownHump: "\u224E",
|
|
HumpEqual: "\u224F",
|
|
IEcy: "\u0415",
|
|
IJlig: "\u0132",
|
|
IOcy: "\u0401",
|
|
Iacute: "\xCD",
|
|
Icirc: "\xCE",
|
|
Icy: "\u0418",
|
|
Idot: "\u0130",
|
|
Ifr: "\u2111",
|
|
Igrave: "\xCC",
|
|
Im: "\u2111",
|
|
Imacr: "\u012A",
|
|
ImaginaryI: "\u2148",
|
|
Implies: "\u21D2",
|
|
Int: "\u222C",
|
|
Integral: "\u222B",
|
|
Intersection: "\u22C2",
|
|
InvisibleComma: "\u2063",
|
|
InvisibleTimes: "\u2062",
|
|
Iogon: "\u012E",
|
|
Iopf: "\u{1D540}",
|
|
Iota: "\u0399",
|
|
Iscr: "\u2110",
|
|
Itilde: "\u0128",
|
|
Iukcy: "\u0406",
|
|
Iuml: "\xCF",
|
|
Jcirc: "\u0134",
|
|
Jcy: "\u0419",
|
|
Jfr: "\u{1D50D}",
|
|
Jopf: "\u{1D541}",
|
|
Jscr: "\u{1D4A5}",
|
|
Jsercy: "\u0408",
|
|
Jukcy: "\u0404",
|
|
KHcy: "\u0425",
|
|
KJcy: "\u040C",
|
|
Kappa: "\u039A",
|
|
Kcedil: "\u0136",
|
|
Kcy: "\u041A",
|
|
Kfr: "\u{1D50E}",
|
|
Kopf: "\u{1D542}",
|
|
Kscr: "\u{1D4A6}",
|
|
LJcy: "\u0409",
|
|
LT: "<",
|
|
Lacute: "\u0139",
|
|
Lambda: "\u039B",
|
|
Lang: "\u27EA",
|
|
Laplacetrf: "\u2112",
|
|
Larr: "\u219E",
|
|
Lcaron: "\u013D",
|
|
Lcedil: "\u013B",
|
|
Lcy: "\u041B",
|
|
LeftAngleBracket: "\u27E8",
|
|
LeftArrow: "\u2190",
|
|
LeftArrowBar: "\u21E4",
|
|
LeftArrowRightArrow: "\u21C6",
|
|
LeftCeiling: "\u2308",
|
|
LeftDoubleBracket: "\u27E6",
|
|
LeftDownTeeVector: "\u2961",
|
|
LeftDownVector: "\u21C3",
|
|
LeftDownVectorBar: "\u2959",
|
|
LeftFloor: "\u230A",
|
|
LeftRightArrow: "\u2194",
|
|
LeftRightVector: "\u294E",
|
|
LeftTee: "\u22A3",
|
|
LeftTeeArrow: "\u21A4",
|
|
LeftTeeVector: "\u295A",
|
|
LeftTriangle: "\u22B2",
|
|
LeftTriangleBar: "\u29CF",
|
|
LeftTriangleEqual: "\u22B4",
|
|
LeftUpDownVector: "\u2951",
|
|
LeftUpTeeVector: "\u2960",
|
|
LeftUpVector: "\u21BF",
|
|
LeftUpVectorBar: "\u2958",
|
|
LeftVector: "\u21BC",
|
|
LeftVectorBar: "\u2952",
|
|
Leftarrow: "\u21D0",
|
|
Leftrightarrow: "\u21D4",
|
|
LessEqualGreater: "\u22DA",
|
|
LessFullEqual: "\u2266",
|
|
LessGreater: "\u2276",
|
|
LessLess: "\u2AA1",
|
|
LessSlantEqual: "\u2A7D",
|
|
LessTilde: "\u2272",
|
|
Lfr: "\u{1D50F}",
|
|
Ll: "\u22D8",
|
|
Lleftarrow: "\u21DA",
|
|
Lmidot: "\u013F",
|
|
LongLeftArrow: "\u27F5",
|
|
LongLeftRightArrow: "\u27F7",
|
|
LongRightArrow: "\u27F6",
|
|
Longleftarrow: "\u27F8",
|
|
Longleftrightarrow: "\u27FA",
|
|
Longrightarrow: "\u27F9",
|
|
Lopf: "\u{1D543}",
|
|
LowerLeftArrow: "\u2199",
|
|
LowerRightArrow: "\u2198",
|
|
Lscr: "\u2112",
|
|
Lsh: "\u21B0",
|
|
Lstrok: "\u0141",
|
|
Lt: "\u226A",
|
|
Map: "\u2905",
|
|
Mcy: "\u041C",
|
|
MediumSpace: "\u205F",
|
|
Mellintrf: "\u2133",
|
|
Mfr: "\u{1D510}",
|
|
MinusPlus: "\u2213",
|
|
Mopf: "\u{1D544}",
|
|
Mscr: "\u2133",
|
|
Mu: "\u039C",
|
|
NJcy: "\u040A",
|
|
Nacute: "\u0143",
|
|
Ncaron: "\u0147",
|
|
Ncedil: "\u0145",
|
|
Ncy: "\u041D",
|
|
NegativeMediumSpace: "\u200B",
|
|
NegativeThickSpace: "\u200B",
|
|
NegativeThinSpace: "\u200B",
|
|
NegativeVeryThinSpace: "\u200B",
|
|
NestedGreaterGreater: "\u226B",
|
|
NestedLessLess: "\u226A",
|
|
NewLine: "\n",
|
|
Nfr: "\u{1D511}",
|
|
NoBreak: "\u2060",
|
|
NonBreakingSpace: "\xA0",
|
|
Nopf: "\u2115",
|
|
Not: "\u2AEC",
|
|
NotCongruent: "\u2262",
|
|
NotCupCap: "\u226D",
|
|
NotDoubleVerticalBar: "\u2226",
|
|
NotElement: "\u2209",
|
|
NotEqual: "\u2260",
|
|
NotEqualTilde: "\u2242\u0338",
|
|
NotExists: "\u2204",
|
|
NotGreater: "\u226F",
|
|
NotGreaterEqual: "\u2271",
|
|
NotGreaterFullEqual: "\u2267\u0338",
|
|
NotGreaterGreater: "\u226B\u0338",
|
|
NotGreaterLess: "\u2279",
|
|
NotGreaterSlantEqual: "\u2A7E\u0338",
|
|
NotGreaterTilde: "\u2275",
|
|
NotHumpDownHump: "\u224E\u0338",
|
|
NotHumpEqual: "\u224F\u0338",
|
|
NotLeftTriangle: "\u22EA",
|
|
NotLeftTriangleBar: "\u29CF\u0338",
|
|
NotLeftTriangleEqual: "\u22EC",
|
|
NotLess: "\u226E",
|
|
NotLessEqual: "\u2270",
|
|
NotLessGreater: "\u2278",
|
|
NotLessLess: "\u226A\u0338",
|
|
NotLessSlantEqual: "\u2A7D\u0338",
|
|
NotLessTilde: "\u2274",
|
|
NotNestedGreaterGreater: "\u2AA2\u0338",
|
|
NotNestedLessLess: "\u2AA1\u0338",
|
|
NotPrecedes: "\u2280",
|
|
NotPrecedesEqual: "\u2AAF\u0338",
|
|
NotPrecedesSlantEqual: "\u22E0",
|
|
NotReverseElement: "\u220C",
|
|
NotRightTriangle: "\u22EB",
|
|
NotRightTriangleBar: "\u29D0\u0338",
|
|
NotRightTriangleEqual: "\u22ED",
|
|
NotSquareSubset: "\u228F\u0338",
|
|
NotSquareSubsetEqual: "\u22E2",
|
|
NotSquareSuperset: "\u2290\u0338",
|
|
NotSquareSupersetEqual: "\u22E3",
|
|
NotSubset: "\u2282\u20D2",
|
|
NotSubsetEqual: "\u2288",
|
|
NotSucceeds: "\u2281",
|
|
NotSucceedsEqual: "\u2AB0\u0338",
|
|
NotSucceedsSlantEqual: "\u22E1",
|
|
NotSucceedsTilde: "\u227F\u0338",
|
|
NotSuperset: "\u2283\u20D2",
|
|
NotSupersetEqual: "\u2289",
|
|
NotTilde: "\u2241",
|
|
NotTildeEqual: "\u2244",
|
|
NotTildeFullEqual: "\u2247",
|
|
NotTildeTilde: "\u2249",
|
|
NotVerticalBar: "\u2224",
|
|
Nscr: "\u{1D4A9}",
|
|
Ntilde: "\xD1",
|
|
Nu: "\u039D",
|
|
OElig: "\u0152",
|
|
Oacute: "\xD3",
|
|
Ocirc: "\xD4",
|
|
Ocy: "\u041E",
|
|
Odblac: "\u0150",
|
|
Ofr: "\u{1D512}",
|
|
Ograve: "\xD2",
|
|
Omacr: "\u014C",
|
|
Omega: "\u03A9",
|
|
Omicron: "\u039F",
|
|
Oopf: "\u{1D546}",
|
|
OpenCurlyDoubleQuote: "\u201C",
|
|
OpenCurlyQuote: "\u2018",
|
|
Or: "\u2A54",
|
|
Oscr: "\u{1D4AA}",
|
|
Oslash: "\xD8",
|
|
Otilde: "\xD5",
|
|
Otimes: "\u2A37",
|
|
Ouml: "\xD6",
|
|
OverBar: "\u203E",
|
|
OverBrace: "\u23DE",
|
|
OverBracket: "\u23B4",
|
|
OverParenthesis: "\u23DC",
|
|
PartialD: "\u2202",
|
|
Pcy: "\u041F",
|
|
Pfr: "\u{1D513}",
|
|
Phi: "\u03A6",
|
|
Pi: "\u03A0",
|
|
PlusMinus: "\xB1",
|
|
Poincareplane: "\u210C",
|
|
Popf: "\u2119",
|
|
Pr: "\u2ABB",
|
|
Precedes: "\u227A",
|
|
PrecedesEqual: "\u2AAF",
|
|
PrecedesSlantEqual: "\u227C",
|
|
PrecedesTilde: "\u227E",
|
|
Prime: "\u2033",
|
|
Product: "\u220F",
|
|
Proportion: "\u2237",
|
|
Proportional: "\u221D",
|
|
Pscr: "\u{1D4AB}",
|
|
Psi: "\u03A8",
|
|
QUOT: '"',
|
|
Qfr: "\u{1D514}",
|
|
Qopf: "\u211A",
|
|
Qscr: "\u{1D4AC}",
|
|
RBarr: "\u2910",
|
|
REG: "\xAE",
|
|
Racute: "\u0154",
|
|
Rang: "\u27EB",
|
|
Rarr: "\u21A0",
|
|
Rarrtl: "\u2916",
|
|
Rcaron: "\u0158",
|
|
Rcedil: "\u0156",
|
|
Rcy: "\u0420",
|
|
Re: "\u211C",
|
|
ReverseElement: "\u220B",
|
|
ReverseEquilibrium: "\u21CB",
|
|
ReverseUpEquilibrium: "\u296F",
|
|
Rfr: "\u211C",
|
|
Rho: "\u03A1",
|
|
RightAngleBracket: "\u27E9",
|
|
RightArrow: "\u2192",
|
|
RightArrowBar: "\u21E5",
|
|
RightArrowLeftArrow: "\u21C4",
|
|
RightCeiling: "\u2309",
|
|
RightDoubleBracket: "\u27E7",
|
|
RightDownTeeVector: "\u295D",
|
|
RightDownVector: "\u21C2",
|
|
RightDownVectorBar: "\u2955",
|
|
RightFloor: "\u230B",
|
|
RightTee: "\u22A2",
|
|
RightTeeArrow: "\u21A6",
|
|
RightTeeVector: "\u295B",
|
|
RightTriangle: "\u22B3",
|
|
RightTriangleBar: "\u29D0",
|
|
RightTriangleEqual: "\u22B5",
|
|
RightUpDownVector: "\u294F",
|
|
RightUpTeeVector: "\u295C",
|
|
RightUpVector: "\u21BE",
|
|
RightUpVectorBar: "\u2954",
|
|
RightVector: "\u21C0",
|
|
RightVectorBar: "\u2953",
|
|
Rightarrow: "\u21D2",
|
|
Ropf: "\u211D",
|
|
RoundImplies: "\u2970",
|
|
Rrightarrow: "\u21DB",
|
|
Rscr: "\u211B",
|
|
Rsh: "\u21B1",
|
|
RuleDelayed: "\u29F4",
|
|
SHCHcy: "\u0429",
|
|
SHcy: "\u0428",
|
|
SOFTcy: "\u042C",
|
|
Sacute: "\u015A",
|
|
Sc: "\u2ABC",
|
|
Scaron: "\u0160",
|
|
Scedil: "\u015E",
|
|
Scirc: "\u015C",
|
|
Scy: "\u0421",
|
|
Sfr: "\u{1D516}",
|
|
ShortDownArrow: "\u2193",
|
|
ShortLeftArrow: "\u2190",
|
|
ShortRightArrow: "\u2192",
|
|
ShortUpArrow: "\u2191",
|
|
Sigma: "\u03A3",
|
|
SmallCircle: "\u2218",
|
|
Sopf: "\u{1D54A}",
|
|
Sqrt: "\u221A",
|
|
Square: "\u25A1",
|
|
SquareIntersection: "\u2293",
|
|
SquareSubset: "\u228F",
|
|
SquareSubsetEqual: "\u2291",
|
|
SquareSuperset: "\u2290",
|
|
SquareSupersetEqual: "\u2292",
|
|
SquareUnion: "\u2294",
|
|
Sscr: "\u{1D4AE}",
|
|
Star: "\u22C6",
|
|
Sub: "\u22D0",
|
|
Subset: "\u22D0",
|
|
SubsetEqual: "\u2286",
|
|
Succeeds: "\u227B",
|
|
SucceedsEqual: "\u2AB0",
|
|
SucceedsSlantEqual: "\u227D",
|
|
SucceedsTilde: "\u227F",
|
|
SuchThat: "\u220B",
|
|
Sum: "\u2211",
|
|
Sup: "\u22D1",
|
|
Superset: "\u2283",
|
|
SupersetEqual: "\u2287",
|
|
Supset: "\u22D1",
|
|
THORN: "\xDE",
|
|
TRADE: "\u2122",
|
|
TSHcy: "\u040B",
|
|
TScy: "\u0426",
|
|
Tab: " ",
|
|
Tau: "\u03A4",
|
|
Tcaron: "\u0164",
|
|
Tcedil: "\u0162",
|
|
Tcy: "\u0422",
|
|
Tfr: "\u{1D517}",
|
|
Therefore: "\u2234",
|
|
Theta: "\u0398",
|
|
ThickSpace: "\u205F\u200A",
|
|
ThinSpace: "\u2009",
|
|
Tilde: "\u223C",
|
|
TildeEqual: "\u2243",
|
|
TildeFullEqual: "\u2245",
|
|
TildeTilde: "\u2248",
|
|
Topf: "\u{1D54B}",
|
|
TripleDot: "\u20DB",
|
|
Tscr: "\u{1D4AF}",
|
|
Tstrok: "\u0166",
|
|
Uacute: "\xDA",
|
|
Uarr: "\u219F",
|
|
Uarrocir: "\u2949",
|
|
Ubrcy: "\u040E",
|
|
Ubreve: "\u016C",
|
|
Ucirc: "\xDB",
|
|
Ucy: "\u0423",
|
|
Udblac: "\u0170",
|
|
Ufr: "\u{1D518}",
|
|
Ugrave: "\xD9",
|
|
Umacr: "\u016A",
|
|
UnderBar: "_",
|
|
UnderBrace: "\u23DF",
|
|
UnderBracket: "\u23B5",
|
|
UnderParenthesis: "\u23DD",
|
|
Union: "\u22C3",
|
|
UnionPlus: "\u228E",
|
|
Uogon: "\u0172",
|
|
Uopf: "\u{1D54C}",
|
|
UpArrow: "\u2191",
|
|
UpArrowBar: "\u2912",
|
|
UpArrowDownArrow: "\u21C5",
|
|
UpDownArrow: "\u2195",
|
|
UpEquilibrium: "\u296E",
|
|
UpTee: "\u22A5",
|
|
UpTeeArrow: "\u21A5",
|
|
Uparrow: "\u21D1",
|
|
Updownarrow: "\u21D5",
|
|
UpperLeftArrow: "\u2196",
|
|
UpperRightArrow: "\u2197",
|
|
Upsi: "\u03D2",
|
|
Upsilon: "\u03A5",
|
|
Uring: "\u016E",
|
|
Uscr: "\u{1D4B0}",
|
|
Utilde: "\u0168",
|
|
Uuml: "\xDC",
|
|
VDash: "\u22AB",
|
|
Vbar: "\u2AEB",
|
|
Vcy: "\u0412",
|
|
Vdash: "\u22A9",
|
|
Vdashl: "\u2AE6",
|
|
Vee: "\u22C1",
|
|
Verbar: "\u2016",
|
|
Vert: "\u2016",
|
|
VerticalBar: "\u2223",
|
|
VerticalLine: "|",
|
|
VerticalSeparator: "\u2758",
|
|
VerticalTilde: "\u2240",
|
|
VeryThinSpace: "\u200A",
|
|
Vfr: "\u{1D519}",
|
|
Vopf: "\u{1D54D}",
|
|
Vscr: "\u{1D4B1}",
|
|
Vvdash: "\u22AA",
|
|
Wcirc: "\u0174",
|
|
Wedge: "\u22C0",
|
|
Wfr: "\u{1D51A}",
|
|
Wopf: "\u{1D54E}",
|
|
Wscr: "\u{1D4B2}",
|
|
Xfr: "\u{1D51B}",
|
|
Xi: "\u039E",
|
|
Xopf: "\u{1D54F}",
|
|
Xscr: "\u{1D4B3}",
|
|
YAcy: "\u042F",
|
|
YIcy: "\u0407",
|
|
YUcy: "\u042E",
|
|
Yacute: "\xDD",
|
|
Ycirc: "\u0176",
|
|
Ycy: "\u042B",
|
|
Yfr: "\u{1D51C}",
|
|
Yopf: "\u{1D550}",
|
|
Yscr: "\u{1D4B4}",
|
|
Yuml: "\u0178",
|
|
ZHcy: "\u0416",
|
|
Zacute: "\u0179",
|
|
Zcaron: "\u017D",
|
|
Zcy: "\u0417",
|
|
Zdot: "\u017B",
|
|
ZeroWidthSpace: "\u200B",
|
|
Zeta: "\u0396",
|
|
Zfr: "\u2128",
|
|
Zopf: "\u2124",
|
|
Zscr: "\u{1D4B5}",
|
|
aacute: "\xE1",
|
|
abreve: "\u0103",
|
|
ac: "\u223E",
|
|
acE: "\u223E\u0333",
|
|
acd: "\u223F",
|
|
acirc: "\xE2",
|
|
acute: "\xB4",
|
|
acy: "\u0430",
|
|
aelig: "\xE6",
|
|
af: "\u2061",
|
|
afr: "\u{1D51E}",
|
|
agrave: "\xE0",
|
|
alefsym: "\u2135",
|
|
aleph: "\u2135",
|
|
alpha: "\u03B1",
|
|
amacr: "\u0101",
|
|
amalg: "\u2A3F",
|
|
amp: "&",
|
|
and: "\u2227",
|
|
andand: "\u2A55",
|
|
andd: "\u2A5C",
|
|
andslope: "\u2A58",
|
|
andv: "\u2A5A",
|
|
ang: "\u2220",
|
|
ange: "\u29A4",
|
|
angle: "\u2220",
|
|
angmsd: "\u2221",
|
|
angmsdaa: "\u29A8",
|
|
angmsdab: "\u29A9",
|
|
angmsdac: "\u29AA",
|
|
angmsdad: "\u29AB",
|
|
angmsdae: "\u29AC",
|
|
angmsdaf: "\u29AD",
|
|
angmsdag: "\u29AE",
|
|
angmsdah: "\u29AF",
|
|
angrt: "\u221F",
|
|
angrtvb: "\u22BE",
|
|
angrtvbd: "\u299D",
|
|
angsph: "\u2222",
|
|
angst: "\xC5",
|
|
angzarr: "\u237C",
|
|
aogon: "\u0105",
|
|
aopf: "\u{1D552}",
|
|
ap: "\u2248",
|
|
apE: "\u2A70",
|
|
apacir: "\u2A6F",
|
|
ape: "\u224A",
|
|
apid: "\u224B",
|
|
apos: "'",
|
|
approx: "\u2248",
|
|
approxeq: "\u224A",
|
|
aring: "\xE5",
|
|
ascr: "\u{1D4B6}",
|
|
ast: "*",
|
|
asymp: "\u2248",
|
|
asympeq: "\u224D",
|
|
atilde: "\xE3",
|
|
auml: "\xE4",
|
|
awconint: "\u2233",
|
|
awint: "\u2A11",
|
|
bNot: "\u2AED",
|
|
backcong: "\u224C",
|
|
backepsilon: "\u03F6",
|
|
backprime: "\u2035",
|
|
backsim: "\u223D",
|
|
backsimeq: "\u22CD",
|
|
barvee: "\u22BD",
|
|
barwed: "\u2305",
|
|
barwedge: "\u2305",
|
|
bbrk: "\u23B5",
|
|
bbrktbrk: "\u23B6",
|
|
bcong: "\u224C",
|
|
bcy: "\u0431",
|
|
bdquo: "\u201E",
|
|
becaus: "\u2235",
|
|
because: "\u2235",
|
|
bemptyv: "\u29B0",
|
|
bepsi: "\u03F6",
|
|
bernou: "\u212C",
|
|
beta: "\u03B2",
|
|
beth: "\u2136",
|
|
between: "\u226C",
|
|
bfr: "\u{1D51F}",
|
|
bigcap: "\u22C2",
|
|
bigcirc: "\u25EF",
|
|
bigcup: "\u22C3",
|
|
bigodot: "\u2A00",
|
|
bigoplus: "\u2A01",
|
|
bigotimes: "\u2A02",
|
|
bigsqcup: "\u2A06",
|
|
bigstar: "\u2605",
|
|
bigtriangledown: "\u25BD",
|
|
bigtriangleup: "\u25B3",
|
|
biguplus: "\u2A04",
|
|
bigvee: "\u22C1",
|
|
bigwedge: "\u22C0",
|
|
bkarow: "\u290D",
|
|
blacklozenge: "\u29EB",
|
|
blacksquare: "\u25AA",
|
|
blacktriangle: "\u25B4",
|
|
blacktriangledown: "\u25BE",
|
|
blacktriangleleft: "\u25C2",
|
|
blacktriangleright: "\u25B8",
|
|
blank: "\u2423",
|
|
blk12: "\u2592",
|
|
blk14: "\u2591",
|
|
blk34: "\u2593",
|
|
block: "\u2588",
|
|
bne: "=\u20E5",
|
|
bnequiv: "\u2261\u20E5",
|
|
bnot: "\u2310",
|
|
bopf: "\u{1D553}",
|
|
bot: "\u22A5",
|
|
bottom: "\u22A5",
|
|
bowtie: "\u22C8",
|
|
boxDL: "\u2557",
|
|
boxDR: "\u2554",
|
|
boxDl: "\u2556",
|
|
boxDr: "\u2553",
|
|
boxH: "\u2550",
|
|
boxHD: "\u2566",
|
|
boxHU: "\u2569",
|
|
boxHd: "\u2564",
|
|
boxHu: "\u2567",
|
|
boxUL: "\u255D",
|
|
boxUR: "\u255A",
|
|
boxUl: "\u255C",
|
|
boxUr: "\u2559",
|
|
boxV: "\u2551",
|
|
boxVH: "\u256C",
|
|
boxVL: "\u2563",
|
|
boxVR: "\u2560",
|
|
boxVh: "\u256B",
|
|
boxVl: "\u2562",
|
|
boxVr: "\u255F",
|
|
boxbox: "\u29C9",
|
|
boxdL: "\u2555",
|
|
boxdR: "\u2552",
|
|
boxdl: "\u2510",
|
|
boxdr: "\u250C",
|
|
boxh: "\u2500",
|
|
boxhD: "\u2565",
|
|
boxhU: "\u2568",
|
|
boxhd: "\u252C",
|
|
boxhu: "\u2534",
|
|
boxminus: "\u229F",
|
|
boxplus: "\u229E",
|
|
boxtimes: "\u22A0",
|
|
boxuL: "\u255B",
|
|
boxuR: "\u2558",
|
|
boxul: "\u2518",
|
|
boxur: "\u2514",
|
|
boxv: "\u2502",
|
|
boxvH: "\u256A",
|
|
boxvL: "\u2561",
|
|
boxvR: "\u255E",
|
|
boxvh: "\u253C",
|
|
boxvl: "\u2524",
|
|
boxvr: "\u251C",
|
|
bprime: "\u2035",
|
|
breve: "\u02D8",
|
|
brvbar: "\xA6",
|
|
bscr: "\u{1D4B7}",
|
|
bsemi: "\u204F",
|
|
bsim: "\u223D",
|
|
bsime: "\u22CD",
|
|
bsol: "\\",
|
|
bsolb: "\u29C5",
|
|
bsolhsub: "\u27C8",
|
|
bull: "\u2022",
|
|
bullet: "\u2022",
|
|
bump: "\u224E",
|
|
bumpE: "\u2AAE",
|
|
bumpe: "\u224F",
|
|
bumpeq: "\u224F",
|
|
cacute: "\u0107",
|
|
cap: "\u2229",
|
|
capand: "\u2A44",
|
|
capbrcup: "\u2A49",
|
|
capcap: "\u2A4B",
|
|
capcup: "\u2A47",
|
|
capdot: "\u2A40",
|
|
caps: "\u2229\uFE00",
|
|
caret: "\u2041",
|
|
caron: "\u02C7",
|
|
ccaps: "\u2A4D",
|
|
ccaron: "\u010D",
|
|
ccedil: "\xE7",
|
|
ccirc: "\u0109",
|
|
ccups: "\u2A4C",
|
|
ccupssm: "\u2A50",
|
|
cdot: "\u010B",
|
|
cedil: "\xB8",
|
|
cemptyv: "\u29B2",
|
|
cent: "\xA2",
|
|
centerdot: "\xB7",
|
|
cfr: "\u{1D520}",
|
|
chcy: "\u0447",
|
|
check: "\u2713",
|
|
checkmark: "\u2713",
|
|
chi: "\u03C7",
|
|
cir: "\u25CB",
|
|
cirE: "\u29C3",
|
|
circ: "\u02C6",
|
|
circeq: "\u2257",
|
|
circlearrowleft: "\u21BA",
|
|
circlearrowright: "\u21BB",
|
|
circledR: "\xAE",
|
|
circledS: "\u24C8",
|
|
circledast: "\u229B",
|
|
circledcirc: "\u229A",
|
|
circleddash: "\u229D",
|
|
cire: "\u2257",
|
|
cirfnint: "\u2A10",
|
|
cirmid: "\u2AEF",
|
|
cirscir: "\u29C2",
|
|
clubs: "\u2663",
|
|
clubsuit: "\u2663",
|
|
colon: ":",
|
|
colone: "\u2254",
|
|
coloneq: "\u2254",
|
|
comma: ",",
|
|
commat: "@",
|
|
comp: "\u2201",
|
|
compfn: "\u2218",
|
|
complement: "\u2201",
|
|
complexes: "\u2102",
|
|
cong: "\u2245",
|
|
congdot: "\u2A6D",
|
|
conint: "\u222E",
|
|
copf: "\u{1D554}",
|
|
coprod: "\u2210",
|
|
copy: "\xA9",
|
|
copysr: "\u2117",
|
|
crarr: "\u21B5",
|
|
cross: "\u2717",
|
|
cscr: "\u{1D4B8}",
|
|
csub: "\u2ACF",
|
|
csube: "\u2AD1",
|
|
csup: "\u2AD0",
|
|
csupe: "\u2AD2",
|
|
ctdot: "\u22EF",
|
|
cudarrl: "\u2938",
|
|
cudarrr: "\u2935",
|
|
cuepr: "\u22DE",
|
|
cuesc: "\u22DF",
|
|
cularr: "\u21B6",
|
|
cularrp: "\u293D",
|
|
cup: "\u222A",
|
|
cupbrcap: "\u2A48",
|
|
cupcap: "\u2A46",
|
|
cupcup: "\u2A4A",
|
|
cupdot: "\u228D",
|
|
cupor: "\u2A45",
|
|
cups: "\u222A\uFE00",
|
|
curarr: "\u21B7",
|
|
curarrm: "\u293C",
|
|
curlyeqprec: "\u22DE",
|
|
curlyeqsucc: "\u22DF",
|
|
curlyvee: "\u22CE",
|
|
curlywedge: "\u22CF",
|
|
curren: "\xA4",
|
|
curvearrowleft: "\u21B6",
|
|
curvearrowright: "\u21B7",
|
|
cuvee: "\u22CE",
|
|
cuwed: "\u22CF",
|
|
cwconint: "\u2232",
|
|
cwint: "\u2231",
|
|
cylcty: "\u232D",
|
|
dArr: "\u21D3",
|
|
dHar: "\u2965",
|
|
dagger: "\u2020",
|
|
daleth: "\u2138",
|
|
darr: "\u2193",
|
|
dash: "\u2010",
|
|
dashv: "\u22A3",
|
|
dbkarow: "\u290F",
|
|
dblac: "\u02DD",
|
|
dcaron: "\u010F",
|
|
dcy: "\u0434",
|
|
dd: "\u2146",
|
|
ddagger: "\u2021",
|
|
ddarr: "\u21CA",
|
|
ddotseq: "\u2A77",
|
|
deg: "\xB0",
|
|
delta: "\u03B4",
|
|
demptyv: "\u29B1",
|
|
dfisht: "\u297F",
|
|
dfr: "\u{1D521}",
|
|
dharl: "\u21C3",
|
|
dharr: "\u21C2",
|
|
diam: "\u22C4",
|
|
diamond: "\u22C4",
|
|
diamondsuit: "\u2666",
|
|
diams: "\u2666",
|
|
die: "\xA8",
|
|
digamma: "\u03DD",
|
|
disin: "\u22F2",
|
|
div: "\xF7",
|
|
divide: "\xF7",
|
|
divideontimes: "\u22C7",
|
|
divonx: "\u22C7",
|
|
djcy: "\u0452",
|
|
dlcorn: "\u231E",
|
|
dlcrop: "\u230D",
|
|
dollar: "$",
|
|
dopf: "\u{1D555}",
|
|
dot: "\u02D9",
|
|
doteq: "\u2250",
|
|
doteqdot: "\u2251",
|
|
dotminus: "\u2238",
|
|
dotplus: "\u2214",
|
|
dotsquare: "\u22A1",
|
|
doublebarwedge: "\u2306",
|
|
downarrow: "\u2193",
|
|
downdownarrows: "\u21CA",
|
|
downharpoonleft: "\u21C3",
|
|
downharpoonright: "\u21C2",
|
|
drbkarow: "\u2910",
|
|
drcorn: "\u231F",
|
|
drcrop: "\u230C",
|
|
dscr: "\u{1D4B9}",
|
|
dscy: "\u0455",
|
|
dsol: "\u29F6",
|
|
dstrok: "\u0111",
|
|
dtdot: "\u22F1",
|
|
dtri: "\u25BF",
|
|
dtrif: "\u25BE",
|
|
duarr: "\u21F5",
|
|
duhar: "\u296F",
|
|
dwangle: "\u29A6",
|
|
dzcy: "\u045F",
|
|
dzigrarr: "\u27FF",
|
|
eDDot: "\u2A77",
|
|
eDot: "\u2251",
|
|
eacute: "\xE9",
|
|
easter: "\u2A6E",
|
|
ecaron: "\u011B",
|
|
ecir: "\u2256",
|
|
ecirc: "\xEA",
|
|
ecolon: "\u2255",
|
|
ecy: "\u044D",
|
|
edot: "\u0117",
|
|
ee: "\u2147",
|
|
efDot: "\u2252",
|
|
efr: "\u{1D522}",
|
|
eg: "\u2A9A",
|
|
egrave: "\xE8",
|
|
egs: "\u2A96",
|
|
egsdot: "\u2A98",
|
|
el: "\u2A99",
|
|
elinters: "\u23E7",
|
|
ell: "\u2113",
|
|
els: "\u2A95",
|
|
elsdot: "\u2A97",
|
|
emacr: "\u0113",
|
|
empty: "\u2205",
|
|
emptyset: "\u2205",
|
|
emptyv: "\u2205",
|
|
emsp13: "\u2004",
|
|
emsp14: "\u2005",
|
|
emsp: "\u2003",
|
|
eng: "\u014B",
|
|
ensp: "\u2002",
|
|
eogon: "\u0119",
|
|
eopf: "\u{1D556}",
|
|
epar: "\u22D5",
|
|
eparsl: "\u29E3",
|
|
eplus: "\u2A71",
|
|
epsi: "\u03B5",
|
|
epsilon: "\u03B5",
|
|
epsiv: "\u03F5",
|
|
eqcirc: "\u2256",
|
|
eqcolon: "\u2255",
|
|
eqsim: "\u2242",
|
|
eqslantgtr: "\u2A96",
|
|
eqslantless: "\u2A95",
|
|
equals: "=",
|
|
equest: "\u225F",
|
|
equiv: "\u2261",
|
|
equivDD: "\u2A78",
|
|
eqvparsl: "\u29E5",
|
|
erDot: "\u2253",
|
|
erarr: "\u2971",
|
|
escr: "\u212F",
|
|
esdot: "\u2250",
|
|
esim: "\u2242",
|
|
eta: "\u03B7",
|
|
eth: "\xF0",
|
|
euml: "\xEB",
|
|
euro: "\u20AC",
|
|
excl: "!",
|
|
exist: "\u2203",
|
|
expectation: "\u2130",
|
|
exponentiale: "\u2147",
|
|
fallingdotseq: "\u2252",
|
|
fcy: "\u0444",
|
|
female: "\u2640",
|
|
ffilig: "\uFB03",
|
|
fflig: "\uFB00",
|
|
ffllig: "\uFB04",
|
|
ffr: "\u{1D523}",
|
|
filig: "\uFB01",
|
|
fjlig: "fj",
|
|
flat: "\u266D",
|
|
fllig: "\uFB02",
|
|
fltns: "\u25B1",
|
|
fnof: "\u0192",
|
|
fopf: "\u{1D557}",
|
|
forall: "\u2200",
|
|
fork: "\u22D4",
|
|
forkv: "\u2AD9",
|
|
fpartint: "\u2A0D",
|
|
frac12: "\xBD",
|
|
frac13: "\u2153",
|
|
frac14: "\xBC",
|
|
frac15: "\u2155",
|
|
frac16: "\u2159",
|
|
frac18: "\u215B",
|
|
frac23: "\u2154",
|
|
frac25: "\u2156",
|
|
frac34: "\xBE",
|
|
frac35: "\u2157",
|
|
frac38: "\u215C",
|
|
frac45: "\u2158",
|
|
frac56: "\u215A",
|
|
frac58: "\u215D",
|
|
frac78: "\u215E",
|
|
frasl: "\u2044",
|
|
frown: "\u2322",
|
|
fscr: "\u{1D4BB}",
|
|
gE: "\u2267",
|
|
gEl: "\u2A8C",
|
|
gacute: "\u01F5",
|
|
gamma: "\u03B3",
|
|
gammad: "\u03DD",
|
|
gap: "\u2A86",
|
|
gbreve: "\u011F",
|
|
gcirc: "\u011D",
|
|
gcy: "\u0433",
|
|
gdot: "\u0121",
|
|
ge: "\u2265",
|
|
gel: "\u22DB",
|
|
geq: "\u2265",
|
|
geqq: "\u2267",
|
|
geqslant: "\u2A7E",
|
|
ges: "\u2A7E",
|
|
gescc: "\u2AA9",
|
|
gesdot: "\u2A80",
|
|
gesdoto: "\u2A82",
|
|
gesdotol: "\u2A84",
|
|
gesl: "\u22DB\uFE00",
|
|
gesles: "\u2A94",
|
|
gfr: "\u{1D524}",
|
|
gg: "\u226B",
|
|
ggg: "\u22D9",
|
|
gimel: "\u2137",
|
|
gjcy: "\u0453",
|
|
gl: "\u2277",
|
|
glE: "\u2A92",
|
|
gla: "\u2AA5",
|
|
glj: "\u2AA4",
|
|
gnE: "\u2269",
|
|
gnap: "\u2A8A",
|
|
gnapprox: "\u2A8A",
|
|
gne: "\u2A88",
|
|
gneq: "\u2A88",
|
|
gneqq: "\u2269",
|
|
gnsim: "\u22E7",
|
|
gopf: "\u{1D558}",
|
|
grave: "`",
|
|
gscr: "\u210A",
|
|
gsim: "\u2273",
|
|
gsime: "\u2A8E",
|
|
gsiml: "\u2A90",
|
|
gt: ">",
|
|
gtcc: "\u2AA7",
|
|
gtcir: "\u2A7A",
|
|
gtdot: "\u22D7",
|
|
gtlPar: "\u2995",
|
|
gtquest: "\u2A7C",
|
|
gtrapprox: "\u2A86",
|
|
gtrarr: "\u2978",
|
|
gtrdot: "\u22D7",
|
|
gtreqless: "\u22DB",
|
|
gtreqqless: "\u2A8C",
|
|
gtrless: "\u2277",
|
|
gtrsim: "\u2273",
|
|
gvertneqq: "\u2269\uFE00",
|
|
gvnE: "\u2269\uFE00",
|
|
hArr: "\u21D4",
|
|
hairsp: "\u200A",
|
|
half: "\xBD",
|
|
hamilt: "\u210B",
|
|
hardcy: "\u044A",
|
|
harr: "\u2194",
|
|
harrcir: "\u2948",
|
|
harrw: "\u21AD",
|
|
hbar: "\u210F",
|
|
hcirc: "\u0125",
|
|
hearts: "\u2665",
|
|
heartsuit: "\u2665",
|
|
hellip: "\u2026",
|
|
hercon: "\u22B9",
|
|
hfr: "\u{1D525}",
|
|
hksearow: "\u2925",
|
|
hkswarow: "\u2926",
|
|
hoarr: "\u21FF",
|
|
homtht: "\u223B",
|
|
hookleftarrow: "\u21A9",
|
|
hookrightarrow: "\u21AA",
|
|
hopf: "\u{1D559}",
|
|
horbar: "\u2015",
|
|
hscr: "\u{1D4BD}",
|
|
hslash: "\u210F",
|
|
hstrok: "\u0127",
|
|
hybull: "\u2043",
|
|
hyphen: "\u2010",
|
|
iacute: "\xED",
|
|
ic: "\u2063",
|
|
icirc: "\xEE",
|
|
icy: "\u0438",
|
|
iecy: "\u0435",
|
|
iexcl: "\xA1",
|
|
iff: "\u21D4",
|
|
ifr: "\u{1D526}",
|
|
igrave: "\xEC",
|
|
ii: "\u2148",
|
|
iiiint: "\u2A0C",
|
|
iiint: "\u222D",
|
|
iinfin: "\u29DC",
|
|
iiota: "\u2129",
|
|
ijlig: "\u0133",
|
|
imacr: "\u012B",
|
|
image: "\u2111",
|
|
imagline: "\u2110",
|
|
imagpart: "\u2111",
|
|
imath: "\u0131",
|
|
imof: "\u22B7",
|
|
imped: "\u01B5",
|
|
in: "\u2208",
|
|
incare: "\u2105",
|
|
infin: "\u221E",
|
|
infintie: "\u29DD",
|
|
inodot: "\u0131",
|
|
int: "\u222B",
|
|
intcal: "\u22BA",
|
|
integers: "\u2124",
|
|
intercal: "\u22BA",
|
|
intlarhk: "\u2A17",
|
|
intprod: "\u2A3C",
|
|
iocy: "\u0451",
|
|
iogon: "\u012F",
|
|
iopf: "\u{1D55A}",
|
|
iota: "\u03B9",
|
|
iprod: "\u2A3C",
|
|
iquest: "\xBF",
|
|
iscr: "\u{1D4BE}",
|
|
isin: "\u2208",
|
|
isinE: "\u22F9",
|
|
isindot: "\u22F5",
|
|
isins: "\u22F4",
|
|
isinsv: "\u22F3",
|
|
isinv: "\u2208",
|
|
it: "\u2062",
|
|
itilde: "\u0129",
|
|
iukcy: "\u0456",
|
|
iuml: "\xEF",
|
|
jcirc: "\u0135",
|
|
jcy: "\u0439",
|
|
jfr: "\u{1D527}",
|
|
jmath: "\u0237",
|
|
jopf: "\u{1D55B}",
|
|
jscr: "\u{1D4BF}",
|
|
jsercy: "\u0458",
|
|
jukcy: "\u0454",
|
|
kappa: "\u03BA",
|
|
kappav: "\u03F0",
|
|
kcedil: "\u0137",
|
|
kcy: "\u043A",
|
|
kfr: "\u{1D528}",
|
|
kgreen: "\u0138",
|
|
khcy: "\u0445",
|
|
kjcy: "\u045C",
|
|
kopf: "\u{1D55C}",
|
|
kscr: "\u{1D4C0}",
|
|
lAarr: "\u21DA",
|
|
lArr: "\u21D0",
|
|
lAtail: "\u291B",
|
|
lBarr: "\u290E",
|
|
lE: "\u2266",
|
|
lEg: "\u2A8B",
|
|
lHar: "\u2962",
|
|
lacute: "\u013A",
|
|
laemptyv: "\u29B4",
|
|
lagran: "\u2112",
|
|
lambda: "\u03BB",
|
|
lang: "\u27E8",
|
|
langd: "\u2991",
|
|
langle: "\u27E8",
|
|
lap: "\u2A85",
|
|
laquo: "\xAB",
|
|
larr: "\u2190",
|
|
larrb: "\u21E4",
|
|
larrbfs: "\u291F",
|
|
larrfs: "\u291D",
|
|
larrhk: "\u21A9",
|
|
larrlp: "\u21AB",
|
|
larrpl: "\u2939",
|
|
larrsim: "\u2973",
|
|
larrtl: "\u21A2",
|
|
lat: "\u2AAB",
|
|
latail: "\u2919",
|
|
late: "\u2AAD",
|
|
lates: "\u2AAD\uFE00",
|
|
lbarr: "\u290C",
|
|
lbbrk: "\u2772",
|
|
lbrace: "{",
|
|
lbrack: "[",
|
|
lbrke: "\u298B",
|
|
lbrksld: "\u298F",
|
|
lbrkslu: "\u298D",
|
|
lcaron: "\u013E",
|
|
lcedil: "\u013C",
|
|
lceil: "\u2308",
|
|
lcub: "{",
|
|
lcy: "\u043B",
|
|
ldca: "\u2936",
|
|
ldquo: "\u201C",
|
|
ldquor: "\u201E",
|
|
ldrdhar: "\u2967",
|
|
ldrushar: "\u294B",
|
|
ldsh: "\u21B2",
|
|
le: "\u2264",
|
|
leftarrow: "\u2190",
|
|
leftarrowtail: "\u21A2",
|
|
leftharpoondown: "\u21BD",
|
|
leftharpoonup: "\u21BC",
|
|
leftleftarrows: "\u21C7",
|
|
leftrightarrow: "\u2194",
|
|
leftrightarrows: "\u21C6",
|
|
leftrightharpoons: "\u21CB",
|
|
leftrightsquigarrow: "\u21AD",
|
|
leftthreetimes: "\u22CB",
|
|
leg: "\u22DA",
|
|
leq: "\u2264",
|
|
leqq: "\u2266",
|
|
leqslant: "\u2A7D",
|
|
les: "\u2A7D",
|
|
lescc: "\u2AA8",
|
|
lesdot: "\u2A7F",
|
|
lesdoto: "\u2A81",
|
|
lesdotor: "\u2A83",
|
|
lesg: "\u22DA\uFE00",
|
|
lesges: "\u2A93",
|
|
lessapprox: "\u2A85",
|
|
lessdot: "\u22D6",
|
|
lesseqgtr: "\u22DA",
|
|
lesseqqgtr: "\u2A8B",
|
|
lessgtr: "\u2276",
|
|
lesssim: "\u2272",
|
|
lfisht: "\u297C",
|
|
lfloor: "\u230A",
|
|
lfr: "\u{1D529}",
|
|
lg: "\u2276",
|
|
lgE: "\u2A91",
|
|
lhard: "\u21BD",
|
|
lharu: "\u21BC",
|
|
lharul: "\u296A",
|
|
lhblk: "\u2584",
|
|
ljcy: "\u0459",
|
|
ll: "\u226A",
|
|
llarr: "\u21C7",
|
|
llcorner: "\u231E",
|
|
llhard: "\u296B",
|
|
lltri: "\u25FA",
|
|
lmidot: "\u0140",
|
|
lmoust: "\u23B0",
|
|
lmoustache: "\u23B0",
|
|
lnE: "\u2268",
|
|
lnap: "\u2A89",
|
|
lnapprox: "\u2A89",
|
|
lne: "\u2A87",
|
|
lneq: "\u2A87",
|
|
lneqq: "\u2268",
|
|
lnsim: "\u22E6",
|
|
loang: "\u27EC",
|
|
loarr: "\u21FD",
|
|
lobrk: "\u27E6",
|
|
longleftarrow: "\u27F5",
|
|
longleftrightarrow: "\u27F7",
|
|
longmapsto: "\u27FC",
|
|
longrightarrow: "\u27F6",
|
|
looparrowleft: "\u21AB",
|
|
looparrowright: "\u21AC",
|
|
lopar: "\u2985",
|
|
lopf: "\u{1D55D}",
|
|
loplus: "\u2A2D",
|
|
lotimes: "\u2A34",
|
|
lowast: "\u2217",
|
|
lowbar: "_",
|
|
loz: "\u25CA",
|
|
lozenge: "\u25CA",
|
|
lozf: "\u29EB",
|
|
lpar: "(",
|
|
lparlt: "\u2993",
|
|
lrarr: "\u21C6",
|
|
lrcorner: "\u231F",
|
|
lrhar: "\u21CB",
|
|
lrhard: "\u296D",
|
|
lrm: "\u200E",
|
|
lrtri: "\u22BF",
|
|
lsaquo: "\u2039",
|
|
lscr: "\u{1D4C1}",
|
|
lsh: "\u21B0",
|
|
lsim: "\u2272",
|
|
lsime: "\u2A8D",
|
|
lsimg: "\u2A8F",
|
|
lsqb: "[",
|
|
lsquo: "\u2018",
|
|
lsquor: "\u201A",
|
|
lstrok: "\u0142",
|
|
lt: "<",
|
|
ltcc: "\u2AA6",
|
|
ltcir: "\u2A79",
|
|
ltdot: "\u22D6",
|
|
lthree: "\u22CB",
|
|
ltimes: "\u22C9",
|
|
ltlarr: "\u2976",
|
|
ltquest: "\u2A7B",
|
|
ltrPar: "\u2996",
|
|
ltri: "\u25C3",
|
|
ltrie: "\u22B4",
|
|
ltrif: "\u25C2",
|
|
lurdshar: "\u294A",
|
|
luruhar: "\u2966",
|
|
lvertneqq: "\u2268\uFE00",
|
|
lvnE: "\u2268\uFE00",
|
|
mDDot: "\u223A",
|
|
macr: "\xAF",
|
|
male: "\u2642",
|
|
malt: "\u2720",
|
|
maltese: "\u2720",
|
|
map: "\u21A6",
|
|
mapsto: "\u21A6",
|
|
mapstodown: "\u21A7",
|
|
mapstoleft: "\u21A4",
|
|
mapstoup: "\u21A5",
|
|
marker: "\u25AE",
|
|
mcomma: "\u2A29",
|
|
mcy: "\u043C",
|
|
mdash: "\u2014",
|
|
measuredangle: "\u2221",
|
|
mfr: "\u{1D52A}",
|
|
mho: "\u2127",
|
|
micro: "\xB5",
|
|
mid: "\u2223",
|
|
midast: "*",
|
|
midcir: "\u2AF0",
|
|
middot: "\xB7",
|
|
minus: "\u2212",
|
|
minusb: "\u229F",
|
|
minusd: "\u2238",
|
|
minusdu: "\u2A2A",
|
|
mlcp: "\u2ADB",
|
|
mldr: "\u2026",
|
|
mnplus: "\u2213",
|
|
models: "\u22A7",
|
|
mopf: "\u{1D55E}",
|
|
mp: "\u2213",
|
|
mscr: "\u{1D4C2}",
|
|
mstpos: "\u223E",
|
|
mu: "\u03BC",
|
|
multimap: "\u22B8",
|
|
mumap: "\u22B8",
|
|
nGg: "\u22D9\u0338",
|
|
nGt: "\u226B\u20D2",
|
|
nGtv: "\u226B\u0338",
|
|
nLeftarrow: "\u21CD",
|
|
nLeftrightarrow: "\u21CE",
|
|
nLl: "\u22D8\u0338",
|
|
nLt: "\u226A\u20D2",
|
|
nLtv: "\u226A\u0338",
|
|
nRightarrow: "\u21CF",
|
|
nVDash: "\u22AF",
|
|
nVdash: "\u22AE",
|
|
nabla: "\u2207",
|
|
nacute: "\u0144",
|
|
nang: "\u2220\u20D2",
|
|
nap: "\u2249",
|
|
napE: "\u2A70\u0338",
|
|
napid: "\u224B\u0338",
|
|
napos: "\u0149",
|
|
napprox: "\u2249",
|
|
natur: "\u266E",
|
|
natural: "\u266E",
|
|
naturals: "\u2115",
|
|
nbsp: "\xA0",
|
|
nbump: "\u224E\u0338",
|
|
nbumpe: "\u224F\u0338",
|
|
ncap: "\u2A43",
|
|
ncaron: "\u0148",
|
|
ncedil: "\u0146",
|
|
ncong: "\u2247",
|
|
ncongdot: "\u2A6D\u0338",
|
|
ncup: "\u2A42",
|
|
ncy: "\u043D",
|
|
ndash: "\u2013",
|
|
ne: "\u2260",
|
|
neArr: "\u21D7",
|
|
nearhk: "\u2924",
|
|
nearr: "\u2197",
|
|
nearrow: "\u2197",
|
|
nedot: "\u2250\u0338",
|
|
nequiv: "\u2262",
|
|
nesear: "\u2928",
|
|
nesim: "\u2242\u0338",
|
|
nexist: "\u2204",
|
|
nexists: "\u2204",
|
|
nfr: "\u{1D52B}",
|
|
ngE: "\u2267\u0338",
|
|
nge: "\u2271",
|
|
ngeq: "\u2271",
|
|
ngeqq: "\u2267\u0338",
|
|
ngeqslant: "\u2A7E\u0338",
|
|
nges: "\u2A7E\u0338",
|
|
ngsim: "\u2275",
|
|
ngt: "\u226F",
|
|
ngtr: "\u226F",
|
|
nhArr: "\u21CE",
|
|
nharr: "\u21AE",
|
|
nhpar: "\u2AF2",
|
|
ni: "\u220B",
|
|
nis: "\u22FC",
|
|
nisd: "\u22FA",
|
|
niv: "\u220B",
|
|
njcy: "\u045A",
|
|
nlArr: "\u21CD",
|
|
nlE: "\u2266\u0338",
|
|
nlarr: "\u219A",
|
|
nldr: "\u2025",
|
|
nle: "\u2270",
|
|
nleftarrow: "\u219A",
|
|
nleftrightarrow: "\u21AE",
|
|
nleq: "\u2270",
|
|
nleqq: "\u2266\u0338",
|
|
nleqslant: "\u2A7D\u0338",
|
|
nles: "\u2A7D\u0338",
|
|
nless: "\u226E",
|
|
nlsim: "\u2274",
|
|
nlt: "\u226E",
|
|
nltri: "\u22EA",
|
|
nltrie: "\u22EC",
|
|
nmid: "\u2224",
|
|
nopf: "\u{1D55F}",
|
|
not: "\xAC",
|
|
notin: "\u2209",
|
|
notinE: "\u22F9\u0338",
|
|
notindot: "\u22F5\u0338",
|
|
notinva: "\u2209",
|
|
notinvb: "\u22F7",
|
|
notinvc: "\u22F6",
|
|
notni: "\u220C",
|
|
notniva: "\u220C",
|
|
notnivb: "\u22FE",
|
|
notnivc: "\u22FD",
|
|
npar: "\u2226",
|
|
nparallel: "\u2226",
|
|
nparsl: "\u2AFD\u20E5",
|
|
npart: "\u2202\u0338",
|
|
npolint: "\u2A14",
|
|
npr: "\u2280",
|
|
nprcue: "\u22E0",
|
|
npre: "\u2AAF\u0338",
|
|
nprec: "\u2280",
|
|
npreceq: "\u2AAF\u0338",
|
|
nrArr: "\u21CF",
|
|
nrarr: "\u219B",
|
|
nrarrc: "\u2933\u0338",
|
|
nrarrw: "\u219D\u0338",
|
|
nrightarrow: "\u219B",
|
|
nrtri: "\u22EB",
|
|
nrtrie: "\u22ED",
|
|
nsc: "\u2281",
|
|
nsccue: "\u22E1",
|
|
nsce: "\u2AB0\u0338",
|
|
nscr: "\u{1D4C3}",
|
|
nshortmid: "\u2224",
|
|
nshortparallel: "\u2226",
|
|
nsim: "\u2241",
|
|
nsime: "\u2244",
|
|
nsimeq: "\u2244",
|
|
nsmid: "\u2224",
|
|
nspar: "\u2226",
|
|
nsqsube: "\u22E2",
|
|
nsqsupe: "\u22E3",
|
|
nsub: "\u2284",
|
|
nsubE: "\u2AC5\u0338",
|
|
nsube: "\u2288",
|
|
nsubset: "\u2282\u20D2",
|
|
nsubseteq: "\u2288",
|
|
nsubseteqq: "\u2AC5\u0338",
|
|
nsucc: "\u2281",
|
|
nsucceq: "\u2AB0\u0338",
|
|
nsup: "\u2285",
|
|
nsupE: "\u2AC6\u0338",
|
|
nsupe: "\u2289",
|
|
nsupset: "\u2283\u20D2",
|
|
nsupseteq: "\u2289",
|
|
nsupseteqq: "\u2AC6\u0338",
|
|
ntgl: "\u2279",
|
|
ntilde: "\xF1",
|
|
ntlg: "\u2278",
|
|
ntriangleleft: "\u22EA",
|
|
ntrianglelefteq: "\u22EC",
|
|
ntriangleright: "\u22EB",
|
|
ntrianglerighteq: "\u22ED",
|
|
nu: "\u03BD",
|
|
num: "#",
|
|
numero: "\u2116",
|
|
numsp: "\u2007",
|
|
nvDash: "\u22AD",
|
|
nvHarr: "\u2904",
|
|
nvap: "\u224D\u20D2",
|
|
nvdash: "\u22AC",
|
|
nvge: "\u2265\u20D2",
|
|
nvgt: ">\u20D2",
|
|
nvinfin: "\u29DE",
|
|
nvlArr: "\u2902",
|
|
nvle: "\u2264\u20D2",
|
|
nvlt: "<\u20D2",
|
|
nvltrie: "\u22B4\u20D2",
|
|
nvrArr: "\u2903",
|
|
nvrtrie: "\u22B5\u20D2",
|
|
nvsim: "\u223C\u20D2",
|
|
nwArr: "\u21D6",
|
|
nwarhk: "\u2923",
|
|
nwarr: "\u2196",
|
|
nwarrow: "\u2196",
|
|
nwnear: "\u2927",
|
|
oS: "\u24C8",
|
|
oacute: "\xF3",
|
|
oast: "\u229B",
|
|
ocir: "\u229A",
|
|
ocirc: "\xF4",
|
|
ocy: "\u043E",
|
|
odash: "\u229D",
|
|
odblac: "\u0151",
|
|
odiv: "\u2A38",
|
|
odot: "\u2299",
|
|
odsold: "\u29BC",
|
|
oelig: "\u0153",
|
|
ofcir: "\u29BF",
|
|
ofr: "\u{1D52C}",
|
|
ogon: "\u02DB",
|
|
ograve: "\xF2",
|
|
ogt: "\u29C1",
|
|
ohbar: "\u29B5",
|
|
ohm: "\u03A9",
|
|
oint: "\u222E",
|
|
olarr: "\u21BA",
|
|
olcir: "\u29BE",
|
|
olcross: "\u29BB",
|
|
oline: "\u203E",
|
|
olt: "\u29C0",
|
|
omacr: "\u014D",
|
|
omega: "\u03C9",
|
|
omicron: "\u03BF",
|
|
omid: "\u29B6",
|
|
ominus: "\u2296",
|
|
oopf: "\u{1D560}",
|
|
opar: "\u29B7",
|
|
operp: "\u29B9",
|
|
oplus: "\u2295",
|
|
or: "\u2228",
|
|
orarr: "\u21BB",
|
|
ord: "\u2A5D",
|
|
order: "\u2134",
|
|
orderof: "\u2134",
|
|
ordf: "\xAA",
|
|
ordm: "\xBA",
|
|
origof: "\u22B6",
|
|
oror: "\u2A56",
|
|
orslope: "\u2A57",
|
|
orv: "\u2A5B",
|
|
oscr: "\u2134",
|
|
oslash: "\xF8",
|
|
osol: "\u2298",
|
|
otilde: "\xF5",
|
|
otimes: "\u2297",
|
|
otimesas: "\u2A36",
|
|
ouml: "\xF6",
|
|
ovbar: "\u233D",
|
|
par: "\u2225",
|
|
para: "\xB6",
|
|
parallel: "\u2225",
|
|
parsim: "\u2AF3",
|
|
parsl: "\u2AFD",
|
|
part: "\u2202",
|
|
pcy: "\u043F",
|
|
percnt: "%",
|
|
period: ".",
|
|
permil: "\u2030",
|
|
perp: "\u22A5",
|
|
pertenk: "\u2031",
|
|
pfr: "\u{1D52D}",
|
|
phi: "\u03C6",
|
|
phiv: "\u03D5",
|
|
phmmat: "\u2133",
|
|
phone: "\u260E",
|
|
pi: "\u03C0",
|
|
pitchfork: "\u22D4",
|
|
piv: "\u03D6",
|
|
planck: "\u210F",
|
|
planckh: "\u210E",
|
|
plankv: "\u210F",
|
|
plus: "+",
|
|
plusacir: "\u2A23",
|
|
plusb: "\u229E",
|
|
pluscir: "\u2A22",
|
|
plusdo: "\u2214",
|
|
plusdu: "\u2A25",
|
|
pluse: "\u2A72",
|
|
plusmn: "\xB1",
|
|
plussim: "\u2A26",
|
|
plustwo: "\u2A27",
|
|
pm: "\xB1",
|
|
pointint: "\u2A15",
|
|
popf: "\u{1D561}",
|
|
pound: "\xA3",
|
|
pr: "\u227A",
|
|
prE: "\u2AB3",
|
|
prap: "\u2AB7",
|
|
prcue: "\u227C",
|
|
pre: "\u2AAF",
|
|
prec: "\u227A",
|
|
precapprox: "\u2AB7",
|
|
preccurlyeq: "\u227C",
|
|
preceq: "\u2AAF",
|
|
precnapprox: "\u2AB9",
|
|
precneqq: "\u2AB5",
|
|
precnsim: "\u22E8",
|
|
precsim: "\u227E",
|
|
prime: "\u2032",
|
|
primes: "\u2119",
|
|
prnE: "\u2AB5",
|
|
prnap: "\u2AB9",
|
|
prnsim: "\u22E8",
|
|
prod: "\u220F",
|
|
profalar: "\u232E",
|
|
profline: "\u2312",
|
|
profsurf: "\u2313",
|
|
prop: "\u221D",
|
|
propto: "\u221D",
|
|
prsim: "\u227E",
|
|
prurel: "\u22B0",
|
|
pscr: "\u{1D4C5}",
|
|
psi: "\u03C8",
|
|
puncsp: "\u2008",
|
|
qfr: "\u{1D52E}",
|
|
qint: "\u2A0C",
|
|
qopf: "\u{1D562}",
|
|
qprime: "\u2057",
|
|
qscr: "\u{1D4C6}",
|
|
quaternions: "\u210D",
|
|
quatint: "\u2A16",
|
|
quest: "?",
|
|
questeq: "\u225F",
|
|
quot: '"',
|
|
rAarr: "\u21DB",
|
|
rArr: "\u21D2",
|
|
rAtail: "\u291C",
|
|
rBarr: "\u290F",
|
|
rHar: "\u2964",
|
|
race: "\u223D\u0331",
|
|
racute: "\u0155",
|
|
radic: "\u221A",
|
|
raemptyv: "\u29B3",
|
|
rang: "\u27E9",
|
|
rangd: "\u2992",
|
|
range: "\u29A5",
|
|
rangle: "\u27E9",
|
|
raquo: "\xBB",
|
|
rarr: "\u2192",
|
|
rarrap: "\u2975",
|
|
rarrb: "\u21E5",
|
|
rarrbfs: "\u2920",
|
|
rarrc: "\u2933",
|
|
rarrfs: "\u291E",
|
|
rarrhk: "\u21AA",
|
|
rarrlp: "\u21AC",
|
|
rarrpl: "\u2945",
|
|
rarrsim: "\u2974",
|
|
rarrtl: "\u21A3",
|
|
rarrw: "\u219D",
|
|
ratail: "\u291A",
|
|
ratio: "\u2236",
|
|
rationals: "\u211A",
|
|
rbarr: "\u290D",
|
|
rbbrk: "\u2773",
|
|
rbrace: "}",
|
|
rbrack: "]",
|
|
rbrke: "\u298C",
|
|
rbrksld: "\u298E",
|
|
rbrkslu: "\u2990",
|
|
rcaron: "\u0159",
|
|
rcedil: "\u0157",
|
|
rceil: "\u2309",
|
|
rcub: "}",
|
|
rcy: "\u0440",
|
|
rdca: "\u2937",
|
|
rdldhar: "\u2969",
|
|
rdquo: "\u201D",
|
|
rdquor: "\u201D",
|
|
rdsh: "\u21B3",
|
|
real: "\u211C",
|
|
realine: "\u211B",
|
|
realpart: "\u211C",
|
|
reals: "\u211D",
|
|
rect: "\u25AD",
|
|
reg: "\xAE",
|
|
rfisht: "\u297D",
|
|
rfloor: "\u230B",
|
|
rfr: "\u{1D52F}",
|
|
rhard: "\u21C1",
|
|
rharu: "\u21C0",
|
|
rharul: "\u296C",
|
|
rho: "\u03C1",
|
|
rhov: "\u03F1",
|
|
rightarrow: "\u2192",
|
|
rightarrowtail: "\u21A3",
|
|
rightharpoondown: "\u21C1",
|
|
rightharpoonup: "\u21C0",
|
|
rightleftarrows: "\u21C4",
|
|
rightleftharpoons: "\u21CC",
|
|
rightrightarrows: "\u21C9",
|
|
rightsquigarrow: "\u219D",
|
|
rightthreetimes: "\u22CC",
|
|
ring: "\u02DA",
|
|
risingdotseq: "\u2253",
|
|
rlarr: "\u21C4",
|
|
rlhar: "\u21CC",
|
|
rlm: "\u200F",
|
|
rmoust: "\u23B1",
|
|
rmoustache: "\u23B1",
|
|
rnmid: "\u2AEE",
|
|
roang: "\u27ED",
|
|
roarr: "\u21FE",
|
|
robrk: "\u27E7",
|
|
ropar: "\u2986",
|
|
ropf: "\u{1D563}",
|
|
roplus: "\u2A2E",
|
|
rotimes: "\u2A35",
|
|
rpar: ")",
|
|
rpargt: "\u2994",
|
|
rppolint: "\u2A12",
|
|
rrarr: "\u21C9",
|
|
rsaquo: "\u203A",
|
|
rscr: "\u{1D4C7}",
|
|
rsh: "\u21B1",
|
|
rsqb: "]",
|
|
rsquo: "\u2019",
|
|
rsquor: "\u2019",
|
|
rthree: "\u22CC",
|
|
rtimes: "\u22CA",
|
|
rtri: "\u25B9",
|
|
rtrie: "\u22B5",
|
|
rtrif: "\u25B8",
|
|
rtriltri: "\u29CE",
|
|
ruluhar: "\u2968",
|
|
rx: "\u211E",
|
|
sacute: "\u015B",
|
|
sbquo: "\u201A",
|
|
sc: "\u227B",
|
|
scE: "\u2AB4",
|
|
scap: "\u2AB8",
|
|
scaron: "\u0161",
|
|
sccue: "\u227D",
|
|
sce: "\u2AB0",
|
|
scedil: "\u015F",
|
|
scirc: "\u015D",
|
|
scnE: "\u2AB6",
|
|
scnap: "\u2ABA",
|
|
scnsim: "\u22E9",
|
|
scpolint: "\u2A13",
|
|
scsim: "\u227F",
|
|
scy: "\u0441",
|
|
sdot: "\u22C5",
|
|
sdotb: "\u22A1",
|
|
sdote: "\u2A66",
|
|
seArr: "\u21D8",
|
|
searhk: "\u2925",
|
|
searr: "\u2198",
|
|
searrow: "\u2198",
|
|
sect: "\xA7",
|
|
semi: ";",
|
|
seswar: "\u2929",
|
|
setminus: "\u2216",
|
|
setmn: "\u2216",
|
|
sext: "\u2736",
|
|
sfr: "\u{1D530}",
|
|
sfrown: "\u2322",
|
|
sharp: "\u266F",
|
|
shchcy: "\u0449",
|
|
shcy: "\u0448",
|
|
shortmid: "\u2223",
|
|
shortparallel: "\u2225",
|
|
shy: "\xAD",
|
|
sigma: "\u03C3",
|
|
sigmaf: "\u03C2",
|
|
sigmav: "\u03C2",
|
|
sim: "\u223C",
|
|
simdot: "\u2A6A",
|
|
sime: "\u2243",
|
|
simeq: "\u2243",
|
|
simg: "\u2A9E",
|
|
simgE: "\u2AA0",
|
|
siml: "\u2A9D",
|
|
simlE: "\u2A9F",
|
|
simne: "\u2246",
|
|
simplus: "\u2A24",
|
|
simrarr: "\u2972",
|
|
slarr: "\u2190",
|
|
smallsetminus: "\u2216",
|
|
smashp: "\u2A33",
|
|
smeparsl: "\u29E4",
|
|
smid: "\u2223",
|
|
smile: "\u2323",
|
|
smt: "\u2AAA",
|
|
smte: "\u2AAC",
|
|
smtes: "\u2AAC\uFE00",
|
|
softcy: "\u044C",
|
|
sol: "/",
|
|
solb: "\u29C4",
|
|
solbar: "\u233F",
|
|
sopf: "\u{1D564}",
|
|
spades: "\u2660",
|
|
spadesuit: "\u2660",
|
|
spar: "\u2225",
|
|
sqcap: "\u2293",
|
|
sqcaps: "\u2293\uFE00",
|
|
sqcup: "\u2294",
|
|
sqcups: "\u2294\uFE00",
|
|
sqsub: "\u228F",
|
|
sqsube: "\u2291",
|
|
sqsubset: "\u228F",
|
|
sqsubseteq: "\u2291",
|
|
sqsup: "\u2290",
|
|
sqsupe: "\u2292",
|
|
sqsupset: "\u2290",
|
|
sqsupseteq: "\u2292",
|
|
squ: "\u25A1",
|
|
square: "\u25A1",
|
|
squarf: "\u25AA",
|
|
squf: "\u25AA",
|
|
srarr: "\u2192",
|
|
sscr: "\u{1D4C8}",
|
|
ssetmn: "\u2216",
|
|
ssmile: "\u2323",
|
|
sstarf: "\u22C6",
|
|
star: "\u2606",
|
|
starf: "\u2605",
|
|
straightepsilon: "\u03F5",
|
|
straightphi: "\u03D5",
|
|
strns: "\xAF",
|
|
sub: "\u2282",
|
|
subE: "\u2AC5",
|
|
subdot: "\u2ABD",
|
|
sube: "\u2286",
|
|
subedot: "\u2AC3",
|
|
submult: "\u2AC1",
|
|
subnE: "\u2ACB",
|
|
subne: "\u228A",
|
|
subplus: "\u2ABF",
|
|
subrarr: "\u2979",
|
|
subset: "\u2282",
|
|
subseteq: "\u2286",
|
|
subseteqq: "\u2AC5",
|
|
subsetneq: "\u228A",
|
|
subsetneqq: "\u2ACB",
|
|
subsim: "\u2AC7",
|
|
subsub: "\u2AD5",
|
|
subsup: "\u2AD3",
|
|
succ: "\u227B",
|
|
succapprox: "\u2AB8",
|
|
succcurlyeq: "\u227D",
|
|
succeq: "\u2AB0",
|
|
succnapprox: "\u2ABA",
|
|
succneqq: "\u2AB6",
|
|
succnsim: "\u22E9",
|
|
succsim: "\u227F",
|
|
sum: "\u2211",
|
|
sung: "\u266A",
|
|
sup1: "\xB9",
|
|
sup2: "\xB2",
|
|
sup3: "\xB3",
|
|
sup: "\u2283",
|
|
supE: "\u2AC6",
|
|
supdot: "\u2ABE",
|
|
supdsub: "\u2AD8",
|
|
supe: "\u2287",
|
|
supedot: "\u2AC4",
|
|
suphsol: "\u27C9",
|
|
suphsub: "\u2AD7",
|
|
suplarr: "\u297B",
|
|
supmult: "\u2AC2",
|
|
supnE: "\u2ACC",
|
|
supne: "\u228B",
|
|
supplus: "\u2AC0",
|
|
supset: "\u2283",
|
|
supseteq: "\u2287",
|
|
supseteqq: "\u2AC6",
|
|
supsetneq: "\u228B",
|
|
supsetneqq: "\u2ACC",
|
|
supsim: "\u2AC8",
|
|
supsub: "\u2AD4",
|
|
supsup: "\u2AD6",
|
|
swArr: "\u21D9",
|
|
swarhk: "\u2926",
|
|
swarr: "\u2199",
|
|
swarrow: "\u2199",
|
|
swnwar: "\u292A",
|
|
szlig: "\xDF",
|
|
target: "\u2316",
|
|
tau: "\u03C4",
|
|
tbrk: "\u23B4",
|
|
tcaron: "\u0165",
|
|
tcedil: "\u0163",
|
|
tcy: "\u0442",
|
|
tdot: "\u20DB",
|
|
telrec: "\u2315",
|
|
tfr: "\u{1D531}",
|
|
there4: "\u2234",
|
|
therefore: "\u2234",
|
|
theta: "\u03B8",
|
|
thetasym: "\u03D1",
|
|
thetav: "\u03D1",
|
|
thickapprox: "\u2248",
|
|
thicksim: "\u223C",
|
|
thinsp: "\u2009",
|
|
thkap: "\u2248",
|
|
thksim: "\u223C",
|
|
thorn: "\xFE",
|
|
tilde: "\u02DC",
|
|
times: "\xD7",
|
|
timesb: "\u22A0",
|
|
timesbar: "\u2A31",
|
|
timesd: "\u2A30",
|
|
tint: "\u222D",
|
|
toea: "\u2928",
|
|
top: "\u22A4",
|
|
topbot: "\u2336",
|
|
topcir: "\u2AF1",
|
|
topf: "\u{1D565}",
|
|
topfork: "\u2ADA",
|
|
tosa: "\u2929",
|
|
tprime: "\u2034",
|
|
trade: "\u2122",
|
|
triangle: "\u25B5",
|
|
triangledown: "\u25BF",
|
|
triangleleft: "\u25C3",
|
|
trianglelefteq: "\u22B4",
|
|
triangleq: "\u225C",
|
|
triangleright: "\u25B9",
|
|
trianglerighteq: "\u22B5",
|
|
tridot: "\u25EC",
|
|
trie: "\u225C",
|
|
triminus: "\u2A3A",
|
|
triplus: "\u2A39",
|
|
trisb: "\u29CD",
|
|
tritime: "\u2A3B",
|
|
trpezium: "\u23E2",
|
|
tscr: "\u{1D4C9}",
|
|
tscy: "\u0446",
|
|
tshcy: "\u045B",
|
|
tstrok: "\u0167",
|
|
twixt: "\u226C",
|
|
twoheadleftarrow: "\u219E",
|
|
twoheadrightarrow: "\u21A0",
|
|
uArr: "\u21D1",
|
|
uHar: "\u2963",
|
|
uacute: "\xFA",
|
|
uarr: "\u2191",
|
|
ubrcy: "\u045E",
|
|
ubreve: "\u016D",
|
|
ucirc: "\xFB",
|
|
ucy: "\u0443",
|
|
udarr: "\u21C5",
|
|
udblac: "\u0171",
|
|
udhar: "\u296E",
|
|
ufisht: "\u297E",
|
|
ufr: "\u{1D532}",
|
|
ugrave: "\xF9",
|
|
uharl: "\u21BF",
|
|
uharr: "\u21BE",
|
|
uhblk: "\u2580",
|
|
ulcorn: "\u231C",
|
|
ulcorner: "\u231C",
|
|
ulcrop: "\u230F",
|
|
ultri: "\u25F8",
|
|
umacr: "\u016B",
|
|
uml: "\xA8",
|
|
uogon: "\u0173",
|
|
uopf: "\u{1D566}",
|
|
uparrow: "\u2191",
|
|
updownarrow: "\u2195",
|
|
upharpoonleft: "\u21BF",
|
|
upharpoonright: "\u21BE",
|
|
uplus: "\u228E",
|
|
upsi: "\u03C5",
|
|
upsih: "\u03D2",
|
|
upsilon: "\u03C5",
|
|
upuparrows: "\u21C8",
|
|
urcorn: "\u231D",
|
|
urcorner: "\u231D",
|
|
urcrop: "\u230E",
|
|
uring: "\u016F",
|
|
urtri: "\u25F9",
|
|
uscr: "\u{1D4CA}",
|
|
utdot: "\u22F0",
|
|
utilde: "\u0169",
|
|
utri: "\u25B5",
|
|
utrif: "\u25B4",
|
|
uuarr: "\u21C8",
|
|
uuml: "\xFC",
|
|
uwangle: "\u29A7",
|
|
vArr: "\u21D5",
|
|
vBar: "\u2AE8",
|
|
vBarv: "\u2AE9",
|
|
vDash: "\u22A8",
|
|
vangrt: "\u299C",
|
|
varepsilon: "\u03F5",
|
|
varkappa: "\u03F0",
|
|
varnothing: "\u2205",
|
|
varphi: "\u03D5",
|
|
varpi: "\u03D6",
|
|
varpropto: "\u221D",
|
|
varr: "\u2195",
|
|
varrho: "\u03F1",
|
|
varsigma: "\u03C2",
|
|
varsubsetneq: "\u228A\uFE00",
|
|
varsubsetneqq: "\u2ACB\uFE00",
|
|
varsupsetneq: "\u228B\uFE00",
|
|
varsupsetneqq: "\u2ACC\uFE00",
|
|
vartheta: "\u03D1",
|
|
vartriangleleft: "\u22B2",
|
|
vartriangleright: "\u22B3",
|
|
vcy: "\u0432",
|
|
vdash: "\u22A2",
|
|
vee: "\u2228",
|
|
veebar: "\u22BB",
|
|
veeeq: "\u225A",
|
|
vellip: "\u22EE",
|
|
verbar: "|",
|
|
vert: "|",
|
|
vfr: "\u{1D533}",
|
|
vltri: "\u22B2",
|
|
vnsub: "\u2282\u20D2",
|
|
vnsup: "\u2283\u20D2",
|
|
vopf: "\u{1D567}",
|
|
vprop: "\u221D",
|
|
vrtri: "\u22B3",
|
|
vscr: "\u{1D4CB}",
|
|
vsubnE: "\u2ACB\uFE00",
|
|
vsubne: "\u228A\uFE00",
|
|
vsupnE: "\u2ACC\uFE00",
|
|
vsupne: "\u228B\uFE00",
|
|
vzigzag: "\u299A",
|
|
wcirc: "\u0175",
|
|
wedbar: "\u2A5F",
|
|
wedge: "\u2227",
|
|
wedgeq: "\u2259",
|
|
weierp: "\u2118",
|
|
wfr: "\u{1D534}",
|
|
wopf: "\u{1D568}",
|
|
wp: "\u2118",
|
|
wr: "\u2240",
|
|
wreath: "\u2240",
|
|
wscr: "\u{1D4CC}",
|
|
xcap: "\u22C2",
|
|
xcirc: "\u25EF",
|
|
xcup: "\u22C3",
|
|
xdtri: "\u25BD",
|
|
xfr: "\u{1D535}",
|
|
xhArr: "\u27FA",
|
|
xharr: "\u27F7",
|
|
xi: "\u03BE",
|
|
xlArr: "\u27F8",
|
|
xlarr: "\u27F5",
|
|
xmap: "\u27FC",
|
|
xnis: "\u22FB",
|
|
xodot: "\u2A00",
|
|
xopf: "\u{1D569}",
|
|
xoplus: "\u2A01",
|
|
xotime: "\u2A02",
|
|
xrArr: "\u27F9",
|
|
xrarr: "\u27F6",
|
|
xscr: "\u{1D4CD}",
|
|
xsqcup: "\u2A06",
|
|
xuplus: "\u2A04",
|
|
xutri: "\u25B3",
|
|
xvee: "\u22C1",
|
|
xwedge: "\u22C0",
|
|
yacute: "\xFD",
|
|
yacy: "\u044F",
|
|
ycirc: "\u0177",
|
|
ycy: "\u044B",
|
|
yen: "\xA5",
|
|
yfr: "\u{1D536}",
|
|
yicy: "\u0457",
|
|
yopf: "\u{1D56A}",
|
|
yscr: "\u{1D4CE}",
|
|
yucy: "\u044E",
|
|
yuml: "\xFF",
|
|
zacute: "\u017A",
|
|
zcaron: "\u017E",
|
|
zcy: "\u0437",
|
|
zdot: "\u017C",
|
|
zeetrf: "\u2128",
|
|
zeta: "\u03B6",
|
|
zfr: "\u{1D537}",
|
|
zhcy: "\u0436",
|
|
zigrarr: "\u21DD",
|
|
zopf: "\u{1D56B}",
|
|
zscr: "\u{1D4CF}",
|
|
zwj: "\u200D",
|
|
zwnj: "\u200C"
|
|
};
|
|
|
|
// node_modules/decode-named-character-reference/index.js
|
|
var own = {}.hasOwnProperty;
|
|
function decodeNamedCharacterReference(value) {
|
|
return own.call(characterEntities, value) ? characterEntities[value] : false;
|
|
}
|
|
|
|
// node_modules/micromark-util-normalize-identifier/index.js
|
|
function normalizeIdentifier(value) {
|
|
return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm-footnote/lib/syntax.js
|
|
var indent = {
|
|
tokenize: tokenizeIndent,
|
|
partial: true
|
|
};
|
|
function gfmFootnote() {
|
|
return {
|
|
document: {
|
|
[91]: {
|
|
tokenize: tokenizeDefinitionStart,
|
|
continuation: {
|
|
tokenize: tokenizeDefinitionContinuation
|
|
},
|
|
exit: gfmFootnoteDefinitionEnd
|
|
}
|
|
},
|
|
text: {
|
|
[91]: {
|
|
tokenize: tokenizeGfmFootnoteCall
|
|
},
|
|
[93]: {
|
|
add: "after",
|
|
tokenize: tokenizePotentialGfmFootnoteCall,
|
|
resolveTo: resolveToPotentialGfmFootnoteCall
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function tokenizePotentialGfmFootnoteCall(effects, ok2, nok) {
|
|
const self = this;
|
|
let index = self.events.length;
|
|
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
|
|
let labelStart;
|
|
while (index--) {
|
|
const token = self.events[index][1];
|
|
if (token.type === "labelImage") {
|
|
labelStart = token;
|
|
break;
|
|
}
|
|
if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") {
|
|
break;
|
|
}
|
|
}
|
|
return start;
|
|
function start(code2) {
|
|
if (!labelStart || !labelStart._balanced) {
|
|
return nok(code2);
|
|
}
|
|
const id = normalizeIdentifier(
|
|
self.sliceSerialize({
|
|
start: labelStart.end,
|
|
end: self.now()
|
|
})
|
|
);
|
|
if (id.charCodeAt(0) !== 94 || !defined.includes(id.slice(1))) {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("gfmFootnoteCallLabelMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteCallLabelMarker");
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
function resolveToPotentialGfmFootnoteCall(events, context) {
|
|
let index = events.length;
|
|
let labelStart;
|
|
while (index--) {
|
|
if (events[index][1].type === "labelImage" && events[index][0] === "enter") {
|
|
labelStart = events[index][1];
|
|
break;
|
|
}
|
|
}
|
|
events[index + 1][1].type = "data";
|
|
events[index + 3][1].type = "gfmFootnoteCallLabelMarker";
|
|
const call = {
|
|
type: "gfmFootnoteCall",
|
|
start: Object.assign({}, events[index + 3][1].start),
|
|
end: Object.assign({}, events[events.length - 1][1].end)
|
|
};
|
|
const marker = {
|
|
type: "gfmFootnoteCallMarker",
|
|
start: Object.assign({}, events[index + 3][1].end),
|
|
end: Object.assign({}, events[index + 3][1].end)
|
|
};
|
|
marker.end.column++;
|
|
marker.end.offset++;
|
|
marker.end._bufferIndex++;
|
|
const string = {
|
|
type: "gfmFootnoteCallString",
|
|
start: Object.assign({}, marker.end),
|
|
end: Object.assign({}, events[events.length - 1][1].start)
|
|
};
|
|
const chunk = {
|
|
type: "chunkString",
|
|
contentType: "string",
|
|
start: Object.assign({}, string.start),
|
|
end: Object.assign({}, string.end)
|
|
};
|
|
const replacement = [
|
|
events[index + 1],
|
|
events[index + 2],
|
|
["enter", call, context],
|
|
events[index + 3],
|
|
events[index + 4],
|
|
["enter", marker, context],
|
|
["exit", marker, context],
|
|
["enter", string, context],
|
|
["enter", chunk, context],
|
|
["exit", chunk, context],
|
|
["exit", string, context],
|
|
events[events.length - 2],
|
|
events[events.length - 1],
|
|
["exit", call, context]
|
|
];
|
|
events.splice(index, events.length - index + 1, ...replacement);
|
|
return events;
|
|
}
|
|
function tokenizeGfmFootnoteCall(effects, ok2, nok) {
|
|
const self = this;
|
|
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
|
|
let size = 0;
|
|
let data;
|
|
return start;
|
|
function start(code2) {
|
|
effects.enter("gfmFootnoteCall");
|
|
effects.enter("gfmFootnoteCallLabelMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteCallLabelMarker");
|
|
return callStart;
|
|
}
|
|
function callStart(code2) {
|
|
if (code2 !== 94)
|
|
return nok(code2);
|
|
effects.enter("gfmFootnoteCallMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteCallMarker");
|
|
effects.enter("gfmFootnoteCallString");
|
|
effects.enter("chunkString").contentType = "string";
|
|
return callData;
|
|
}
|
|
function callData(code2) {
|
|
let token;
|
|
if (code2 === null || code2 === 91 || size++ > 999) {
|
|
return nok(code2);
|
|
}
|
|
if (code2 === 93) {
|
|
if (!data) {
|
|
return nok(code2);
|
|
}
|
|
effects.exit("chunkString");
|
|
token = effects.exit("gfmFootnoteCallString");
|
|
return defined.includes(normalizeIdentifier(self.sliceSerialize(token))) ? end(code2) : nok(code2);
|
|
}
|
|
effects.consume(code2);
|
|
if (!markdownLineEndingOrSpace(code2)) {
|
|
data = true;
|
|
}
|
|
return code2 === 92 ? callEscape : callData;
|
|
}
|
|
function callEscape(code2) {
|
|
if (code2 === 91 || code2 === 92 || code2 === 93) {
|
|
effects.consume(code2);
|
|
size++;
|
|
return callData;
|
|
}
|
|
return callData(code2);
|
|
}
|
|
function end(code2) {
|
|
effects.enter("gfmFootnoteCallLabelMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteCallLabelMarker");
|
|
effects.exit("gfmFootnoteCall");
|
|
return ok2;
|
|
}
|
|
}
|
|
function tokenizeDefinitionStart(effects, ok2, nok) {
|
|
const self = this;
|
|
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
|
|
let identifier;
|
|
let size = 0;
|
|
let data;
|
|
return start;
|
|
function start(code2) {
|
|
effects.enter("gfmFootnoteDefinition")._container = true;
|
|
effects.enter("gfmFootnoteDefinitionLabel");
|
|
effects.enter("gfmFootnoteDefinitionLabelMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteDefinitionLabelMarker");
|
|
return labelStart;
|
|
}
|
|
function labelStart(code2) {
|
|
if (code2 === 94) {
|
|
effects.enter("gfmFootnoteDefinitionMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteDefinitionMarker");
|
|
effects.enter("gfmFootnoteDefinitionLabelString");
|
|
return atBreak;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function atBreak(code2) {
|
|
let token;
|
|
if (code2 === null || code2 === 91 || size > 999) {
|
|
return nok(code2);
|
|
}
|
|
if (code2 === 93) {
|
|
if (!data) {
|
|
return nok(code2);
|
|
}
|
|
token = effects.exit("gfmFootnoteDefinitionLabelString");
|
|
identifier = normalizeIdentifier(self.sliceSerialize(token));
|
|
effects.enter("gfmFootnoteDefinitionLabelMarker");
|
|
effects.consume(code2);
|
|
effects.exit("gfmFootnoteDefinitionLabelMarker");
|
|
effects.exit("gfmFootnoteDefinitionLabel");
|
|
return labelAfter;
|
|
}
|
|
if (markdownLineEnding(code2)) {
|
|
effects.enter("lineEnding");
|
|
effects.consume(code2);
|
|
effects.exit("lineEnding");
|
|
size++;
|
|
return atBreak;
|
|
}
|
|
effects.enter("chunkString").contentType = "string";
|
|
return label(code2);
|
|
}
|
|
function label(code2) {
|
|
if (code2 === null || markdownLineEnding(code2) || code2 === 91 || code2 === 93 || size > 999) {
|
|
effects.exit("chunkString");
|
|
return atBreak(code2);
|
|
}
|
|
if (!markdownLineEndingOrSpace(code2)) {
|
|
data = true;
|
|
}
|
|
size++;
|
|
effects.consume(code2);
|
|
return code2 === 92 ? labelEscape : label;
|
|
}
|
|
function labelEscape(code2) {
|
|
if (code2 === 91 || code2 === 92 || code2 === 93) {
|
|
effects.consume(code2);
|
|
size++;
|
|
return label;
|
|
}
|
|
return label(code2);
|
|
}
|
|
function labelAfter(code2) {
|
|
if (code2 === 58) {
|
|
effects.enter("definitionMarker");
|
|
effects.consume(code2);
|
|
effects.exit("definitionMarker");
|
|
return factorySpace(effects, done, "gfmFootnoteDefinitionWhitespace");
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function done(code2) {
|
|
if (!defined.includes(identifier)) {
|
|
defined.push(identifier);
|
|
}
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
function tokenizeDefinitionContinuation(effects, ok2, nok) {
|
|
return effects.check(blankLine, ok2, effects.attempt(indent, ok2, nok));
|
|
}
|
|
function gfmFootnoteDefinitionEnd(effects) {
|
|
effects.exit("gfmFootnoteDefinition");
|
|
}
|
|
function tokenizeIndent(effects, ok2, nok) {
|
|
const self = this;
|
|
return factorySpace(
|
|
effects,
|
|
afterPrefix,
|
|
"gfmFootnoteDefinitionIndent",
|
|
4 + 1
|
|
);
|
|
function afterPrefix(code2) {
|
|
const tail = self.events[self.events.length - 1];
|
|
return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok2(code2) : nok(code2);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js
|
|
function gfmStrikethrough(options = {}) {
|
|
let single = options.singleTilde;
|
|
const tokenizer = {
|
|
tokenize: tokenizeStrikethrough,
|
|
resolveAll: resolveAllStrikethrough
|
|
};
|
|
if (single === null || single === void 0) {
|
|
single = true;
|
|
}
|
|
return {
|
|
text: {
|
|
[126]: tokenizer
|
|
},
|
|
insideSpan: {
|
|
null: [tokenizer]
|
|
},
|
|
attentionMarkers: {
|
|
null: [126]
|
|
}
|
|
};
|
|
function resolveAllStrikethrough(events, context) {
|
|
let index = -1;
|
|
while (++index < events.length) {
|
|
if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) {
|
|
let open = index;
|
|
while (open--) {
|
|
if (events[open][0] === "exit" && events[open][1].type === "strikethroughSequenceTemporary" && events[open][1]._open && events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {
|
|
events[index][1].type = "strikethroughSequence";
|
|
events[open][1].type = "strikethroughSequence";
|
|
const strikethrough = {
|
|
type: "strikethrough",
|
|
start: Object.assign({}, events[open][1].start),
|
|
end: Object.assign({}, events[index][1].end)
|
|
};
|
|
const text2 = {
|
|
type: "strikethroughText",
|
|
start: Object.assign({}, events[open][1].end),
|
|
end: Object.assign({}, events[index][1].start)
|
|
};
|
|
const nextEvents = [
|
|
["enter", strikethrough, context],
|
|
["enter", events[open][1], context],
|
|
["exit", events[open][1], context],
|
|
["enter", text2, context]
|
|
];
|
|
splice(
|
|
nextEvents,
|
|
nextEvents.length,
|
|
0,
|
|
resolveAll(
|
|
context.parser.constructs.insideSpan.null,
|
|
events.slice(open + 1, index),
|
|
context
|
|
)
|
|
);
|
|
splice(nextEvents, nextEvents.length, 0, [
|
|
["exit", text2, context],
|
|
["enter", events[index][1], context],
|
|
["exit", events[index][1], context],
|
|
["exit", strikethrough, context]
|
|
]);
|
|
splice(events, open - 1, index - open + 3, nextEvents);
|
|
index = open + nextEvents.length - 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
index = -1;
|
|
while (++index < events.length) {
|
|
if (events[index][1].type === "strikethroughSequenceTemporary") {
|
|
events[index][1].type = "data";
|
|
}
|
|
}
|
|
return events;
|
|
}
|
|
function tokenizeStrikethrough(effects, ok2, nok) {
|
|
const previous2 = this.previous;
|
|
const events = this.events;
|
|
let size = 0;
|
|
return start;
|
|
function start(code2) {
|
|
if (previous2 === 126 && events[events.length - 1][1].type !== "characterEscape") {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("strikethroughSequenceTemporary");
|
|
return more(code2);
|
|
}
|
|
function more(code2) {
|
|
const before = classifyCharacter(previous2);
|
|
if (code2 === 126) {
|
|
if (size > 1)
|
|
return nok(code2);
|
|
effects.consume(code2);
|
|
size++;
|
|
return more;
|
|
}
|
|
if (size < 2 && !single)
|
|
return nok(code2);
|
|
const token = effects.exit("strikethroughSequenceTemporary");
|
|
const after = classifyCharacter(code2);
|
|
token._open = !after || after === 2 && Boolean(before);
|
|
token._close = !before || before === 2 && Boolean(after);
|
|
return ok2(code2);
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm-table/lib/syntax.js
|
|
var gfmTable = {
|
|
flow: {
|
|
null: {
|
|
tokenize: tokenizeTable,
|
|
resolve: resolveTable
|
|
}
|
|
}
|
|
};
|
|
var nextPrefixedOrBlank = {
|
|
tokenize: tokenizeNextPrefixedOrBlank,
|
|
partial: true
|
|
};
|
|
function resolveTable(events, context) {
|
|
let index = -1;
|
|
let inHead;
|
|
let inDelimiterRow;
|
|
let inRow;
|
|
let contentStart;
|
|
let contentEnd;
|
|
let cellStart;
|
|
let seenCellInRow;
|
|
while (++index < events.length) {
|
|
const token = events[index][1];
|
|
if (inRow) {
|
|
if (token.type === "temporaryTableCellContent") {
|
|
contentStart = contentStart || index;
|
|
contentEnd = index;
|
|
}
|
|
if ((token.type === "tableCellDivider" || token.type === "tableRow") && contentEnd) {
|
|
const content = {
|
|
type: "tableContent",
|
|
start: events[contentStart][1].start,
|
|
end: events[contentEnd][1].end
|
|
};
|
|
const text2 = {
|
|
type: "chunkText",
|
|
start: content.start,
|
|
end: content.end,
|
|
contentType: "text"
|
|
};
|
|
events.splice(
|
|
contentStart,
|
|
contentEnd - contentStart + 1,
|
|
["enter", content, context],
|
|
["enter", text2, context],
|
|
["exit", text2, context],
|
|
["exit", content, context]
|
|
);
|
|
index -= contentEnd - contentStart - 3;
|
|
contentStart = void 0;
|
|
contentEnd = void 0;
|
|
}
|
|
}
|
|
if (events[index][0] === "exit" && cellStart !== void 0 && cellStart + (seenCellInRow ? 0 : 1) < index && (token.type === "tableCellDivider" || token.type === "tableRow" && (cellStart + 3 < index || events[cellStart][1].type !== "whitespace"))) {
|
|
const cell = {
|
|
type: inDelimiterRow ? "tableDelimiter" : inHead ? "tableHeader" : "tableData",
|
|
start: events[cellStart][1].start,
|
|
end: events[index][1].end
|
|
};
|
|
events.splice(index + (token.type === "tableCellDivider" ? 1 : 0), 0, [
|
|
"exit",
|
|
cell,
|
|
context
|
|
]);
|
|
events.splice(cellStart, 0, ["enter", cell, context]);
|
|
index += 2;
|
|
cellStart = index + 1;
|
|
seenCellInRow = true;
|
|
}
|
|
if (token.type === "tableRow") {
|
|
inRow = events[index][0] === "enter";
|
|
if (inRow) {
|
|
cellStart = index + 1;
|
|
seenCellInRow = false;
|
|
}
|
|
}
|
|
if (token.type === "tableDelimiterRow") {
|
|
inDelimiterRow = events[index][0] === "enter";
|
|
if (inDelimiterRow) {
|
|
cellStart = index + 1;
|
|
seenCellInRow = false;
|
|
}
|
|
}
|
|
if (token.type === "tableHead") {
|
|
inHead = events[index][0] === "enter";
|
|
}
|
|
}
|
|
return events;
|
|
}
|
|
function tokenizeTable(effects, ok2, nok) {
|
|
const self = this;
|
|
const align = [];
|
|
let tableHeaderCount = 0;
|
|
let seenDelimiter;
|
|
let hasDash;
|
|
return start;
|
|
function start(code2) {
|
|
effects.enter("table")._align = align;
|
|
effects.enter("tableHead");
|
|
effects.enter("tableRow");
|
|
if (code2 === 124) {
|
|
return cellDividerHead(code2);
|
|
}
|
|
tableHeaderCount++;
|
|
effects.enter("temporaryTableCellContent");
|
|
return inCellContentHead(code2);
|
|
}
|
|
function cellDividerHead(code2) {
|
|
effects.enter("tableCellDivider");
|
|
effects.consume(code2);
|
|
effects.exit("tableCellDivider");
|
|
seenDelimiter = true;
|
|
return cellBreakHead;
|
|
}
|
|
function cellBreakHead(code2) {
|
|
if (code2 === null || markdownLineEnding(code2)) {
|
|
return atRowEndHead(code2);
|
|
}
|
|
if (markdownSpace(code2)) {
|
|
effects.enter("whitespace");
|
|
effects.consume(code2);
|
|
return inWhitespaceHead;
|
|
}
|
|
if (seenDelimiter) {
|
|
seenDelimiter = void 0;
|
|
tableHeaderCount++;
|
|
}
|
|
if (code2 === 124) {
|
|
return cellDividerHead(code2);
|
|
}
|
|
effects.enter("temporaryTableCellContent");
|
|
return inCellContentHead(code2);
|
|
}
|
|
function inWhitespaceHead(code2) {
|
|
if (markdownSpace(code2)) {
|
|
effects.consume(code2);
|
|
return inWhitespaceHead;
|
|
}
|
|
effects.exit("whitespace");
|
|
return cellBreakHead(code2);
|
|
}
|
|
function inCellContentHead(code2) {
|
|
if (code2 === null || code2 === 124 || markdownLineEndingOrSpace(code2)) {
|
|
effects.exit("temporaryTableCellContent");
|
|
return cellBreakHead(code2);
|
|
}
|
|
effects.consume(code2);
|
|
return code2 === 92 ? inCellContentEscapeHead : inCellContentHead;
|
|
}
|
|
function inCellContentEscapeHead(code2) {
|
|
if (code2 === 92 || code2 === 124) {
|
|
effects.consume(code2);
|
|
return inCellContentHead;
|
|
}
|
|
return inCellContentHead(code2);
|
|
}
|
|
function atRowEndHead(code2) {
|
|
if (code2 === null) {
|
|
return nok(code2);
|
|
}
|
|
effects.exit("tableRow");
|
|
effects.exit("tableHead");
|
|
const originalInterrupt = self.interrupt;
|
|
self.interrupt = true;
|
|
return effects.attempt(
|
|
{
|
|
tokenize: tokenizeRowEnd,
|
|
partial: true
|
|
},
|
|
function(code3) {
|
|
self.interrupt = originalInterrupt;
|
|
effects.enter("tableDelimiterRow");
|
|
return atDelimiterRowBreak(code3);
|
|
},
|
|
function(code3) {
|
|
self.interrupt = originalInterrupt;
|
|
return nok(code3);
|
|
}
|
|
)(code2);
|
|
}
|
|
function atDelimiterRowBreak(code2) {
|
|
if (code2 === null || markdownLineEnding(code2)) {
|
|
return rowEndDelimiter(code2);
|
|
}
|
|
if (markdownSpace(code2)) {
|
|
effects.enter("whitespace");
|
|
effects.consume(code2);
|
|
return inWhitespaceDelimiter;
|
|
}
|
|
if (code2 === 45) {
|
|
effects.enter("tableDelimiterFiller");
|
|
effects.consume(code2);
|
|
hasDash = true;
|
|
align.push("none");
|
|
return inFillerDelimiter;
|
|
}
|
|
if (code2 === 58) {
|
|
effects.enter("tableDelimiterAlignment");
|
|
effects.consume(code2);
|
|
effects.exit("tableDelimiterAlignment");
|
|
align.push("left");
|
|
return afterLeftAlignment;
|
|
}
|
|
if (code2 === 124) {
|
|
effects.enter("tableCellDivider");
|
|
effects.consume(code2);
|
|
effects.exit("tableCellDivider");
|
|
return atDelimiterRowBreak;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function inWhitespaceDelimiter(code2) {
|
|
if (markdownSpace(code2)) {
|
|
effects.consume(code2);
|
|
return inWhitespaceDelimiter;
|
|
}
|
|
effects.exit("whitespace");
|
|
return atDelimiterRowBreak(code2);
|
|
}
|
|
function inFillerDelimiter(code2) {
|
|
if (code2 === 45) {
|
|
effects.consume(code2);
|
|
return inFillerDelimiter;
|
|
}
|
|
effects.exit("tableDelimiterFiller");
|
|
if (code2 === 58) {
|
|
effects.enter("tableDelimiterAlignment");
|
|
effects.consume(code2);
|
|
effects.exit("tableDelimiterAlignment");
|
|
align[align.length - 1] = align[align.length - 1] === "left" ? "center" : "right";
|
|
return afterRightAlignment;
|
|
}
|
|
return atDelimiterRowBreak(code2);
|
|
}
|
|
function afterLeftAlignment(code2) {
|
|
if (code2 === 45) {
|
|
effects.enter("tableDelimiterFiller");
|
|
effects.consume(code2);
|
|
hasDash = true;
|
|
return inFillerDelimiter;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function afterRightAlignment(code2) {
|
|
if (code2 === null || markdownLineEnding(code2)) {
|
|
return rowEndDelimiter(code2);
|
|
}
|
|
if (markdownSpace(code2)) {
|
|
effects.enter("whitespace");
|
|
effects.consume(code2);
|
|
return inWhitespaceDelimiter;
|
|
}
|
|
if (code2 === 124) {
|
|
effects.enter("tableCellDivider");
|
|
effects.consume(code2);
|
|
effects.exit("tableCellDivider");
|
|
return atDelimiterRowBreak;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function rowEndDelimiter(code2) {
|
|
effects.exit("tableDelimiterRow");
|
|
if (!hasDash || tableHeaderCount !== align.length) {
|
|
return nok(code2);
|
|
}
|
|
if (code2 === null) {
|
|
return tableClose(code2);
|
|
}
|
|
return effects.check(
|
|
nextPrefixedOrBlank,
|
|
tableClose,
|
|
effects.attempt(
|
|
{
|
|
tokenize: tokenizeRowEnd,
|
|
partial: true
|
|
},
|
|
factorySpace(effects, bodyStart, "linePrefix", 4),
|
|
tableClose
|
|
)
|
|
)(code2);
|
|
}
|
|
function tableClose(code2) {
|
|
effects.exit("table");
|
|
return ok2(code2);
|
|
}
|
|
function bodyStart(code2) {
|
|
effects.enter("tableBody");
|
|
return rowStartBody(code2);
|
|
}
|
|
function rowStartBody(code2) {
|
|
effects.enter("tableRow");
|
|
if (code2 === 124) {
|
|
return cellDividerBody(code2);
|
|
}
|
|
effects.enter("temporaryTableCellContent");
|
|
return inCellContentBody(code2);
|
|
}
|
|
function cellDividerBody(code2) {
|
|
effects.enter("tableCellDivider");
|
|
effects.consume(code2);
|
|
effects.exit("tableCellDivider");
|
|
return cellBreakBody;
|
|
}
|
|
function cellBreakBody(code2) {
|
|
if (code2 === null || markdownLineEnding(code2)) {
|
|
return atRowEndBody(code2);
|
|
}
|
|
if (markdownSpace(code2)) {
|
|
effects.enter("whitespace");
|
|
effects.consume(code2);
|
|
return inWhitespaceBody;
|
|
}
|
|
if (code2 === 124) {
|
|
return cellDividerBody(code2);
|
|
}
|
|
effects.enter("temporaryTableCellContent");
|
|
return inCellContentBody(code2);
|
|
}
|
|
function inWhitespaceBody(code2) {
|
|
if (markdownSpace(code2)) {
|
|
effects.consume(code2);
|
|
return inWhitespaceBody;
|
|
}
|
|
effects.exit("whitespace");
|
|
return cellBreakBody(code2);
|
|
}
|
|
function inCellContentBody(code2) {
|
|
if (code2 === null || code2 === 124 || markdownLineEndingOrSpace(code2)) {
|
|
effects.exit("temporaryTableCellContent");
|
|
return cellBreakBody(code2);
|
|
}
|
|
effects.consume(code2);
|
|
return code2 === 92 ? inCellContentEscapeBody : inCellContentBody;
|
|
}
|
|
function inCellContentEscapeBody(code2) {
|
|
if (code2 === 92 || code2 === 124) {
|
|
effects.consume(code2);
|
|
return inCellContentBody;
|
|
}
|
|
return inCellContentBody(code2);
|
|
}
|
|
function atRowEndBody(code2) {
|
|
effects.exit("tableRow");
|
|
if (code2 === null) {
|
|
return tableBodyClose(code2);
|
|
}
|
|
return effects.check(
|
|
nextPrefixedOrBlank,
|
|
tableBodyClose,
|
|
effects.attempt(
|
|
{
|
|
tokenize: tokenizeRowEnd,
|
|
partial: true
|
|
},
|
|
factorySpace(effects, rowStartBody, "linePrefix", 4),
|
|
tableBodyClose
|
|
)
|
|
)(code2);
|
|
}
|
|
function tableBodyClose(code2) {
|
|
effects.exit("tableBody");
|
|
return tableClose(code2);
|
|
}
|
|
function tokenizeRowEnd(effects2, ok3, nok2) {
|
|
return start2;
|
|
function start2(code2) {
|
|
effects2.enter("lineEnding");
|
|
effects2.consume(code2);
|
|
effects2.exit("lineEnding");
|
|
return factorySpace(effects2, prefixed, "linePrefix");
|
|
}
|
|
function prefixed(code2) {
|
|
if (self.parser.lazy[self.now().line] || code2 === null || markdownLineEnding(code2)) {
|
|
return nok2(code2);
|
|
}
|
|
const tail = self.events[self.events.length - 1];
|
|
if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) {
|
|
return nok2(code2);
|
|
}
|
|
self._gfmTableDynamicInterruptHack = true;
|
|
return effects2.check(
|
|
self.parser.constructs.flow,
|
|
function(code3) {
|
|
self._gfmTableDynamicInterruptHack = false;
|
|
return nok2(code3);
|
|
},
|
|
function(code3) {
|
|
self._gfmTableDynamicInterruptHack = false;
|
|
return ok3(code3);
|
|
}
|
|
)(code2);
|
|
}
|
|
}
|
|
}
|
|
function tokenizeNextPrefixedOrBlank(effects, ok2, nok) {
|
|
let size = 0;
|
|
return start;
|
|
function start(code2) {
|
|
effects.enter("check");
|
|
effects.consume(code2);
|
|
return whitespace;
|
|
}
|
|
function whitespace(code2) {
|
|
if (code2 === -1 || code2 === 32) {
|
|
effects.consume(code2);
|
|
size++;
|
|
return size === 4 ? ok2 : whitespace;
|
|
}
|
|
if (code2 === null || markdownLineEndingOrSpace(code2)) {
|
|
return ok2(code2);
|
|
}
|
|
return nok(code2);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
|
|
var tasklistCheck = {
|
|
tokenize: tokenizeTasklistCheck
|
|
};
|
|
var gfmTaskListItem = {
|
|
text: {
|
|
[91]: tasklistCheck
|
|
}
|
|
};
|
|
function tokenizeTasklistCheck(effects, ok2, nok) {
|
|
const self = this;
|
|
return open;
|
|
function open(code2) {
|
|
if (self.previous !== null || !self._gfmTasklistFirstContentOfListItem) {
|
|
return nok(code2);
|
|
}
|
|
effects.enter("taskListCheck");
|
|
effects.enter("taskListCheckMarker");
|
|
effects.consume(code2);
|
|
effects.exit("taskListCheckMarker");
|
|
return inside;
|
|
}
|
|
function inside(code2) {
|
|
if (markdownLineEndingOrSpace(code2)) {
|
|
effects.enter("taskListCheckValueUnchecked");
|
|
effects.consume(code2);
|
|
effects.exit("taskListCheckValueUnchecked");
|
|
return close;
|
|
}
|
|
if (code2 === 88 || code2 === 120) {
|
|
effects.enter("taskListCheckValueChecked");
|
|
effects.consume(code2);
|
|
effects.exit("taskListCheckValueChecked");
|
|
return close;
|
|
}
|
|
return nok(code2);
|
|
}
|
|
function close(code2) {
|
|
if (code2 === 93) {
|
|
effects.enter("taskListCheckMarker");
|
|
effects.consume(code2);
|
|
effects.exit("taskListCheckMarker");
|
|
effects.exit("taskListCheck");
|
|
return effects.check(
|
|
{
|
|
tokenize: spaceThenNonSpace
|
|
},
|
|
ok2,
|
|
nok
|
|
);
|
|
}
|
|
return nok(code2);
|
|
}
|
|
}
|
|
function spaceThenNonSpace(effects, ok2, nok) {
|
|
const self = this;
|
|
return factorySpace(effects, after, "whitespace");
|
|
function after(code2) {
|
|
const tail = self.events[self.events.length - 1];
|
|
return (tail && tail[1].type === "whitespace" || markdownLineEnding(code2)) && code2 !== null ? ok2(code2) : nok(code2);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-gfm/index.js
|
|
function gfm(options) {
|
|
return combineExtensions([
|
|
gfmAutolinkLiteral,
|
|
gfmFootnote(),
|
|
gfmStrikethrough(options),
|
|
gfmTable,
|
|
gfmTaskListItem
|
|
]);
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-autolink-literal/node_modules/ccount/index.js
|
|
function ccount(value, character) {
|
|
const source = String(value);
|
|
if (typeof character !== "string") {
|
|
throw new TypeError("Expected character");
|
|
}
|
|
let count = 0;
|
|
let index = source.indexOf(character);
|
|
while (index !== -1) {
|
|
count++;
|
|
index = source.indexOf(character, index + character.length);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js
|
|
function escapeStringRegexp(string) {
|
|
if (typeof string !== "string") {
|
|
throw new TypeError("Expected a string");
|
|
}
|
|
return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
|
|
}
|
|
|
|
// node_modules/unist-util-is/index.js
|
|
var convert = function(test) {
|
|
if (test === void 0 || test === null) {
|
|
return ok;
|
|
}
|
|
if (typeof test === "string") {
|
|
return typeFactory(test);
|
|
}
|
|
if (typeof test === "object") {
|
|
return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
|
|
}
|
|
if (typeof test === "function") {
|
|
return castFactory(test);
|
|
}
|
|
throw new Error("Expected function, string, or object as test");
|
|
};
|
|
function anyFactory(tests) {
|
|
const checks = [];
|
|
let index = -1;
|
|
while (++index < tests.length) {
|
|
checks[index] = convert(tests[index]);
|
|
}
|
|
return castFactory(any);
|
|
function any(...parameters) {
|
|
let index2 = -1;
|
|
while (++index2 < checks.length) {
|
|
if (checks[index2].call(this, ...parameters))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function propsFactory(check) {
|
|
return castFactory(all);
|
|
function all(node) {
|
|
let key;
|
|
for (key in check) {
|
|
if (node[key] !== check[key])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function typeFactory(check) {
|
|
return castFactory(type);
|
|
function type(node) {
|
|
return node && node.type === check;
|
|
}
|
|
}
|
|
function castFactory(check) {
|
|
return assertion;
|
|
function assertion(...parameters) {
|
|
return Boolean(check.call(this, ...parameters));
|
|
}
|
|
}
|
|
function ok() {
|
|
return true;
|
|
}
|
|
|
|
// node_modules/unist-util-visit-parents/color.js
|
|
function color(d) {
|
|
return "\x1B[33m" + d + "\x1B[39m";
|
|
}
|
|
|
|
// node_modules/unist-util-visit-parents/index.js
|
|
var CONTINUE = true;
|
|
var SKIP = "skip";
|
|
var EXIT = false;
|
|
var visitParents = function(tree, test, visitor, reverse) {
|
|
if (typeof test === "function" && typeof visitor !== "function") {
|
|
reverse = visitor;
|
|
visitor = test;
|
|
test = null;
|
|
}
|
|
const is = convert(test);
|
|
const step = reverse ? -1 : 1;
|
|
factory(tree, null, [])();
|
|
function factory(node, index, parents) {
|
|
const value = typeof node === "object" && node !== null ? node : {};
|
|
let name;
|
|
if (typeof value.type === "string") {
|
|
name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : void 0;
|
|
Object.defineProperty(visit, "name", {
|
|
value: "node (" + color(value.type + (name ? "<" + name + ">" : "")) + ")"
|
|
});
|
|
}
|
|
return visit;
|
|
function visit() {
|
|
let result = [];
|
|
let subresult;
|
|
let offset;
|
|
let grandparents;
|
|
if (!test || is(node, index, parents[parents.length - 1] || null)) {
|
|
result = toResult(visitor(node, parents));
|
|
if (result[0] === EXIT) {
|
|
return result;
|
|
}
|
|
}
|
|
if (node.children && result[0] !== SKIP) {
|
|
offset = (reverse ? node.children.length : -1) + step;
|
|
grandparents = parents.concat(node);
|
|
while (offset > -1 && offset < node.children.length) {
|
|
subresult = factory(node.children[offset], offset, grandparents)();
|
|
if (subresult[0] === EXIT) {
|
|
return subresult;
|
|
}
|
|
offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
};
|
|
function toResult(value) {
|
|
if (Array.isArray(value)) {
|
|
return value;
|
|
}
|
|
if (typeof value === "number") {
|
|
return [CONTINUE, value];
|
|
}
|
|
return [value];
|
|
}
|
|
|
|
// node_modules/mdast-util-find-and-replace/lib/index.js
|
|
var own2 = {}.hasOwnProperty;
|
|
var findAndReplace = function(tree, find, replace2, options) {
|
|
let settings;
|
|
let schema;
|
|
if (typeof find === "string" || find instanceof RegExp) {
|
|
schema = [[find, replace2]];
|
|
settings = options;
|
|
} else {
|
|
schema = find;
|
|
settings = replace2;
|
|
}
|
|
if (!settings) {
|
|
settings = {};
|
|
}
|
|
const ignored = convert(settings.ignore || []);
|
|
const pairs = toPairs(schema);
|
|
let pairIndex = -1;
|
|
while (++pairIndex < pairs.length) {
|
|
visitParents(tree, "text", visitor);
|
|
}
|
|
return tree;
|
|
function visitor(node, parents) {
|
|
let index = -1;
|
|
let grandparent;
|
|
while (++index < parents.length) {
|
|
const parent = parents[index];
|
|
if (ignored(
|
|
parent,
|
|
grandparent ? grandparent.children.indexOf(parent) : void 0,
|
|
grandparent
|
|
)) {
|
|
return;
|
|
}
|
|
grandparent = parent;
|
|
}
|
|
if (grandparent) {
|
|
return handler(node, parents);
|
|
}
|
|
}
|
|
function handler(node, parents) {
|
|
const parent = parents[parents.length - 1];
|
|
const find2 = pairs[pairIndex][0];
|
|
const replace3 = pairs[pairIndex][1];
|
|
let start = 0;
|
|
const index = parent.children.indexOf(node);
|
|
let change = false;
|
|
let nodes = [];
|
|
let position;
|
|
find2.lastIndex = 0;
|
|
let match = find2.exec(node.value);
|
|
while (match) {
|
|
position = match.index;
|
|
const matchObject = {
|
|
index: match.index,
|
|
input: match.input,
|
|
stack: [...parents, node]
|
|
};
|
|
let value = replace3(...match, matchObject);
|
|
if (typeof value === "string") {
|
|
value = value.length > 0 ? { type: "text", value } : void 0;
|
|
}
|
|
if (value !== false) {
|
|
if (start !== position) {
|
|
nodes.push({
|
|
type: "text",
|
|
value: node.value.slice(start, position)
|
|
});
|
|
}
|
|
if (Array.isArray(value)) {
|
|
nodes.push(...value);
|
|
} else if (value) {
|
|
nodes.push(value);
|
|
}
|
|
start = position + match[0].length;
|
|
change = true;
|
|
}
|
|
if (!find2.global) {
|
|
break;
|
|
}
|
|
match = find2.exec(node.value);
|
|
}
|
|
if (change) {
|
|
if (start < node.value.length) {
|
|
nodes.push({ type: "text", value: node.value.slice(start) });
|
|
}
|
|
parent.children.splice(index, 1, ...nodes);
|
|
} else {
|
|
nodes = [node];
|
|
}
|
|
return index + nodes.length;
|
|
}
|
|
};
|
|
function toPairs(schema) {
|
|
const result = [];
|
|
if (typeof schema !== "object") {
|
|
throw new TypeError("Expected array or object as schema");
|
|
}
|
|
if (Array.isArray(schema)) {
|
|
let index = -1;
|
|
while (++index < schema.length) {
|
|
result.push([
|
|
toExpression(schema[index][0]),
|
|
toFunction(schema[index][1])
|
|
]);
|
|
}
|
|
} else {
|
|
let key;
|
|
for (key in schema) {
|
|
if (own2.call(schema, key)) {
|
|
result.push([toExpression(key), toFunction(schema[key])]);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function toExpression(find) {
|
|
return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
|
|
}
|
|
function toFunction(replace2) {
|
|
return typeof replace2 === "function" ? replace2 : () => replace2;
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-autolink-literal/index.js
|
|
var inConstruct = "phrasing";
|
|
var notInConstruct = ["autolink", "link", "image", "label"];
|
|
var gfmAutolinkLiteralFromMarkdown = {
|
|
transforms: [transformGfmAutolinkLiterals],
|
|
enter: {
|
|
literalAutolink: enterLiteralAutolink,
|
|
literalAutolinkEmail: enterLiteralAutolinkValue,
|
|
literalAutolinkHttp: enterLiteralAutolinkValue,
|
|
literalAutolinkWww: enterLiteralAutolinkValue
|
|
},
|
|
exit: {
|
|
literalAutolink: exitLiteralAutolink,
|
|
literalAutolinkEmail: exitLiteralAutolinkEmail,
|
|
literalAutolinkHttp: exitLiteralAutolinkHttp,
|
|
literalAutolinkWww: exitLiteralAutolinkWww
|
|
}
|
|
};
|
|
var gfmAutolinkLiteralToMarkdown = {
|
|
unsafe: [
|
|
{
|
|
character: "@",
|
|
before: "[+\\-.\\w]",
|
|
after: "[\\-.\\w]",
|
|
inConstruct,
|
|
notInConstruct
|
|
},
|
|
{
|
|
character: ".",
|
|
before: "[Ww]",
|
|
after: "[\\-.\\w]",
|
|
inConstruct,
|
|
notInConstruct
|
|
},
|
|
{ character: ":", before: "[ps]", after: "\\/", inConstruct, notInConstruct }
|
|
]
|
|
};
|
|
function enterLiteralAutolink(token) {
|
|
this.enter({ type: "link", title: null, url: "", children: [] }, token);
|
|
}
|
|
function enterLiteralAutolinkValue(token) {
|
|
this.config.enter.autolinkProtocol.call(this, token);
|
|
}
|
|
function exitLiteralAutolinkHttp(token) {
|
|
this.config.exit.autolinkProtocol.call(this, token);
|
|
}
|
|
function exitLiteralAutolinkWww(token) {
|
|
this.config.exit.data.call(this, token);
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.url = "http://" + this.sliceSerialize(token);
|
|
}
|
|
function exitLiteralAutolinkEmail(token) {
|
|
this.config.exit.autolinkEmail.call(this, token);
|
|
}
|
|
function exitLiteralAutolink(token) {
|
|
this.exit(token);
|
|
}
|
|
function transformGfmAutolinkLiterals(tree) {
|
|
findAndReplace(
|
|
tree,
|
|
[
|
|
[/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl],
|
|
[/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/g, findEmail]
|
|
],
|
|
{ ignore: ["link", "linkReference"] }
|
|
);
|
|
}
|
|
function findUrl(_, protocol, domain2, path2, match) {
|
|
let prefix = "";
|
|
if (!previous(match)) {
|
|
return false;
|
|
}
|
|
if (/^w/i.test(protocol)) {
|
|
domain2 = protocol + domain2;
|
|
protocol = "";
|
|
prefix = "http://";
|
|
}
|
|
if (!isCorrectDomain(domain2)) {
|
|
return false;
|
|
}
|
|
const parts = splitUrl(domain2 + path2);
|
|
if (!parts[0])
|
|
return false;
|
|
const result = {
|
|
type: "link",
|
|
title: null,
|
|
url: prefix + protocol + parts[0],
|
|
children: [{ type: "text", value: protocol + parts[0] }]
|
|
};
|
|
if (parts[1]) {
|
|
return [result, { type: "text", value: parts[1] }];
|
|
}
|
|
return result;
|
|
}
|
|
function findEmail(_, atext, label, match) {
|
|
if (!previous(match, true) || /[_-\d]$/.test(label)) {
|
|
return false;
|
|
}
|
|
return {
|
|
type: "link",
|
|
title: null,
|
|
url: "mailto:" + atext + "@" + label,
|
|
children: [{ type: "text", value: atext + "@" + label }]
|
|
};
|
|
}
|
|
function isCorrectDomain(domain2) {
|
|
const parts = domain2.split(".");
|
|
if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2]))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function splitUrl(url) {
|
|
const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
|
|
let closingParenIndex;
|
|
let openingParens;
|
|
let closingParens;
|
|
let trail;
|
|
if (trailExec) {
|
|
url = url.slice(0, trailExec.index);
|
|
trail = trailExec[0];
|
|
closingParenIndex = trail.indexOf(")");
|
|
openingParens = ccount(url, "(");
|
|
closingParens = ccount(url, ")");
|
|
while (closingParenIndex !== -1 && openingParens > closingParens) {
|
|
url += trail.slice(0, closingParenIndex + 1);
|
|
trail = trail.slice(closingParenIndex + 1);
|
|
closingParenIndex = trail.indexOf(")");
|
|
closingParens++;
|
|
}
|
|
}
|
|
return [url, trail];
|
|
}
|
|
function previous(match, email) {
|
|
const code2 = match.input.charCodeAt(match.index - 1);
|
|
return (match.index === 0 || unicodeWhitespace(code2) || unicodePunctuation(code2)) && (!email || code2 !== 47);
|
|
}
|
|
|
|
// node_modules/micromark-util-decode-numeric-character-reference/index.js
|
|
function decodeNumericCharacterReference(value, base) {
|
|
const code2 = Number.parseInt(value, base);
|
|
if (code2 < 9 || code2 === 11 || code2 > 13 && code2 < 32 || code2 > 126 && code2 < 160 || code2 > 55295 && code2 < 57344 || code2 > 64975 && code2 < 65008 || (code2 & 65535) === 65535 || (code2 & 65535) === 65534 || code2 > 1114111) {
|
|
return "\uFFFD";
|
|
}
|
|
return String.fromCharCode(code2);
|
|
}
|
|
|
|
// node_modules/micromark-util-decode-string/index.js
|
|
var characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
|
|
function decodeString(value) {
|
|
return value.replace(characterEscapeOrReference, decode);
|
|
}
|
|
function decode($0, $1, $2) {
|
|
if ($1) {
|
|
return $1;
|
|
}
|
|
const head = $2.charCodeAt(0);
|
|
if (head === 35) {
|
|
const head2 = $2.charCodeAt(1);
|
|
const hex = head2 === 120 || head2 === 88;
|
|
return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);
|
|
}
|
|
return decodeNamedCharacterReference($2) || $0;
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/association.js
|
|
function association(node) {
|
|
if (node.label || !node.identifier) {
|
|
return node.label || "";
|
|
}
|
|
return decodeString(node.identifier);
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/track.js
|
|
function track(options_) {
|
|
const options = options_ || {};
|
|
const now = options.now || {};
|
|
let lineShift = options.lineShift || 0;
|
|
let line = now.line || 1;
|
|
let column = now.column || 1;
|
|
return { move, current, shift };
|
|
function current() {
|
|
return { now: { line, column }, lineShift };
|
|
}
|
|
function shift(value) {
|
|
lineShift += value;
|
|
}
|
|
function move(value = "") {
|
|
const chunks = value.split(/\r?\n|\r/g);
|
|
const tail = chunks[chunks.length - 1];
|
|
line += chunks.length - 1;
|
|
column = chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift;
|
|
return value;
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/container-flow.js
|
|
function containerFlow(parent, context, safeOptions) {
|
|
const indexStack = context.indexStack;
|
|
const children = parent.children || [];
|
|
const tracker = track(safeOptions);
|
|
const results = [];
|
|
let index = -1;
|
|
indexStack.push(-1);
|
|
while (++index < children.length) {
|
|
const child = children[index];
|
|
indexStack[indexStack.length - 1] = index;
|
|
results.push(
|
|
tracker.move(
|
|
context.handle(child, parent, context, {
|
|
before: "\n",
|
|
after: "\n",
|
|
...tracker.current()
|
|
})
|
|
)
|
|
);
|
|
if (child.type !== "list") {
|
|
context.bulletLastUsed = void 0;
|
|
}
|
|
if (index < children.length - 1) {
|
|
results.push(tracker.move(between(child, children[index + 1])));
|
|
}
|
|
}
|
|
indexStack.pop();
|
|
return results.join("");
|
|
function between(left, right) {
|
|
let index2 = context.join.length;
|
|
while (index2--) {
|
|
const result = context.join[index2](left, right, parent, context);
|
|
if (result === true || result === 1) {
|
|
break;
|
|
}
|
|
if (typeof result === "number") {
|
|
return "\n".repeat(1 + result);
|
|
}
|
|
if (result === false) {
|
|
return "\n\n<!---->\n\n";
|
|
}
|
|
}
|
|
return "\n\n";
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
|
|
var eol = /\r?\n|\r/g;
|
|
function indentLines(value, map) {
|
|
const result = [];
|
|
let start = 0;
|
|
let line = 0;
|
|
let match;
|
|
while (match = eol.exec(value)) {
|
|
one(value.slice(start, match.index));
|
|
result.push(match[0]);
|
|
start = match.index + match[0].length;
|
|
line++;
|
|
}
|
|
one(value.slice(start));
|
|
return result.join("");
|
|
function one(value2) {
|
|
result.push(map(value2, line, !value2));
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js
|
|
function patternCompile(pattern) {
|
|
if (!pattern._compiled) {
|
|
const before = (pattern.atBreak ? "[\\r\\n][\\t ]*" : "") + (pattern.before ? "(?:" + pattern.before + ")" : "");
|
|
pattern._compiled = new RegExp(
|
|
(before ? "(" + before + ")" : "") + (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? "\\" : "") + pattern.character + (pattern.after ? "(?:" + pattern.after + ")" : ""),
|
|
"g"
|
|
);
|
|
}
|
|
return pattern._compiled;
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
|
|
function patternInScope(stack, pattern) {
|
|
return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
|
|
}
|
|
function listInScope(stack, list, none) {
|
|
if (!list) {
|
|
return none;
|
|
}
|
|
if (typeof list === "string") {
|
|
list = [list];
|
|
}
|
|
let index = -1;
|
|
while (++index < list.length) {
|
|
if (stack.includes(list[index])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/safe.js
|
|
function safe(context, input, config) {
|
|
const value = (config.before || "") + (input || "") + (config.after || "");
|
|
const positions = [];
|
|
const result = [];
|
|
const infos = {};
|
|
let index = -1;
|
|
while (++index < context.unsafe.length) {
|
|
const pattern = context.unsafe[index];
|
|
if (!patternInScope(context.stack, pattern)) {
|
|
continue;
|
|
}
|
|
const expression = patternCompile(pattern);
|
|
let match;
|
|
while (match = expression.exec(value)) {
|
|
const before = "before" in pattern || Boolean(pattern.atBreak);
|
|
const after = "after" in pattern;
|
|
const position = match.index + (before ? match[1].length : 0);
|
|
if (positions.includes(position)) {
|
|
if (infos[position].before && !before) {
|
|
infos[position].before = false;
|
|
}
|
|
if (infos[position].after && !after) {
|
|
infos[position].after = false;
|
|
}
|
|
} else {
|
|
positions.push(position);
|
|
infos[position] = { before, after };
|
|
}
|
|
}
|
|
}
|
|
positions.sort(numerical);
|
|
let start = config.before ? config.before.length : 0;
|
|
const end = value.length - (config.after ? config.after.length : 0);
|
|
index = -1;
|
|
while (++index < positions.length) {
|
|
const position = positions[index];
|
|
if (position < start || position >= end) {
|
|
continue;
|
|
}
|
|
if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) {
|
|
continue;
|
|
}
|
|
if (start !== position) {
|
|
result.push(escapeBackslashes(value.slice(start, position), "\\"));
|
|
}
|
|
start = position;
|
|
if (/[!-/:-@[-`{-~]/.test(value.charAt(position)) && (!config.encode || !config.encode.includes(value.charAt(position)))) {
|
|
result.push("\\");
|
|
} else {
|
|
result.push(
|
|
"&#x" + value.charCodeAt(position).toString(16).toUpperCase() + ";"
|
|
);
|
|
start++;
|
|
}
|
|
}
|
|
result.push(escapeBackslashes(value.slice(start, end), config.after));
|
|
return result.join("");
|
|
}
|
|
function numerical(a, b) {
|
|
return a - b;
|
|
}
|
|
function escapeBackslashes(value, after) {
|
|
const expression = /\\(?=[!-/:-@[-`{-~])/g;
|
|
const positions = [];
|
|
const results = [];
|
|
const whole = value + after;
|
|
let index = -1;
|
|
let start = 0;
|
|
let match;
|
|
while (match = expression.exec(whole)) {
|
|
positions.push(match.index);
|
|
}
|
|
while (++index < positions.length) {
|
|
if (start !== positions[index]) {
|
|
results.push(value.slice(start, positions[index]));
|
|
}
|
|
results.push("\\");
|
|
start = positions[index];
|
|
}
|
|
results.push(value.slice(start));
|
|
return results.join("");
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-footnote/index.js
|
|
function gfmFootnoteFromMarkdown() {
|
|
return {
|
|
enter: {
|
|
gfmFootnoteDefinition: enterFootnoteDefinition,
|
|
gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
|
|
gfmFootnoteCall: enterFootnoteCall,
|
|
gfmFootnoteCallString: enterFootnoteCallString
|
|
},
|
|
exit: {
|
|
gfmFootnoteDefinition: exitFootnoteDefinition,
|
|
gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
|
|
gfmFootnoteCall: exitFootnoteCall,
|
|
gfmFootnoteCallString: exitFootnoteCallString
|
|
}
|
|
};
|
|
function enterFootnoteDefinition(token) {
|
|
this.enter(
|
|
{ type: "footnoteDefinition", identifier: "", label: "", children: [] },
|
|
token
|
|
);
|
|
}
|
|
function enterFootnoteDefinitionLabelString() {
|
|
this.buffer();
|
|
}
|
|
function exitFootnoteDefinitionLabelString(token) {
|
|
const label = this.resume();
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.label = label;
|
|
node.identifier = normalizeIdentifier(
|
|
this.sliceSerialize(token)
|
|
).toLowerCase();
|
|
}
|
|
function exitFootnoteDefinition(token) {
|
|
this.exit(token);
|
|
}
|
|
function enterFootnoteCall(token) {
|
|
this.enter({ type: "footnoteReference", identifier: "", label: "" }, token);
|
|
}
|
|
function enterFootnoteCallString() {
|
|
this.buffer();
|
|
}
|
|
function exitFootnoteCallString(token) {
|
|
const label = this.resume();
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.label = label;
|
|
node.identifier = normalizeIdentifier(
|
|
this.sliceSerialize(token)
|
|
).toLowerCase();
|
|
}
|
|
function exitFootnoteCall(token) {
|
|
this.exit(token);
|
|
}
|
|
}
|
|
function gfmFootnoteToMarkdown() {
|
|
footnoteReference.peek = footnoteReferencePeek;
|
|
return {
|
|
unsafe: [{ character: "[", inConstruct: ["phrasing", "label", "reference"] }],
|
|
handlers: { footnoteDefinition, footnoteReference }
|
|
};
|
|
function footnoteReference(node, _, context, safeOptions) {
|
|
const tracker = track(safeOptions);
|
|
let value = tracker.move("[^");
|
|
const exit2 = context.enter("footnoteReference");
|
|
const subexit = context.enter("reference");
|
|
value += tracker.move(
|
|
safe(context, association(node), {
|
|
...tracker.current(),
|
|
before: value,
|
|
after: "]"
|
|
})
|
|
);
|
|
subexit();
|
|
exit2();
|
|
value += tracker.move("]");
|
|
return value;
|
|
}
|
|
function footnoteReferencePeek() {
|
|
return "[";
|
|
}
|
|
function footnoteDefinition(node, _, context, safeOptions) {
|
|
const tracker = track(safeOptions);
|
|
let value = tracker.move("[^");
|
|
const exit2 = context.enter("footnoteDefinition");
|
|
const subexit = context.enter("label");
|
|
value += tracker.move(
|
|
safe(context, association(node), {
|
|
...tracker.current(),
|
|
before: value,
|
|
after: "]"
|
|
})
|
|
);
|
|
subexit();
|
|
value += tracker.move(
|
|
"]:" + (node.children && node.children.length > 0 ? " " : "")
|
|
);
|
|
tracker.shift(4);
|
|
value += tracker.move(
|
|
indentLines(containerFlow(node, context, tracker.current()), map)
|
|
);
|
|
exit2();
|
|
return value;
|
|
function map(line, index, blank) {
|
|
if (index) {
|
|
return (blank ? "" : " ") + line;
|
|
}
|
|
return line;
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
|
|
function containerPhrasing(parent, context, safeOptions) {
|
|
const indexStack = context.indexStack;
|
|
const children = parent.children || [];
|
|
const results = [];
|
|
let index = -1;
|
|
let before = safeOptions.before;
|
|
indexStack.push(-1);
|
|
let tracker = track(safeOptions);
|
|
while (++index < children.length) {
|
|
const child = children[index];
|
|
let after;
|
|
indexStack[indexStack.length - 1] = index;
|
|
if (index + 1 < children.length) {
|
|
let handle = context.handle.handlers[children[index + 1].type];
|
|
if (handle && handle.peek)
|
|
handle = handle.peek;
|
|
after = handle ? handle(children[index + 1], parent, context, {
|
|
before: "",
|
|
after: "",
|
|
...tracker.current()
|
|
}).charAt(0) : "";
|
|
} else {
|
|
after = safeOptions.after;
|
|
}
|
|
if (results.length > 0 && (before === "\r" || before === "\n") && child.type === "html") {
|
|
results[results.length - 1] = results[results.length - 1].replace(
|
|
/(\r?\n|\r)$/,
|
|
" "
|
|
);
|
|
before = " ";
|
|
tracker = track(safeOptions);
|
|
tracker.move(results.join(""));
|
|
}
|
|
results.push(
|
|
tracker.move(
|
|
context.handle(child, parent, context, {
|
|
...tracker.current(),
|
|
before,
|
|
after
|
|
})
|
|
)
|
|
);
|
|
before = results[results.length - 1].slice(-1);
|
|
}
|
|
indexStack.pop();
|
|
return results.join("");
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-strikethrough/index.js
|
|
var gfmStrikethroughFromMarkdown = {
|
|
canContainEols: ["delete"],
|
|
enter: { strikethrough: enterStrikethrough },
|
|
exit: { strikethrough: exitStrikethrough }
|
|
};
|
|
var gfmStrikethroughToMarkdown = {
|
|
unsafe: [{ character: "~", inConstruct: "phrasing" }],
|
|
handlers: { delete: handleDelete }
|
|
};
|
|
handleDelete.peek = peekDelete;
|
|
function enterStrikethrough(token) {
|
|
this.enter({ type: "delete", children: [] }, token);
|
|
}
|
|
function exitStrikethrough(token) {
|
|
this.exit(token);
|
|
}
|
|
function handleDelete(node, _, context, safeOptions) {
|
|
const tracker = track(safeOptions);
|
|
const exit2 = context.enter("emphasis");
|
|
let value = tracker.move("~~");
|
|
value += containerPhrasing(node, context, {
|
|
...tracker.current(),
|
|
before: value,
|
|
after: "~"
|
|
});
|
|
value += tracker.move("~~");
|
|
exit2();
|
|
return value;
|
|
}
|
|
function peekDelete() {
|
|
return "~";
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
|
|
inlineCode.peek = inlineCodePeek;
|
|
function inlineCode(node, _, context) {
|
|
let value = node.value || "";
|
|
let sequence = "`";
|
|
let index = -1;
|
|
while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) {
|
|
sequence += "`";
|
|
}
|
|
if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) {
|
|
value = " " + value + " ";
|
|
}
|
|
while (++index < context.unsafe.length) {
|
|
const pattern = context.unsafe[index];
|
|
const expression = patternCompile(pattern);
|
|
let match;
|
|
if (!pattern.atBreak)
|
|
continue;
|
|
while (match = expression.exec(value)) {
|
|
let position = match.index;
|
|
if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) {
|
|
position--;
|
|
}
|
|
value = value.slice(0, position) + " " + value.slice(match.index + 1);
|
|
}
|
|
}
|
|
return sequence + value + sequence;
|
|
}
|
|
function inlineCodePeek() {
|
|
return "`";
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-table/node_modules/markdown-table/index.js
|
|
function markdownTable(table, options = {}) {
|
|
const align = (options.align || []).concat();
|
|
const stringLength = options.stringLength || defaultStringLength;
|
|
const alignments = [];
|
|
const cellMatrix = [];
|
|
const sizeMatrix = [];
|
|
const longestCellByColumn = [];
|
|
let mostCellsPerRow = 0;
|
|
let rowIndex = -1;
|
|
while (++rowIndex < table.length) {
|
|
const row2 = [];
|
|
const sizes2 = [];
|
|
let columnIndex2 = -1;
|
|
if (table[rowIndex].length > mostCellsPerRow) {
|
|
mostCellsPerRow = table[rowIndex].length;
|
|
}
|
|
while (++columnIndex2 < table[rowIndex].length) {
|
|
const cell = serialize(table[rowIndex][columnIndex2]);
|
|
if (options.alignDelimiters !== false) {
|
|
const size = stringLength(cell);
|
|
sizes2[columnIndex2] = size;
|
|
if (longestCellByColumn[columnIndex2] === void 0 || size > longestCellByColumn[columnIndex2]) {
|
|
longestCellByColumn[columnIndex2] = size;
|
|
}
|
|
}
|
|
row2.push(cell);
|
|
}
|
|
cellMatrix[rowIndex] = row2;
|
|
sizeMatrix[rowIndex] = sizes2;
|
|
}
|
|
let columnIndex = -1;
|
|
if (typeof align === "object" && "length" in align) {
|
|
while (++columnIndex < mostCellsPerRow) {
|
|
alignments[columnIndex] = toAlignment(align[columnIndex]);
|
|
}
|
|
} else {
|
|
const code2 = toAlignment(align);
|
|
while (++columnIndex < mostCellsPerRow) {
|
|
alignments[columnIndex] = code2;
|
|
}
|
|
}
|
|
columnIndex = -1;
|
|
const row = [];
|
|
const sizes = [];
|
|
while (++columnIndex < mostCellsPerRow) {
|
|
const code2 = alignments[columnIndex];
|
|
let before = "";
|
|
let after = "";
|
|
if (code2 === 99) {
|
|
before = ":";
|
|
after = ":";
|
|
} else if (code2 === 108) {
|
|
before = ":";
|
|
} else if (code2 === 114) {
|
|
after = ":";
|
|
}
|
|
let size = options.alignDelimiters === false ? 1 : Math.max(
|
|
1,
|
|
longestCellByColumn[columnIndex] - before.length - after.length
|
|
);
|
|
const cell = before + "-".repeat(size) + after;
|
|
if (options.alignDelimiters !== false) {
|
|
size = before.length + size + after.length;
|
|
if (size > longestCellByColumn[columnIndex]) {
|
|
longestCellByColumn[columnIndex] = size;
|
|
}
|
|
sizes[columnIndex] = size;
|
|
}
|
|
row[columnIndex] = cell;
|
|
}
|
|
cellMatrix.splice(1, 0, row);
|
|
sizeMatrix.splice(1, 0, sizes);
|
|
rowIndex = -1;
|
|
const lines = [];
|
|
while (++rowIndex < cellMatrix.length) {
|
|
const row2 = cellMatrix[rowIndex];
|
|
const sizes2 = sizeMatrix[rowIndex];
|
|
columnIndex = -1;
|
|
const line = [];
|
|
while (++columnIndex < mostCellsPerRow) {
|
|
const cell = row2[columnIndex] || "";
|
|
let before = "";
|
|
let after = "";
|
|
if (options.alignDelimiters !== false) {
|
|
const size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0);
|
|
const code2 = alignments[columnIndex];
|
|
if (code2 === 114) {
|
|
before = " ".repeat(size);
|
|
} else if (code2 === 99) {
|
|
if (size % 2) {
|
|
before = " ".repeat(size / 2 + 0.5);
|
|
after = " ".repeat(size / 2 - 0.5);
|
|
} else {
|
|
before = " ".repeat(size / 2);
|
|
after = before;
|
|
}
|
|
} else {
|
|
after = " ".repeat(size);
|
|
}
|
|
}
|
|
if (options.delimiterStart !== false && !columnIndex) {
|
|
line.push("|");
|
|
}
|
|
if (options.padding !== false && !(options.alignDelimiters === false && cell === "") && (options.delimiterStart !== false || columnIndex)) {
|
|
line.push(" ");
|
|
}
|
|
if (options.alignDelimiters !== false) {
|
|
line.push(before);
|
|
}
|
|
line.push(cell);
|
|
if (options.alignDelimiters !== false) {
|
|
line.push(after);
|
|
}
|
|
if (options.padding !== false) {
|
|
line.push(" ");
|
|
}
|
|
if (options.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) {
|
|
line.push("|");
|
|
}
|
|
}
|
|
lines.push(
|
|
options.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join("")
|
|
);
|
|
}
|
|
return lines.join("\n");
|
|
}
|
|
function serialize(value) {
|
|
return value === null || value === void 0 ? "" : String(value);
|
|
}
|
|
function defaultStringLength(value) {
|
|
return value.length;
|
|
}
|
|
function toAlignment(value) {
|
|
const code2 = typeof value === "string" ? value.codePointAt(0) : 0;
|
|
return code2 === 67 || code2 === 99 ? 99 : code2 === 76 || code2 === 108 ? 108 : code2 === 82 || code2 === 114 ? 114 : 0;
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-table/lib/index.js
|
|
var gfmTableFromMarkdown = {
|
|
enter: {
|
|
table: enterTable,
|
|
tableData: enterCell,
|
|
tableHeader: enterCell,
|
|
tableRow: enterRow
|
|
},
|
|
exit: {
|
|
codeText: exitCodeText,
|
|
table: exitTable,
|
|
tableData: exit,
|
|
tableHeader: exit,
|
|
tableRow: exit
|
|
}
|
|
};
|
|
function enterTable(token) {
|
|
const align = token._align;
|
|
this.enter(
|
|
{
|
|
type: "table",
|
|
align: align.map((d) => d === "none" ? null : d),
|
|
children: []
|
|
},
|
|
token
|
|
);
|
|
this.setData("inTable", true);
|
|
}
|
|
function exitTable(token) {
|
|
this.exit(token);
|
|
this.setData("inTable");
|
|
}
|
|
function enterRow(token) {
|
|
this.enter({ type: "tableRow", children: [] }, token);
|
|
}
|
|
function exit(token) {
|
|
this.exit(token);
|
|
}
|
|
function enterCell(token) {
|
|
this.enter({ type: "tableCell", children: [] }, token);
|
|
}
|
|
function exitCodeText(token) {
|
|
let value = this.resume();
|
|
if (this.getData("inTable")) {
|
|
value = value.replace(/\\([\\|])/g, replace);
|
|
}
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.value = value;
|
|
this.exit(token);
|
|
}
|
|
function replace($0, $1) {
|
|
return $1 === "|" ? $1 : $0;
|
|
}
|
|
function gfmTableToMarkdown(options) {
|
|
const settings = options || {};
|
|
const padding = settings.tableCellPadding;
|
|
const alignDelimiters = settings.tablePipeAlign;
|
|
const stringLength = settings.stringLength;
|
|
const around = padding ? " " : "|";
|
|
return {
|
|
unsafe: [
|
|
{ character: "\r", inConstruct: "tableCell" },
|
|
{ character: "\n", inConstruct: "tableCell" },
|
|
{ atBreak: true, character: "|", after: "[ :-]" },
|
|
{ character: "|", inConstruct: "tableCell" },
|
|
{ atBreak: true, character: ":", after: "-" },
|
|
{ atBreak: true, character: "-", after: "[:|-]" }
|
|
],
|
|
handlers: {
|
|
table: handleTable,
|
|
tableRow: handleTableRow,
|
|
tableCell: handleTableCell,
|
|
inlineCode: inlineCodeWithTable
|
|
}
|
|
};
|
|
function handleTable(node, _, context, safeOptions) {
|
|
return serializeData(
|
|
handleTableAsData(node, context, safeOptions),
|
|
node.align
|
|
);
|
|
}
|
|
function handleTableRow(node, _, context, safeOptions) {
|
|
const row = handleTableRowAsData(node, context, safeOptions);
|
|
const value = serializeData([row]);
|
|
return value.slice(0, value.indexOf("\n"));
|
|
}
|
|
function handleTableCell(node, _, context, safeOptions) {
|
|
const exit2 = context.enter("tableCell");
|
|
const subexit = context.enter("phrasing");
|
|
const value = containerPhrasing(node, context, {
|
|
...safeOptions,
|
|
before: around,
|
|
after: around
|
|
});
|
|
subexit();
|
|
exit2();
|
|
return value;
|
|
}
|
|
function serializeData(matrix, align) {
|
|
return markdownTable(matrix, {
|
|
align,
|
|
alignDelimiters,
|
|
padding,
|
|
stringLength
|
|
});
|
|
}
|
|
function handleTableAsData(node, context, safeOptions) {
|
|
const children = node.children;
|
|
let index = -1;
|
|
const result = [];
|
|
const subexit = context.enter("table");
|
|
while (++index < children.length) {
|
|
result[index] = handleTableRowAsData(
|
|
children[index],
|
|
context,
|
|
safeOptions
|
|
);
|
|
}
|
|
subexit();
|
|
return result;
|
|
}
|
|
function handleTableRowAsData(node, context, safeOptions) {
|
|
const children = node.children;
|
|
let index = -1;
|
|
const result = [];
|
|
const subexit = context.enter("tableRow");
|
|
while (++index < children.length) {
|
|
result[index] = handleTableCell(
|
|
children[index],
|
|
node,
|
|
context,
|
|
safeOptions
|
|
);
|
|
}
|
|
subexit();
|
|
return result;
|
|
}
|
|
function inlineCodeWithTable(node, parent, context) {
|
|
let value = inlineCode(node, parent, context);
|
|
if (context.stack.includes("tableCell")) {
|
|
value = value.replace(/\|/g, "\\$&");
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
|
|
function checkBullet(context) {
|
|
const marker = context.options.bullet || "*";
|
|
if (marker !== "*" && marker !== "+" && marker !== "-") {
|
|
throw new Error(
|
|
"Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`"
|
|
);
|
|
}
|
|
return marker;
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
|
|
function checkListItemIndent(context) {
|
|
const style = context.options.listItemIndent || "tab";
|
|
if (style === 1 || style === "1") {
|
|
return "one";
|
|
}
|
|
if (style !== "tab" && style !== "one" && style !== "mixed") {
|
|
throw new Error(
|
|
"Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`"
|
|
);
|
|
}
|
|
return style;
|
|
}
|
|
|
|
// node_modules/mdast-util-to-markdown/lib/handle/list-item.js
|
|
function listItem(node, parent, context, safeOptions) {
|
|
const listItemIndent = checkListItemIndent(context);
|
|
let bullet = context.bulletCurrent || checkBullet(context);
|
|
if (parent && parent.type === "list" && parent.ordered) {
|
|
bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (context.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
|
|
}
|
|
let size = bullet.length + 1;
|
|
if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) {
|
|
size = Math.ceil(size / 4) * 4;
|
|
}
|
|
const tracker = track(safeOptions);
|
|
tracker.move(bullet + " ".repeat(size - bullet.length));
|
|
tracker.shift(size);
|
|
const exit2 = context.enter("listItem");
|
|
const value = indentLines(
|
|
containerFlow(node, context, tracker.current()),
|
|
map
|
|
);
|
|
exit2();
|
|
return value;
|
|
function map(line, index, blank) {
|
|
if (index) {
|
|
return (blank ? "" : " ".repeat(size)) + line;
|
|
}
|
|
return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm-task-list-item/index.js
|
|
var gfmTaskListItemFromMarkdown = {
|
|
exit: {
|
|
taskListCheckValueChecked: exitCheck,
|
|
taskListCheckValueUnchecked: exitCheck,
|
|
paragraph: exitParagraphWithTaskListItem
|
|
}
|
|
};
|
|
var gfmTaskListItemToMarkdown = {
|
|
unsafe: [{ atBreak: true, character: "-", after: "[:|-]" }],
|
|
handlers: { listItem: listItemWithTaskListItem }
|
|
};
|
|
function exitCheck(token) {
|
|
const node = this.stack[this.stack.length - 2];
|
|
node.checked = token.type === "taskListCheckValueChecked";
|
|
}
|
|
function exitParagraphWithTaskListItem(token) {
|
|
const parent = this.stack[this.stack.length - 2];
|
|
const node = this.stack[this.stack.length - 1];
|
|
const siblings = parent.children;
|
|
const head = node.children[0];
|
|
let index = -1;
|
|
let firstParaghraph;
|
|
if (parent && parent.type === "listItem" && typeof parent.checked === "boolean" && head && head.type === "text") {
|
|
while (++index < siblings.length) {
|
|
const sibling = siblings[index];
|
|
if (sibling.type === "paragraph") {
|
|
firstParaghraph = sibling;
|
|
break;
|
|
}
|
|
}
|
|
if (firstParaghraph === node) {
|
|
head.value = head.value.slice(1);
|
|
if (head.value.length === 0) {
|
|
node.children.shift();
|
|
} else if (node.position && head.position && typeof head.position.start.offset === "number") {
|
|
head.position.start.column++;
|
|
head.position.start.offset++;
|
|
node.position.start = Object.assign({}, head.position.start);
|
|
}
|
|
}
|
|
}
|
|
this.exit(token);
|
|
}
|
|
function listItemWithTaskListItem(node, parent, context, safeOptions) {
|
|
const head = node.children[0];
|
|
const checkable = typeof node.checked === "boolean" && head && head.type === "paragraph";
|
|
const checkbox = "[" + (node.checked ? "x" : " ") + "] ";
|
|
const tracker = track(safeOptions);
|
|
if (checkable) {
|
|
tracker.move(checkbox);
|
|
}
|
|
let value = listItem(node, parent, context, {
|
|
...safeOptions,
|
|
...tracker.current()
|
|
});
|
|
if (checkable) {
|
|
value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
|
|
}
|
|
return value;
|
|
function check($0) {
|
|
return $0 + checkbox;
|
|
}
|
|
}
|
|
|
|
// node_modules/mdast-util-gfm/lib/index.js
|
|
function gfmFromMarkdown() {
|
|
return [
|
|
gfmAutolinkLiteralFromMarkdown,
|
|
gfmFootnoteFromMarkdown(),
|
|
gfmStrikethroughFromMarkdown,
|
|
gfmTableFromMarkdown,
|
|
gfmTaskListItemFromMarkdown
|
|
];
|
|
}
|
|
function gfmToMarkdown(options) {
|
|
return {
|
|
extensions: [
|
|
gfmAutolinkLiteralToMarkdown,
|
|
gfmFootnoteToMarkdown(),
|
|
gfmStrikethroughToMarkdown,
|
|
gfmTableToMarkdown(options),
|
|
gfmTaskListItemToMarkdown
|
|
]
|
|
};
|
|
}
|
|
|
|
// node_modules/remark-gfm/index.js
|
|
function remarkGfm(options = {}) {
|
|
const data = this.data();
|
|
add("micromarkExtensions", gfm(options));
|
|
add("fromMarkdownExtensions", gfmFromMarkdown());
|
|
add("toMarkdownExtensions", gfmToMarkdown(options));
|
|
function add(field, value) {
|
|
const list = data[field] ? data[field] : data[field] = [];
|
|
list.push(value);
|
|
}
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {});
|