mirror of
https://github.com/facebook/docusaurus.git
synced 2025-04-30 02:37:59 +02:00
3846 lines
91 KiB
JavaScript
Vendored
3846 lines
91 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-directive/index.js
|
|
var remark_directive_exports = {};
|
|
__export(remark_directive_exports, {
|
|
default: () => remarkDirective201
|
|
});
|
|
module.exports = __toCommonJS(remark_directive_exports);
|
|
|
|
// 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 markdownLineEndingOrSpace(code) {
|
|
return code !== null && (code < 0 || code === 32);
|
|
}
|
|
function markdownLineEnding(code) {
|
|
return code !== null && code < -2;
|
|
}
|
|
function markdownSpace(code) {
|
|
return code === -2 || code === -1 || code === 32;
|
|
}
|
|
var unicodeWhitespace = regexCheck(/\s/);
|
|
var unicodePunctuation = regexCheck(unicodePunctuationRegex);
|
|
function regexCheck(regex) {
|
|
return check;
|
|
function check(code) {
|
|
return code !== null && regex.test(String.fromCharCode(code));
|
|
}
|
|
}
|
|
|
|
// 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(code) {
|
|
if (markdownSpace(code)) {
|
|
effects.enter(type);
|
|
return prefix(code);
|
|
}
|
|
return ok2(code);
|
|
}
|
|
function prefix(code) {
|
|
if (markdownSpace(code) && size++ < limit) {
|
|
effects.consume(code);
|
|
return prefix;
|
|
}
|
|
effects.exit(type);
|
|
return ok2(code);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-factory-whitespace/index.js
|
|
function factoryWhitespace(effects, ok2) {
|
|
let seen;
|
|
return start;
|
|
function start(code) {
|
|
if (markdownLineEnding(code)) {
|
|
effects.enter("lineEnding");
|
|
effects.consume(code);
|
|
effects.exit("lineEnding");
|
|
seen = true;
|
|
return start;
|
|
}
|
|
if (markdownSpace(code)) {
|
|
return factorySpace(
|
|
effects,
|
|
start,
|
|
seen ? "linePrefix" : "lineSuffix"
|
|
)(code);
|
|
}
|
|
return ok2(code);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/factory-attributes.js
|
|
function factoryAttributes(effects, ok2, nok, attributesType, attributesMarkerType, attributeType, attributeIdType, attributeClassType, attributeNameType, attributeInitializerType, attributeValueLiteralType, attributeValueType, attributeValueMarker, attributeValueData, disallowEol) {
|
|
let type;
|
|
let marker;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter(attributesType);
|
|
effects.enter(attributesMarkerType);
|
|
effects.consume(code);
|
|
effects.exit(attributesMarkerType);
|
|
return between;
|
|
}
|
|
function between(code) {
|
|
if (code === 35) {
|
|
type = attributeIdType;
|
|
return shortcutStart(code);
|
|
}
|
|
if (code === 46) {
|
|
type = attributeClassType;
|
|
return shortcutStart(code);
|
|
}
|
|
if (code === 58 || code === 95 || asciiAlpha(code)) {
|
|
effects.enter(attributeType);
|
|
effects.enter(attributeNameType);
|
|
effects.consume(code);
|
|
return name;
|
|
}
|
|
if (disallowEol && markdownSpace(code)) {
|
|
return factorySpace(effects, between, "whitespace")(code);
|
|
}
|
|
if (!disallowEol && markdownLineEndingOrSpace(code)) {
|
|
return factoryWhitespace(effects, between)(code);
|
|
}
|
|
return end(code);
|
|
}
|
|
function shortcutStart(code) {
|
|
effects.enter(attributeType);
|
|
effects.enter(type);
|
|
effects.enter(type + "Marker");
|
|
effects.consume(code);
|
|
effects.exit(type + "Marker");
|
|
return shortcutStartAfter;
|
|
}
|
|
function shortcutStartAfter(code) {
|
|
if (code === null || code === 34 || code === 35 || code === 39 || code === 46 || code === 60 || code === 61 || code === 62 || code === 96 || code === 125 || markdownLineEndingOrSpace(code)) {
|
|
return nok(code);
|
|
}
|
|
effects.enter(type + "Value");
|
|
effects.consume(code);
|
|
return shortcut2;
|
|
}
|
|
function shortcut2(code) {
|
|
if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96) {
|
|
return nok(code);
|
|
}
|
|
if (code === 35 || code === 46 || code === 125 || markdownLineEndingOrSpace(code)) {
|
|
effects.exit(type + "Value");
|
|
effects.exit(type);
|
|
effects.exit(attributeType);
|
|
return between(code);
|
|
}
|
|
effects.consume(code);
|
|
return shortcut2;
|
|
}
|
|
function name(code) {
|
|
if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {
|
|
effects.consume(code);
|
|
return name;
|
|
}
|
|
effects.exit(attributeNameType);
|
|
if (disallowEol && markdownSpace(code)) {
|
|
return factorySpace(effects, nameAfter, "whitespace")(code);
|
|
}
|
|
if (!disallowEol && markdownLineEndingOrSpace(code)) {
|
|
return factoryWhitespace(effects, nameAfter)(code);
|
|
}
|
|
return nameAfter(code);
|
|
}
|
|
function nameAfter(code) {
|
|
if (code === 61) {
|
|
effects.enter(attributeInitializerType);
|
|
effects.consume(code);
|
|
effects.exit(attributeInitializerType);
|
|
return valueBefore;
|
|
}
|
|
effects.exit(attributeType);
|
|
return between(code);
|
|
}
|
|
function valueBefore(code) {
|
|
if (code === null || code === 60 || code === 61 || code === 62 || code === 96 || code === 125 || disallowEol && markdownLineEnding(code)) {
|
|
return nok(code);
|
|
}
|
|
if (code === 34 || code === 39) {
|
|
effects.enter(attributeValueLiteralType);
|
|
effects.enter(attributeValueMarker);
|
|
effects.consume(code);
|
|
effects.exit(attributeValueMarker);
|
|
marker = code;
|
|
return valueQuotedStart;
|
|
}
|
|
if (disallowEol && markdownSpace(code)) {
|
|
return factorySpace(effects, valueBefore, "whitespace")(code);
|
|
}
|
|
if (!disallowEol && markdownLineEndingOrSpace(code)) {
|
|
return factoryWhitespace(effects, valueBefore)(code);
|
|
}
|
|
effects.enter(attributeValueType);
|
|
effects.enter(attributeValueData);
|
|
effects.consume(code);
|
|
marker = void 0;
|
|
return valueUnquoted;
|
|
}
|
|
function valueUnquoted(code) {
|
|
if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96) {
|
|
return nok(code);
|
|
}
|
|
if (code === 125 || markdownLineEndingOrSpace(code)) {
|
|
effects.exit(attributeValueData);
|
|
effects.exit(attributeValueType);
|
|
effects.exit(attributeType);
|
|
return between(code);
|
|
}
|
|
effects.consume(code);
|
|
return valueUnquoted;
|
|
}
|
|
function valueQuotedStart(code) {
|
|
if (code === marker) {
|
|
effects.enter(attributeValueMarker);
|
|
effects.consume(code);
|
|
effects.exit(attributeValueMarker);
|
|
effects.exit(attributeValueLiteralType);
|
|
effects.exit(attributeType);
|
|
return valueQuotedAfter;
|
|
}
|
|
effects.enter(attributeValueType);
|
|
return valueQuotedBetween(code);
|
|
}
|
|
function valueQuotedBetween(code) {
|
|
if (code === marker) {
|
|
effects.exit(attributeValueType);
|
|
return valueQuotedStart(code);
|
|
}
|
|
if (code === null) {
|
|
return nok(code);
|
|
}
|
|
if (markdownLineEnding(code)) {
|
|
return disallowEol ? nok(code) : factoryWhitespace(effects, valueQuotedBetween)(code);
|
|
}
|
|
effects.enter(attributeValueData);
|
|
effects.consume(code);
|
|
return valueQuoted;
|
|
}
|
|
function valueQuoted(code) {
|
|
if (code === marker || code === null || markdownLineEnding(code)) {
|
|
effects.exit(attributeValueData);
|
|
return valueQuotedBetween(code);
|
|
}
|
|
effects.consume(code);
|
|
return valueQuoted;
|
|
}
|
|
function valueQuotedAfter(code) {
|
|
return code === 125 || markdownLineEndingOrSpace(code) ? between(code) : end(code);
|
|
}
|
|
function end(code) {
|
|
if (code === 125) {
|
|
effects.enter(attributesMarkerType);
|
|
effects.consume(code);
|
|
effects.exit(attributesMarkerType);
|
|
effects.exit(attributesType);
|
|
return ok2;
|
|
}
|
|
return nok(code);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/factory-label.js
|
|
function factoryLabel(effects, ok2, nok, type, markerType, stringType, disallowEol) {
|
|
let size = 0;
|
|
let balance = 0;
|
|
let previous2;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter(type);
|
|
effects.enter(markerType);
|
|
effects.consume(code);
|
|
effects.exit(markerType);
|
|
return afterStart;
|
|
}
|
|
function afterStart(code) {
|
|
if (code === 93) {
|
|
effects.enter(markerType);
|
|
effects.consume(code);
|
|
effects.exit(markerType);
|
|
effects.exit(type);
|
|
return ok2;
|
|
}
|
|
effects.enter(stringType);
|
|
return lineStart(code);
|
|
}
|
|
function lineStart(code) {
|
|
if (code === 93 && !balance) {
|
|
return atClosingBrace(code);
|
|
}
|
|
const token = effects.enter("chunkText", {
|
|
contentType: "text",
|
|
previous: previous2
|
|
});
|
|
if (previous2)
|
|
previous2.next = token;
|
|
previous2 = token;
|
|
return data(code);
|
|
}
|
|
function data(code) {
|
|
if (code === null || size > 999) {
|
|
return nok(code);
|
|
}
|
|
if (code === 91 && ++balance > 32) {
|
|
return nok(code);
|
|
}
|
|
if (code === 93 && !balance--) {
|
|
effects.exit("chunkText");
|
|
return atClosingBrace(code);
|
|
}
|
|
if (markdownLineEnding(code)) {
|
|
if (disallowEol) {
|
|
return nok(code);
|
|
}
|
|
effects.consume(code);
|
|
effects.exit("chunkText");
|
|
return lineStart;
|
|
}
|
|
effects.consume(code);
|
|
return code === 92 ? dataEscape : data;
|
|
}
|
|
function dataEscape(code) {
|
|
if (code === 91 || code === 92 || code === 93) {
|
|
effects.consume(code);
|
|
size++;
|
|
return data;
|
|
}
|
|
return data(code);
|
|
}
|
|
function atClosingBrace(code) {
|
|
effects.exit(stringType);
|
|
effects.enter(markerType);
|
|
effects.consume(code);
|
|
effects.exit(markerType);
|
|
effects.exit(type);
|
|
return ok2;
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/factory-name.js
|
|
function factoryName(effects, ok2, nok, type) {
|
|
const self = this;
|
|
return start;
|
|
function start(code) {
|
|
if (asciiAlpha(code)) {
|
|
effects.enter(type);
|
|
effects.consume(code);
|
|
return name;
|
|
}
|
|
return nok(code);
|
|
}
|
|
function name(code) {
|
|
if (code === 45 || code === 95 || asciiAlphanumeric(code)) {
|
|
effects.consume(code);
|
|
return name;
|
|
}
|
|
effects.exit(type);
|
|
return self.previous === 45 || self.previous === 95 ? nok(code) : ok2(code);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/directive-container.js
|
|
var directiveContainer = {
|
|
tokenize: tokenizeDirectiveContainer,
|
|
concrete: true
|
|
};
|
|
var label = {
|
|
tokenize: tokenizeLabel,
|
|
partial: true
|
|
};
|
|
var attributes = {
|
|
tokenize: tokenizeAttributes,
|
|
partial: true
|
|
};
|
|
var nonLazyLine = {
|
|
tokenize: tokenizeNonLazyLine,
|
|
partial: true
|
|
};
|
|
function tokenizeDirectiveContainer(effects, ok2, nok) {
|
|
const self = this;
|
|
const tail = self.events[self.events.length - 1];
|
|
const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
|
|
let sizeOpen = 0;
|
|
let previous2;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter("directiveContainer");
|
|
effects.enter("directiveContainerFence");
|
|
effects.enter("directiveContainerSequence");
|
|
return sequenceOpen(code);
|
|
}
|
|
function sequenceOpen(code) {
|
|
if (code === 58) {
|
|
effects.consume(code);
|
|
sizeOpen++;
|
|
return sequenceOpen;
|
|
}
|
|
if (sizeOpen < 3) {
|
|
return nok(code);
|
|
}
|
|
effects.exit("directiveContainerSequence");
|
|
return factoryName.call(
|
|
self,
|
|
effects,
|
|
afterName,
|
|
nok,
|
|
"directiveContainerName"
|
|
)(code);
|
|
}
|
|
function afterName(code) {
|
|
return code === 91 ? effects.attempt(label, afterLabel, afterLabel)(code) : afterLabel(code);
|
|
}
|
|
function afterLabel(code) {
|
|
return code === 123 ? effects.attempt(attributes, afterAttributes, afterAttributes)(code) : afterAttributes(code);
|
|
}
|
|
function afterAttributes(code) {
|
|
return factorySpace(effects, openAfter, "whitespace")(code);
|
|
}
|
|
function openAfter(code) {
|
|
effects.exit("directiveContainerFence");
|
|
if (code === null) {
|
|
return afterOpening(code);
|
|
}
|
|
if (markdownLineEnding(code)) {
|
|
if (self.interrupt) {
|
|
return ok2(code);
|
|
}
|
|
return effects.attempt(nonLazyLine, contentStart, afterOpening)(code);
|
|
}
|
|
return nok(code);
|
|
}
|
|
function afterOpening(code) {
|
|
effects.exit("directiveContainer");
|
|
return ok2(code);
|
|
}
|
|
function contentStart(code) {
|
|
if (code === null) {
|
|
effects.exit("directiveContainer");
|
|
return ok2(code);
|
|
}
|
|
effects.enter("directiveContainerContent");
|
|
return lineStart(code);
|
|
}
|
|
function lineStart(code) {
|
|
if (code === null) {
|
|
return after(code);
|
|
}
|
|
return effects.attempt(
|
|
{
|
|
tokenize: tokenizeClosingFence,
|
|
partial: true
|
|
},
|
|
after,
|
|
initialSize ? factorySpace(effects, chunkStart, "linePrefix", initialSize + 1) : chunkStart
|
|
)(code);
|
|
}
|
|
function chunkStart(code) {
|
|
if (code === null) {
|
|
return after(code);
|
|
}
|
|
const token = effects.enter("chunkDocument", {
|
|
contentType: "document",
|
|
previous: previous2
|
|
});
|
|
if (previous2)
|
|
previous2.next = token;
|
|
previous2 = token;
|
|
return contentContinue(code);
|
|
}
|
|
function contentContinue(code) {
|
|
if (code === null) {
|
|
const t = effects.exit("chunkDocument");
|
|
self.parser.lazy[t.start.line] = false;
|
|
return after(code);
|
|
}
|
|
if (markdownLineEnding(code)) {
|
|
return effects.check(nonLazyLine, nonLazyLineAfter, lineAfter)(code);
|
|
}
|
|
effects.consume(code);
|
|
return contentContinue;
|
|
}
|
|
function nonLazyLineAfter(code) {
|
|
effects.consume(code);
|
|
const t = effects.exit("chunkDocument");
|
|
self.parser.lazy[t.start.line] = false;
|
|
return lineStart;
|
|
}
|
|
function lineAfter(code) {
|
|
const t = effects.exit("chunkDocument");
|
|
self.parser.lazy[t.start.line] = false;
|
|
return after(code);
|
|
}
|
|
function after(code) {
|
|
effects.exit("directiveContainerContent");
|
|
effects.exit("directiveContainer");
|
|
return ok2(code);
|
|
}
|
|
function tokenizeClosingFence(effects2, ok3, nok2) {
|
|
let size = 0;
|
|
return factorySpace(effects2, closingPrefixAfter, "linePrefix", 4);
|
|
function closingPrefixAfter(code) {
|
|
effects2.enter("directiveContainerFence");
|
|
effects2.enter("directiveContainerSequence");
|
|
return closingSequence(code);
|
|
}
|
|
function closingSequence(code) {
|
|
if (code === 58) {
|
|
effects2.consume(code);
|
|
size++;
|
|
return closingSequence;
|
|
}
|
|
if (size < sizeOpen)
|
|
return nok2(code);
|
|
effects2.exit("directiveContainerSequence");
|
|
return factorySpace(effects2, closingSequenceEnd, "whitespace")(code);
|
|
}
|
|
function closingSequenceEnd(code) {
|
|
if (code === null || markdownLineEnding(code)) {
|
|
effects2.exit("directiveContainerFence");
|
|
return ok3(code);
|
|
}
|
|
return nok2(code);
|
|
}
|
|
}
|
|
}
|
|
function tokenizeLabel(effects, ok2, nok) {
|
|
return factoryLabel(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveContainerLabel",
|
|
"directiveContainerLabelMarker",
|
|
"directiveContainerLabelString",
|
|
true
|
|
);
|
|
}
|
|
function tokenizeAttributes(effects, ok2, nok) {
|
|
return factoryAttributes(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveContainerAttributes",
|
|
"directiveContainerAttributesMarker",
|
|
"directiveContainerAttribute",
|
|
"directiveContainerAttributeId",
|
|
"directiveContainerAttributeClass",
|
|
"directiveContainerAttributeName",
|
|
"directiveContainerAttributeInitializerMarker",
|
|
"directiveContainerAttributeValueLiteral",
|
|
"directiveContainerAttributeValue",
|
|
"directiveContainerAttributeValueMarker",
|
|
"directiveContainerAttributeValueData",
|
|
true
|
|
);
|
|
}
|
|
function tokenizeNonLazyLine(effects, ok2, nok) {
|
|
const self = this;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter("lineEnding");
|
|
effects.consume(code);
|
|
effects.exit("lineEnding");
|
|
return lineStart;
|
|
}
|
|
function lineStart(code) {
|
|
return self.parser.lazy[self.now().line] ? nok(code) : ok2(code);
|
|
}
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/directive-leaf.js
|
|
var directiveLeaf = {
|
|
tokenize: tokenizeDirectiveLeaf
|
|
};
|
|
var label2 = {
|
|
tokenize: tokenizeLabel2,
|
|
partial: true
|
|
};
|
|
var attributes2 = {
|
|
tokenize: tokenizeAttributes2,
|
|
partial: true
|
|
};
|
|
function tokenizeDirectiveLeaf(effects, ok2, nok) {
|
|
const self = this;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter("directiveLeaf");
|
|
effects.enter("directiveLeafSequence");
|
|
effects.consume(code);
|
|
return inStart;
|
|
}
|
|
function inStart(code) {
|
|
if (code === 58) {
|
|
effects.consume(code);
|
|
effects.exit("directiveLeafSequence");
|
|
return factoryName.call(
|
|
self,
|
|
effects,
|
|
afterName,
|
|
nok,
|
|
"directiveLeafName"
|
|
);
|
|
}
|
|
return nok(code);
|
|
}
|
|
function afterName(code) {
|
|
return code === 91 ? effects.attempt(label2, afterLabel, afterLabel)(code) : afterLabel(code);
|
|
}
|
|
function afterLabel(code) {
|
|
return code === 123 ? effects.attempt(attributes2, afterAttributes, afterAttributes)(code) : afterAttributes(code);
|
|
}
|
|
function afterAttributes(code) {
|
|
return factorySpace(effects, end, "whitespace")(code);
|
|
}
|
|
function end(code) {
|
|
if (code === null || markdownLineEnding(code)) {
|
|
effects.exit("directiveLeaf");
|
|
return ok2(code);
|
|
}
|
|
return nok(code);
|
|
}
|
|
}
|
|
function tokenizeLabel2(effects, ok2, nok) {
|
|
return factoryLabel(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveLeafLabel",
|
|
"directiveLeafLabelMarker",
|
|
"directiveLeafLabelString",
|
|
true
|
|
);
|
|
}
|
|
function tokenizeAttributes2(effects, ok2, nok) {
|
|
return factoryAttributes(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveLeafAttributes",
|
|
"directiveLeafAttributesMarker",
|
|
"directiveLeafAttribute",
|
|
"directiveLeafAttributeId",
|
|
"directiveLeafAttributeClass",
|
|
"directiveLeafAttributeName",
|
|
"directiveLeafAttributeInitializerMarker",
|
|
"directiveLeafAttributeValueLiteral",
|
|
"directiveLeafAttributeValue",
|
|
"directiveLeafAttributeValueMarker",
|
|
"directiveLeafAttributeValueData",
|
|
true
|
|
);
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/directive-text.js
|
|
var directiveText = {
|
|
tokenize: tokenizeDirectiveText,
|
|
previous
|
|
};
|
|
var label3 = {
|
|
tokenize: tokenizeLabel3,
|
|
partial: true
|
|
};
|
|
var attributes3 = {
|
|
tokenize: tokenizeAttributes3,
|
|
partial: true
|
|
};
|
|
function previous(code) {
|
|
return code !== 58 || this.events[this.events.length - 1][1].type === "characterEscape";
|
|
}
|
|
function tokenizeDirectiveText(effects, ok2, nok) {
|
|
const self = this;
|
|
return start;
|
|
function start(code) {
|
|
effects.enter("directiveText");
|
|
effects.enter("directiveTextMarker");
|
|
effects.consume(code);
|
|
effects.exit("directiveTextMarker");
|
|
return factoryName.call(self, effects, afterName, nok, "directiveTextName");
|
|
}
|
|
function afterName(code) {
|
|
return code === 58 ? nok(code) : code === 91 ? effects.attempt(label3, afterLabel, afterLabel)(code) : afterLabel(code);
|
|
}
|
|
function afterLabel(code) {
|
|
return code === 123 ? effects.attempt(attributes3, afterAttributes, afterAttributes)(code) : afterAttributes(code);
|
|
}
|
|
function afterAttributes(code) {
|
|
effects.exit("directiveText");
|
|
return ok2(code);
|
|
}
|
|
}
|
|
function tokenizeLabel3(effects, ok2, nok) {
|
|
return factoryLabel(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveTextLabel",
|
|
"directiveTextLabelMarker",
|
|
"directiveTextLabelString"
|
|
);
|
|
}
|
|
function tokenizeAttributes3(effects, ok2, nok) {
|
|
return factoryAttributes(
|
|
effects,
|
|
ok2,
|
|
nok,
|
|
"directiveTextAttributes",
|
|
"directiveTextAttributesMarker",
|
|
"directiveTextAttribute",
|
|
"directiveTextAttributeId",
|
|
"directiveTextAttributeClass",
|
|
"directiveTextAttributeName",
|
|
"directiveTextAttributeInitializerMarker",
|
|
"directiveTextAttributeValueLiteral",
|
|
"directiveTextAttributeValue",
|
|
"directiveTextAttributeValueMarker",
|
|
"directiveTextAttributeValueData"
|
|
);
|
|
}
|
|
|
|
// node_modules/micromark-extension-directive/lib/syntax.js
|
|
function directive() {
|
|
return {
|
|
text: {
|
|
[58]: directiveText
|
|
},
|
|
flow: {
|
|
[58]: [directiveContainer, directiveLeaf]
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/parse-entities/node_modules/character-entities-legacy/index.js
|
|
var characterEntitiesLegacy = [
|
|
"AElig",
|
|
"AMP",
|
|
"Aacute",
|
|
"Acirc",
|
|
"Agrave",
|
|
"Aring",
|
|
"Atilde",
|
|
"Auml",
|
|
"COPY",
|
|
"Ccedil",
|
|
"ETH",
|
|
"Eacute",
|
|
"Ecirc",
|
|
"Egrave",
|
|
"Euml",
|
|
"GT",
|
|
"Iacute",
|
|
"Icirc",
|
|
"Igrave",
|
|
"Iuml",
|
|
"LT",
|
|
"Ntilde",
|
|
"Oacute",
|
|
"Ocirc",
|
|
"Ograve",
|
|
"Oslash",
|
|
"Otilde",
|
|
"Ouml",
|
|
"QUOT",
|
|
"REG",
|
|
"THORN",
|
|
"Uacute",
|
|
"Ucirc",
|
|
"Ugrave",
|
|
"Uuml",
|
|
"Yacute",
|
|
"aacute",
|
|
"acirc",
|
|
"acute",
|
|
"aelig",
|
|
"agrave",
|
|
"amp",
|
|
"aring",
|
|
"atilde",
|
|
"auml",
|
|
"brvbar",
|
|
"ccedil",
|
|
"cedil",
|
|
"cent",
|
|
"copy",
|
|
"curren",
|
|
"deg",
|
|
"divide",
|
|
"eacute",
|
|
"ecirc",
|
|
"egrave",
|
|
"eth",
|
|
"euml",
|
|
"frac12",
|
|
"frac14",
|
|
"frac34",
|
|
"gt",
|
|
"iacute",
|
|
"icirc",
|
|
"iexcl",
|
|
"igrave",
|
|
"iquest",
|
|
"iuml",
|
|
"laquo",
|
|
"lt",
|
|
"macr",
|
|
"micro",
|
|
"middot",
|
|
"nbsp",
|
|
"not",
|
|
"ntilde",
|
|
"oacute",
|
|
"ocirc",
|
|
"ograve",
|
|
"ordf",
|
|
"ordm",
|
|
"oslash",
|
|
"otilde",
|
|
"ouml",
|
|
"para",
|
|
"plusmn",
|
|
"pound",
|
|
"quot",
|
|
"raquo",
|
|
"reg",
|
|
"sect",
|
|
"shy",
|
|
"sup1",
|
|
"sup2",
|
|
"sup3",
|
|
"szlig",
|
|
"thorn",
|
|
"times",
|
|
"uacute",
|
|
"ucirc",
|
|
"ugrave",
|
|
"uml",
|
|
"uuml",
|
|
"yacute",
|
|
"yen",
|
|
"yuml"
|
|
];
|
|
|
|
// node_modules/character-reference-invalid/index.js
|
|
var characterReferenceInvalid = {
|
|
0: "\uFFFD",
|
|
128: "\u20AC",
|
|
130: "\u201A",
|
|
131: "\u0192",
|
|
132: "\u201E",
|
|
133: "\u2026",
|
|
134: "\u2020",
|
|
135: "\u2021",
|
|
136: "\u02C6",
|
|
137: "\u2030",
|
|
138: "\u0160",
|
|
139: "\u2039",
|
|
140: "\u0152",
|
|
142: "\u017D",
|
|
145: "\u2018",
|
|
146: "\u2019",
|
|
147: "\u201C",
|
|
148: "\u201D",
|
|
149: "\u2022",
|
|
150: "\u2013",
|
|
151: "\u2014",
|
|
152: "\u02DC",
|
|
153: "\u2122",
|
|
154: "\u0161",
|
|
155: "\u203A",
|
|
156: "\u0153",
|
|
158: "\u017E",
|
|
159: "\u0178"
|
|
};
|
|
|
|
// node_modules/parse-entities/node_modules/is-decimal/index.js
|
|
function isDecimal(character) {
|
|
const code = typeof character === "string" ? character.charCodeAt(0) : character;
|
|
return code >= 48 && code <= 57;
|
|
}
|
|
|
|
// node_modules/is-hexadecimal/index.js
|
|
function isHexadecimal(character) {
|
|
const code = typeof character === "string" ? character.charCodeAt(0) : character;
|
|
return code >= 97 && code <= 102 || code >= 65 && code <= 70 || code >= 48 && code <= 57;
|
|
}
|
|
|
|
// node_modules/is-alphanumerical/node_modules/is-alphabetical/index.js
|
|
function isAlphabetical(character) {
|
|
const code = typeof character === "string" ? character.charCodeAt(0) : character;
|
|
return code >= 97 && code <= 122 || code >= 65 && code <= 90;
|
|
}
|
|
|
|
// node_modules/is-alphanumerical/node_modules/is-decimal/index.js
|
|
function isDecimal2(character) {
|
|
const code = typeof character === "string" ? character.charCodeAt(0) : character;
|
|
return code >= 48 && code <= 57;
|
|
}
|
|
|
|
// node_modules/is-alphanumerical/index.js
|
|
function isAlphanumerical(character) {
|
|
return isAlphabetical(character) || isDecimal2(character);
|
|
}
|
|
|
|
// 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/parse-entities/lib/index.js
|
|
var fromCharCode = String.fromCharCode;
|
|
var messages = [
|
|
"",
|
|
"Named character references must be terminated by a semicolon",
|
|
"Numeric character references must be terminated by a semicolon",
|
|
"Named character references cannot be empty",
|
|
"Numeric character references cannot be empty",
|
|
"Named character references must be known",
|
|
"Numeric character references cannot be disallowed",
|
|
"Numeric character references cannot be outside the permissible Unicode range"
|
|
];
|
|
function parseEntities(value, options = {}) {
|
|
const additional = typeof options.additional === "string" ? options.additional.charCodeAt(0) : options.additional;
|
|
const result = [];
|
|
let index = 0;
|
|
let lines = -1;
|
|
let queue = "";
|
|
let point;
|
|
let indent;
|
|
if (options.position) {
|
|
if ("start" in options.position || "indent" in options.position) {
|
|
indent = options.position.indent;
|
|
point = options.position.start;
|
|
} else {
|
|
point = options.position;
|
|
}
|
|
}
|
|
let line = (point ? point.line : 0) || 1;
|
|
let column = (point ? point.column : 0) || 1;
|
|
let previous2 = now();
|
|
let character;
|
|
index--;
|
|
while (++index <= value.length) {
|
|
if (character === 10) {
|
|
column = (indent ? indent[lines] : 0) || 1;
|
|
}
|
|
character = value.charCodeAt(index);
|
|
if (character === 38) {
|
|
const following = value.charCodeAt(index + 1);
|
|
if (following === 9 || following === 10 || following === 12 || following === 32 || following === 38 || following === 60 || Number.isNaN(following) || additional && following === additional) {
|
|
queue += fromCharCode(character);
|
|
column++;
|
|
continue;
|
|
}
|
|
const start = index + 1;
|
|
let begin = start;
|
|
let end = start;
|
|
let type;
|
|
if (following === 35) {
|
|
end = ++begin;
|
|
const following2 = value.charCodeAt(end);
|
|
if (following2 === 88 || following2 === 120) {
|
|
type = "hexadecimal";
|
|
end = ++begin;
|
|
} else {
|
|
type = "decimal";
|
|
}
|
|
} else {
|
|
type = "named";
|
|
}
|
|
let characterReferenceCharacters = "";
|
|
let characterReference = "";
|
|
let characters = "";
|
|
const test = type === "named" ? isAlphanumerical : type === "decimal" ? isDecimal : isHexadecimal;
|
|
end--;
|
|
while (++end <= value.length) {
|
|
const following2 = value.charCodeAt(end);
|
|
if (!test(following2)) {
|
|
break;
|
|
}
|
|
characters += fromCharCode(following2);
|
|
if (type === "named" && characterEntitiesLegacy.includes(characters)) {
|
|
characterReferenceCharacters = characters;
|
|
characterReference = decodeNamedCharacterReference(characters);
|
|
}
|
|
}
|
|
let terminated = value.charCodeAt(end) === 59;
|
|
if (terminated) {
|
|
end++;
|
|
const namedReference = type === "named" ? decodeNamedCharacterReference(characters) : false;
|
|
if (namedReference) {
|
|
characterReferenceCharacters = characters;
|
|
characterReference = namedReference;
|
|
}
|
|
}
|
|
let diff = 1 + end - start;
|
|
let reference = "";
|
|
if (!terminated && options.nonTerminated === false) {
|
|
} else if (!characters) {
|
|
if (type !== "named") {
|
|
warning(4, diff);
|
|
}
|
|
} else if (type === "named") {
|
|
if (terminated && !characterReference) {
|
|
warning(5, 1);
|
|
} else {
|
|
if (characterReferenceCharacters !== characters) {
|
|
end = begin + characterReferenceCharacters.length;
|
|
diff = 1 + end - begin;
|
|
terminated = false;
|
|
}
|
|
if (!terminated) {
|
|
const reason = characterReferenceCharacters ? 1 : 3;
|
|
if (options.attribute) {
|
|
const following2 = value.charCodeAt(end);
|
|
if (following2 === 61) {
|
|
warning(reason, diff);
|
|
characterReference = "";
|
|
} else if (isAlphanumerical(following2)) {
|
|
characterReference = "";
|
|
} else {
|
|
warning(reason, diff);
|
|
}
|
|
} else {
|
|
warning(reason, diff);
|
|
}
|
|
}
|
|
}
|
|
reference = characterReference;
|
|
} else {
|
|
if (!terminated) {
|
|
warning(2, diff);
|
|
}
|
|
let referenceCode = Number.parseInt(
|
|
characters,
|
|
type === "hexadecimal" ? 16 : 10
|
|
);
|
|
if (prohibited(referenceCode)) {
|
|
warning(7, diff);
|
|
reference = fromCharCode(65533);
|
|
} else if (referenceCode in characterReferenceInvalid) {
|
|
warning(6, diff);
|
|
reference = characterReferenceInvalid[referenceCode];
|
|
} else {
|
|
let output = "";
|
|
if (disallowed(referenceCode)) {
|
|
warning(6, diff);
|
|
}
|
|
if (referenceCode > 65535) {
|
|
referenceCode -= 65536;
|
|
output += fromCharCode(referenceCode >>> (10 & 1023) | 55296);
|
|
referenceCode = 56320 | referenceCode & 1023;
|
|
}
|
|
reference = output + fromCharCode(referenceCode);
|
|
}
|
|
}
|
|
if (reference) {
|
|
flush();
|
|
previous2 = now();
|
|
index = end - 1;
|
|
column += end - start + 1;
|
|
result.push(reference);
|
|
const next = now();
|
|
next.offset++;
|
|
if (options.reference) {
|
|
options.reference.call(
|
|
options.referenceContext,
|
|
reference,
|
|
{ start: previous2, end: next },
|
|
value.slice(start - 1, end)
|
|
);
|
|
}
|
|
previous2 = next;
|
|
} else {
|
|
characters = value.slice(start - 1, end);
|
|
queue += characters;
|
|
column += characters.length;
|
|
index = end - 1;
|
|
}
|
|
} else {
|
|
if (character === 10) {
|
|
line++;
|
|
lines++;
|
|
column = 0;
|
|
}
|
|
if (Number.isNaN(character)) {
|
|
flush();
|
|
} else {
|
|
queue += fromCharCode(character);
|
|
column++;
|
|
}
|
|
}
|
|
}
|
|
return result.join("");
|
|
function now() {
|
|
return {
|
|
line,
|
|
column,
|
|
offset: index + ((point ? point.offset : 0) || 0)
|
|
};
|
|
}
|
|
function warning(code, offset) {
|
|
let position;
|
|
if (options.warning) {
|
|
position = now();
|
|
position.column += offset;
|
|
position.offset += offset;
|
|
options.warning.call(
|
|
options.warningContext,
|
|
messages[code],
|
|
position,
|
|
code
|
|
);
|
|
}
|
|
}
|
|
function flush() {
|
|
if (queue) {
|
|
result.push(queue);
|
|
if (options.text) {
|
|
options.text.call(options.textContext, queue, {
|
|
start: previous2,
|
|
end: now()
|
|
});
|
|
}
|
|
queue = "";
|
|
}
|
|
}
|
|
}
|
|
function prohibited(code) {
|
|
return code >= 55296 && code <= 57343 || code > 1114111;
|
|
}
|
|
function disallowed(code) {
|
|
return code >= 1 && code <= 8 || code === 11 || code >= 13 && code <= 31 || code >= 127 && code <= 159 || code >= 64976 && code <= 65007 || (code & 65535) === 65535 || (code & 65535) === 65534;
|
|
}
|
|
|
|
// node_modules/mdast-util-directive/node_modules/stringify-entities/lib/core.js
|
|
function core(value, options) {
|
|
value = value.replace(
|
|
options.subset ? charactersToExpression(options.subset) : /["&'<>`]/g,
|
|
basic
|
|
);
|
|
if (options.subset || options.escapeOnly) {
|
|
return value;
|
|
}
|
|
return value.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate).replace(
|
|
/[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,
|
|
basic
|
|
);
|
|
function surrogate(pair, index, all) {
|
|
return options.format(
|
|
(pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536,
|
|
all.charCodeAt(index + 2),
|
|
options
|
|
);
|
|
}
|
|
function basic(character, index, all) {
|
|
return options.format(
|
|
character.charCodeAt(0),
|
|
all.charCodeAt(index + 1),
|
|
options
|
|
);
|
|
}
|
|
}
|
|
function charactersToExpression(subset) {
|
|
const groups = [];
|
|
let index = -1;
|
|
while (++index < subset.length) {
|
|
groups.push(subset[index].replace(/[|\\{}()[\]^$+*?.]/g, "\\$&"));
|
|
}
|
|
return new RegExp("(?:" + groups.join("|") + ")", "g");
|
|
}
|
|
|
|
// node_modules/mdast-util-directive/node_modules/stringify-entities/lib/util/format-basic.js
|
|
function formatBasic(code) {
|
|
return "&#x" + code.toString(16).toUpperCase() + ";";
|
|
}
|
|
|
|
// node_modules/mdast-util-directive/node_modules/stringify-entities/lib/index.js
|
|
function stringifyEntitiesLight(value, options) {
|
|
return core(value, Object.assign({ format: formatBasic }, options));
|
|
}
|
|
|
|
// 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-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/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-to-markdown/lib/util/check-quote.js
|
|
function checkQuote(context) {
|
|
const marker = context.options.quote || '"';
|
|
if (marker !== '"' && marker !== "'") {
|
|
throw new Error(
|
|
"Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`"
|
|
);
|
|
}
|
|
return marker;
|
|
}
|
|
|
|
// node_modules/mdast-util-directive/index.js
|
|
var own2 = {}.hasOwnProperty;
|
|
var shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
|
|
handleDirective.peek = peekDirective;
|
|
var directiveFromMarkdown = {
|
|
canContainEols: ["textDirective"],
|
|
enter: {
|
|
directiveContainer: enterContainer,
|
|
directiveContainerAttributes: enterAttributes,
|
|
directiveContainerLabel: enterContainerLabel,
|
|
directiveLeaf: enterLeaf,
|
|
directiveLeafAttributes: enterAttributes,
|
|
directiveText: enterText,
|
|
directiveTextAttributes: enterAttributes
|
|
},
|
|
exit: {
|
|
directiveContainer: exit,
|
|
directiveContainerAttributeClassValue: exitAttributeClassValue,
|
|
directiveContainerAttributeIdValue: exitAttributeIdValue,
|
|
directiveContainerAttributeName: exitAttributeName,
|
|
directiveContainerAttributeValue: exitAttributeValue,
|
|
directiveContainerAttributes: exitAttributes,
|
|
directiveContainerLabel: exitContainerLabel,
|
|
directiveContainerName: exitName,
|
|
directiveLeaf: exit,
|
|
directiveLeafAttributeClassValue: exitAttributeClassValue,
|
|
directiveLeafAttributeIdValue: exitAttributeIdValue,
|
|
directiveLeafAttributeName: exitAttributeName,
|
|
directiveLeafAttributeValue: exitAttributeValue,
|
|
directiveLeafAttributes: exitAttributes,
|
|
directiveLeafName: exitName,
|
|
directiveText: exit,
|
|
directiveTextAttributeClassValue: exitAttributeClassValue,
|
|
directiveTextAttributeIdValue: exitAttributeIdValue,
|
|
directiveTextAttributeName: exitAttributeName,
|
|
directiveTextAttributeValue: exitAttributeValue,
|
|
directiveTextAttributes: exitAttributes,
|
|
directiveTextName: exitName
|
|
}
|
|
};
|
|
var directiveToMarkdown = {
|
|
unsafe: [
|
|
{
|
|
character: "\r",
|
|
inConstruct: ["leafDirectiveLabel", "containerDirectiveLabel"]
|
|
},
|
|
{
|
|
character: "\n",
|
|
inConstruct: ["leafDirectiveLabel", "containerDirectiveLabel"]
|
|
},
|
|
{
|
|
before: "[^:]",
|
|
character: ":",
|
|
after: "[A-Za-z]",
|
|
inConstruct: ["phrasing"]
|
|
},
|
|
{ atBreak: true, character: ":", after: ":" }
|
|
],
|
|
handlers: {
|
|
containerDirective: handleDirective,
|
|
leafDirective: handleDirective,
|
|
textDirective: handleDirective
|
|
}
|
|
};
|
|
function enterContainer(token) {
|
|
enter.call(this, "containerDirective", token);
|
|
}
|
|
function enterLeaf(token) {
|
|
enter.call(this, "leafDirective", token);
|
|
}
|
|
function enterText(token) {
|
|
enter.call(this, "textDirective", token);
|
|
}
|
|
function enter(type, token) {
|
|
this.enter({ type, name: "", attributes: {}, children: [] }, token);
|
|
}
|
|
function exitName(token) {
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.name = this.sliceSerialize(token);
|
|
}
|
|
function enterContainerLabel(token) {
|
|
this.enter(
|
|
{ type: "paragraph", data: { directiveLabel: true }, children: [] },
|
|
token
|
|
);
|
|
}
|
|
function exitContainerLabel(token) {
|
|
this.exit(token);
|
|
}
|
|
function enterAttributes() {
|
|
this.setData("directiveAttributes", []);
|
|
this.buffer();
|
|
}
|
|
function exitAttributeIdValue(token) {
|
|
const list = this.getData("directiveAttributes");
|
|
list.push([
|
|
"id",
|
|
parseEntities(this.sliceSerialize(token), {
|
|
attribute: true
|
|
})
|
|
]);
|
|
}
|
|
function exitAttributeClassValue(token) {
|
|
const list = this.getData("directiveAttributes");
|
|
list.push([
|
|
"class",
|
|
parseEntities(this.sliceSerialize(token), {
|
|
attribute: true
|
|
})
|
|
]);
|
|
}
|
|
function exitAttributeValue(token) {
|
|
const list = this.getData("directiveAttributes");
|
|
list[list.length - 1][1] = parseEntities(this.sliceSerialize(token), {
|
|
attribute: true
|
|
});
|
|
}
|
|
function exitAttributeName(token) {
|
|
const list = this.getData("directiveAttributes");
|
|
list.push([this.sliceSerialize(token), ""]);
|
|
}
|
|
function exitAttributes() {
|
|
const list = this.getData("directiveAttributes");
|
|
const cleaned = {};
|
|
let index = -1;
|
|
while (++index < list.length) {
|
|
const attribute = list[index];
|
|
if (attribute[0] === "class" && cleaned.class) {
|
|
cleaned.class += " " + attribute[1];
|
|
} else {
|
|
cleaned[attribute[0]] = attribute[1];
|
|
}
|
|
}
|
|
this.setData("directiveAttributes");
|
|
this.resume();
|
|
const node = this.stack[this.stack.length - 1];
|
|
node.attributes = cleaned;
|
|
}
|
|
function exit(token) {
|
|
this.exit(token);
|
|
}
|
|
function handleDirective(node, _, context, safeOptions) {
|
|
const tracker = track(safeOptions);
|
|
const sequence = fence(node);
|
|
const exit2 = context.enter(node.type);
|
|
let value = tracker.move(sequence + (node.name || ""));
|
|
let label4 = node;
|
|
if (node.type === "containerDirective") {
|
|
const head = (node.children || [])[0];
|
|
label4 = inlineDirectiveLabel(head) ? head : void 0;
|
|
}
|
|
if (label4 && label4.children && label4.children.length > 0) {
|
|
const exit3 = context.enter("label");
|
|
const subexit = context.enter(node.type + "Label");
|
|
value += tracker.move("[");
|
|
value += tracker.move(
|
|
containerPhrasing(label4, context, {
|
|
...tracker.current(),
|
|
before: value,
|
|
after: "]"
|
|
})
|
|
);
|
|
value += tracker.move("]");
|
|
subexit();
|
|
exit3();
|
|
}
|
|
value += tracker.move(attributes4(node, context));
|
|
if (node.type === "containerDirective") {
|
|
const head = (node.children || [])[0];
|
|
let shallow = node;
|
|
if (inlineDirectiveLabel(head)) {
|
|
shallow = Object.assign({}, node, { children: node.children.slice(1) });
|
|
}
|
|
if (shallow && shallow.children && shallow.children.length > 0) {
|
|
value += tracker.move("\n");
|
|
value += tracker.move(containerFlow(shallow, context, tracker.current()));
|
|
}
|
|
value += tracker.move("\n" + sequence);
|
|
}
|
|
exit2();
|
|
return value;
|
|
}
|
|
function peekDirective() {
|
|
return ":";
|
|
}
|
|
function attributes4(node, context) {
|
|
const quote = checkQuote(context);
|
|
const subset = node.type === "textDirective" ? [quote] : [quote, "\n", "\r"];
|
|
const attrs = node.attributes || {};
|
|
const values = [];
|
|
let classesFull;
|
|
let classes;
|
|
let id;
|
|
let key;
|
|
for (key in attrs) {
|
|
if (own2.call(attrs, key) && attrs[key] !== void 0 && attrs[key] !== null) {
|
|
const value = String(attrs[key]);
|
|
if (key === "id") {
|
|
id = shortcut.test(value) ? "#" + value : quoted("id", value);
|
|
} else if (key === "class") {
|
|
const list = value.split(/[\t\n\r ]+/g);
|
|
const classesFullList = [];
|
|
const classesList = [];
|
|
let index = -1;
|
|
while (++index < list.length) {
|
|
;
|
|
(shortcut.test(list[index]) ? classesList : classesFullList).push(
|
|
list[index]
|
|
);
|
|
}
|
|
classesFull = classesFullList.length > 0 ? quoted("class", classesFullList.join(" ")) : "";
|
|
classes = classesList.length > 0 ? "." + classesList.join(".") : "";
|
|
} else {
|
|
values.push(quoted(key, value));
|
|
}
|
|
}
|
|
}
|
|
if (classesFull) {
|
|
values.unshift(classesFull);
|
|
}
|
|
if (classes) {
|
|
values.unshift(classes);
|
|
}
|
|
if (id) {
|
|
values.unshift(id);
|
|
}
|
|
return values.length > 0 ? "{" + values.join(" ") + "}" : "";
|
|
function quoted(key2, value) {
|
|
return key2 + (value ? "=" + quote + stringifyEntitiesLight(value, { subset }) + quote : "");
|
|
}
|
|
}
|
|
function inlineDirectiveLabel(node) {
|
|
return Boolean(
|
|
node && node.type === "paragraph" && node.data && node.data.directiveLabel
|
|
);
|
|
}
|
|
function fence(node) {
|
|
let size = 0;
|
|
if (node.type === "containerDirective") {
|
|
visitParents(node, "containerDirective", onvisit);
|
|
size += 3;
|
|
} else if (node.type === "leafDirective") {
|
|
size = 2;
|
|
} else {
|
|
size = 1;
|
|
}
|
|
return ":".repeat(size);
|
|
function onvisit(_, parents) {
|
|
let index = parents.length;
|
|
let nesting = 0;
|
|
while (index--) {
|
|
if (parents[index].type === "containerDirective") {
|
|
nesting++;
|
|
}
|
|
}
|
|
if (nesting > size)
|
|
size = nesting;
|
|
}
|
|
}
|
|
|
|
// node_modules/remark-directive/index.js
|
|
function remarkDirective201() {
|
|
const data = this.data();
|
|
add("micromarkExtensions", directive());
|
|
add("fromMarkdownExtensions", directiveFromMarkdown);
|
|
add("toMarkdownExtensions", directiveToMarkdown);
|
|
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 = {});
|